Search

Algorithmic Differentiation (AD) has become a powerful tool to improve our understanding of the Earth System, because it can generate adjoint code which permits efficient calculation of gradients that are essential to sensitivity studies, inverse problems, parameter estimation and data assimilation. Most source-to-source transformation tools, however, have been designed for FORTRAN and support for C remains limited. Here we use the Adjoinable Land Ice Flow model (ALIF), a C clone of the C++ Ice Sheet System Model (ISSM) and employ source-to-source AD to produce its adjoint code. We present the first running source-to-source adjoint of ALIF, and its application to basal drag inversion under Pine Island Glacier, West Antarctica. ALIF brought several challenges to AD tool development, such as the correct treatment of the context code, which does not compute the differentiable function, but controls this computation through the setup of data structures, including possible aliasing, as well as data-flow reversal in the presence of pointers and dynamic memory, which are ubiquitous in codes such as ISSM and ALIF. We present the strategies we have developed to overcome these challenges.

Differentiation arithmetic is a principal and accurate technique for the computational evaluation of derivatives of first and higher order. This article aims at recasting real differentiation arithmetic in a formalized theory of dyadic real differentiation numbers that provides a foundation for first and higher order automatic derivatives. After we set the stage by putting on a systematic basis certain fundamental notions of the algebra of differentiation numbers, we begin by setting up an axiomatic theory of real differentiation arithmetic, as a many-sorted extension of the theory of a continuously ordered field, and then establish the proofs for its consistency and categoricity. Next, we carefully construct the algebraic system of real differentiation arithmetic, deduce its fundamental properties, and prove that it constitutes a commutative unital ring. Furthermore, we describe briefly the extensionality of the system to an interval differentiation arithmetic and to an algebraically closed commutative ring of complex differentiation arithmetic. Finally, a word is said on machine realization of real differentiation arithmetic and its correctness, with an addendum on how to compute automatic derivatives of first and higher order., Supplementary Material: https://doi.org/10.5281/zenodo.3352442. Download latest release of InCLosure via https://doi.org/10.5281/zenodo.2702404

Fundamental and thematic climate data records derived from satellite observations provide unique information for climate monitoring and research. Since any satellite operates over a limited period of time only, creating a climate data record requires the combination of space-borne measurements from a series of several (often similar) satellite sensors. A simple combination of calibrated measurements from several sensors, however, can produce an inconsistent climate data record. This is particularly true of older, historic sensors whose behavior in space was often different from their behavior during pre-launch calibration in the laboratory. More scientific value can be derived from considering the series of historical and present satellites as a whole. Here we consider harmonisation as a process that obtains new calibration coefficients for revised sensor calibration models by comparing calibrated measurements over appropriate satellite-to-satellite match-ups, such as simultaneous nadir overpasses. When we perform a comparison of two sensors, however, we must consider that those sensors are not observing exactly the same Earth radiance. This is in part due to differences in exact location and time tolerated by the match-up process itself, but also due to differences in the spectral response functions of the two instruments, even when nominally observing the same spectral band. To derive a harmonised data set we do not aim to correct for spectral response function differences, but to reconcile the calibration of different sensors given their estimated spectral response function differences. Here we present the concept of a framework that establishes calibration coefficients and their uncertainty and error covariance for an arbitrary number of sensors in a metrologically-rigorous manner. We describe harmonisation and its mathematical formulation as an inverse problem. Solving this problem is challenging when some hundreds of millions of match-ups are involved and the errors of fundamental sensor measurements are correlated. We solve the harmonisation problem as marginalised errors in variables regression. The algorithm involves computation of first and second order partial derivatives, for which the corresponding computer source code is generated by Automatic Differentiation. Finally we present re-calibrated AVHRR radiances from a series of 10 sensors. It is shown that the new time series have much less match-up differences while being consistent with uncertainty statistics.

In this work we present useful techniques and possible enhancements when applying an Algorithmic Differentiation (AD) tool to the linear algebra library Eigen using our in-house AD by overloading (AD-O) tool dco/c++ as a case study. After outlining performance and feasibility issues when calculating derivatives for the official Eigen release, we propose Eigen-AD, which enables different optimization options for an AD-O tool by providing add-on modules for Eigen. The range of features includes a better handling of expression templates for general performance improvements, as well as implementations of symbolically derived expressions for calculating derivatives of certain core operations. The software design allows an AD-O tool to provide specializations to automatically include symbolic operations and thereby keep the look and feel of plain AD by overloading. As a showcase, dco/c++ is provided with such a module and its significant performance improvements are validated by benchmarks., Comment: Updated with accepted version for ICCS 2020 conference proceedings. The final authenticated publication is available online at https://doi.org/10.1007/978-3-030-50371-0_51. See v1 for the original, extended preprint. 14 pages, 7 figures

