Search

We present a high-order consistent compressible flow solver, based on a hybridized discontinuous Galerkin (HDG) discretization, for applications covering subsonic to hypersonic flow. In the context of high-order discretization, this broad range of applications presents unique difficulty, especially at the high-Mach number end. For instance, if a high-order discretization is to efficiently resolve shock and shear layers, it is imperative to use adaptive methods. Furthermore, high-Enthalpy flow requires non-trivial physical modeling. The aim of the present paper is to present the key enabling technologies. We discuss efficient discretization methods, including anisotropic metric-based adaptation, as well as the implementation of flexible modeling using object-oriented programming and algorithmic differentiation. We present initial verification and validation test cases focusing on external aerodynamics.

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.

There are several AD tools available that all implement different strategies for the reverse mode of AD. The most common strategies are primal value taping (implemented e.g. by ADOL-C) and Jacobian taping (implemented e.g. by Adept and dco/c++). Particulary for Jacobian taping, recent advances using expression templates make it very attractive for large scale software. However, the current implementations are either closed source or miss essential features and flexibility. Therefore, we present the new AD tool CoDiPack (Code Differentiation Package) in this paper. It is specifically designed for minimal memory consumption and optimal runtime, such that it can be used for the differentiation of large scale software. An essential part of the design of CoDiPack is the modular layout and the recursive data structures which not only allow the efficient implementation of the Jacobian taping approach but will also enable other approaches like the primal value taping or new research ideas. We will finally present the performance values of CoDiPack on a generic PDE example and on the SU2 code. [ABSTRACT FROM AUTHOR]

An algorithmic differentiation technique gives a simpler, faster power series expansion of the finite displacement of a closed-loop linkage. It accomplishes this by using a higher order than what has been implemented by complicated prior formulas for kinematic derivatives. In this expansion, the joint rates and axis lines generate the instantaneous screw of each link. Constraining the terminal link to have a zero instantaneous screw satisfies closure. In order to maintain closure over a finite displacement, it is necessary to track the spatial trajectory of each joint axis line, which in turn is directed by the instantaneous screw of a link to which it is attached. Prior algorithms express these screws in a common ground-referenced coordinate frame. Motivated by the kinematics solver portion of the recursive Newton–Euler algorithm, an alternative formulation uses sparse matrices to update the instantaneous screw between successive link-local frames. The recursive Newton–Euler algorithm, however, conducts the expansion to only second order, where this paper shows local coordinate frames that are only instantaneously aligned with their respective links give identical expressions to those in frames that move with the links. Moving frames, however, require about 40% of the operations of the global-frame formulation in the asymptotic limit. Both incrementally translated (Java) and statically compiled (C++) software implementations offer more modest performance gains; execution profiling shows reasons in order of importance (1) balance of calculation tasks when below the asymptotic limit, (2) Java array bounds checking, and (3) hardware acceleration of loops. [ABSTRACT FROM AUTHOR]

• Solves singularity avoidance problem with a redundant closed kinematic chain in a path-following framework. • Extends a previously disclosed high-order path-following method to control the redundant joints. • Proves the continuous path encountering the singularity meets position with least-maximum orientational deviation. • Limits both joint rate and acceleration in that modified kinematic path. In encountering the wrist singularity, certain tasks require (1) limits on joint rates, (2) tool traversal without slowdown and (3) accurate position of tool contact on the work surface. A small tool angle deviation is accepted. Adding three virtual joints to the wrist accomplishes this. One redundant degree-of-freedom (dof) is constrained by assigning equal-and-opposite angles to the 1st and 3rd joints. This makes the angle of the 2nd joint equal to the deviation in orientation. A second dof is constrained by directing the 1st virtual joint angle to minimize the 2nd angle. The 3rd and last redundant dof is constrained by limiting a physical joint rate to a specified ratio with the rate of tool traversal. A method for a high-order power series expansion of the kinematic variables is enhanced to achieve and maintain the minimum tool deviation angle along a continuous displacement path. Controlling a redundant kinematic chain in this manner limits joint rates, even when locating the wrist singularity. Knowing this location allows planning a tool motion satisfying limits on both joint rate and acceleration. This path is optimal in the sense of minimizing the maximum deviation angle along the robot's path. [ABSTRACT FROM AUTHOR]

