Programme of the 15th Euro AD Workshop

The ADiMat software is a tool that offers Automatic Differentiation of any Matlab function using a hybrid approach combining source transformation and operator overloading. Performance tests showed a weakness with a derivative class of ADiMat. In a first step, the Matlab runtime environment is tested regarding function and method call overheads as well as property access overhead with Matlabs objects. An automatic method, transforming the XML based abstract syntax tree created with the existing ADiMat toolchain, was developed. The process completely removes the derivative object usage from any derivative function with the goal to improve the performance.

A source transformation via operator overloading method is presented for computing derivatives of mathematical functions defined by MATLAB computer programs. The transformed derivative code that results from the method computes the possible non-zero derivatives of a fixed input size version of the original function code. Moreover, the resulting derivative code relies solely on the native MATLAB library and the method may be recursively applied to generate any order derivative code. The method has been recently implemented in the MATLAB AD tool ADiGator.

We present ongoing work on implementing an automatic differentiation (AD) package in F# language. F# is a strongly typed functional language with type inference, with origins in OCaml, developed by the F# Software Foundation and supported by Microsoft as one of its .NET languages. We implement forward, reverse, and mixed-mode AD using operator overloading. In addition to this, we use the “quotations” meta-programming feature in F# to implement a source-transformation approach allowing transparent use of AD operators with existing code with minimal change. This works by gaining access to the abstract syntax tree of F# code segments, including those residing in separate libraries and called from within the function that is being differentiated. The use of F# quotations also opens up the possibility of compiling AD code to run on GPUs and special-hardware. The resulting package can be used by all .NET languages.

Modelica is a simulation language that provides a highly modular design tool to engineers. Several implementation and libraries for the Modelica language are available. One such implementation is OpenModelica being developed in a cooperation at Universitetet Linköping and Fachhochschule Bielefeld. OpenModelica works by generating C code from the provided Modelica language model and then using a C-Compiler to do the rest. Libraries of such compiled models can be created and used in more complicated models. One of the additions to the Modelica language in this implementation is called Optimica, which can be used to solve optimization problems with Modelica models as constraints. This requires the computation of derivatives. First order derivatives have been implemented by handcoding them into the libraries. Recently OpenModelica developers started looking at algorithmic differentiation techniques in order to compute Hessians in particular. We have now successfully integrated ADOL-C based derivative computation for some kinds of models. This talk will illustrate this integration of the two tools and present some numerical results.

We discuss the application of Algorithmic Differentiation (AD) to an industrial turbomachinery code for shape optimization. AD is a method to generate discrete adjoint solvers in a semi-automated fashion. In an industrial framework, the differentiation process needs to be carefully designed to meet certain requirements on computer resources, coding standards and maintenance. Once a first adjoint solver is built in a semi-automated fashion, new developed code parts should be capable to be differentiated automatically and easy to be augmented to the adjoint solver.

Newsam-Ramsdell-Pascal-Lagrange-revisited by Andreas Griewank and Nikolai Strogies We discuss new results on the almost classic issue of matrix compression beyond grouping, which limits the seed matrices to 0,1 matrices. We show how compression to the minimal seed width is possible in a numerically stable and efficient way. Of course all this can be done in combining column and row compression for Jacobians and Hessians alike.

TBD

Piecewise linearization of piecewise smooth systems of equations yields PL equations in abs-normal form. These can be solved by various generalized Newton and fixed point methods. Typical global convergence conditions are smooth dominance or coherent orientation. These will be explained and numerical examples provided.

Piecewise linearization of piecewise smooth systems of equations yields PL equations in abs-normal form. These can be solved by various generalized Newton and fixed point methods. Typical global convergence conditions are smooth dominance or coherent orientation. These will be explained and numerical examples provided.

Piecewise linearization of piecewise smooth systems of equations yields PL equations in abs-normal form. These can be solved by various generalized Newton and fixed point methods. Typical global convergence conditions are smooth dominance or coherent orientation. These will be explained and numerical examples provided.