Dissertation, RWTH Aachen University, 2019; Aachen 1 Online-Ressource (viii, 144 Seiten) : Illustrationen (2019). = Dissertation, RWTH Aachen University, 2019, This dissertation is concerned with algorithmic differentiation (AD), which is a method for algorithmically computing the derivatives of mathematical functions implemented as computer programs. Traditionally, there are a number of numerical methods for computing derivatives that scientists and engineers commonly use. One of these methods that are widely used is the method of finite differences. The method of finite differences is very straightforward and easy to implement as a computer program as it is a non-intrusive approach in the sense that it does not require any change to the function of interest. Nevertheless, since it is only an approximating method, it requires that a sufficiently small step size must be chosen so that a reasonably good approximation to the exact derivatives can be obtained. Such numerical inaccuracy due to the wrong choice of step size can potentially and adversely affect the convergence behaviour of numerical simulations. Therefore, we need a method for computing derivatives that is both efficient and exact in the sense that it does not suffer from such numerical inaccuracy. Algorithmic differentiation can address these problems because AD can be used to compute exact derivatives accurately up to machine precision. AD provides a much more computationally efficient method for computing derivatives for certain kinds of mathematical functions than the method of finite differences. There are several approaches in AD to computing derivatives for different kinds of mathematical functions. For the kind of functions where the number of outputs m is far greater than than the number of inputs n, the tangent mode of AD is often used. On the contrary, the adjoint mode of AD is often preferably used for the kind of functions where the number of inputs n is far greater than the number of outputs m. Althoughthe tangent mode is relatively cheap in terms of memory storage, it is computationally expensive for functions with m << n. Similarly, although the adjoint mode is relatively cheap in terms of runtime, it requires a relatively large amount of storage, especially for large problems. In the adjoint mode, an adjoint program records derivative information on a randomly accessed data structure called the tape, which is essentially the linearised directed acyclic graph (linearised DAG), during the so called forward sweep, and interprets the tape according to the derivative information recorded on the tape during the forward sweep to accumulate the gradient during the so called reverse sweep. During there verse sweep, adjoints are propagated in the reverse order of the control flow of the original program. In this way, adjoints are propagated from the outputs to the inputs of the adjoint program. In the case where the number of inputs n and the number of outputs m are roughly the same and much greater than one, the tangent mode of AD is preferable because it has a lower computational overhead for computing a column than the adjoint mode for computing a row of the Jacobian. Moreover, the tangent mode requires a smaller memory requirement than the adjoint mode. This dissertation aims to develop algorithms for automatically accumulating the Jacobian of any arbitrarily large linearised DAG in order to solve the problem of running out of memory when the linearised DAG is too large to fit in main memory of the machine being used. In this dissertation, we focus on adjoint problems where m << n. With an insufficient amount of memory storage, an adjoint program will eventually run out of memory at a certain point and crash when the problem size is too large to fit in main memory. To this end, check pointing can be employed in order to prevent the adjoint program from running out of memory by 1) saving the results of intermediate computations at certain points, 2) restoring these values from the checkpoints and 3) resuming execution from these checkpoints onwards. By doing this, we can avoid the need to redundantly recompute everything from scratch at the expense of a certain amount of storage for storing the values from the intermediate computations that were previously check pointed. Nevertheless, the use of check pointing schemes requires a fairly good knowledge of the adjoint mode of AD, which can be rather complicated for a beginner and sometimes for even an intermediate user. Therefore, it is highly desirable that we have a software tool for AD that can transparently solve the memory problem in an automatic fashion without the need for users to manually checkpoint and parallelise the original AD code. To deal with the a for emention edissues, we developed a fully black-box AD software tool based on operator overloading that does not require any user intervention at all and can automatically run any arbitrary numerical problemof arbitrarily large size written in the C++ programming language. The AD software tool providesusers with a new overloaded active data type together with a set of user-friendly APIs (ApplicationProgramming Interfaces). The resulting derivative code stays virtually the same as the original sourcecode except for a couple of trivial changes that need to be made to the original source code.In Chapter 3, we propose and discuss several serial implementations, namely, Serial Global VertexElimination (SGVE), Iterative Vertex Elimination (IVE) and Serial Vertex Elimination using GraphPartitioning (SVEGP).SGVE is essentially the conventional adjoint mode of AD, which generates the entire linearisedcomputational graph of a function of interest in main memory and performs vertex elimination on thegraph in the reverse order in one go. Therefore, SGVE requires a huge amount of memory for largeproblems.IVE was developed in order to attempt to reduce memory consumption. IVE manages to decreasememory consumption to a certain extent. However, it suffers from poor runtime behaviour due to thefact that it locally performs either forward or reverse vertex elimination on subgraphs once the memoryupper bound is reached. Hence, this effectively renders the resulting vertex elimination sequence across-country ordering, and causes its runtime performance to become much worse compared to thatof SGVE.Therefore, SVEGP was developed in such a way that it generates the subgraphs of the linearisedcomputational graph in the reverse order. SVEGP starts by 1) partitioning the entire linearised graphinto several subgraphs, each of which does not exceed a given memory upper bound, and 2) generatingthese subgraphs in the reverse order. After the generation of each subgraph, SVEGP will eliminatethe dead intermediate vertices from the subgraph using reverse vertex elimination. This is effectivelyequivalent to eliminating all of the intermediate vertices from the linearised computational graph usingreverse vertex elimination in one go as in the case of SGVE. By doing so, SVEGP can preserve thenumber of floating point multiplications, which remains the same as that in SGVE using reverse vertexelimination. However, its computational overhead also depends on the number of subgraphs as everytime before each subgraph can be generated, SVEGP is required to recompute from scratch by restoringthe saved inputs. Therefore, an adjoint program using SVEGP incurs a computational overhead thatgrows quadratically in the number of subgraphs.To mitigate the additional computational overhead in SVEGP that grows quadratically in the numberof subgraphs, we developed a parallel implementation called Parallelised Adjoint Accumulation(PAA) discussed in detail in Chapter 4, where the linearised DAG is partitioned into multiple subgraphs,each of which can fit in main memory. PAA uses MPI (Message Passing Interface) to distributethese subgraphs across the available processors. These processors can also perform preaccumulationon their own subgraphs in parallel, which can help further improve the runtime performance of theaccumulation process. Experimental results from applying PAA to several case studies show that PAAcan successfully run to completion without exceeding the given memory upper bounds and can solvethe runtime problem SGVE is faced with. Moreover, our experimental results show that PAA canachieve significant speedups when compared with the original serial version SVEGP, which suffersfrom a time complexity that grows quadratically in the number of subgraphs. Furthermore, the resultsalso demonstrate that PAA outperforms tangent-mode AD in terms of runtime, which performs poorlywhen the number of inputs n is sufficiently large compared with the number of outputs m., Published by Aachen