We present an optimization method for Lipschitz continuous, piecewise smooth (PS) objective functions based on successive piecewise linearization. Since, in many realistic cases, nondifferentiabilities are caused by the occurrence of abs(), max(), and min(), we concentrate on these nonsmooth elemental functions. The method's idea is to locate an optimum of a PS objective function by explicitly handling the kink structure at the level of piecewise linear models. This piecewise linearization can be generated in its abs-normal-form by minor extension of standard algorithmic, or automatic, differentiation tools. In this paper it is shown that the new method when started from within a compact level set generates a sequence of iterates whose cluster points are all Clarke stationary. Numerical results including comparisons with other nonsmooth optimization methods then illustrate the capabilities of the proposed approach. [ABSTRACT FROM AUTHOR]

Motivated by the high accuracy requirements and the huge ratio of the largest to smallest time scales of Coulomb collision simulations of a considerable number of charges, we developed a novel numerical integration scheme, which uses algorithmic differentiation to produce variable, high-order integrators with dense output. We show that Picard iterations are not only a nice theoretical tool, but can also be successfully implemented to develop competitive integrators, especially when accuracies close to machine precision are required. The numerical integrators' performance and applications to the electrostatic n-body problem are illustrated. [ABSTRACT FROM AUTHOR]

Reverse-mode algorithmic differentiation (AD) is an established method for obtaining adjoint derivatives of computer simulation applications. In computational fluid dynamics (CFD), adjoint derivatives of a cost function output such as drag or lift with respect to design parameters such as surface coordinates or geometry control points are a key ingredient for shape optimization, uncertainty quantification and flow control. The computational cost of CFD applications and their derivatives makes it essential to use high-performance computing hardware efficiently, including multi- and many-core architectures. Nevertheless, OpenMP is not supported in most AD tools, and previously shown methods achieve poor scalability of the derivative code. We present the AD of an OpenMP-parallelized finite volume compressible flow solver for unstructured meshes. Our approach enables us to reuse the parallelization of the original code in the computation of adjoint derivatives. The method works by identifying code segments that can be differentiated in reverse-mode without changing their memory access pattern. The OpenMP parallelization is integrated into the derivative code during the build process in a way that is robust to modifications of the original code and independent of the OpenMP support of the differentiation tool. We show the scalability of our adjoint CFD solver on test cases ranging from thousands to millions of finite volume mesh cells on CPUs with up to 16 threads as well as on an Intel XeonPhi card with 236 threads. We demonstrate that our approach is more practical to implement for production-sized CFD codes and produces more efficient adjoint derivative code than previously shown AD methods. [ABSTRACT FROM AUTHOR]

In the framework of fusion energy research, divertor design and model calibration based on plasma edge codes currently rely either on manual iterative tuning of parameters, or alternatively on parameter scans. This, combined with the complex and computationally expensive nature of plasma edge codes, makes these procedures extremely cumbersome. Gradient-based optimization methods can significantly reduce this effort, but require an efficient strategy for sensitivity calculation. Algorithmic Differentiation (AD) offers an efficient and accurate solution, allowing semi-automatic sensitivity computation in complex, continuously developed codes. The adjoint AD mode is especially attractive, as its cost is independent of the number of input parameters. In this paper, adjoint AD sensitivity calculation is deployed for the first time in plasma edge codes, applying the TAPENADE AD tool to SOLPS-ITER. Adjoint AD results are verified to be machine precision accurate compared to tangent AD mode, and up to 10−9 compared to finite differences. Scalings of AD computational efforts prove the advantages of adjoint compared to tangent AD, while memory requirements rapidly increase for adjoint, showing the need for an improved checkpointing strategy. With the new tool, a wealth of information becomes accessible to the modeler. An adjoint sensitivity analysis for a COMPASS density scan identifies the input parameters with largest impact on the solution, and 2D sensitivity maps show their spatial dependence. • Algorithmic Differentiation allows adjoint sensitivity computation in complex codes. • Algorithmic Differentiation is applied to the plasma edge code SOLPS-ITER. • Adjoint sensitivities are obtained for the first time in plasma edge codes. • The computational cost of the sensitivities agrees with the expected performance. • A large amount of new sensitivity information is made available for the community. [ABSTRACT FROM AUTHOR]

