Cost function and its minimization
In the previous section, spacecraft data were qualitatively compared to the
results of the MHD simulation. To quantify the deviations, a cost function is
introduced. Therefore, the method of least squares is used. The sum of
squared residuals, FQ, of Mdata-measured values ym at points
xm with a model f depending on the parameters s is
FQ:=∑m=1Mdataym-f(xm,s)2.
The parameters s of the MHD model are related to a vector space P.
Here, for simplification, we consider only the planetary magnetic field parameters of the dipole and quadrupole.
Thus, the parameters are
s=(m,Q)T=(mx,my,mz,Qxx,Qxy,Qxz,Qyy,Qyz)T,
with Q:=(Qxx,Qxy,Qxz,Qyy,Qyz)T. The
vector space corresponding to these parameters is named
PD,Q. The parameters of the model s are
estimated by minimizing the sum of squared residuals FQ. Transferred to the
magnetic field observations
Bdata:=(Bx,data,By,data,Bz,data)T
and MHD simulation results
Bsimu:=(Bx,simu,By,simu,Bz,simu)T
with the spacecraft's position in the orbit rSC,m, the cost
function K is
K(s)=∑m=1Mdata(Bx,data(rSC,m)-Bx,simu(rSC,m,s)2+By,data(rSC,m)-By,simu(rSC,m,s)2+Bz,data(rSC,m)-Bz,simu(rSC,m,s)2).
A gradient-based optimization can be used to minimize the cost function with
respect to the parameters of the model s. Starting from a point
s0 in parameter space, new points
sk=(mk,Qk)T are determined with every kth
gradient calculation. This optimization problem is without constraints and
can be solved using a quasi-Newton method. We use the
Broyden–Fletcher–Goldfarb–Shanno (BFGS) algorithm to
minimize the cost function.
The algorithm requires the gradient of the cost function K with respect to
the parameters of the model at points sk in parameter space. There
are different possibilities to compute these gradients. For example, the
gradient can be approximated by difference quotients:
∂K(s)∂s|s=sk≈∑l=1NPK(sk+Δslel)-K(sk)Δslel,
where el denotes the lth unit vector and Δsl is the
corresponding step size in parameter space P. The sum of
Eq. () includes all dimensions in parameter space
(NP:=dim(P)). Note that the gradient
∂sK(s) is used as a column vector. The step sizes
Δsl need to be adequately small to approximate the gradient
sufficiently well.
Automatic differentiation and adjoint method
Each calculation of the cost function for a certain set of parameters
requires a full global MHD simulation of the data along the spacecraft's
trajectory. Thus, (NP+1) simulations have to be performed in
the calculation of the gradient according to Eq. (). In
general, the calculation is extremely time-consuming because of the
nonlinearity of the MHD equations.
Another possibility to calculate the gradient ∂sK(s) is the differentiation using analytical expressions, as explained
in detail in the following. The solution of the MHD simulation depending on
space and time coordinates u(t,x) can be represented by a
vector ut,x on a numerical grid. This vector contains the
solution at all time steps and discrete positions in space for all physical
quantities in its components. Thus, the number of components of the vector
ut,x is
Nv=NvarNgridlmax,
with the constants as defined in the previous chapter. The simulation code
calculates the time- and spatially dependent solution of the MHD quantities
u(t,x) iteratively. The iteration is implemented by a time loop
in the simulation code, whereby u(t=lΔt,x) is computed
from the results of the previous time step u(t=(l-1)Δt,x) and the boundary conditions. Equivalently, the time iteration of
l can be considered as an iteration that steadily improves the approximation
of the final solution vector ut,x , sketched in
Fig. . Thereby, after the lth iteration step, the vector
qt,xl contains the valid solution for all time steps that
satisfy t≤lΔt. The final solution
qt,xlmax=ut,x is obtained
after lmax iteration steps. At the 0th iteration step, the
simulation needs to be initialized. The simulation code calculates the
solution in the lth iteration step from the previous approximation by a
function F. Thus, the lth iteration step can be expressed by
qt,xl(s)=F(qt,xl-1(s)).
The cost function K(qt,xlmax(s)) depends
implicitly on the parameters s. With respect to the nested
dependences of the solution in Eq. (), the gradient of the
cost function can be expressed by the chain rule:
∂K(qt,xlmax(s))∂s=∂K(qt,xlmax)∂qt,xlmax⋅∂qt,xlmax∂qt,xlmax-1⋅…⋅∂qt,x1∂qt,x0⋅∂qt,x0(s)∂s.
This expression contains the stationary solution at l=lst because
0<lst<lmax. Although the cost function is evaluated
only after the stationary state has been obtained, i.e. l>lst, the
cost function also depends implicitly on prior time steps because the
stationary solution emerges from the initial state. The magnetic field
components of the initial state vector ut,x0 depend on the parameters
s because the initial magnetic field distribution in the
simulation is created by the dipole and quadrupole parameters.
Equation () can be written as
The left column sketches the time iteration of the MHD simulation
code starting from the initial state at t=0 determined by the planetary
magnetic field parameters s. At a certain time step, a stationary
solution ust,x is obtained and time iteration continues
using time-dependent solar wind conditions until the simulation ends at
utE,x. In the middle column, the corresponding
interpretation of updating the complete time- and spatially dependent solution
vector qt,x is presented. The cost function K is
calculated from the final vector. On the right side, the automatic
differentiation gradient calculation is presented, starting from the bottom
and multiplying each factor according to Eq. ().
![]()
∂K(s)∂s=gT⋅Almax-1⋅Almax-1-1⋅…⋅A1-1⋅L
using the following abbreviations:
Al-1:=∂qt,xl∂qt,xl-1,l=1,2,…,lmax,gT:=∂K(qt,xlmax)∂qt,xlmax,L:=∂qt,x0(s)∂s.
The function F in Eq. () is determined by the Lax–Wendroff
scheme of the differential equations, which is related to the MHD equations
and the boundary conditions. Therefore, the derivatives of the matrices in
Eq. () can be determined by analytical expressions. The time
iteration of the simulation code starts at l=0 and ends at
lmax. After the lth iteration step, the corresponding matrix
Al-1 can be calculated. Starting from a unit matrix, the
matrix containing the derivatives is multiplied after every time step to the
left side. Finally, after lmax iterations, the gradient ∂K(s)/∂s is obtained.
This procedure is called forward differentiation because the gradient is
calculated parallel to the execution of the time loop in the simulation code.
The advantage over the computation of the gradient using difference quotients
according to Eq. () is that no errors due to finite step
sizes occur. Forward differentiation can be applied by hand to the simulation
code, or alternatively, by an automatic differentiation (AD) tool
. Therefore, the cost function K and its dependent
parameters s need to be declared in the code. The AD tool identifies
all implicit dependences. The required analytical expressions for the
derivations are taken from a library of the AD tool and inserted at the
correct positions in the code. Note that the library contains elementary
analytical derivations of all important expressions such as ∂xsin(x)=cos(x). According to Eq. (), the inserted
expressions are related to each other such that the required gradient is
computed. Several different AD tools were developed during the last decades.
Here, the Transformation of Algorithms in Fortran (TAF) tool
from the company FastOpt was used
(http://www.FastOpt.com).
An AD tool is able to differentiate a numerical code automatically, i.e., the
tool can be applied without considering details of the implementation.
However, for complex numerical codes, such as MHD simulation codes, problems
might occur. For example, codes using parallel computing function calls by
the message-passing interface (MPI), as they are also used for our simulation
code, usually need further treatment. The analytical forward differentiation
with an AD tool is also called automatic forward differentiation.
The computational costs for the calculation of the gradient with difference
quotients or using automatic forward differentiation do not differ much.
However, the latter procedure leads to a more efficient approach, the adjoint
method. The adjoint method is extensively used for optimization problems in
fluid dynamics, e.g., drag minimization by variations in surface geometry
e.g., or in
seismology e.g.,.
The adjoint method can be introduced with systems of linear equations, as
described briefly in the following
e.g.,. The symbols used for
variables, vectors, and matrices refer to the previous considerations and
will be marked by an asterisk as an index for distinction. We consider the
following system of equations
A*⋅X*=L*,
with the matrices of the coefficients A*, the solution X*, and the inhomogeneity L*.
All elements of the matrices are real numbers.
The scalar product of a vector g* with the matrix X* should be calculated using the following equation:
g*T⋅X*=?.
This scalar product can be computed by solving Eq. () first, and then calculating the product of vector g* with the solution X*.
This approach is called forward calculation.
Another possibility is to use the adjoint method. To deduce the method, the
product of a vector yT with both sides of the system of linear
Eq. () is considered:
y*T⋅A*⋅X*=y*T⋅L*.
The vector y* is defined by
y*T⋅A*=g*T.
This equation is transposed, which leads to the adjoint system of equations
A*Ty*=g*.
Using Eqs. () and (), the scalar product (Eq. ) can be written as
g*T⋅X*=y*T⋅A*⋅X*=y*T⋅L*.
If the adjoint system of Eq. () is solved,
y*T⋅L* can be computed, which is nothing
other than
the scalar product (Eq. ) as seen in Eq. ().
The computational costs are mainly determined by the number of multiplications
and differ for both possibilities of calculating the scalar
product (Eq. ). Only in case of a column vector inhomogeneity
L*, is the number of multiplications equal. If the matrix
L* consists of N*,P column vectors,
N*,P systems of linear equations with a vector inhomogeneity
need to be solved in the forward calculation. The adjoint method is
independent of N*,P and only a single system of linear
equations needs to be solved. Therefore, the latter approach requires
N*,P times fewer multiplications.
The adjoint approach can be applied to the calculation of the gradient in
Eq. (). If the product of all matrices
A-1:=Almax-1⋅…⋅A1-1 in Eq. () is substituted, this leads
to
∂K(s)∂s=gT⋅A-1⋅L.
The second product on the right side of Eq. () can be substituted by
X:=A-1⋅L.
This equation can be related to the system of linear Eq. () by
identifying the quantities with an asterisk as an index.
During the analytical forward differentiation, the gradient is computed
successively using chain rule from the right to the left. This corresponds to
a procedure, where, at first, the system of linear Eq. () is
solved with respect to X* and then, the scalar product
(Eq. ) is calculated. If the matrix products of Eq. ()
are computed from left to right, at first, the product
yT:=gT⋅A-1
is determined. This corresponds to solving the adjoint
Eq. () with respect to y*. The scalar product
(Eq. ) is determined by y*T⋅L*, which is
related to the multiplication of yT⋅L to determine
the cost function. Thus, the adjoint method for the gradient calculation of
the cost function can be identified with the execution of the multiplications
from the left to the right in Eq. ().
The dimensions of the vectors and matrices involved are dim(g)=Nv×1, dim(L)=Nv×NP, and dim(A)=Nv×Nv. The calculation of the gradient by computing the matrices from
the right to the left in Eq. () requires Nrl
multiplications of components, whereby
Nrl=Nv2NPNv+1.
If the gradient is calculated from the left to the right in Eq. (), Nlr multiplications of components are performed:
Nlr=Nv2Nv+NP.
The limit NP=1 leads to Nrl=Nlr.
Usually, one can assume NP≪Nv because the number
of grid points exceeds the dimensions of parameter space, which is eight for the
dipole and quadrupole parameters. Then, Eq. () simplifies to
Nlr=NrlNP.
Thus, the multiplication of the matrices in Eq. () from the
left to the right, the adjoint approach, is more efficient for many
parameters and requires about NP times fewer multiplications.
The evaluation procedure for the simulation code is depicted in
Fig. .
However, the numerical implementation of the adjoint method is more difficult
than the analytical forward differentiation. As described, the calculation of
the gradient with the analytical forward differentiation is parallel to the
execution of the time loop in the simulation code. In contrast, the solution
at the last time iteration qt,xlmax has to be
known to calculate gT⋅Almax-1. Thus,
at first, the simulation needs to be performed once, whereby all calculation
results that are required for the matrix multiplications are stored
temporarily. Then, the gradient can be computed according to the adjoint
approach.
There are AD tools that can derive codes not only according to forward
differentiation but also according to the adjoint method. However, the
available memory on a computer is often too small to store all the required
results in the central memory. The memory consumption MMemory can
be estimated by multiplying the number of grid points of the simulation box
Ngrid according to Eq. () with the number of time
steps lmax, the number of MHD variables Nvar, and the
size of a MHD variable Mvar:
MMemory≈NgridlmaxNvarMvar.
The number of variables of the MHD simulation is Nvar=8 and the
size of such a variable is Mvar=4 bytes if a float
variable is assumed. This gives a memory consumption of about
1600 GB for a simulation grid
imax=jmax=kmax=100 and lmax=5×105. The central memory is often much smaller, so that a certain
portion of the variables needs to be stored on the hard disk. However, the
seek time of the central memory is much smaller, and thus, the runtime of the
algorithm becomes longer by storing data on the hard disk.
To minimize the access to the hard disk, checkpointing can be used.
Thereby, the main iteration loop of the algorithm is split at certain checkpoints into smaller loops.
Then, the smaller loop iterates over Nloop,check iterations instead of the complete time loop with lmax iterations.
This reduces the memory requirements for such a loop to
MMemory,check=Nloop,checklmaxMMemory.
The variables during a calculation of such a smaller loop can be stored
within the central memory. After the execution of the smaller loop, the
results are stored to the hard disk to combine all results of the smaller
loop. However, using smaller loops, the adjoint method can only be applied
within these smaller loops. Thus, checkpointing reduces the seek time of the
memory, but the adjoint approach is restricted to a smaller part of the
algorithm. In total, this reduces the runtime of the algorithm, but the
performance is below the theoretical possible performance of the adjoint
approach with unlimited central memory space.
Note that instead of using only observations of a single spacecraft,
simultaneous measurements from multiple spacecraft at different locations can
be calculated in Eq. () as well. This can be done without
additional computational costs and memory capacity because the solution of
the MHD simulation is calculated in the entire simulation domain and stored
anyway.
The relative errors for gradients determined by difference quotients
and the adjoint method for the dipole components. Thereby, on the left side,
different points in parameter space are considered. On the right side, the
dependence of the error on a different number of time iteration steps is
shown.
![]()
The runtime of calculating gradients using the adjoint method
tAdj and using difference quotients tDQ. On the left
side, the dependence on the number of time iteration steps is presented. On
the right side, the ratio of the runtimes is shown.
![]()
Adjoint MHD simulation code
The AD tool applied for an automatic backward differentiation transfers a
numerical code for the calculation of a cost function into an adjoint code,
which can compute the gradient according to the adjoint approach. This was
done for the MHD simulation code presented in the previous chapter by the TAF
tool of the company FastOpt. Thereby, the parameter space of the dipole and
quadrupole parameters PD,Q was considered. Thus, the
adjoint code computes the gradient of the cost function () with
respect to the parameters ().
To validate the adjoint MHD simulation code, the gradients produced by the
adjoint code are compared to those calculated by difference quotients
according to Eq. (). Therefore, at first, the interaction of
the solar wind with the planetary magnetic field is neglected and the
planetary magnetic field represented by its dipole and quadrupole moments is
only taken into account. Gradients at certain points
s0=(0,0,mz,0,0,0,0,0)T in parameter space are considered. Thereby,
the mz component varies between 0.7 and 1.2 mnorm with a
step size of 0.1 mnorm. The spacecraft data
Bdata on a trajectory rSC, required to
calculate the cost function, are generated synthetically along the x axis
between 20.2 and 9 RE with a step size of 0.42 RE.
The gradient of the cost function is calculated using difference quotients
∂s0KDQ and the adjoint method
∂s0KAdj for different s0. The
relative error of the ith component of the gradient is defined by
rel. error:=∂s0KDQ-∂s0KAdj⋅eimax(∂s0KDQ⋅ei,∂s0KAdj⋅ei).
Here, The result of the maximum function max(a,b) is the larger value of a and b and
ei defines the i unit vector. The relative error of the dipole
moment for different s0 is depicted in Fig. . The
error is smaller than 10-4, i.e., both gradients agree for different
values of mz.
Now, the interaction of the planet with the solar wind is taken into account.
Thereby, the gradients calculated by the adjoint method can be compared to
gradients computed by difference quotients for a different number of time
iterations. The corresponding relative errors of the dipole components of the
gradient are shown in Fig. on the right side. It is seen
that the gradients agree very well.
Estimation of planetary moments neglecting the interaction with the
solar wind and using synthetic data. The reconstructions shown in the upper
panels take only a dipole moment into account. These two results consider a
different spacecraft trajectory, with a trajectory closer to the planet
corresponding to the left figure. All reconstructions presented use the same
dipole moment for calculating the synthetic spacecraft data. However, in the
lower panels, an additional quadrupole component was introduced. The
reconstructions in the lower panels use a different choice of the initial
parameters for the estimation.
![]()
To determine the runtime of the adjoint code, the gradient calculations are
performed on a test computer for different numbers of time iteration steps.
The test computer uses 64 GB of central memory and has an Intel Xeon E5
processor with 12 cores and 24 threads at 2.5 GHz. The results are
shown in Fig. on the left side. The runtime of calculating
the gradients increases linearly with the number of iteration steps
performed,
as expected. The plot on the right side presents the ratio of the runtime of
the adjoint code tAdj and the runtime using difference quotients
tDQ. On the test computer, the adjoint method calculates the
gradient about 33 % faster than using the difference quotients. According
to the previous argumentation, eight parameters require nine MHD simulation calls
to determine the gradient with difference quotients of
Eq. (). The adjoint method needs to run the simulation once
to store all necessary results and another simulation run to calculate the
gradient. In Fig. , the first simulation run is shown on the
left side from top to bottom, storing all results in vector representation
presented in the middle. Using these results, the automatic differentiation
procedure calculates the gradient as sketched on the right from bottom to
top,
which corresponds to another simulation run. Thus, in theory, the adjoint
method can be up to 78 % faster than the difference quotient calculation.
However, our adjoint code uses checkpointing because the central memory is
too small, which increases the runtime.
Consequently, the test computer configuration is not optimal to achieve the
best performance. The performance can be improved by using a computer cluster
with distributed memory space. Then, each core can access its own memory
space and checkpointing can be avoided. This can increase the performance.
Furthermore, it should be noted that without additional computational costs and
memory requirements, more parameters can be introduced in the estimation
process of the adjoint approach, such as octupole planetary magnetic field
parameters.