Introduction to Data Assimilation

Transcription

1 Introduction to Data Assimilation Eric Kostelich and David Kuhl MSRI Climate Change Summer School July 21, 2008 Introduction The goal of these exercises is to familiarize you with LETKF data assimilation. We will first set-up the Lorenz 96 model. Then we will create some fake observations to assimilate. Finally we will set-up the LETKF and play with all of the variables and see what happens. The Lorenz 96 Model First we will setup the Lorenz 96 (Lorenz-40) model. Step 1. Download from the website: eric/ two MAT- LAB scripts: lorenz 96 initialize lorenz 96 cycle. Save them to your working MATLAB directory. Step 2. Open a new MATLAB window and clear all previous variables: clear all; Step 3. Type in the following settings for the model: modelresolution=40; ensemblesize=10; forcing=8.0; timestep=0.05; maxtime=51000; initial_model_perturbation=0.008; initial_ensemble_perturbation=0.01; 1

2 truth=ones(modelresolution,1)*forcing; ensemble=ones(modelresolution,ensemblesize)*forcing; Modelresolution is the number of points of the model around a sphere (kindof...). Ensemblesize is the number of ensembles we are using. forcing is the forcing term for the Lorenz 96 model. Timestep is set to represent 0.25 days each time interval. Maxtime is just a limit on this code for how long we can integrate the model. Initial model perturbation is the initial perturbation given to the true solution of the Lorenz 96 model. Initial ensemble perturbation is multiplied by a random gaussian number (mean of 0 and standard deviation of 1) and added to the perturbed model initial condition to produce an ensemble of initial perturbed states. The truth matrix holds the solutions for the current time-step of the model. The ensemble matrix holds the solutions for the current time-step for all of the initially perturbed ensembles. Step 4. Call the initialization script for the Lorenz model: lorenz_96_initialize Step 5. Set up the time-step cycle for the model as a for-loop: for t=1:maxtime figure(1); plot(truth(:), k- ); hold on for j=1:ensemblesize plot(ensemble(:,j), b-- ); hold off lorenz_96_cycle pause This step cycles through time t and plots the truth and the ensembles then cycles to the next time step. The pause is included to add user control to the time steps. Now run the model through 20 or so cycles. You will see the perturbations grow and expand along the x-axis for the truth as well as all of the ensembles. 2

3 You may add a counter to the screen which displays the time step in days with each time cycle equalling 0.25 day. Now fix the axis on the plot with the following code inserted before the hold off command: axis([ ]); In the above plots we see the differences in forecasts from an ensemble of initially perturbed conditions. If you like you can try playing around with any of the model parameters like the ensemble size, initial model perturbation or initial ensemble perturbation. LETKF data assimilation In this section we will apply the LETKF data assimilation sequentially to the Lorenz 96 model. The LETKF data assimilation technique is described in Hunt et. al (available on Eric s website) and we will follow the cookbook steps found in the Hunt et. al article starting on page 18. Above we plotted the model truth in black and the set of ensemble solutions in blue. From the truth we will create a set of observations at each of the model grid points. These observations will be randomly perturbed from the true state. The observations will need to be created each step of the model cycle. In this way we simulate a continuous collection of observations. Observations First we include at the top of the script the initialization of the observation variables: observation error, observation array, observation error covariance matrix and associated variables. obs_percent=100; number_observations=round(modelresolution*(obs_percent/100)); observation_error=0.5; observations=zeros(number_observations,1); plot_observations=zeros(modelresolution,1); R=zeros(number_observations,number_observations); I=eye(modelresolution); H=zeros(number_observations,modelresolution); 3

4 The obs percent variable sets the number of observations relative to the model resolution. We will start with 100% where we will have an observation at every model grid point. The number observations is set based upon the modelresolution and obs percent. The observation error variable sets the amount of error we will perturb the model truth by. The observation error variable is multiplied by a gaussian random number with mean 0 and standard deviation 1 and added to the model truth. The observations vector holds the observations. The plot observations vector holds the observations to plot on the figure. R is the observation error covariance matrix. I is simply an identity matrix the size of the model resolution. H is the observation operator matrix which will transform from the model space into the observation space. Next we create the observation error covariance matrix which we will assume is constant and diagonal. This can be thought of as the error of making a measurement, like the error of reading a thermometer. Since this matrix is diagonal we are assuming the error of one measurement is completely indepent of any other measurement. This is not always true however, like in satellite measurements or radar measurements where one measurement impacts another measurement. Also in this step we create the H-operator matrix which we will use to transform from the model space into the observation space. Insert the following code just after the initialization of the observation variables outside of the cycle. We insert this outside of the cycle since we assume the errors of the observations and the H-operator is constant over time. count=0; for j=1:modelresolution if mod(j,obs_count) == 0 count=count+1; R(count,count)=observation_error; H(count,:)=I(j,:); Finally we create the observations within the time cycle before plotting the figure. To do this we insert the following code: count=0; for j=1:modelresolution if mod(j,obs_count) == 0 count=count+1; 4