There are two main methods for implementing algorithmic differentiation(AD): source code transformation or using derived data types and operator overloading. Here we apply a combination of source-to-source transformation and operator overloading, using Tapenade and dco/Fortran AD tools. The operator overloading tool we apply here is called dco/fortran that is developed at the institute of Software and Tools for Computational Engineering implementing Algorithmic Differentiation (AD) by overloading in Fortran. By using the Tapenade source transformation tool, new code is generated that computes tangent or adjoint derivatives of the primal code. This approach reduces the memory requirements for the differentiating purposes and it is easier for the compiler to do compile time optimizations. However in terms of ease of implementation and ability to handle arbitrary functions, operator overloading provides the differentiated code with a greater flexibility and robustness in comparison with AD by source transformation. Therefore coupling these two AD tools remains an efficient approach to decrease in one hand the development time of differentiated code specially for medium to bigsize test cases and in other hand to reduce the memory requirement of the adjoint code. We demonstrate a significant improvement in terms of memory consumption and runtime of the resulting code for a sample CFD problem with a medium size test case.

Jan Riehme, Uwe Naumann

We report first results of significance analysis developed within the FET-open project SCoRPiO (\url{ http://www.scorpio-project.eu/outline/}).

SCoRPiO aims to introduce result significance to the hardware development process in order to reduce the safeguard power consumption by permitting a controlled level of imprecision into computations and data.

Within SCoRPiO, computational significance as an algorithmic property is introduced formally in order to expose reliability and energy to the level of the programming model and algorithm. SCoRPiO seeks to devise techniques that facilitate automatic characterization of code and data significance using compile-time or runtime analysis.

At STCE techniques for significance analysis are developed that utilizes the well known coalition of Algorithmic Differentiation and Interval Analysis to quantify the significance of individual elemental operations to the final result. Based on the source code of algorithms and user-provided initial significance information, an annotated version is used to identify parts of the algorithms that can be evaluated with less accuracy and, hence, higher energy efficiency, or does not need to be evaluated repeatedly or not at all.

In the talk we present the initial version of our significance model, that is work in progress.

Algorithmic Differentiation (AD) is typically implemented using either Operator-Overloading (OO) or Source-Code-Transformation (SCT). A new extension of the C++ template library CppAD, which uses an OO strategy, was developed in order to produce efficient C code for the algorithm and its derivative evaluations up to the second-order. Consequently, this extension allows to create a hybrid approach which provides the ease of use and flexibility of OO and the runtime performance of SCT approaches.

Due to the fact that some modeling frameworks do not use loops to define repeating equations and that OO approaches typically unrool loops, very large source files can be obtained which, in turn, can lead to very prolonged compilation times. Therefore, a pattern detection and exploitation strategy of repeating operation graphs of dependent variables was developed in order to reduce the amount of source-code to be processed by the compiler. The evaluation of differential information for these patterns should not be interpreted as simply using vectors/arrays in all algebraic operations. Detected equation patterns might be only defined for an arbitrary set of iterations of a loop while independent variables used by each operation graph pattern need not be in any specific order.

The hybrid AD strategy with pattern detection not only preserves the runtime efficiency of the original hybrid AD, which is orders of magnitude faster than the pure OO approach, but also provides a significant decrease of the preparation time. Additionally, a JIT compilation can further reduce preprocessing times.

We recently added the feature of obtaining adjoints by reverse accumulation[1] to our discrete adjoint OpenFOAM version. We were able to reuse our existing checkpointing interface to simplify the handling of get/setting the adjoints. The ability of dco/c++ to efficiently reinterpret the tape in connection with the external function interface which allows to treat the adjoints of the linear solvers analytically leads to a major reduction in runtime and memory-consumption, thus allowing us to tackle more sophisticated problems.

We will show the foundations of the implementation and show case studies involving different geometries and turbulence models.

[1] B. Christianson, Reverse accumulation and attractive fixed points, Optimization Methods and Software, 1994

Discrete methods have the distinct advantage of flexibility and robustness for obtaining adjoints of various CFD-models over continuous methods. We use operator overloading tool dco/c++ to obtain a discrete adjoint version of OpenFOAM. This discrete adjoint version is then used to calculate sensitivities based on various objective functions. We intend to demonstrate a brief overview of the application of our discrete adjoint OpenFOAM version to various industrial test cases- S-bend, VW-polo car, Motorbike, heat transfer applications etc. The various challenges facing discrete adjoint methods are mostly in terms of additional overheads in form of runtime and memory requirements for application to large size industrial test cases. Therefore we also state various AD strategies employed on a case by case basis for the industrial applications stated above like checkpointing, linear solver treatment, use of mpi-tape for efficient memory management etc.