Objective. Gradient-based optimization using algorithmic derivatives can be a useful technique to improve engineering designs with respect to a computer-implemented objective function. Likewise, uncertainty quantification through computer simulations can be carried out by means of derivatives of the computer simulation. However, the effectiveness of these techniques depends on how 'well-linearizable' the software is. In this study, we assess how promising derivative information of a typical proton computed tomography (pCT) scan computer simulation is for the aforementioned applications. Approach. This study is mainly based on numerical experiments, in which we repeatedly evaluate three representative computational steps with perturbed input values. We support our observations with a review of the algorithmic steps and arithmetic operations performed by the software, using debugging techniques. Main results. The model-based iterative reconstruction (MBIR) subprocedure (at the end of the software pipeline) and the Monte Carlo (MC) simulation (at the beginning) were piecewise differentiable. However, the observed high density and magnitude of jumps was likely to preclude most meaningful uses of the derivatives. Jumps in the MBIR function arose from the discrete computation of the set of voxels intersected by a proton path, and could be reduced in magnitude by a 'fuzzy voxels' approach. The investigated jumps in the MC function arose from local changes in the control flow that affected the amount of consumed random numbers. The tracking algorithm solves an inherently non-differentiable problem. Significance. Besides the technical challenges of merely applying AD to existing software projects, the MC and MBIR codes must be adapted to compute smoother functions. For the MBIR code, we presented one possible approach for this while for the MC code, this will be subject to further research. For the tracking subprocedure, further research on surrogate models is necessary., (Creative Commons Attribution license.)

A characteristic feature of differential-algebraic equations is that one needs to find derivatives of some of their equations with respect to time, as part of the so-called index reduction or regularization, to prepare them for numerical solution. This is often done with the help of a computer algebra system. We show in two significant cases that it can be done efficiently by pure algorithmic differentiation. The first is the Dummy Derivatives method; here we give a mainly theoretical description, with tutorial examples. The second is the solution of a mechanical system directly from its Lagrangian formulation. Here, we outline the theory and show several non-trivial examples of using the ‘Lagrangian facility’ of the Nedialkov-Pryce initial-value solver DAETS, namely a spring-mass-multi-pendulum system; a prescribed-trajectory control problem; and long-time integration of a model of the outer planets of the solar system, taken from the DETEST testing package for ODE solvers. [ABSTRACT FROM AUTHOR]

The reverse mode of Algorithmic Differentiation (AD) can be implemented in several ways. The major choices are primal value taping vs. Jacobian taping, managed indices vs. unmanaged indices and operator level taping vs. statement level taping. Most of the current AD tools have implemented only one of the eight possible choices, and the data management of the implementation adds another complexity hierarchy. The focus in this paper is the implementation of primal value taping on a statement level. Statement level taping removes the need to create intermediate values on the AD tape which results in reduced memory compared to operator level taping. The implementation will be done for managed and unmanaged indices in the AD tool CoDiPack. Primal value taping with statement level taping has not yet been implemented in any other AD tool, thus we will analyse the properties of the taping approaches and highlight the important details for an efficient implementation. Furthermore, all existing taping approaches in CoDiPack will be compared with the new primal value taping approach. The comparison have been conducted on a simple toy problem and a fully featured computational fluid dynamics solver in the multi-physics suite SU2. [ABSTRACT FROM AUTHOR]