Considering the increasing number of modern thermodynamic models for engineering applications and their continuously growing algebraic complexity, in the chemical process industry and research there is a high demand for methods and mechanisms that enhance the dissemination and reuse of these models in an efficient way. Experience shows that the common practice of providing model equations as annexes of publications does not lead to a successful spread of the models. Coding complex algebraic expressions can be highly challenging and prone to error, in particular when considering inconsistencies that frequently appear between model documentation provided by the authors and their actual software implementations. In light of the above, the use of documentation based models, as supported by the modeling environment MOSAICmodeling, appears to be a promising approach. This type of models guarantees the consistency between model documentation and implementation and builds the basis of model implementations in arbitrary programming or modeling languages. This work focuses on the development and evaluation of methodologies conceived to ease the implementation of modern molecularly based equation of state models while enhancing their dissemination. The core of the concept is the use of computational methods for structural analysis and derivative evaluation, in particular algorithmic differentiation. These are applied on an equation-oriented model implementation of the free Helmholtz energy, originally developed on the documentation level. The resulting model implementations can be used on different modeling environments, including those supporting sequential evaluations and explicit functions, and those supporting fully equation-oriented systems. In general, it was shown that the developed methods not only considerably facilitate the implementation of modern thermodynamic models; in fact, the resulting implementations proved to be highly efficient in terms of computational performance. Furthermore, within this thesis a comparative evaluation of thermodynamic models was performed in order to quantify the influence of the model selection on the quality of the process simulation of a homogeneous catalytic process. By extending the search space for the heterosegmented PCP-SAFT equation of state model, a new set of parameters was estimated which leads to a significant improvement in the description of the phase behaviour of systems containing long chain aldehydes. With a properly parameterized EoS/gE model a successful description of phase equilibrium of comparable quality could be reached as well, however, as expected, with relatively large deviations in the density calculations., Im Angesicht der zunehmenden Anzahl moderner thermodynamischer Modelle für ingenieurtechnische Anwendungen und deren immer größer werdenden algebraischen Komplexität besteht in der Prozessindustrie und in der Forschung ein großer Bedarf an Methoden, die die Verbreitung und Wiederverwendung der neuen Modelle effizienter gestalten, und somit die Vorteile dieser Modelle schneller zugänglich machen können. Die bisher gängige Praxis, Modellgleichungen als Anhang von Publikationen mitzuliefern, ist ohne Zweifel verbesserungswürdig, nicht zuletzt wegen häufig auftretender Inkonsistenzen zwischen der von den Autoren zur Verfügung gestellten Modelldokumentation und der von ihnen tatsächlich benutzten softwaretechnischen Implementierung. Vor diesem Hintergrund stellt die Nutzung von dokumentationsbasierten Modellen, wie sie von der Modellierungsumgebung MOSAICmodeling unterstützt werden, einen wertvollen Ansatz dar, da diese nicht nur Konsistenz zwischen Dokumentation und Modellimplementierung garantieren, sondern auch die Möglichkeit bieten, mittels Code-Generierung Modellimplementierungen in beliebigen Programmier- und Modelliersprachen zu erzeugen. Im Rahmen dieser Arbeit werden Methoden entwickelt und evaluiert, die das Ziel haben, den Implementierungsaufwand moderner thermodynamischer Modelle zu reduzieren und gleichzeitig die Verbreitung dieser Modelle zu fördern. Der Kern der Konzepte basiert auf der Anwendung rechnergestützter Methoden für strukturelle Analyse und Ableitungsberechnung, insbesondere algorithmische Differentiation, auf gleichungsbasierte, dokumentationsnahe Modelle der freien Helmholtz Energie. Die resultierenden Implementierungen sind nicht nur für Sprachen und Modellierungsumgebungen gültig, welche sequentielle Auswertungen zulassen. Geeignete Implementierungen werden auch für Tools generiert, welche vollständig gleichungsbasiert arbeiten. Es konnte insgesamt gezeigt werden, wie die entwickelten Methoden nicht nur die Implementierung moderner thermodynamischer Modelle erheblich erleichtern, sondern auch zu hocheffizienten rechnergestützten Modellimplementierungen führen können. Darüber hinaus wurde im Rahmen einer vergleichenden Analyse der Einfluss der thermodynamischen Modelle auf die Qualität der Prozesssimulation am Beispiel eines homogenkatalytischen Prozesses bewertet. Hinsichtlich der Beschreibung des Phasenverhaltens mit dem heterosegmentierten PCP-SAFT-Modell konnte, unter Erweiterung des Suchraumes, ein neuer Parametersatz gefunden werden, welcher eine deutlich verbesserte Beschreibung aldehydhaltiger Systeme ermöglicht und sich somit für den Einsatz in rigoroser Prozesssimulation eignet. Eine vergleichbar gute Beschreibung der Phasengleichgewichte konnte mit einem entsprechend parametrierten EoS/gE-Modell mit niedrigerem Rechenaufwand erreicht werden. Hinsichtlich der Dichteberechnung ist jedoch mit dem EoS/gE-Modell erwartungsgemäß eine größere Abweichung in Kauf zu nehmen.

In C++, new features and semantics can be added to an existing software package without sweeping code changes by introducing a user-defined type using operator overloading. This approach is used, for example, to add capabilities such as algorithmic differentiation. However, the introduction of operator overloading can cause a multitude of compilation errors. In a previous paper, we identified code constructs that cause a violation of the C++ language standard after a type change, and a tool called OO-Lint based on the Clang compiler that identifies these code constructs with lint-like messages. In this paper, we present an extension of this work that automatically transforms such problematic code constructs in order to make an existing code base compatible with a semantic augmentation through operator overloading. We applied our tool to the CFD software OpenFOAM and detected and transformed 23 instances of problematic code constructs in 160,000 lines of code. A significant amount of these root causes are included up to 425 times in other files causing a tremendous compiler error amplification. In addition, we show the significance of our work with a case study of the evolution of the ice flow modeling software ISSM, comparing a recent version which was manually type changed with a legacy version. The recent version shows no signs of problematic code constructs. In contrast, our tool detected and transformed a remarkable amount of issues in the legacy version that previously had to be manually located and fixed.

In the field of turbomachinery, a multidisciplinary optimization may seek to optimize an objective in the discipline of fluid dynamics, e.g. maximizing efficiency, while satisfying constraints in the discipline of structural mechanics, e.g.keeping the maximum von Mises stress beneath a defined threshhold. This enables the design of components that are both aerodynamically optimized and structurally feasible. In order to respect structural constraints, gradient-based optimization methods require the sensitivities of the structural objectives with respect to the design variables. A discrete adjoint structural solver, based on the finite element method (FEM), and differentiated using adjoint algorithmic differentiation (AD), plays a key role in computing the structural sensitivities efficiently. The gradients can be computed at a cost of a single adjoint run for each objective function, independent on the size of the design space. Not only does this give us the opportunity to include a large number of design parameters, e.g. a large number of control points for a CAD-based shape paremetrization, but even to go beyond the usual shape design parameters and include composite material design parameters [1], [2] as well. This paves the way for an efficient simultaneous shape and material optimization using adjoint AD. In this work, we introduce the ongoing developments of a discrete adjoint structural solver that has the capabilities of computing sensitivities with respect to shape design parameters, as well as composite material design parameters, with a single adjoint run for each structural objective function. The solver is written in C++ and differentiated using the AD tool CoDiPack [3]. The theory behind this concept is discussed first, followed by preliminary results and a conclusion.

The current state-of-the-art adjoint design optimizations for turbomachinery components focus solely on aerodynamic cost functions and constraints, yet disregard structural feasibility during the optimization procedure. This paper presents the first steps taken towards including structural constraints in a multidisiplinary adjoint optimization design chain for turbomachinery components. Particularly in turbomachinery, deformations arise due to centrifugal and pressure load during running conditions, which lead to a coupled fluid-structure interaction problem. While most optimization methods treat the fluid and structure domains separately in a single-disciplinary fashion, we seek to directly include the coupled fluid-structure interaction within the adjoint optimization. To this end, a cold-to-hot transformation tool that deforms a CAD geometry based on FEM displacements is implemented and differentiated using adjoint algorithmic differentiation to compute the required transformation sensitivities.

International audience; As AD usage is spreading to larger and more sophisticated applications, problems arise for codes that use several programming languages. Many AD tools have been designed with one application language in mind. Only a few use an internal representation that promotes language-independence, at least conceptually. When faced with the problem of building (with AD) the derivative code of a mixed-language application, end-users may consider using several AD tools, one per language. However, this leads to several problems: • Different AD tools may implemented very different AD models such as overloading-based versus source-transformation based or association-by-address versus association-by-name. These models are often not compatible. • When selecting the source-transformation model (for efficiency of the differentiated code), performance of the differentiated code strongly depends on the quality of data-flow analysis, which must be global on the code. A global analysis with separate AD tools would require inter-tool communication at the level of data-flow analysis, which does not exist at present. In any case, interoperable data-flow analysis between tools imply that the tools share their analysis strategy, which is almost never the case. Consequently, we think the only viable approach is to use a single tool, with a single internal representation and data-flow analysis strategy, therefore converting each source file to this unique representation regardless of its original language. It turns out that Tapenade [1] provides such an internal representation, accessible at present from C or Fortran sources. Other AD tools provide a language-independent internal representation. OpenAD provides such a representation based on the XAIF formalism. However, this gives birth to two separate tools, OpenAD/F for Fortran, and ADIC2 for C. Still, it seems that their is no deep reason to prevent OpenAD application to mixed-language codes. We are lacking information about common architecture between TAF and TAC++ that would allow such mixed-language AD. Rapsodia [2] was the first AD tool to support algorithmic differentiation in tangent mode of mixed-language components, specifically C++ and Fortran. As Rapsodia uses operator overloading, it performs no global analysis of the code. To our knowledge the extension of mixed-language differentiation with Rapsodia to adjoint mode is not yet provided.

