Team Ecuador studies Algorithmic Differentiation (AD) of computer programs, blending :

**AD theory:** We study software engineering techniques, to
analyze and transform programs mechanically. Algorithmic Differentiation (AD)
transforms a program `P` that computes a function `P'`
that computes analytical derivatives of *adjoint mode* of AD,
a sophisticated transformation that yields gradients for optimization at a remarkably low cost.

**AD application to Scientific Computing:**
We adapt the strategies of Scientific Computing
to take full advantage of AD.
We validate our work on real-size applications.

We want to produce AD code that can compete with hand-written sensitivity and adjoint programs used in the industry. We implement our algorithms into the tool Tapenade, one of the most popular AD tools now.

Our research directions :

Efficient adjoint AD of frequent dialects e.g. Fixed-Point loops.

Development of the adjoint AD model towards Dynamic Memory Management.

Development of the adjoint AD model towards Parallel Languages.

Optimal shape design and optimal control for steady and unsteady simulations. Higher-order derivatives for uncertainty quantification.

Adjoint-driven mesh adaptation.

(AD, aka Automatic Differentiation) Transformation of a program, that returns a new program that computes derivatives of the initial program, i.e. some combination of the partial derivatives of the program's outputs with respect to its inputs.

Mathematical manipulation of the Partial Differential Equations that define a problem, obtaining new differential equations that define the gradient of the original problem's solution.

General trade-off technique, used in adjoint AD, that trades duplicate execution of a part of the program to save some memory space that was used to save intermediate results.

Algorithmic Differentiation (AD) differentiates
*programs*. The input of AD is
a source program

Any execution of

where each

which can be mechanically written as a sequence of instructions

In practice, many applications only need cheaper projections of

**Sensitivities**, defined for a given direction

This expression is easily computed from right to left, interleaved with the original
program instructions. This is the *tangent mode* of AD.