The solution of inverse problems in a variational setting finds best estimates of the model parameters by minimizing a cost function that penalizes the mismatch between model outputs and observations. The gradients required by the numerical optimization process are computed using adjoint models. Exponential integrators are a promising family of time discretization schemes for evolutionary partial differential equations. In order to allow the use of these discretization schemes in the context of inverse problems, adjoints of exponential integrators are required. This work derives the discrete adjoint formulae for W-type exponential propagation iterative methods of Runge-Kutta type (EPIRK-W). These methods allow arbitrary approximations of the Jacobian while maintaining the overall accuracy of the forward integration. The use of Jacobian approximation matrices that do not depend on the model state avoids the complex calculation of Hessians in the discrete adjoint formulae. The adjoint code itself is generated efficiently via algorithmic differentiation and used to solve inverse problems with the Lorenz-96 model and a model from computational magnetics. Numerical results are encouraging and indicate the suitability of exponential integrators for this class of problems. [ABSTRACT FROM AUTHOR]

The directional derivatives of a piecewise smooth function at a given point can be computed with Griewank's absolute normal form (ANF). When the given point is a non-differentiable point, the resulting derivative by ordinary algorithmic differentiation is included in the subdifferential. In this paper, with ANF, a method for computing and enumerating the elements of the limiting subdifferential at a given non-differential point is described with branch and bound search. Using such an enumeration, we can compute the values of limiting derivatives and, if required, we can check the first-order optimality of the piecewise linear function derived by the piecewise smooth function given by the form of the evaluation procedure, when the sophisticated algorithm for checking the optimalities is known. The worst-case complexity of the proposed algorithm is exponential in general, but we show that there may be some cases in which computational work may be reduced using the branch and bound search with numerical examples. [ABSTRACT FROM AUTHOR]

This paper concerns the implementation and application of the extended one-shot approach including additional equality constraints to achieve a direct transition from simulation to optimization. The approach can be applied for different areas of scientific computing where partial differential equations are treated by using a fixed-point solver. The solver is extended in a semi-automated fashion. In a first step it is augmented with a consistent adjoint solver using algorithmic differentiation. Then the obtained reduced derivative information is directly employed to simultaneously achieve optimality and primal as well as adjoint feasibility. The methodology is implemented in the multi-physics package SU2 and applied for multi-objective aerodynamic shape optimization. [ABSTRACT FROM AUTHOR]

Algorithmic differentiation (AD) is a tool for generating discrete adjoint solvers, which efficiently compute gradients of functions with many inputs, for example for use in gradient-based optimization. AD is often applied to large computations such as stencil operators, which are an important part of most structured-mesh PDE solvers. Stencil computations are often parallelized, for example by using OpenMP, and optimized by using techniques such as cache-blocking and tiling to fully utilize multicore CPUs and many-core accelerators and GPUs. Differentiating these codes with conventional reverse-mode AD results in adjoint codes that cannot be expressed as stencil operations and may not be easily parallelizable. They thus leave most of the compute power of modern architectures unused. We present a method that combines forward-mode AD and loop transformation to generate adjoint solvers that use the same memory access pattern as the original computation that they are derived from and can benefit from the same optimization techniques. The effectiveness of this method is demonstrated by generating a scalable adjoint CFD solver for multicore CPUs and Xeon Phi accelerators. [ABSTRACT FROM AUTHOR]

This paper gives details on how to obtain mathematically rigorous results for global unconstrained and equality constrained optimization problems, as well as for finding all roots of a nonlinear function within a box. When trying to produce mathematically rigorous results for such problems of global nature, the main issue is to mathematically verify that a certain sub-box cannot contain a solution to the problem, i.e. to discard boxes. The presented verification methods are based on mathematical theorems, the assumptions of which are verified using Algorithmic Differentiation and interval arithmetic. In contrast to traditional numerical algorithms, the main problem of verification methods is how to formulate those assumptions. We present mathematical and implementation details on how to obtain fast verification algorithms in pure Matlab/Octave code. The methods are implemented in INTLAB, the Matlab/Octave toolbox for Reliable Computing. Several examples together with executable code show advantages and weaknesses of the proposed methods. New results are included, however, the main goal is to introduce and give enough details to understand black-box Matlab/Octave routines to solve the mentioned problems. An outlook on current research on verification methods for large problems with several million variables and several tens of thousands of constraints based on conic programming is given as well. The latter can be regarded as an extension of interval arithmetic. [ABSTRACT FROM AUTHOR]