Tese de doutoramento em Engenharia Química, apresentada ao Departamento de Engenharia Química da Faculdade de Ciências e Tecnologia da Universidade de Coimbra This thesis focuses on the computational implementation aspects of Nonlinear Model Predictive Control (NMPC) using first-principle-based models. NMPC performs a feedback control strategy based on the online solution of a moving horizon optimal control problem which uses a nonlinear mathematical model to predict the dynamic behavior of the system. This Advanced Process Control (APC) strategy requires the formulation of a sufficiently good plant model to allow describing the dynamic behavior of the process with enough accuracy. The development of first-principle-based models can be extremely laborious, commonly representing the majority of the time and expense of an NMPC implementation. Computer aided modeling tools can considerably lower the effort to setup and maintain these models. However, existing equation-based modeling tools require the user to either write all equations or to select them from a repository. In this work, a novel modeling framework, Daedalus, is presented that expedites the development of lumped dynamic models for chemical engineering applications by employing an automatic equation and property selection algorithm. This framework uses a phenomena-oriented modeling strategy to define higher-level concepts, such as process elements, connectors, coordinators, and equilibria, that can be combined to produce different systems of equations depending on the available model inputs and requested outputs. Control strategies that explicitly use nonlinear models require more sophisticated algorithms than linear approaches due to the extra complexity of solving nonlinear Optimal Control Problems (OCPs). Most of the computational effort in NMPC stems from numerical integrations and/or the solution of Nonlinear Programming (NLP) problems. Usually, the evaluation of model and derivative information plays a major role in the implementation feasibility of NMPC applications. Handwriting derivatives can be time-consuming and error-prone, while some automated derivative evaluation strategies can dominate the computational effort of integrators and optimizers. Therefore, Algorithmic Differentiation (AD) is employed in this thesis. AD is a family of computational techniques that automatically performs differentiation of a computer call sequence and determines exact derivatives free from truncation errors. There are two main implementation strategies in AD software tools: Source Code Transformation (SCT) and operator overloading. While the first approach can produce very efficient source code for the evaluation of differential information, the second can be applied to more complex settings. In this thesis, a new hybrid AD package, CppADCodeGen, is formulated to exploit the benefits of operator overloading and source code generation. This AD strategy is well-suited for the differentiation of models generated by Daedalus and produces highly efficient source code. This new AD strategy brings new challenges. Several procedures are applied to reduce the compilation time of the generated source code, such as the detection of equation patterns. Several other techniques are employed to improve the runtime performance, such as efficient memory use and parallelization. The Daedalus and the CppADCodeGen packages were integrated into the Plantegrity® NMPC framework. In this work, several other improvements have been made, such as the possibility of defining nonlinear models as semi-explicit Differential and Algebraic Equation (DAE) systems with any structural index, the parallelization of several methods, the implementation of the simultaneous NMPC approach, and the development of new modules and many improvements to the preexisting ones. The advanced step NMPC (asNMPC), Linear Model Predictive Control (LMPC), and Quadratic Dynamic Matrix Control (QDMC) formulations are also now available in Plantegrity®. This thesis also presents a new nonlinear optimizer, BConTR. It uses a trust-region algorithm where the Newton step is divided into the normal and tangential steps. Three matrix-free iterative methods are used, including a new method for the evaluation of the tangential step inspired by the Modified Proportioning with Reduced Gradient Projections (MPRGP) algorithm, which takes into account the linearized equality constraints and box constraints on all variables. The solver BConTR is still at the early stages of development. Several implementation and performance aspects require further research. The current version has been integrated into Plantegrity® and successfully tested with an illustrative Continuously Stirred Tank Reactor (CSTR) example. Finally, NMPC using CppADCodeGen to compute differential information has been successfully applied by simulation to three chemical process models developed with Daedalus: a CSTR with an exothermic zero-order reaction, a water-ethanol distillation column, and a Dividing-Wall Column (DWC) distillation for the separation of Benzene-Toluene-p-Xylene. Nesta tese são abordados aspectos da implementação computacional de estratégias de controlo preditivo não-linear (Nonlinear Model Predictive Control – NMPC) usando modelos baseados em primeiros princípios. A metodologia NMPC é uma estratégia de controlo por realimentação baseada na solução em linha de um problema de controlo ótimo de janela deslizante que utiliza um modelo matemático não-linear para prever o comportamento dinâmico do sistema. Esta estratégia de controlo avançado requer a formulação de um modelo matemático capaz de descrever o comportamento dinâmico do processo com suficiente precisão. A formulação de um modelo baseado em primeiros princípios pode ser uma tarefa extremamente laboriosa, representando tipicamente a maioria do tempo e investimento de uma implementação de NMPC. A utilização de ferramentas de modelação auxiliada por computador podem reduzir consideravelmente o esforço de construção e manutenção destes modelos. Contudo, as ferramentas existentes de modelação que permitem formular equações necessitam que o utilizador escreva todas as equações ou as selecione de um repositório. Neste trabalho é apresentada uma nova framework de modelação, Daedalus. Esta permite um desenvolvimento mais rápido de modelos dinâmicos de parâmetros agrupados para aplicações em engenharia química através de um algoritmo de seleção automático de equações e propriedades. Esta framework baseia-se numa abordagem de modelação fenomenológica para definir conceitos de alto nível que podem ser combinados para gerar diferentes sistemas de equações de acordo com as variáveis de entrada e saída definidas. As estratégias de controlo que utlizam modelos não-lineares de forma explícita necessitam de algoritmos mais sofisticados que as estratégias de controlo baseadas em modelos lineares, devido à complexidade acrescida da solução de problemas de controlo óptimo não-lineares. A maioria do esforço computacional na resolução de um problema de NMPC provém das integrações numéricas e/ou da solução de problemas de programação não-linear. Tipicamente, a avaliação do modelo e das suas derivadas tem um papel crucial na viabilidade de implementação de projetos de NMPC. A escrita manual das expressões das derivadas pode ser demorada e propensa a erros, enquanto que algumas estratégias automatizadas de avaliação de derivadas podem dominar o esforço computacional de integradores e otimizadores. Consequentemente, a Diferenciação Algorítmica (DA) é utilizada neste trabalho. A DA é uma família de técnicas computacionais que realiza automaticamente a diferenciação de uma sequência de cálculo e determina derivadas exactas. Existem duas abordagens principais de implementação em ferramentas de DA: a transformação de código-fonte e a sobrecarga de operadores. Enquanto a primeira abordagem produz código-fonte muito eficiente para avaliação de derivadas, a segunda pode ser aplicada em configurações mais complexas. Neste trabalho, um novo pacote de DA híbrido, o CppADCodeGen, é formulado para explorar os benefícios da sobrecarga de operadores e da geração de código. Esta estratégia é adequada para a diferenciação de modelos produzidos pelo Daedalus e cria código-fonte altamente eficiente. Esta nova estratégia de DA acarreta também novos desafios. Nela são aplicados vários procedimentos para reduzir o tempo de compilação do código-fonte gerado, como a deteção de padrões de equações. São empregadas várias outras técnicas para melhorar o desempenho do tempo de execução, tal como o uso eficiente da memória e a paralelização. Os pacotes Daedalus e CppADCodeGen foram integrados na framework de NMPC Plantegrity® . Neste trabalho, foram ainda realizadas diversas melhorias adicionais, tal como a possibilidade de definir modelos não-lineares como sistemas semi-explícitos de equações diferenciais e algébricas com qualquer índice estrutural, a paralelização de vários métodos, a implementação da abordagem de NMPC simultânea, o desenvolvimento de novos módulos e diversas melhorias nos módulos preexistentes. A estratégia de NMPC de passo avançado (asNMPC), o controlo preditivo de modelos lineares e o controlo quadrático de matriz dinâmica (QDMC) foram também incorporados no Plantegrity®. Nesta tese é apresentado um novo otimizador não-linear, o BConTR. Baseia-se num algoritmo de região de confiança em que o passo de Newton é dividido no passo normal e tangencial. São utilizados três métodos iterativos, incluindo um novo método para o cálculo do passo tangencial inspirado no algoritmo MPRGP (Modified Proportioning with Reduced Gradient Projection). A sua formulação contempla as restrições de desigualdade em relação a todas as variáveis e as restrições de igualdade linearizadas. O optimizador BConTR encontra-se num estágio inicial de desenvolvimento. Há vários aspectos de implementação e desempenho que requerem ainda uma investigação mais aprofundada. A versão atual foi integrada no Plantegrity® e testada com sucesso num exemplo de um reactor químico. Finalmente, a estratégia de NMPC usando o CppADCodeGen para o cálculo de informação diferencial foi aplicada por simulação com sucesso em três modelos de processos químicos desenvolvidos com o Daedalus: um reactor perfeitamento agitado com uma reação exotérmica de ordem zero, uma coluna de destilação de água-etanol e uma colunade destilação com parede divisória para a separação de uma mistura de benzeno-tolueno-p-xileno. Ciengis, SA

