Introduction to LETKF Data Assimilation

Transcription

1 Introduction to LETKF Data Assimilation David Kuhl and Eric Kostelich AOSC614 November 12, 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 a modified version the LETKF and play with all of the variables and see what happens. For these exercises you will need to write a MATLAB script. So you will need to open up a MATLAB script window, save it to a name, then run the script by typing that name into the MATLAB command prompt window. Set-up the Lorenz 96 Model Step 1. Create a working Matlab directory in your account. mkdir matlab cd matlab Step 2. Download from the website: dkuhl/ two MATLAB scripts: lorenz 96 initialize lorenz 96 cycle and save them in your newly created matlab directory. The files can be found on the left-hand side under AOSC614. You will not be modifying these scripts for this exercise, simply calling them. You of course are welcome to look at them. Step 3. Start Matlab by typing matlab at the command prompt. Then open an editor window (file new M-file). All the following commands will be written and saved to this M-file. Start the script by clearing all previous variables: 1

2 clear all; Step 4. Type in the following settings for the model: % Initialization of Model Variables modelresolution=40; ensemblesize=10; forcing=8.0; timestep=0.05; maxtime=51000; initial_model_perturbation=0.008; initial_ensemble_perturbation=0.01; truth=ones(modelresolution,1)*forcing; ensemble=ones(modelresolution,ensemblesize)*forcing; Modelresolution is the number of points of the model. The model may be thought of as a wave traveling around the globe along a longitude line. 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 5. Call the initialization script for the Lorenz model: % Lorenz 96 initialization script lorenz_96_initialize Step 6. Set up the time-step cycle for the model as a for-loop: % Begin time cycle portion of the code for t=1:maxtime % Begin plotting portion of the code figure(1); plot(truth(:), k- ); 2

3 hold on for j=1:ensemblesize plot(ensemble(:,j), b-- ); % Lorenz 96 cycle advance script lorenz_96_cycle pause hold off 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. Step 7. Now run the model through 20 or so cycles. To do this write the name of your script into the MATLAB command prompt window and press return. To continue to the next time-step you will press return again. Each cycle is equivalent to a quarter of a day. You will see the perturbations grow and expand along the x-axis for the truth as well as all of the ensembles. You may add a counter to the screen which displays the time step in days. For more information on this model see the Lorenz-96 link the to reference on my website under AOSC614- References. Step 8. 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 my website under AOSC614-References) and we will follow the cookbook steps found in the Hunt et. al article starting on page 18. 3

4 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. % Initialization of Observation 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); 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 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 for examble in satellite measurements or radar measurements where one measurement impacts another measurement. 4

5 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. % Create Observation Error Covariance count=0; for j=1:modelresolution if mod(j,(obs_percent/100)^-1) == 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: % Create Observations count=0; for j=1:modelresolution if mod(j,(obs_percent/100)^-1) == 0 count=count+1; 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. 5

6 Set-up a Modified LETKF Algorithm Now we will follow a series of 9 steps as outlined in the Hunt et. al. paper. For coding symplicity we will not be using localization. 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. % Initialization of LETKF Variables 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.10; 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 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 6

7 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: % LETKF Steps 1 and 2 for j=1:modelresolution 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 7

8 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 expensive. 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: % LETKF Step 4 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 8

9 ρ > 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: % LETKF Step 5 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: % LETKF Step 6 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: % LETKF Step 7 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. 9

10 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: % LETKF Step 8 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. % LETKF Step 9 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: Try cutting back on the number of observation points by modifying the obs percent variable. Try 50%, 25% and 10% (note only evenly devisable percentages of 40). 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 be while still tracking 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. 10

11 Run the model out for long time period. What happens to the observations influence on the ensemble? Try modifying the inflation factor rho to 1.01, 1.05, 1.25 (1%, 5% and 25% inflation factors). What happens to ensemble? 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. Also you should run the model out for a long period of time, i.e. months or years. 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. 11