In the context of numerical simulation a system of partial differential equations is typically solved by discretizing it into a set of linear equations. The non-linear effects in the solution are then approximated by repeatedly discretizing, solving and correcting the equations using some outer iteration scheme. One example for such a scheme is the SIMPLE algorithm. In this paper, we show how we obtained an algorithmic adjoint version of the SIMPLE algorithm in OpenFOAM with particular focus on the adjoint message passing interface communication inside the linear solvers. Due to the sparse matrix storage and specifics of the implementation of the linear solvers, this method requires special attention to the inner workings of said structures and algorithms. We show the feasibility of the chosen method by presenting two case studies. In addition to the SIMPLE algorithm, the presented ideas are applicable to a wide range of algorithms whenever linear systems are embedded into an overlying non-linear context. [ABSTRACT FROM AUTHOR]

Computer-aided design (CAD) tools are extensively used to design industrial components, however, contrary to e.g. computational fluid dynamics (CFD) solvers, shape sensitivities for gradient-based optimization of CAD-parametrized geometries have only been available with inaccurate and non-robust finite differences. Here, algorithmic differentiation (AD) is applied to the open-source CAD kernel Open CASCADE Technology using the AD software tool ADOL-C (Automatic Differentiation by OverLoading in C++). The differentiated CAD kernel is coupled with a discrete adjoint CFD solver, thus providing the first example of a complete differentiated design chain built from generic, multi-purpose tools. The design chain is demonstrated on the gradient-based optimization of a squared U-bend turbo-machinery cooling duct to minimize the total pressure loss. [ABSTRACT FROM AUTHOR]

Data of material properties given by manufacturers of piezoelectric ceramics is often flawed due to, for example, slightly different manufacturing conditions for each production batch. Hence, the need for more reliable data arises. Recently published material parameter estimation methods are based on the solution of an inverse problem fitting impedance measurements of the piezoelectric ceramic to simulations by varying the material parameters in the simulation. However, the sensitivity of impedance with respect to some material parameters is close to zero and thus alternative measurement quantities which require expensive and error-prone measurement devices would be required. In order to assist in experiment design, the simulation software must be able to compute accurate sensitivity information. We applied the algorithmic differentiation (AD) package ADOL-C to the C++-based sophisticated simulation software CFS++ and thus are now able to compute the sensitivity of impedance with respect to material parameters without the use of finite differences. As these sensitivities depend on the geometry of the piezoelectric ceramic and the electrodes, we then use these sensitivities as a cost function for maximization. We compare the results of optimization with results of optimization previously obtained using a finite difference scheme. We document implementation issues and limits for integrating ADOL-C into CFS++. Nevertheless, we show the now much improved results of optimization using AD instead of finite differences and its potential for further optimization. [ABSTRACT FROM AUTHOR]

Scripting languages are gaining acceptance because of their ease of use and value for rapid prototyping in many fields, including machine learning and statistics. In the context of algorithmic differentiation, however, the main development effort continues to be concentrated on traditional compiled languages such as Fortran and C/C++, whether source transformation tools or operator overloading tools. There is therefore a need for AD tools for computing derivatives efficiently within scripting languages. ADOL-C is an operator overloading-based C++ library that provides accurate first- and higher order derivatives for applications in C++. SWIG is a preprocessor that uses the C/C++ header files to wrap the API of a library to be callable from scripting languages such as R and Python and several other high-level programming languages. Although every language has its caveats, the overall process of making the C/C++ API available via SWIG is the same for all scripting languages. After an initial effort required per language, because SWIG is an automated interface generator based on the library's actual header files, only minimal effort is required to maintain the scripting interface in sync with upstream developments in the original C/C++ library. In addition to achieving our original goal of creating an interface for R, we were able to generate an interface for Python that proved an order of magnitude faster than the previously implemented interface. This paper gives an overview of the interface generation process, the challenges we encountered with both scripting languages and some numerical results to demonstrate both usefulness and efficiency. [ABSTRACT FROM AUTHOR]