Für den Einsatz von ableitungsbasierten Optimierungsverfahren für die Verbesserung von Zielgrößen industrieller Produkte, wie z.B. dem Wirkungsgrad einer Turbine, werden exakte Ableitungen benötigt, um die letzten Prozent an möglicher Effizienz-steigerung zu erhalten. Dafür ist es notwendig, dass die Ableitungen immer konsistent zu den Lösungsverfahren in der eingesetzten Lösersoftware sind. Problematisch ist dabei die fortlaufende Weiterentwicklung an der Lösersoftware, die meist dazu führt, dass approximative Ableitungsverfahren eingesetzt werden oder die Ableitungsberechnung in der Software nicht erneuert wird und somit veraltet und inkonsistent ist. In dieser Arbeit wird ein universeller Ansatz vorgeschlagen, der zum einen die gesamte Software mittels Algorithmischen Differenzierens (AD) ableitet und zum anderem eine korrekte und konsistente Ableitung nach jeder Änderung sicherstellt. Um die Korrektheit und Konsistenz zu garantieren, wird die Technik des Variable Tagging entwickelt. Diese überprüft zur Laufzeit ob alle Abhängigkeiten von den eingesetzten Ableitungsmethoden korrekt berücksichtigt werden. Für die generelle Überprüfung, ob eine Ableitungsmethode korrekt implementiert ist, wird ein Theorem für die Vergleichbarkeit von AD Ableitungen entwickelt. Aus diesem Theorem ergeben sich Techniken, wie eine Implementierung getestet werden kann. Durch Analyse von vorliegenden industriellen Fällen wird die praktische Anwendbarkeit der entwickelten Techniken erfolgreich bestätigt. Die so erzeugten Ableitungen sind damit bereits konsistent und korrekt, jedoch kann die Effizienz des Verfahrens noch gesteigert werden. Dazu werden neue Ablei-tungsalgorithmen entwickelt. Eine konsistente Herleitung mit einem Fix-Punkt-Iterator beinhaltet alle dem Stand der Technik entsprechenden Algorithmen und ergibt zwei neue Algorithmen, die alle implementationstechnischen Details mitberücksichtigen und damit die Konsistenz der Ableitungsergebnisse nicht verletzen. Des Weiteren werden bekannte Techniken für das automatische Auffinden der größ-ten Ressourcenverbraucher vorgestellt und erweitert. Das Datenlayout für die Berechnung der Kenngrößen für die Ressourcenverbraucher, wie z.B. die Anzahl der Eingabe- und Ausgabewerte oder der Speicherverbrauch, wurde so erweitert, dass die Geschwindigkeit der Anwendung nur geringfügig verändert wird. Die Ressourcenverbraucher können mit Techniken wie Checkpointing und Preaccumulation behandelt werden. Die bisher in der Literatur fehlende Analyse, wie diese Techniken den Zeit- und Speicherverbrauch verändern, wird durchgeführt und Besonderheiten bezüglich verschiedener AD-Werkzeuge werden betrachtet. Als letzten Schritt werden die benutzten AD Werkzeuge genauer analysiert. Basie-rend auf den existierenden Implementierungen wird eine generelle Übersicht von allen möglichen Implementationstechniken durch Operatorüberladen gezeigt. Das Hauptaugenmerk liegt auf dem minimalen Speicherverbrauch eines AD-Werkzeuges und stellt implementationstechnische Verbesserungen vor. Es resultiert die erstmals mögliche Vergleichbarkeit von AD-Werkzeugen auf einer theoretischen Ebene. Dies dient als Basis zur Entwicklung eines optimalen Werkzeugs. Das neue Software-Werkzeug CoDiPack geht aus diesen Überlegungen hervor und wird in seinem Design und Konzepten vorgestellt. Die in dieser Arbeit vorgestellten Verbesserungen und Analysen ermöglichen es, eine automatisierte, konsistente und korrekte Ableitung für industrielle Zwecke effizient zur Verfügung zu stellen. If gradient based derivative algorithms are used to improve industrial products by reducing their target functions, the derivatives need to be exact. The last percent of possible improvement, like the efficiency of a turbine, can only be gained if the derivatives are consistent with the solution process that is used in the simulation software. It is problematic that the development of the simulation software is an ongoing process which leads to the use of approximated derivatives. If a derivative computation is implemented manually, it will be inconsistent after some time if it is not updated. This thesis presents a generalized approach which differentiates the whole simulation software with Algorithmic Differentiation (AD), and guarantees a correct and consistent derivative computation after each change to the software. For this purpose, the variable tagging technique is developed. The technique checks at run-time if all dependencies, which are used by the derivative algorithms, are correct. Since it is also necessary to check the correctness of the implementation, a theorem is developed which describes how AD derivatives can be compared. This theorem is used to develop further methods that can detect and correct errors. All methods are designed such that they can be applied in real world applications and are used within industrial configurations. The process described above yields consistent and correct derivatives but the efficiency can still be improved. This is done by deriving new derivative algorithms. A fixed-point iterator approach, with a consistent derivation, yields all state of the art algorithms and produces two new algorithms. These two new algorithms include all implementation details and therefore they produce consistent derivative results. For detecting hot spots in the application, the state of the art techniques are presented and extended. The data management is changed such that the performance of the software is affected only marginally when quantities, like the number of input and output variables or the memory consumption, are computed for the detection. The hot spots can be treated with techniques like checkpointing or preaccumulation. How these techniques change the time and memory consumption is analyzed and it is shown how they need to be used in selected AD tools. As a last step, the used AD tools are analyzed in more detail. The major implementation strategies for operator overloading AD tools are presented and implementation improvements for existing AD tools are discussed.\ The discussion focuses on a minimal memory consumption and makes it possible to compare AD tools on a theoretical level. The new AD tool CoDiPack is based on these findings and its design and concepts are presented. The improvements and findings in this thesis make it possible, that an automatic, consistent and correct derivative is generated in an efficient way for industrial applications.