5 plot_observations(j)=truth(j)+observation_error*randn(1); observations(count)=truth(j)+observation_error*randn(1); else plot_observations(j)=nan; To check the code we plot the observations by inserting the following code before the hold off command: plot(plot_observations(:), r* ); Run the model out for 20 or so time-steps to see the observations dance around the model truth. You can try modifying the observation error to see the points move closer and farther from the truth. LETKF Algorithm Now we will follow a series of 9 steps as outlined in the Hunt et. al. paper. For this implementation we will not be using localization. This simplifies the implementation. I will quote the Hunt paper at each step and then I will follow the quote with the code to insert into MATLAB. Before we begin we need to initialize several variables which we will be using in the LETKF at the top of the script. Insert the following code after the initialization of the observation variables outside of the time cycle loop. xb_bar=zeros(modelresolution,1); Xb=zeros(modelresolution,ensemblesize); yb_bar=zeros(number_observations,1); Yb=zeros(number_observations,ensemblesize); C=zeros(ensemblesize,number_observations); rho=1.01; Pa_bar=zeros(ensemblesize,ensemblesize); Wa=zeros(ensemblesize,ensemblesize); xb bar is the sample mean of the background ensemble. Xb is the difference between the background ensemble and the mean of the background ensemble. yb bar is the mean of the background ensemble in observation space. Yb is the difference between the background ensemble and the mean of the background ensemble in observation space. C is an intermediate calculated quantity 5

6 for the LETKF. rho is the mutiplicitve inflation factor which can be tuned to the model (1.01 represents a 1% inflation factor, 1.10 would be a 10% inflation factor). Pa bar is the average analysis error covariance matrix. Wa is the weighting matrix. The nomenclature used in the Hunt et. al paper has m=modelresolution, k=ensemblesize and l =number of observations. In the Hunt et al paper the subscript g signfies the input reflecting the global model state and all available observations. Again, for this example we will not be performing the localization. If we were performing a localization then m=localization size and m =modelresolution. I suggest you first read the non-italicised text and insert the code for all of the steps to get your script running first. Then, with your working code, go back and look at Hunt et. al s explanation of each step carefully. Step 1: From Hunt et. al: Apply H to each x b(i) to form the global background observation ensemble y b(i), and average the latter vectors to get the l - dimensional column vector ȳ b. Subtract this vector from each yb(i) to form the columns of the l k matrix Y b. (This subtraction can be done in place, since the vectors yb(i) are no longer needed.) This requires k applications of H, plus 2kl (floatingpoint) operations. If H is an interpolation operator that requires only a few model variables to compute each observation variable, then the total number of operations for this step is proportional to kl times the average number of model variables required to compute each scalar observation. In this case our H linear so we can combine steps 1 and 2. See the note in step 2. Step 2: From Hunt et. al: Average the vectors x b(i) to get the m -dimensional vector x b, and subtract this vector from each xb(i) to form the columns of the m k matrix X b. (Again the subtraction can be done in place; the vectors xb(i) are no longer needed). This step requires a total of 2km operations. (If H is linear, one can equivalently perform Step 2 before Step 1, and obtain ȳ b and Y b by applying H to x b and X b.) Into the cycle, after the creation of the observations and observation operator, we insert the following code to calculate xb bar, Xb, yb bar and Yb: for j=1:modelresolution 6