Algorithmic differentiation (AD) based on operator overloading is often the only feasible approach for applying AD in complex C++ software environments. Challenges pertaining to the introduction of an AD tool based on operator overloading have been studied in the past. However, in order to assess possible performance gains or to verify derivative values, it is advantageous to be able to apply more than one AD tool to a given code. Hence, in this work, we investigate usability issues when exchanging AD tools. Our study is based on the NASA/JPL/UCI Ice Sheet System Model (ISSM) which currently employs the AD tool ADOL-C. We introduce CoDiPack to ISSM, a more recent AD tool offering a similar set of features while promising performance improvements. In addition to the obvious type change for the AD-augmented float type, this transition requires the change to a different adjoint MPI library, adaptation of the MUMPS solver wrapper, and changes to the derivative seeding and extraction routines. We believe that these issues are fairly generic for numerical simulation software, and the issues we report on provide a blueprint for similar undertakings. We also believe that our experiences provide guidance towards the development of AD interfaces that support AD tool interoperability. In addition, we improve upon the memory management of the existing ADOL-C instrumentation, which exhibited considerable runtime problems for higher mesh resolutions. We conduct serial and parallel ISSM model runs on a 2D mass transport benchmark as well as a model of the Pine Island Glacier to verify the derivatives computed by both tools and report on runtime performance and memory usage. In comparison, the CoDiPack AD variant of ISSM runs faster with less memory overhead than the ADOL-C variant and, thus, enables future model runs with an increased number of mesh elements. But the existence of two different AD implementations provides added confidence in the correctness of derivatives, in particular for future AD tool versions. [ABSTRACT FROM AUTHOR]

This paper presents a minimization method for Lipschitz continuous, piecewise smooth objective functions based on algorithmic differentiation (AD). We assume that all nondifferentiabilities are caused by abs(), min(), and max(). The optimization method generates successively piecewise linearizations in abs-normal form and solves these local subproblems by exploiting the resulting kink structure. Both the generation of the abs-normal form and the exploitation of the kink structure are possible due to extensions of standard AD tools. This work presents corresponding drivers for the AD tool ADOL-C which are embedded in the nonsmooth solver LiPsMin. Finally, minimax problems from robust optimization are considered. Numerical results and a comparison of LiPsMin with other nonsmooth optimization methods are discussed. [ABSTRACT FROM AUTHOR]

Scripting languages are gaining acceptance because of their ease of use and value for rapid prototyping in many fields, including machine learning and statistics. In the context of algorithmic differentiation, however, the main development effort continues to be concentrated on traditional compiled languages such as Fortran and C/C++, whether source transformation tools or operator overloading tools. There is therefore a need for AD tools for computing derivatives efficiently within scripting languages. ADOL-C is an operator overloading-based C++ library that provides accurate first- and higher order derivatives for applications in C++. SWIG is a preprocessor that uses the C/C++ header files to wrap the API of a library to be callable from scripting languages such as R and Python and several other high-level programming languages. Although every language has its caveats, the overall process of making the C/C++ API available via SWIG is the same for all scripting languages. After an initial effort required per language, because SWIG is an automated interface generator based on the library's actual header files, only minimal effort is required to maintain the scripting interface in sync with upstream developments in the original C/C++ library. In addition to achieving our original goal of creating an interface for R, we were able to generate an interface for Python that proved an order of magnitude faster than the previously implemented interface. This paper gives an overview of the interface generation process, the challenges we encountered with both scripting languages and some numerical results to demonstrate both usefulness and efficiency. [ABSTRACT FROM AUTHOR]

We present a general technique to compute the sensitivities of the Monte Carlo prices of discontinuous financial products. It is a natural extension of the pathwise adjoints method, which would require an almost-surely differentiable payoff; the efficiency of the latter method when many sensitivities must be calculated is preserved. We show empirically that the new algorithm is competitive in terms of accuracy and execution time when compared to benchmarks obtained by smoothing of the payoff, which benchmarks are biased and require a nonobvious tuning of their parameters. [ABSTRACT FROM AUTHOR]