Dissertation, RWTH Aachen University, 2018; Aachen 1 Online-Ressource (vii, 232 Seiten) : Illustrationen (2019). = Dissertation, RWTH Aachen University, 2018, Computer simulations and computer aided design in the past decades have evolved into a valuable instrument, penetrating just about every branch of engineering in industry and academia. More specifically, computational fluid dynamics (CFD) simulations allow to inspect flow phenomena in a variety of applications. As simulation methods evolve, mature, and are adopted by a rising number of users, the demand for methods which not only predict the result of a specific configuration, but can give indications on how to improve the design, increases. This thesis is concerned with the efficient calculation of sensitivity information of CFD algorithms, and their application to numerical optimization. The sensitivities are obtained by applying Algorithmic Differentiation (AD).A specific emphasis of this thesis is placed on the efficient application of adjoint methods, including parallelism, for commonly used CFD finite volume methods (FVM) and their implementation in the open source framework OpenFOAM., Published by Aachen

Computational science at the gates of nature : International Conference on Computational Science (ICCS 2015) ; Reykjavik, Iceland, 1 - 3 June 2015 / [organised by: Háskólinn í Reykjavík ...]. Ed.: Slawomir Koziel ... - Pt. 1 International Conference On Computational Science, ICCS 2015, Reykjavík, Iceland, 1 Jun 2015 - 3 Jun 2015; Red Hook, NY : Curran, Procedia computer science, 51, 231-238 (2015). doi:10.1016/j.procs.2015.05.232, Published by Curran, Red Hook, NY

Computational science at the gates of nature : International Conference on Computational Science (ICCS 2015) ; Reykjavik, Iceland, 1 - 3 June 2015 / [organised by: Háskólinn í Reykjavík ...]. Ed.: Slawomir Koziel ... - Pt. 1 International Conference On Computational Science, ICCS 2015, Reykjavík, Iceland, 1 Jun 2015 - 3 Jun 2015; Red Hook, NY : Curran, Procedia computer science, 51, 19-28 (2015). doi:10.1016/j.procs.2015.05.181, Published by Curran, Red Hook, NY

The unsteady discrete adjoint method for the calculation of objective function gradients for transient turbomachinery compressible viscous flows is presented. The URANS state equations are used along with the one-equation Spalart-Allmaras model. The implementation relies on an existing unsteady three-dimensional unstructured grid solver and discrete adjoint capabilities previously developed for steady flows. The formulation of the adjoint equations is introduced within a generic time-dependent CFD optimal design problem. An adjoint sliding plane functionality is also presented in order to enable multi-row time-dependent adjoint calculations, exploiting the rotor-stator interface. Algorithmic Differentiation (AD) is used to compute differential terms. Two testcases, a turbine vane and a turbine stage, are selected to demonstrate the feasibility of the method.

This work introduces and compares two different CAD-based mesh deformation methods. The methods are used within an adjoint structural shape optimization, which is part of an evolving CAD-based adjoint multidisciplinary optimization framework for turbomachinery components. During an optimization, the CAD geometry is updated at each design iteration, such that the structural mesh has to be deformed appropriately. The mesh is deformed in three stages. First, the nodes along the edges of the outer mesh are displaced to match the shape of the CAD edges, which are given by B-spline curves. Next, the remaining outer mesh nodes are displaced to match the shape of the CAD faces, which are given by B-spline surfaces. Finally, the outer mesh node deformations are used to solve for the inner node deformations using either an inverse distance interpolation or the linear elasticity analogy. Coupling the mesh deformation with an adjoint structural solver enables gradient computations of structural constraints with respect to CAD design parameters. To compare the robustness of the two mesh deformation methods, a CAD-based structural shape optimization using each method was performed. &nbsp

This paper summarizes work done within the framework of an adjoint multidisciplinary optimization for turbomachinery components. Adjoint models for the linear stress and vibration analysis are implemented by the discrete adjoint method using algorithmic differentiation. It is also shown that the design space of the implemented adjoint models can be extended to compute sensitivities relevant to composite material applications. &nbsp

Stan is a probabilistic programming language for specifying statistical models. A Stan program imperatively defines a log probability function over parameters conditioned on specified data and constants. As of version 2.14.0, Stan provides full Bayesian inference for continuous-variable models through Markov chain Monte Carlo methods such as the No-U-Turn sampler, an adaptive form of Hamiltonian Monte Carlo sampling. Penalized maximum likelihood estimates are calculated using optimization methods such as the limited memory Broyden-Fletcher-Goldfarb-Shanno algorithm. Stan is also a platform for computing log densities and their gradients and Hessians, which can be used in alternative algorithms such as variational Bayes, expectation propagation, and marginal inference using approximate integration. To this end, Stan is set up so that the densities, gradients, and Hessians, along with intermediate quantities of the algorithm such as acceptance probabilities, are easily accessible. Stan can be called from the command line using the cmdstan package, through R using the rstan package, and through Python using the pystan package. All three interfaces support sampling and optimization-based inference with diagnostics and posterior analysis. rstan and pystan also provide access to log probabilities, gradients, Hessians, parameter transforms, and specialized plotting.