**Adjoints**, defined after transposition (

This expression is most efficiently computed from right to left,
because matrix*adjoint mode* of AD, most effective for
optimization, data assimilation ,
adjoint problems , or inverse problems.

Adjoint AD builds a very efficient program Section 3.3.
This adjoint program will compute the gradient in a time independent from the number of parameters *tangent mode*
would require running the tangent differentiated program

However, the *inverse* of their computation order. If the
original program *overwrites* a part of

Another research issue is to make the AD model cope with the constant evolution of modern language constructs. From the old days of Fortran77, novelties include pointers and dynamic allocation, modularity, structured data types, objects, vectorial notation and parallel programming. We keep developing our models and tools to handle these new constructs.

Tree representation of a computer program, that keeps only the semantically significant information and abstracts away syntactic sugar such as indentation, parentheses, or separators.

Representation of a procedure body as a directed graph, whose nodes, known as basic blocks, each contain a sequence of instructions and whose arrows represent all possible control jumps that can occur at run-time.

Model that describes program static analysis
as a special sort of execution, in which all branches of control switches are taken
concurrently, and where computed values are replaced by abstract values
from a given *semantic domain*. Each particular analysis gives birth to
a specific semantic domain.

Program analysis that studies how a given property of variables evolves with execution of the program. Data Flow analysis is static, therefore studying all possible run-time behaviors and making conservative approximations. A typical data-flow analysis is to detect, at any location in the source program, whether a variable is initialized or not.

Program analysis that studies the itinerary of values
during program execution, from the place where a value is defined to the places where it is used,
and finally to the place where it is overwritten. The collection of all these itineraries
is stored as *Def-Use and Use-Def chains* or as a *data dependence graph*, and data flow analysis most
often rely on this graph.

Directed graph that relates accesses to program variables, from the write access that defines a new value to the read accesses that use this value, and from the read accesses to the write access that overwrites this value. Dependences express a partial order between operations, that must be preserved to preserve the program's result.

The most obvious example of a program transformation tool is certainly a compiler. Other examples are program translators, that go from one language or formalism to another, or optimizers, that transform a program to make it run better. AD is just one such transformation. These tools use sophisticated analysis . These tools share their technological basis. More importantly, there are common mathematical models to specify and analyze them.

An important principle is *abstraction*: the core of a compiler
should not bother about syntactic details of the compiled program.
The optimization and code generation phases must be independent
from the particular input programming language. This is generally achieved
using language-specific *front-ends*, language-independent *middle-ends*,
and target-specific *back-ends*.
In the middle-end, analysis can concentrate on the semantics
of only a small set of constructs. This analysis operates
on an abstract representation of programs made of one
*call graph*, whose nodes are themselves *flow graphs* whose
nodes (*basic blocks*) contain abstract *syntax trees* for the individual
atomic instructions.
To each level are attached symbol tables, nested to capture scoping.

Static program analysis can be defined on this internal representation,
which is largely language independent. The simplest analyses on trees can be
specified with inference rules , , .
But many *data-flow analyses* are more complex, and better defined on graphs than on trees.
Since both call graphs and flow graphs may be cyclic, these global analyses will be solved iteratively.
*Abstract Interpretation* is a theoretical framework to
study complexity and termination of these analyses.

Data flow analyses must be carefully designed to avoid or control
combinatorial explosion. At the call graph level, they can run bottom-up or top-down,
and they yield more accurate results when they take into account the different
call sites of each procedure, which is called *context sensitivity*.
At the flow graph level, they can run forwards or backwards, and
yield more accurate results when they take into account only the possible
execution flows resulting from possible control, which is called *flow sensitivity*.

Even then, data flow analyses are limited, because they are static and thus have very
little knowledge of actual run-time values. Far before reaching the very theoretical limit of
*undecidability*, one reaches practical limitations to how much information one can infer
from programs that use arrays , or pointers.
Therefore, conservative *over-approximations* must be made, leading to
derivative code less efficient than ideal.

In Scientific Computing, the mathematical model often consists of Partial Differential Equations, that are discretized and then solved by a computer program. Linearization of these equations, or alternatively linearization of the computer program, predict the behavior of the model when small perturbations are applied. This is useful when the perturbations are effectively small, as in acoustics, or when one wants the sensitivity of the system with respect to one parameter, as in optimization.

Consider a system of Partial Differential Equations that define some characteristics of a system with respect to some input parameters. Consider one particular scalar characteristic. Its sensitivity, (or gradient) with respect to the input parameters can be defined as the solution of “adjoint” equations, deduced from the original equations through linearization and transposition. The solution of the adjoint equations is known as the adjoint state.

Scientific Computing provides reliable simulations
of complex systems. For example it is possible to *simulate*
the steady or unsteady 3D air flow around a plane that captures the physical phenomena
of shocks and turbulence. Next comes *optimization*,
one degree higher in complexity because it repeatedly simulates and
applies gradient-based optimization steps until an optimum is reached.
The next sophistication is *robustness* i.e. to detect and to lower preference to a solution which,
although maybe optimal, is very sensitive to uncertainty on design parameters or
on manufacturing tolerances. This makes second derivative come into play.
Similarly *Uncertainty Quantification* can use second derivatives to evaluate how uncertainty on
the simulation inputs imply uncertainty on its outputs.

We investigate several approaches to obtain the gradient, between two extremes:

One can write an *adjoint system* of mathematical equations,
then discretize it and program it by hand. This is time consuming.
Although this looks mathematically sound , this does not provide
the gradient of the discretized function itself, thus
degrading the final convergence of gradient-descent optimization.

One can apply adjoint AD (*cf* )
on the program that discretizes and solves the direct system.
This gives exactly the adjoint of the discrete function
computed by the program. Theoretical results guarantee convergence
of these derivatives when the direct program converges.
This approach is highly mechanizable, but leads to massive use of storage
and may require code transformation by hand , to reduce memory
usage.

If for instance the model is steady, or when the computation uses a Fixed-Point iteration, tradeoffs exist between these two extremes , that combine low storage consumption with possible automated adjoint generation. We advocate incorporating them into the AD model and into the AD tools.

Algorithmic Differentiation of programs gives sensitivities or gradients, useful for instance for :

optimum shape design under constraints, multidisciplinary optimization, and more generally any algorithm based on local linearization,

inverse problems, such as parameter estimation and in particular 4Dvar data assimilation in climate sciences (meteorology, oceanography),

first-order linearization of complex systems, or higher-order simulations, yielding reduced models for simulation of complex systems around a given state,

mesh adaptation and mesh optimization with gradients or adjoints,

equation solving with the Newton method,

sensitivity analysis, propagation of truncation errors.

A CFD program computes the flow around a shape, starting from a number of inputs that define the shape and other parameters. On this flow one can define optimization criteria e.g. the lift of an aircraft. To optimize a criterion by a gradient descent, one needs the gradient of the output criterion with respect to all the inputs, and possibly additional gradients when there are constraints. Adjoint AD is the most efficient way to compute these gradients.

Inverse problems aim at estimating the value of hidden parameters from other measurable values, that depend on the hidden parameters through a system of equations. For example, the hidden parameter might be the shape of the ocean floor, and the measurable values of the altitude and velocities of the surface.

One particular case of inverse problems is *data assimilation*
in weather forecasting or in oceanography.
The quality of the initial state of the simulation conditions the quality of the
prediction. But this initial state is not well known. Only some
measurements at arbitrary places and times are available.
A good initial state is found by solving a least squares problem
between the measurements and a guessed initial state which itself must verify the
equations of meteorology. This boils down to solving an adjoint problem,
which can be done though AD .
Figure shows an example of a data assimilation exercise
using the oceanography code OPA and its AD-adjoint
produced by Tapenade.

The special case of *4Dvar* data assimilation is particularly challenging.
The 4^{th} dimension in “4D” is time, as available measurements are distributed
over a given assimilation period. Therefore the least squares mechanism must be
applied to a simulation over time that follows the time evolution model.
This process gives a much better estimation of the initial state, because
both position and time of measurements are taken into account.
On the other hand, the adjoint problem involved is more complex,
because it must run (backwards) over many time steps.
This demanding application of AD justifies our efforts in
reducing the runtime and memory costs of AD adjoint codes.

Simulating a complex system often requires solving a system of Partial Differential Equations.
This can be too expensive, in particular in the context of real time.
When one wants to simulate the reaction of this complex system to small perturbations around a fixed
set of parameters, there is an efficient approximation: just suppose that the system
is linear in a small neighborhood of the current set of parameters. The reaction of the system
is thus approximated by a simple product of the variation of the parameters with the
Jacobian matrix of the system. This Jacobian matrix can be obtained by AD.
This is especially cheap when the Jacobian matrix is sparse.
The simulation can be improved further by introducing higher-order derivatives, such as Taylor
expansions, which can also be computed through AD.
The result is often called a *reduced model*.

Some approximation errors can be expressed by an adjoint state. Mesh adaptation can benefit from this. The classical optimization step can give an optimization direction not only for the control parameters, but also for the approximation parameters, and in particular the mesh geometry. The ultimate goal is to obtain optimal control parameters up to a precision prescribed in advance.

Scientific Description

Aironum is an experimental software that solves the unsteady compressible Navier-Stokes equations with k-, LES-VMS and hybrid turbulence modelling on parallel platforms, using MPI. The mesh model is unstructured tetrahedrization, with possible mesh motion.

Functional Description

Aironum was developed by Inria and University of Montpellier. It is used by Inria, University of Montpellier and University of Pisa (I). Aironum is used as an experimental platform for:

Numerical approximation of compressible flows, such as upwind mixed element volume approximation with superconvergence on regular meshes.

Numerical solution algorithms for the implicit time advancing of the compressible Navier-Stokes equations, such as parallel scalable deflated additive Schwarz algorithms.

Turbulence modelling such as the Variational Multiscale Large eddy Simulation and its hybridization with RANS statistical models.

Participant: Alain Dervieux

Contact: Alain Dervieux

Keywords: Static analysis - Optimization - Compilation - Gradients

Scientific Description

Tapenade implements the results of our research about models and static analyses for AD. For a full specification and description, see . AD produces analytical derivatives, that are exact up to machine precision. Adjoint AD computes gradients at a cost which is independent from the number of input variables. Tapenade performs sophisticated flow- and context-sensitive data-flow analysis on the complete source program to produce an efficient differentiated code. Analyses include Type-Checking, Read-Write analysis, Pointer analysis. AD-specific analyses include:

Activity analysis: Detects variables whose derivative is either null or useless, to reduce the number of derivative instructions.

Adjoint Liveness analysis: Detects the source statements that are dead code for the computation of derivatives.

TBR analysis: In Adjoint AD, reduces the set of source variables that need to be recovered.

Functional Description

Tapenade transforms an original program into a new program that computes derivatives of the original program. Tapenade accepts source programs written in Fortran77, Fortran90, or C. Tapenade can differentiate in tangent, vector tangent, adjoint, and vector adjoint modes. Tapenade can be downloaded and installed on most architectures. Alternatively, it can be used as a web server. Higher-order derivatives can be obtained through repeated application.

Participants: Laurent Hascoët, Valérie Pascual, Ala Taftaf

Contact: Laurent Hascoët

One of the current frontiers of AD research is the definition of an adjoint AD model that can cope with dynamic memory management. This research is central in our ongoing effort towards adjoint AD of C, and more remotely towards AD of C++. This research is conducted in collaboration with the MCS department of Argonne National Lab. Our partnership is formalized by joint participation in the Inria joint lab JLESC, and partly funded by the Partner University Fund (PUF) of the French embassy in the USA.

Adjoint AD must reproduce in reversed order the control decisions of the original code. In languages such as C, allocation of dynamic memory and pointer management form a significant part of these control decisions. Reproducing memory (de)allocation in reverse means reallocating memory, possibly receiving a different memory chunk. Reproducing pointer addresses in reverse thus require to convert addresses in the former memory chunks into equivalent addresses in the new reallocated chunks. Together with Krishna Narayanan from Argonne, we experiment on real applications to find the most efficient solution to this address conversion problem. We jointly develop a library (called ADMM, ADjoint Memory Management) whose primitives can be used in AD adjoint code to handle this address conversion. Using this library together with Tapenade, we could obtain a correct AD adjoint code of a medium-size industrial code (“Multibody", structural mechanics) that exhibits a typical usage of C pointer arithmetic. This year, the same effort was conducted with the OpenAD AD tool, leading us to an ADMM library less dependent on the particular target AD tool. A joint publication with our colleagues from Argonne is in preparation.

In parallel, we investigate alternative implementation strategies for ADMM, one of which could be to build our own memory (de)allocation mechanism, This should ultimately rely on the standard C library. As a result, management of adjoint memory addresses could be done deeper in the system and therefore with a smaller overhead, at the cost of some additional portability issues.

We pursue our objective of improving reliability of the AD adjoint model for C codes to a similar level as achieved for Fortran. To this end we apply Tapenade to increasingly larger and complex C codes. In addition to the already mentioned “Multibody" application, we initiated differentiation of two new complex applications:

“BLN" is a code developed by the Inria team ABS, that computes the potential energy of possible conformations of a macromolecule. Its gradient is used to explore the local minima in the energy landscape of these conformations. The AD adjoint of a Fortran implementation of BLN has been built by Tapenade and successfully validated. The adjoint of the C implementation is a challenge that helps us clarify the adjoint AD model that we use in Tapenade. The C version of BLN that we are considering is actually a (partly mechanical) translation of the actual C++ source. This makes this code an even more appealing and challenging test case. This work was mostly conducted by Raphaël Couronné as a part of his summer internship with us.

“SEISM" is a code developed by Mathieu Morlighem from UC Irvine, jointly with Eric Larour from JPL. This is a glaciology code closely related to the larger “ISSM" code, in C++. One objective, addressed mostly by Mathieu Morlighem, is to clarify recommendations on the C programming style (again very much inspired here from the C++ style) that allows AD to perform better. The other objective, adressed mostly by our team, it to experiment with quite intricate data structures, where Tapenade's static pointer destination analysis is used intensively.

We have a long-standing collaboration with Argonne National Lab on the question of adjoint AD of message-passing parallel codes. We continued joint development of the Adjoinable-MPI library (AMPI) that provides efficient tangent and adjoint AD for MPI-parallel codes, independently of the AD tool used (now AdolC, dco, OpenAD, Tapenade).

During her PhD work, Ala Taftaf is considering the question of checkpointing applied to the AD-adjoint of an MPI-parallel code. Checkpointing is a memory/runtime tradeoff which is essential for adjoint AD of large codes, in particular parallel codes. However, for MPI codes this question has always been addressed by ad-hoc hand manipulations of the differentiated code, and with no formal assurance of correctness. Ala Taftaf is investigating the assumptions implicitly made during past experiments, to clarify and generalize them. On one hand we propose an extension of the adjoint of MPI point-to-point communication primitives, so that the semantics of an adjoint program is preserved for any placement of checkpoints. On the other hand, we propose an alternative extension of these adjoint communications, more efficient but that requires a number of restrictions on the placement of checkpoints. We shall try to provide proof of correctness of these strategies, and in particular demonstrate that they cannot introduce deadlocks. Tradeoffs between the two extensions should be investigated. Ala Taftaf presented her research on “`Adjoint-Checkpointing on MPI-parallel codes” at the EuroAD workshop in Paderborn, Germany, december 1-2. A conference article has been submitted to Eccomas 2016 in Crete.

Adjoint codes naturally propagate partial gradients backwards from the result of the simulation. However, this uses the data flow of the simulation in reverse order, at a cost that increases with the length of the simulation. In the special case of iterative Fixed-Point loops, only the final converged result should be used: the “initial guess” and the intermediate non-converged states should not be considered by the adjoint calculation, and this remark brings enormous gain in memory use. We selected the strategy proposed by Bruce Christianson and this year we continued its application to medium-size testcases provided by Queen Mary University for the AboutFlow project. We also simplified the user interface provided to trigger this special strategy extension in Tapenade. Ala Taftaf presented her results at the ECCOMAS Eurogen conference in Glasgow , september 14-16.

In parallel, we collaborated with Krishna Narayanan from ANL and Dan Goldberg from University of Edinburgh (UK) to implement the same strategy into the OpenAD tool, in view of applying it to a glaciology configuration of the MIT GCM code. A joint article describing the results has been submitted for publication.

In collaboration with EDF, Valérie Pascual is applying Tapenade to the hydrographic code “Mascaret". Both tangent and adjoint diferentiated codes have been built and validated. Application of the tangent differentiated Mascaret for data assimilation on two real cases is described in a joint publication .

During his summer internship, Raphaël Couronné has applied Tapenade to the MIT “GCM", a reference code in the Earth Sciences community. We have obtained a valid adjoint for a recommended configuration of this very large Fortran code. This test showed some maturity of the Tapenade tool for Fortran, as it turned out that no modification nor debug of the tool was needed. We are now discussing with the MIT team to schedule further collaboration.

In cooperation with the partners of the FP7 project UMRIDA, the team has assisted Alenia-Aermacchi (Filomena Cariglino and Nicola Ceresola) in the efficient differentiation of their Euler/Navier Stokes code “UNS3D" in tangent mode, dealing in particular with its use of MPI.

The team has assisted Marcin Wyrozebski from Warsaw University of Technology, to apply Tapenade to a CFD software from WUT.

For Fluid Mechanics as well as for Structural Mechanics, an implicit time-advancing is mandatory. It can be applied efficiently if the large systems involved are solved with a good parallel algorithm. In the 90's, a generation of solution algorithms was devised on the basis of Domain Decomposition Methods (DDM). For complex models (compressible flows...), Schwarz DDM were combined with quasi-Newton algorithms such as GMRES. These are for example Restrictive Additive Schwarz (RAS), which is used in our platform AIRONUM. RAS was developed by Cai, Farhat and others. RAS is an ancestor of the widely used class of Newton-Krylov-Schwarz (NKS) algorithms. For hundreds of processors many versions of NKS, and in particular RAS, are almost scalable (convergence rate independant of the number of processors). But scalability vanishes for a medium-large number of processors (thousands). In the ANR ECINADS, coordinated by Ecuador, a Coarse-Grid Deflated RAS was developped: iteration-wise scalability holds for all parts, except for the coarse grid direct solver, which concerns a much smaller problem. Effective Convergence Scalability (ECS) was confirmed up to 2048 processors. Beyond this level the asymptotic complexity of the coarse-grid direct solver becomes predominant and ECS is lost. In other words, with a Coarse-Grid Deflated RAS, the size of the coarse grid problem which is solved by a direct algebraic solver must be limited in order to enjoy ECS. For finer meshes, the coarse system cannot be finer, and the efficiency is lower. It is then natural to consider intermediate meshes on which iterative solvers will be applied. In the ANR MAIDESC, Gautier Brèthes has defined a multi-mesh Full MultiGrid (FMG) algorithm adapted to anisotropic mesh adaptation. In 2015, the method has been extended to MPI-based massive parallelism, in cooperation with the Lemma team for the computation of incompressible flows. As a perspective, our parallel MG can be complemented with the previous version of the solver (deflated RAS) for a higher degree of scalability.

A second issue which we addressed is the use of explicit time advancing. Many unsteady flows have to be computed with explicit time advancing. A single explicit time step is of a low cost and can be highly accurate. Explicit time advancing is mandatory for wave propagation: blast shocks of vortices in wakes. However the meshes used may involve small regions in which the explicit time step should be very small and large regions in which such a small time step is a waste. The family of time-advancing methods in which unsteady phenomena are computed using different time steps in different regions is called the multirate methods. In our cooperation with University of Montpellier, a novel multirate method using cell-agglomeration has been designed and developed in our AIRONUM platform. An article is in preparation. This work takes place in the ANR MAIDESC programme.

The study of combination of full multigrid (FMG) with anisotropic mesh adaption (AA), started with the thesis of Gautier Brèthes, has been published .

Further studies of mesh adaptation for viscous flows are currently performed and a journal paper, joint with Inria team Gamma3 and University of Paris 6 (Anca Belme) is in preparation.

An important novelty in mesh adaption is the norm-oriented AA method. The method relies on the definition of ad hoc correctors. It has been developed in the academic platform “FMG" for elliptic problems. Gautier Brèthes gave several presentations in conferences, a journal article has been submitted. The introduction of the norm-oriented idea considerably amplifies the impact of adjoint-based AA. The applied mathematician and the engineer now have methods when faced to mesh adaptation for the simulation of a complex PDE system, since they can specify which error norm level they wish, and for which norm , . Another version is developed jointly with Inria team Gamma3 for the compressible Euler model .

A cooperation has started between Gautier Brèthes et Thierry Coupez (Ecole Centrale de Nantes) concerning discrete metrics. This takes place in the ANR MAIDESC program. An article is in preparation.

Éléonore Gauci started last year a thesis (co-advised by Frédéric Alauzet) on the study of norm-oriented criteria for CFD and coupled CSM-CFD systems. She gave a presentation at the “Coupled Problems" symposium.

Post-doc Guilherme Cunha did a study (in cooperation with Lemma) on the combination of mesh adaptation and coefficient identification for unsteady phenomena.

The theoretical studies are supported by an ANR project MAIDESC coordinated by ECUADOR and Gamma3, which deals with meshes for interfaces, third-order accuracy, meshes for boundary layers, and curved meshes.

CFD application are supported by the European FP7 project UMRIDA which deals with the application of AA to approximation error modelling and control.

The purpose of our work in hybrid RANS/LES is to develop new approaches for industrial applications of LES-based analyses. In the applications targetted (aeronautics, hydraulics), the Reynolds number can be as high as several tenth millions, far too high for pure LES models. However, certain regions in the flow can be better predicted with LES than with usual statistical RANS (Reynolds averaged Navier-Stokes) models. These are mainly vortical separated regions as assumed in one of the most popular hybrid model, the hybrid Detached Eddy Simulation model. Here, “hybrid” means that a blending is applied between LES and RANS. An important difference between a real life flow and a wind tunnel or basin is that the turbulence of the flow upstream of each body is not well known.

This year, we have continued the evaluation of a dynamic formulation of Piomelli-Germano type for the Variational-multiscale model. We have also modified the integration of the boundary layer by adding the so-called Menter correction imposing the Bradshaw law. We have studied these improvements on multiple-body flows. An emblematic case is the interaction between two parallel cylinders, one being in the wake of the other. A flow around a space probe at high Reynolds number is also studied , .

Ecuador and Lemma share the results of Gautier Brèthes' thesis, which is partly supported by Lemma, the other part being supported by a PACA region fellowship.

Ecuador and Lemma have a bilateral contract to share the results of Stephen Wornom, Lemma engineer provided to Inria and hosted by Inria under a Inria-Lemma contract.

Ecuador and EDF have a bilateral contract on AD of the hydrology code “Mascaret”. The correspondent on the Ecuador side is Valérie Pascual.

Ecuador is coordinator of the ANR project MAIDESC, with Inria team Gamma3, University of Montpellier II, CEMEF-Ecole des Mines, Inria-Bordeaux, Lemma and Transvalor. MAIDESC concentrates on mesh adaptation and in particular meshes for interfaces, third-order accuracy, meshes for boundary layers, and curved meshes.

Type: PEOPLE

Instrument: Initial Training Network

Duration: 2012-2016

Coordinator: Jens-Dominik Mueller

Partner: Queen Mary University of London (UK)

Inria contact: Laurent Hascoët

Abstract: The aim of AboutFlow is to develop robust gradient-based optimisation methods
using adjoint sensitivities for numerical optimisation of flows.
http://

Type:AAT

Instrument:Aeronautics and Air Transport

Duration: 2013-2016

Coordinator: Charles Hirsch

Partner: Numeca S.A. (Belgium)

Inria contact: Alain Dervieux

Abstract: UMRIDA addresses major research challenges in Uncertainty Quantification and Robust Design: develop new methods that handle large numbers of simultaneous uncertainties and generalized geometrical uncertainties. Apply these methods to representative industrial configurations.

Ecuador participates in the Joint Laboratory for Exascale Computing (JLESC) together with colleagues at Argonne National Laboratory. Laurent Hascoët attended the JLESC meeting in Bonn, Germany, december 2-5.

Krishna Narayanan from Argonne National Laboratory, september 21-25.

Marcin Wyrozebski from Warsaw University of Technology, september 1-30.

Laurent Hascoët visited Argonne National Laboratory, april 13-23.

Laurent Hascoët is on the organizing commitee of the EuroAD Workshops on Algorithmic Differentiation.

Master : Laurent Hascoët, Optimisation avancée, 15 h, M2, University of Nice

PhD : Gautier Brèthes, “Multigrilles anisotropes adaptatives”, defended december 10, advisor A. Dervieux

PhD in progress : Ala Taftaf, “Adjoint Automatic Differentiation on High-performance codes”, started july 2013, advisor L. Hascoët.

PhD in progress : Éléonore Gauci, “Norm-oriented criteria for CFD and coupled CSM-CFD systems”, started october 2014, advisor A. Dervieux

Alain Dervieux, jury, PhD defense of Nicolas Barral, University Paris VI, november 27.

Alain Dervieux, jury, PhD defense of Vilas Schinde, X-IMSIA, december 17.

Alain Dervieux and Ala Taftaf participated to the event “la fête de la science” in Antibes, october 10-11.