Sensitivity computations by automatic differentiation of a CFD code based on spectral differences

We compute flow sensitivities by modifying a CFD code which is spatially-discretized with spectral differences. Our discrete approach relies on algorithmic differentiation. We obtain two transformed codes, one for each differentiation mode : tangent and adjoint. Both codes compute sensitivities in an unsteady test case of two-dimensional incompressible flow inside a periodic cube with an initial double-shear profile. The sensitivities from both codes agree to within machine accuracy, and compare well with those approximated by finite difference computations. We discuss execution times and describe our strategy to automatically differentiate in adjoint mode a parallel code containing MPI instructions

Sensitivity computations by algorithmic differentiation of a high-­order cfd code based on spectral differences

We compute flow sensitivities by differentiating a high-­order computational fluid dynamics code. Our fully discrete approach relies on automatic differentiation (AD) of the original source code. We obtain two transformed codes by using the AD tool Tapenade (INRIA), one for each differentiation mode: tangent and adjoint. Both differentiated codes are tested against each other by computing sensitivities in an unsteady test case. The results from both codes agree to within machine accuracy, and compare well with those approximated by finite differences. We compare execution times and discuss the encountered technical difficulties due to 1) the code parallelism and 2) the memory overhead caused by unsteady problems

Seeding and adjoining zero-halo partitioned parallel scientific codes

Algorithmic differentiation tools can automate the adjoint transformation of parallel message passing codes [18] using the AMPI library. Nevertheless, a non-trivial and manual step post-differentiation is seed initialisation and retrieval of the output values from the differentiated code. In this work, we present the problems and ambiguities associated with seed initialisation and output retrieval for adjoint transformation of zero-halo partitioned MPI programs. Shared-node reduction is an important parallel primitive in the zero-halo context. We introduce a general framework to eliminate ambiguities in seeding and retrieval for a general class of shared-node reduction using a conceptual master-worker model. Corollaries from the model show the need for new MPI calls for retrieval and eliminate MPI calls for seed initialisation. Different possible implementations for seeding manually assembled adjoints were inferred from the model, namely, (i) partial and (ii) unique. We successfully demonstrate the seeding of the manually assembled adjoint FPI in a 3d zero-halo partitioned unstructured compressible flow solver. The different implementations, their merits and demerits are highlighted. Tapenade AD tool was used throughout this work. Keywords

Parallel problem generation for structured problems in mathematical programming

The aim of this research is to investigate parallel problem generation for structured optimization problems. The result of this research has produced a novel parallel model generator tool, namely the Parallel Structured Model Generator (PSMG). PSMG adopts the model syntax from SML to attain backward compatibility for the models already written in SML [1]. Unlike the proof-of-concept implementation for SML in [2], PSMG does not depend on AMPL [3]. In this thesis, we firstly explain what a structured problem is using concrete real-world problems modelled in SML. Presenting those example models allows us to exhibit PSMG’s modelling syntax and techniques in detail. PSMG provides an easy to use framework for modelling large scale nested structured problems including multi-stage stochastic problems. PSMG can be used for modelling linear programming (LP), quadratic programming (QP), and nonlinear programming (NLP) problems. The second part of this thesis describes considerable thoughts on logical calling sequence and dependencies in parallel operation and algorithms in PSMG. We explain the design concept for PSMG’s solver interface. The interface follows a solver driven work assignment approach that allows the solver to decide how to distribute problem parts to processors in order to obtain better data locality and load balancing for solving problems in parallel. PSMG adopts a delayed constraint expansion design. This allows the memory allocation for computed entities to only happen on a process when it is necessary. The computed entities can be the set expansions of the indexing expressions associated with the variable, parameter and constraint declarations, or temporary values used for set and parameter constructions. We also illustrate algorithms that are important for delivering efficient implementation of PSMG, such as routines for partitioning constraints according to blocks and automatic differentiation algorithms for evaluating Jacobian and Hessian matrices and their corresponding sparsity partterns. Furthermore, PSMG implements a generic solver interface which can be linked with different structure exploiting optimization solvers such as decomposition or interior point based solvers. The work required for linking with PSMG’s solver interface is also discussed. Finally, we evaluate PSMG’s run-time performance and memory usage by generating structured problems with various sizes. The results from both serial and parallel executions are discussed. The benchmark results show that PSMG achieve good parallel efficiency on up to 96 processes. PSMG distributes memory usage among parallel processors which enables the generation of problems that are too large to be processed on a single node due to memory restriction

Automatic differentiation for message-passing parallel programs.

Many applications require the derivatives of functions defined by computer programs. Automatic differentiation (AD) is a means of developing code to compute the derivatives of complicated functions accurately and efficiently, without the difficulties associated with developing correct code by hand. We discuss some of the issues involved in developing automatic differentiation tools for parallel programming environments