Dissertation, RWTH Aachen University, 2017; Aachen, 1 Online-Ressource (180 Seiten) : Diagramme (2017). = Dissertation, RWTH Aachen University, 2017, The efficient computation of derivatives of mathematical functions which are implemented as computer programs has become more important in various branches of industry and academia. While derivative information is highly desired, its efficient and reliable computation remains a big challenge. In the past finite differences was a very popular approach to approximate derivatives This approach fails in more and more real world problems for two reasons. The first one is that for many functions approximating tangents by secants does not provide satisfactory results. The second problem of using finite differences is that the computational costs for computing the full dense Jacobian grows linearly with the number of inputs of the function. Therefore Algorithmic (or Automatic) Differentiation (AD) becomes the method of choice for computing derivatives as it promises to address both problems. AD is a collection of techniques allowing computation of accurate derivative information of a function F : Rn →Rm that is implemented as a computer program in some high level programming language. Often the algorithms for AD are expressed as elimination methods on the linearized directed acyclic graphs or l-DAGs. L-DAGs are computational graphs, where the edge weights are equal to the local partial derivatives of the respective operations. The most popular elimination methods are edge and vertex elimination. To compute the Jacobian with the help of edge or vertex eliminations one need to transform the l-DAG into a bipartite graph. Both techniques are based on local exploitation of the chain rule. Vertex elimination is a special case of edge elimination as it can be expressed by a sequence of edge eliminations. Associativity of the chain rule allows to perform the edge and vertex eliminations in different orders. The problem of finding an order of vertex [edge] eliminations that minimizes the number of multiplications involved in the computation of the Jacobian is known as vertex [edge] elimination problem (VE [EE]). Another closely related problem is the minimum edge count problem (MEC). This problem arises when Jacobian-vector products are needed and computation of full Jacobian is not required. The MEC problem aims to find a sequence of vertex (edge) eliminations such that the resulting l-DAG has the smallest amount of edges. VE, EE and MEC problems are conjectured to be NP-hard. Therefore in practice the solution of these problems is approximated by greedy like heuristics or computed by branch and bound based methods if the exact solution is of interest. The main aim of this thesis is to support further development of algorithms for solving these problems. Therefore this thesis tries to provide a better understanding of the problem structure by proving several properties of the l-DAGs. These properties help to reduce the search space and establish the base for other outcomes of the thesis. Building blocks for new algorithms are provided by introducing a new approach for computing lower bounds and proving various optimality preserving eliminations for all three problems. It is shown that the lower bounds computed according to this new approach are in most cases superior to the existing lower bounds. For the MEC problem this is the first algorithm for computing lower bounds so far. Better lower bounds allow to perform earlier cuts in the branch and bound type of algorithms and also help to understand the quality of the given solution. Optimality preserving eliminations is another useful technique for branch and bound and greedy like algorithms. They allow the search space for the branch and bound algorithm to be reduced and can also be used to improve the greedy heuristics. The underlying search space of the edge elimination is significantly bigger compared to that of vertex elimination, therefore edge elimination is almost never used in applications. In this thesis several optimality preserving elimination are proved. The optimality preserving eliminations for edge eliminations are generalized versions of the results for vertex eliminations. Thus mixing of edge and vertex elimination in algorithms is suggested to improve the results for approximative algorithm and to reduce the corresponding search space if the exact solution is required, demonstrating that edge eliminations should not be neglected in praxis., Published by Aachen

The adjoint mode of Algorithmic Differentiation (AD) is particularly attractive for computing gradients. However, this mode needs to use the intermediate values of the original simulation in reverse order at a cost that increases with the length of the simulation. AD research looks for strategies to reduce this cost, for instance by taking advantage of the structure of the given program. In this work, we consider on one hand the frequent case of Fixed-Point loops for which several authors have proposed adapted adjoint strategies. Among these strategies, we select the one introduced by B. Christianson. We specify further the selected method and we describe the way we implemented it inside the AD tool Tapenade. Experiments on a medium-size application shows a major reduction of the memory needed to store trajectories. On the other hand, we study checkpointing in the case of MPI parallel programs with point-to-point communications. We propose techniques to apply checkpointing to these programs. We provide proof of correctness of our techniques and we experiment them on representative CFD codes, Le mode adjoint de la Différentiation Algorithmique (DA) est particulièrement intéressant pour le calcul des gradients. Cependant, ce mode utilise les valeurs intermédiaires de la simulation d'origine dans l'ordre inverse à un coût qui augmente avec la longueur de la simulation. La DA cherche des stratégies pour réduire ce coût, par exemple en profitant de la structure du programme donné. Dans ce travail, nous considérons d'une part le cas des boucles à point-fixe pour lesquels plusieurs auteurs ont proposé des stratégies adjointes adaptées. Parmi ces stratégies, nous choisissons celle de B. Christianson. Nous spécifions la méthode choisie et nous décrivons la manière dont nous l'avons implémentée dans l'outil de DA Tapenade. Les expériences sur une application de taille moyenne montrent une réduction importante de la consommation de mémoire. D'autre part, nous étudions le checkpointing dans le cas de programmes parallèles MPI avec des communications point-à-point. Nous proposons des techniques pour appliquer le checkpointing à ces programmes. Nous fournissons des éléments de preuve de correction de nos techniques et nous les expérimentons sur des codes représentatifs. Ce travail a été effectué dans le cadre du projet européen ``AboutFlow''

The LS89 high pressure axial turbine vane was originally designed and optimized for a downstream isentropic Mach number of 0.9. This profile has been widely used for computational fluid dynamics (CFD) validation in the open literature but very few attempts have been made to improve the already optimized design. This paper presents a sound methodology to design and optimize the LS89 using computer-aided design (CAD) at design conditions. The novelty of the study resides in the parametrization of design space, which is done at the CAD level, and the detailed analysis of the aerodynamic performance of the optimized design. Higher level constraints are imposed on the shape, such as the trailing edge thickness, the axial chord length, and G2 geometric continuity between the suction side and pressure side at the leading edge. The gradients used for the optimization are obtained by applying algorithmic differentiation to the CAD kernel and grid generator and the discrete adjoint method to the CFD solver. A reduction of almost 12% entropy generation is achieved, which is equivalent to a 16% total pressure loss reduction. The entropy generation is reduced while keeping the exit flow angle as a flow constraint, which is enforced via the penalty formulation. The resulting unconstrained optimization problem is solved by the L-BFGS-B algorithm. The flow is governed by the Reynolds-averaged Navier-Stokes equations and the one-equation transport Spalart-Allmaras turbulence model. The optimal profile is compared and benchmarked against the baseline case.