7 xb_bar(j)=mean(ensemble(j,:)); for i=1:ensemblesize Xb(j,i)=ensemble(j,i)-xb_bar(j); yb_bar=h*xb_bar; Yb=H*Xb; Step 3: From Hunt et. al: This step selects the necessary data for a given grid point (whether it is better to form the local arrays described below explicitly or select them later as needed from the global arrays deps on ones implementation). Select the rows of average(x b ) and Xb corresponding to the given grid point, forming their local counterparts: the m-dimensional vector average(x b ) and the m k matrix X b, which will be used in Step 8. Likewise, select the rows of average(y b and Y b corresponding to the observations chosen for the analysis at the given grid point, forming the l dimensional vector average(y b ) and the l k matrix Y b. Select the corresponding rows of y o and rows and columns of R to form the l dimensional vector y o and the l l matrix R. (For a high-resolution model, it may be reasonable to use the same set of observations for multiple grid points, in which case one should select here the rows of X b and ( xb corresponding to all of these grid points.) This is the localization step so for our implementation this step is skipped since we will be a local region of size 40 (or the entire grid). Step 4: From Hunt et. al: Compute the k l matrix C = (Y b ) T R 1. If desired, one can multiply entries of R 1 or C corresponding to a given observation by a factor less than one to decrease (or greater than one to increase) its influence on the analysis. (For example, one can use a multiplier that deps on distance from the analysis grid point to discount observations near the edge of the local region from which they are selected; this will smooth the spatial influence of observations, as described in Section 2.3 under Local Implementation.) Since this is the only step in which R is used, it may be most efficient to compute C by solving the linear system RC T = Y b rather than inverting R. In some applications, R may be diagonal, but in others R will be block diagonal with each block representing a group of correlated observations. As long as the size of each block is relatively small, inverting R or solving the linear system above will not be computationally expen- 7

8 sive. Furthermore, many or all of the blocks that make up R may be unchanged from one analysis time to the next, so that their inverses need not be recomputed each time. Based on these considerations, the number of operations required (at each grid point) for this step in a typical application should be proportional to kl, multiplied by a factor related to the typical block size of R. Into the cycle, after Step 2, we insert the following code to calculate the intermediate calculated variable C: C=Yb *R^-1; Step 5: From Hunt et. al: Compute the k k matrix P a = [(k 1)I/ρ +CY b ] 1, as in (21). Here rho 1 is a multiplicative covariance inflation factor, as described at the of the previous section. Though trying some of the other approaches described there may be fruitful, a reasonable general approach is to start with ρ > 1 and increase it gradually until one finds a value that is optimal according to some measure of analysis quality. Multiplying C and Yb requires less than 2k 2 l operations,while the number of operations needed to invert the k k matrix is proportional to k 3. Into the cycle, after Step 4, we insert the following code to calculate the average analysis error covariance matrix: Pa_bar=(((ensemblesize-1)*eye(ensemblesize))/rho+C*Yb)^-1; Step 6: From Hunt et. al: Compute the k k matrix W a = [(k 1) P a ] 1/2, as in (24). Again the number of operations required is proportional to k 3 ; it may be most efficient to compute the eigenvalues and eigen- vectors of (k 1)I/ρ +CY b in the previous step and then use them to compute both P a ) and W a. Into the cycle, after Step 5, we insert the following code to calculate the weighting matrix: Wa=((ensemblesize-1)*Pa_bar)^0.5; Step 7: From Hunt et. al: Compute the k-dimensional vector w a = Pa C (y o ȳ b ), as in (20), and add it to each column of W a, forming a k k matrix whose columns are the analysis vectors w a(i). Computing the formula for w a from right-to-left, the total number of operations required for this step is less than 3k(l + k). Into the cycle, after Step 6, we insert the average weighting matrix and the local weight matrix: 8

9 wa_bar=pa_bar*c*(observations-yb_bar); for j=1:ensemblesize wai(:,j)=wa(:,j)+wa_bar; Step 8: From Hunt et. al: Multiply X b by each w a(i) and add x b to get the analysis ensemble members x a(i) at the analysis grid point, as in (25). This requires 2k 2 m operations. Into the cycle, after Step 7, we insert the following code to calculate our analysis result for each ensemble. This calculates the LETKF analysis result: temp=xb*wai; for j=1:ensemblesize xai(:,j)=xb_bar+temp(:,j); Step 9: From Hunt et. al: After performing Steps 38 for each grid point, the outputs of Step 8 form the global analysis ensemble x a(i). In this case, since we are operating without localization, this step is skipped. This step simply stitches back together all our results from all of the local regions into a global result. Now after adding in all of the LETKF steps into our forecast cycle we now need to update our background. To do this insert the following code after Step 9 to update the background ensemble. ensemble(:,:)=xai(:,:); Cross your fingers and run the code 20 or so steps to see what the affect of assimilating the data has on the analysis. You should see the background ensemble now tracks the truth. Feel free to manipulate different variables like the observation error and the covariance inflation factor (ρ). What happens to the results? Now modify the inital ensemble perturbation and see how quickly the ensemble tracks back to the truth. Go back and look at the Hunt et. al explanation of each step. Playing with the model: 9

10 Try cutting back on the number of observation points by modifying the obs percent variable. Try 50%, 25% and 10%. How many observations do we need. Inflate the error of our observations by modifying the observation error variable. How bad can the observations and the analysis still tracks the truth? Try modifying the number of ensembles used. How many ensembles are necessary to have the analysis still track the truth? Remember that it costs a lot of computational time to calculate each of the ensembles. For take home problems you can also track the RMS error between the ensemble mean of the analysis and the truth. Then quantify the effects from making the above changes to the code. For calculating the RMS errors you should throw out the first several steps of the analysis as the model is spinning up. Another take home suggestion is to modify the the truth used to calculate the observations and insert a bias to the observations. Finally, if you are very ambitious, you can modify the code to perform the localization steps of the LETKF. 10