Non-Ideal Compressible Fluid-Dynamics (NICFD) has recently been established as a sector of fluid mechanics dealing with the flows of dense vapors, supercritical fluids, and two-phase fluids, whose properties significantly depart from those of the ideal gas. The flow through an Organic Rankine Cycle (ORC) turbine is an exemplary application, as stators often operate in the supersonic and transonic regime, and are affected by NICFD effects. Other applications are turbomachinery using supercritical CO2 as working fluid or other fluids typical of the oil and gas industry, and components of air conditioning and refrigeration systems. Due to the comparably lower level of experience in the design of this fluid machinery, and the lack of experimental information on NICFD flows, the design of the main components of these processes (i.e., turbomachinery and nozzles) may benefit from adjoint-based automated fluid-dynamic shape optimization. Hence, this work is related to the development and testing of a fully-turbulent adjoint method capable of treating NICFD flows. The method was implemented within the SU2 open-source software infrastructure. The adjoint solver was obtained by linearizing the discretized flow equations and the fluid thermodynamic models by means of advanced Automatic Differentiation (AD) techniques. The new adjoint solver was tested on exemplary turbomachinery cases. Results demonstrate the method effectiveness in improving simulated fluid-dynamic performance, and underline the importance of accurately modeling non-ideal thermodynamic and viscous effects when optimizing internal flows influenced by NICFD phenomena.

Fundamental and thematic climate data records derived from satellite observations provide unique information for climate monitoring and research. Since any satellite only operates over a relatively short period of time, creating a climate data record also requires the combination of space-borne measurements from a series of several (often similar) satellite sensors. Simply combining calibrated measurements from several sensors can, however, produce an inconsistent climate data record. This is particularly true of older, historic sensors whose behaviour in space was often different from their behaviour during pre-launch calibration and 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 matchups, such as simultaneous nadir overpasses and which reconciles the calibration of different sensors given their estimated spectral response function differences. 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 that is extremely challenging when some hundreds of millions of matchups 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 using Algorithmic Differentiation. Finally, we present re-calibrated radiances from a series of nine Advanced Very High Resolution Radiometer sensors showing that the new time series has smaller matchup differences compared to the unharmonised case while being consistent with uncertainty statistics.

How can the in-flight spectral response functions of a series of decades-old broad band radiometers in Space be retrieved post-flight? This question is the key to developing Climate Data Records from the Meteosat Visible and Infrared Imager on board the Meteosat First Generation (MFG) of geostationary satellites, which acquired Earth radiance images in the Visible (VIS) broad band from 1977 to 2017. This article presents a new metrologically sound method for retrieving the VIS spectral response from matchups of pseudo-invariant calibration site (PICS) pixels with datasets of simulated top-of-atmosphere spectral radiance used as reference. Calibration sites include bright desert, open ocean and deep convective cloud targets. The absolute instrument spectral response function is decomposed into generalised Bernstein basis polynomials and a degradation function that is based on plain physical considerations and able to represent typical chromatic ageing characteristics. Retrieval uncertainties are specified in terms of an error covariance matrix, which is projected from model parameter space into the spectral response function domain and range. The retrieval method considers target type-specific biases due to errors in, e.g., the selection of PICS target pixels and the spectral radiance simulation explicitly. It has been tested with artificial and well-comprehended observational data from the Spinning Enhanced Visible and Infrared Imager on-board Meteosat Second Generation and has retrieved meaningful results for all MFG satellites apart from Meteosat-1, which was not available for analysis.

A toolbox called ADiGator is described for algorithmically differentiating mathematical functions in MATLAB. ADiGator performs source transformation via operator overloading using forward mode algorithmic differentiation and produces a file that can be evaluated to obtain the derivative of the original function at a numeric value of the input. A convenient by-product of the file generation is the sparsity pattern of the derivative function. Moreover, because both the input and output to the algorithm are source codes, the algorithm may be applied recursively to generate derivatives of any order. A key component of the algorithm is its ability to statically exploit derivative sparsity at the MATLAB operation level to improve runtime performance. The algorithm is applied to four different classes of example problems and is shown to produce runtime efficient derivative code. Due to the static nature of the approach, the algorithm is well suited and intended for use with problems requiring many repeated derivative computations. [ABSTRACT FROM AUTHOR]