Tapenade is an Automatic Differentiation (AD) tool which, given a Fortran or C code that computes a function, creates a new code that computes its tangent or adjoint derivatives. Tapenade puts particular emphasis on adjoint differentiation, which computes gradients at a remarkably low cost. This article describes the principles of Tapenade, a subset of the general principles of AD. We motivate and illustrate with examples the AD model of Tapenade, that is, the structure of differentiated codes and the strategies used to make them more efficient. Along with this informal description, we formally specify this model by means of data-flow equations and rules of Operational Semantics, making this the reference specification of the tangent and adjoint modes of Tapenade. One benefit we expect from this formal specification is the capacity to formally study the AD model itself, especially for the adjoint mode and its sophisticated strategies. This article also describes the architectural choices of the implementation of Tapenade. We describe the current performance of Tapenade on a set of codes that include industrial-size applications. We present the extensions of the tool that are planned in a foreseeable future, deriving from our ongoing research on AD.

Adjoint Algorithmic Differentiation is an efficient way to obtain price derivatives with respect to the data inputs. We describe how the process efficiency can be further improved when a model calibration is performed. Using the implicit function theorem, differentiating the numerical process used in calibration is not required. The resulting implementation is more efficient than automatic differentiation. The efficiency is described for root-finding and least square calibration.

The separation of concerns in the development of numerical models not only leads to a separation into components but, based on their purpose, these components may also be written in different programming languages. The sensitivity analysis of a numerical model provides quantitative information about the dependencies of the model outputs with respect to its inputs. An analysis of mixed-language models using derivatives computed with algorithmic (or automatic) differentiation needs to comprehensively handle all the involved components and the respective interfaces in a mixed-language environment. We describe the issues arising in the context of the sensitivity analysis, present a solution implemented with the algorithmic differentiation tool Rapsodia for C++ and Fortran, and discuss its practical use in a large-scale engineering application.

International audience; Algorithmic Differentiation (AD) has become one of the most powerful tools to improve our understanding of theEarth System. If AD has been used by the ocean and atmospheric circulation modelingcommunity for almost 20 years, it is relatively new in the ice sheet modeling community. The Ice SheetSystem Model (ISSM) is a C++, object-oriented, massively parallelized, new generation ice sheet model that recentlyimplemented AD to improve its data assimilation capabilities. ISSM currently relies on Object Overloading throughADOL-C and AMPI. However, experience shows that Object Overloading AD on ISSM is significantly more memoryintensive compared to the primal code. We want to investigate other AD approaches to improve the performance ofthe AD adjoint. Yet, to our knowledge, there is no source-to-source AD tool that supports C++.To overcome this problem, we have developed a prototype of ISSM entirely in C, called Boreas, in order to testsource-to-source transformation and compare the performance of these two approaches to AD. Boreas is a clone ofISSM, the main difference with ISSM is that all the objects are converted to C-structures and some function nameshave been adapted in order to be unique, but the code architectures are identical. The programming style of Boreas isa first attempt at defining a programming style of (or a sub-language of) C++ that source-transformation AD couldhandle. We present here the first results of Source-Transformation AD of Boread with the AD tool Tapenade.

This dissertation is concerned with the computation of arbitrary-order derivative projections (tangents and adjoints) of numerical simulation programs written in C++. Thanks to the increasing computational power, simulation nowadays plays a fundamental role within a wide range of applications. On this basis, in the last decades simulation programs became the foundation for optimization problems in a wide variety of domains, e.g. design optimization in computational fluid dynamics. When using derivative-based algorithms to carry out the optimization, first- and higher-order sensitivities of the underlying simulation program are required. Since in many cases gradients of scalar objective functions need to be computed, the adjoint method should be used. Adjoint programs can either be written by hand or generated by Algorithmic (or Automatic) Differentiation (AD) tools. AD is a semantic program transformation exploiting the chain rule of differential calculus to automatically generate programs such that sensitivities are computed in addition to the original function values. Writing adjoint programs by hand can be a tedious, time-consuming, and error-prone task, but on the other hand, the well-versed programmer can possibly write much more efficient code, especially when exploiting mathematical properties by symbolic transformations. When hand-coding an adjoint simulation program, an incremental software development process is difficult. To achieve an effective development process and get an efficient program, hybridization techniques can be used to couple an AD tool with hand-written code. This makes a top-down adjoint code development possible -- beginning with a pure AD solution, going step by step to a more efficient implementation.This thesis consists of three main points. First, the software dco/c++ is presented. dco/c++ implements AD by overloading in C++ and features hybridization techniques in a flexible and efficient way. Flexibility is meant in terms of compliance with a modern C++ environment (e.g. generic concepts, exception-safety, thread-safety, or portability), and in terms of a convenient interface with emphasis on the support for arbitrary-order derivatives. Efficiency on the other hand is ensured by the newly developed AD test suite, which carries out performance tests also in comparison to other AD tools.As the second main point, arbitrary-order derivative projections of common numerical algorithms like linear and nonlinear solvers are derived symbolically, exploiting mathematical properties. Those results are shown to be of practical relevance by connecting them to the hybridization capabilities of dco/c++. This combination is presented with the help of an extensive case study demonstrating the effectiveness of the approach. In addition, dco/c++ was successfully used in many projects and its applicability is therefore shown in terms of "reference projects".When using AD to generate an adjoint program, the resulting executable typically requires a huge amount of memory. The third point of this thesis therefore covers the Call Tree Reversal (CTR) problem. CTR is a checkpointing technique, which allows for a tradeoff between additional runtime and memory requirements. The problem itself is an NP-complete optimization problem, which in this thesis is approached by a mixed integer programming formulation for the first time.

Adjoint based calculation of sensitivities pertaining to a Computational Fluid Dynamics (CFD) Solver has proven to be a vital tool in tackling large scale problems often found in industrial applications. There are two basic approaches for applying Algorithmic Differentiation (AD) to a CFD solver, namely, Operator Overloading and Source Transformation. Unfortunately, in both cases, it is still necessary to invest a significant amount of manual coding in order to get to an application that performs acceptably in terms of memory consumption and runtime. In this paper reverse mode of AD has been applied to an unstructured pressure based steady Navier-Stokes solver. We explore the feasibility of combining both kinds of AD approaches to show where and how the advantages of each method can be exploited in order to reach a suitable compromise between performance, simplicity and efficiency. Additionally,we propose a methodology to automate the implementation of an adjoint software in order to minimize work the developer must carry out to produce the desired derivative. We investigate the effectiveness of this approach for relevant flow test cases.

International Conference on Computational Science 2016, ICCS 2016, 6-8 June 2016, San Diego, California, USA / Edited by Ilkay Altintas, Michael Norman, Jack Dongarra, Valeria V. Krzhizhanovskaya, Michael Lees and Peter M.A. Sloot International Conference on Computational Science 2016, ICCS 2016, San Diego, CA, USA, 6 Jun 2017 - 8 Jun 2017; Amsterdam [u.a.] : Elsevier, Procedia computer science, 80, 2231-2235 (2016). doi:10.1016/j.procs.2016.05.388, Published by Elsevier, Amsterdam [u.a.]