We investigate the Oneshot Optimization strategy introduced by Hamdi and Griewank for the applicability and efficiency to identify parameters in models of the earth's climate system. Parameters of a box model of the North Atlantic Thermohaline Circulation are optimized with respect to the fit of model output to data given by another model of intermediate complexity. Since the model is run into a steady state by a pseudo time-stepping, efficient techniques are necessary to avoid extensive recomputations or storing when using gradient-based local optimization algorithms. The Oneshot approach simultaneously updates state, adjoint and parameter values. For the required partial derivatives, the algorithmic/automatic differentiation tool TAF was used. Numerical results are compared to results obtained by the BFGS-quasi-Newton method.

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.

• Squared Jacobian determinant locates serial robot singularities. • Method deviates from intended path to avoid singularities. • Controls deviation with bivariate second-order expansion of squared determinant. • Variable step length suppresses jumps between path bifurcation branches. • Effective for singularities in isolation or in combination. A new variable step (VS) method rapidly calculates continuous kinematic paths that encounter singularities of a serial robot. Mitigating adverse effects of such encounters by applying small deviations to the intended path achieves high precision. The method is motivated by a simplified geometric model representing the arm extension, overhead and wrist singularities found in a wrist-separable 6-axis robot. A variable step length limits the kinematic closure error in a high-order combined predictor-corrector. Squaring the determinant of the robot Jacobian matrix gives its Taylor series favorable convergence. The resulting estimate of the distance to the nearest singularity affecting convergence of other kinematic variables bounds the step length, avoiding jumps between branches of path bifurcations associated with robot singularities. Finally, a 2nd order bivariate expansion of the squared determinant targets a minimum determinant magnitude by controlling deviation from an intended path. This process obviates the need for matrix regularization giving unintended switches between solution branches. The VS method demonstrates the ability to deviate from an intended path through dead center of any of the above singularities in isolation, pairwise and three-fold combination. [ABSTRACT FROM AUTHOR]

Derivatives of eigenvalues and eigenvectors with respect to design variables are required for gradient-based optimization in many engineering design problems. However, for the generalized and standard eigenvalue problems with general complex and non-Hermitian coefficient matrices, no method can accurately compute the eigenvalue and eigenvector derivatives while remaining efficient for large numbers of design variables. In this paper, we develop an adjoint method to compute complex eigenvalue and eigenvector derivatives with machine precision. For the special case when only the eigenvalue derivative is required, we propose a reverse algorithmic differentiation (RAD) formula using a newly developed dot product identity for complex functions. We verify the proposed method against the finite differences (FD) for a simple algebraic example with a 3-by-3 complex non-Hermitian matrix and a plane Poiseulle flow stability problem that is modeled as a generalized eigenvalue problem. The adjoint method is demonstrated to scale well with the number of design variables, matching the FD reference to about 5 to 7 digits. [ABSTRACT FROM AUTHOR]

Algorithmic differentiation (AD) by source-transformation is an established method for computing derivatives of computational algorithms. Static dataflow analysis is commonly used by AD tools to determine the set of active variables, that is, variables that are influenced by the program input in a differentiable way and have a differentiable influence on the program output. In this work, a context-sensitive static analysis combined with procedure cloning is used to generate specialised versions of differentiated procedures for each call site. This enables better detection and elimination of unused computations and memory storage, resulting in performance improvements of the generated code, in both forward- and reverse-mode AD. The implications of this multi-activity AD approach on the static analysis of an AD tool is shown using dataflow equations. The worst-case cost of multi-activity AD on the differentiation process is analysed and practical remedies to avoid running into this worst case are presented. The method was implemented in the AD tool Tapenade, and we present its application to a 3D unstructured compressible flow solver, for which we generate an adjoint solver that performs significantly faster when multi-activity AD is used. [ABSTRACT FROM AUTHOR]