lin_evol_opt_rb_derivative_simulation_separate_bases.m

function simulation_data = lin_evol_opt_rb_derivative_simulation_separate_bases(model, reduced_data)
%function simulation_data = lin_evol_opt_rb_derivative_simulation_separate_bases(model, reduced_data)
%
%performs in parallel a reduced simulation and calculation of the
%derivative @f$\partial_{\mu_i}u@f$
%
% This function is an extension of the \\c lin_evol_rb_simulation function.
% Except that in this method the time step is not included in the
% operators, but the time integration is conducted here by an explicit Euler.
% In parallel to the reduced basis online simulation a calculation of the
% derivative @f$\partial_{\mu_i}u@f$. The derivatives are approximated in
% different reduced spaces than the solution.
%
% It is assumed that the wanted mu is already set in the model.
% (setmu(model,mu))
%
% The calculation of the derivative is made in parallel by solving in each
% time step the ODE @f$\partial_t \partial_{\mu_i} a + L_E \partial_{\mu_i}
% a + \sum \partial_{\mu_i}(\Theta^q(\mu))L^q a -\partial_{mu_i} b(x,t,\mu) =
% 0@f$ plus derivative of the initial conditions.
% All information calculating the derivative is already contained in
% reduced_data or is already calculated for the normal rb_simulation except
% @f$\partial_{\mu_i}\Theta(\mu)@f$ and @f$\partial_{\mu_i}\Theta_b @f$
% which are obtained calling the field \\c model.rb_derivative_operators.
% The field \\c model.rb_derivative_init_values points to a method
% providing derivative initial values.
%
% allowed dependency of data: Nmax, N, M, mu
% not allowed dependency of data: H
% allowed dependency of computation: Nmax, N, M, mu
% not allowed dependency of computation: H
%
% Required fields of model
%  mu_names       : the cell array of names of mu-components and
%                   for each of these strings, a corresponding
%                   field in model is expected.
%  T              : end-time of simulation
%  nt             : number of timesteps to compute
%  error_norm     : 'l2' or 'energy'
%  L_I_inv_norm_bound: upper bound on implicit operator inverse norm
%                  constant in time, a single scalar
%  L_E_norm_bound: upper bounds on explicit operator
%                  constant in time, a single scalar
%  L_E_der_norm_bound: upper bound on explicit derivative operator
%                  constant in time, a single scalar
%  L_I_der_norm_bound: upper bound on implicit derivative operator
%                  constant in time, a single scalar
%  energy_norm_gamma: gamma >= 0 defining the weight in the energy norm
%  coercivity_bound_name : name of the function, which can
%                  computes a lower bound on the coercivity, e.g.
%                  fv_coercivity_bound
%  compute_derivative_info: 0 if no derivative information is needed
%                           1 if derivative information is needed
% 
% plus fields required by coercivity_bound_name.m
%
% optional fields of model:
%  data_const_in_time : if this flag is set, then only operators
%                       for first time instance are computed
%  name_output_functional: if this field is existent, then an
%        output estimation is performed and error.estimtations
%
% generated fields of simulation_data:
%   a: time sequence of solution coefficients, columns are
%      'a(:,k)' = `a^(k-1)`
%   c: matrix(3-dimensional) of time secquence representing the derivative of a for
%   @f$\mu_i@f$
%   Delta:time sequence of `L^2`-posteriori error estimates
%            'Delta(k)' = `\Delta^{k-1}_N`
%         or energy-norm-posterior error estimates
%            'Delta_energy(k)' = `\bar \Delta^{k-1}_N`
%         depending on the field "error_norm" in model.
%
% if model.name_output_functional is set, then additionally, a
% sequence of output estimates 's(U(:,))' and error bound Delta_s is returned
%
% see the ***_gen_reduced_data() routine for specifications of the
% fields of reduced_data

% Markus Dihlmann 25.03.2011

if model.verbose >= 10
    if model.compute_derivative_info
        printf('performing simulation and derivative calculation for mu = %s', mat2str(get_mu(model)));
    else
        printf('performing simulation');
    end
end;

if (~isequal(model.error_norm,'l2')) && ...
      (~isequal(model.error_norm,'energy'))
  error('error_norm unknown!!');
end;

%needed for derivative information
if ~isfield(model,'optimization')
    disp('Model has no field optimization.')
    model.optimization =[];
end
if isfield(model.optimization,'params_to_optimize')
    indx_mu_i = find(model.optimization.params_to_optimize); %indexes i of \mu_i for which derivative information is needed
else
    indx_mu_i = 1:length(get_mu(model));
end
nr_indx_mu_i= length(indx_mu_i); %nr of parameters to be optimized

if isfield(model,'compute_derivative_indices')
    indx_derivatives = find(model.compute_derivative_indices);
else
    indx_derivatives = 1:length(get_mu(model));
end

%cgrid     = grid_geometry(params);
nRB       = length(reduced_data.a0{1});
a         = zeros(nRB,model.nt+1);   % matrix of RB-coefficients
Delta     = zeros(1,model.nt+1); % vector of error estimators
model.dt  = model.T/model.nt;

%debug
res_u     = zeros(1,model.nt+1);
res_u_der     = zeros(1,model.nt+1);
%end debug


if model.compute_derivative_info
    c = cell(nr_indx_mu_i,1);
    c_0 = cell(nr_indx_mu_i,1);
    nRB_der = zeros(1,nr_indx_mu_i);
    Delta_der = zeros(nr_indx_mu_i, model.nt+1); % vector of derivative error estimators
    for i=1:nr_indx_mu_i
        nRB_der(i)=length(reduced_data.c0{indx_mu_i(i)}{1});
        c{i} = zeros(nRB_der(i), model.nt+1); %cell-array of RB-derivative-coefficients
    end
end


% initial data projection and linear combination
model.decomp_mode = 2;
sa0 = rb_init_values(model,[]);
a0 = lincomb_sequence(reduced_data.a0,sa0);
a(:,1) = a0;

if model.compute_derivative_info
    sc_0 = model.rb_derivative_init_values_coefficients(model);
    for i=1:nr_indx_mu_i
        c_0{i} = lincomb_sequence(reduced_data.c0{indx_mu_i(i)},sc_0(indx_mu_i(i),:)'); 
        c{i}(:,1) = c_0{i};
    end
    
    %initialisation of error matrices
    %initialize cells
     L_E_dd = cell(nr_indx_mu_i,1);
     L_I_dd = cell(nr_indx_mu_i,1);
     dL_E_sd = cell(nr_indx_mu_i,1);
     dL_I_sd = cell(nr_indx_mu_i,1);
     db = cell(nr_indx_mu_i,1);
     K_E = cell(nr_indx_mu_i,1);
     K_I = cell(nr_indx_mu_i,1);
     K_EE = cell(nr_indx_mu_i,1);
     %K_Eb = cell(nr_indx_mu_i,1);
     %K_bb = cell(nr_indx_mu_i,1);
     K_II =  cell(nr_indx_mu_i,1);
     %K_Ib = cell(nr_indx_mu_i,1);
     K_IE = cell(nr_indx_mu_i,1);
     K_EdEd = cell(nr_indx_mu_i,1);
     K_IdId = cell(nr_indx_mu_i,1);
     K_bdbd = cell(nr_indx_mu_i,1);
     K_Ed = cell(nr_indx_mu_i,1);
     K_Id = cell(nr_indx_mu_i,1);
     K_bd = cell(nr_indx_mu_i,1);
     K_IEd = cell(nr_indx_mu_i,1);
     K_IId = cell(nr_indx_mu_i,1);
     K_Ibd = cell(nr_indx_mu_i,1);
     K_EEd = cell(nr_indx_mu_i,1);
     K_EId = cell(nr_indx_mu_i,1);
     K_Ebd = cell(nr_indx_mu_i,1);
     K_EdId = cell(nr_indx_mu_i,1);
     K_Edbd = cell(nr_indx_mu_i,1);
     K_Idbd =  cell(nr_indx_mu_i,1);
     
     %fix size for all b-dependent matrices to prevent errors in
     %approximation error calculation
     for i=1:nr_indx_mu_i
         K_bd{i} = zeros(1,nRB_der(i));
         K_Ibd{i} = zeros(nRB_der(i),1);
         K_Ebd{i} = zeros(nRB_der(i),1);
         K_Edbd{i} = zeros(nRB_der(i),1);
         K_Idbd{i} = zeros(nRB,1);
         K_EId{i}  = zeros(nRB_der(i),nRB);
         K_EdId{i} = zeros(nRB,nRB);
         K_I{i}  = 0;
         K_II{i} = 0;
         K_IE{i} = 0;
         K_IdId{i} = 0;
         K_Id{i}   = zeros(nRB_der(i),nRB);
         K_IEd{i}  = zeros(nRB_der(i),nRB);
         K_IId{i}  = zeros(nRB_der(i),nRB);
         
     end
      
end


model.decomp_mode =2;
% loop over time steps: computation of a(t+1)==a^t
for t = 1:model.nt
  model.t = (t-1)*model.dt;
  if model.verbose >= 20
    disp(['entered time-loop step ',num2str(t)]);
  end;

  % linear combination of all quantities
  % only once, if data is const in time
  if (t==1) || (~model.data_const_in_time)
      if model.compute_derivative_info% NEU
        [sLL_I, sLL_E, sbb, sM_E, sM_b, sM_EE, sM_Eb, sM_bb, sM_I, sM_II, sM_IE, sM_Ib, ...
         sL_E_dd, sL_I_dd, sdL_E_sd, sdL_I_sd, sdb,...
         sK_E, sK_I, sK_EE, sK_II, sK_IE,...
        sK_EdEd, sK_IdId, sK_bdbd, sK_Ed, sK_Id, sK_bd, sK_IEd, sK_IId, sK_Ibd, sK_EEd, ...
        sK_EId, sK_Ebd, sK_EdId, sK_Edbd, sK_Idbd] = rb_operators(model,[]);
      else
          [sLL_I, sLL_E, sbb, sM_E, sM_b, sM_EE, sM_Eb, sM_bb, sM_I, sM_II, sM_IE, sM_Ib] ...
           = rb_operators(model,[]);
      end
      
    LL_I = lincomb_sequence(reduced_data.LL_I,sLL_I);
    LL_E = lincomb_sequence(reduced_data.LL_E,sLL_E);
    bb   = lincomb_sequence(reduced_data.bb,sbb);
    M_E  = lincomb_sequence(reduced_data.M_E,sM_E);
    M_b  = lincomb_sequence(reduced_data.M_b,sM_b);
    M_EE = lincomb_sequence(reduced_data.M_EE,sM_EE);
    M_Eb = lincomb_sequence(reduced_data.M_Eb,sM_Eb);
    M_bb = lincomb_sequence(reduced_data.M_bb,sM_bb);
    M_I  = lincomb_sequence(reduced_data.M_I,sM_I);
    M_II = lincomb_sequence(reduced_data.M_II,sM_II);
    M_Ib = lincomb_sequence(reduced_data.M_Ib,sM_Ib);
    M_IE = lincomb_sequence(reduced_data.M_IE,sM_IE);
    

% 
%     if model.data_const_in_time
%       % inverse of implicit matrix! L_I' = Id, L_E' = L_I^(-1) *
%       % L_E, bb = L_I^(-1) bb
%       LL_E = (speye(size(LL_I)) - LL_I) \ LL_E;
%       bb   = (speye(size(LL_I)) - LL_I) \ bb;
%       LL_I = zeros(size(LL_I)); 
%     end;
  end;


  % solve (I-dt*LL_I) a(:,t+1) = (I+dt*LL_E) * a(:,t) + bb
  rhs = (speye(size(LL_E)) + model.dt*LL_E) * a(:,t) + model.dt*bb;
  
  %  warning('this does not work for pure space operators (independent of delta t). In that case use the commented line below.');
  %rhs = a(:,t) + model.dt * (LL_E * a(:,t) + bb);
  % check whether pure explicit problem:
  if isequal(LL_I, zeros(size(LL_I))) 
    a(:,t+1) = rhs;
    %debug 28.10.10: folgende zeile mit reingenommen, damit
    %res_norm_times_dt_sqr ein skalar wird
    M_Ib=zeros(nRB,1);
    % end debug 28.10.10
  else % solve linear system
    a(:,t+1) = (speye(size(LL_I)) - model.dt*LL_I)\rhs;
  end;
  
    
  % compute error estimate recursively
  % Delta^k := |L_I^(k-1)|^-1 * (res_norm(k-1)+
  % |L_E^(k-1)|*Delta^(k-1))
  res_norm_times_dt_sqr =   a(:,t+1)'*a(:,t+1) - 2*a(:,t+1)' * a(:,t) + a(:,t)'*a(:,t) ...
                            +2*model.dt*( a(:,t)'*M_E*a(:,t) - a(:,t)'*M_E*a(:,t+1) ...
                                        +M_b*a(:,t) - M_b*a(:,t+1) ...
                                        +a(:,t+1)'*M_I*a(:,t) - a(:,t+1)'*M_I*a(:,t+1)) ...
                            +((model.dt)^2)* ( a(:,t)'*M_EE*a(:,t) + a(:,t+1)'*M_II*a(:,t+1) + M_bb ...
                                               +2*( a(:,t+1)'*M_IE*a(:,t) +a(:,t)'*M_Eb + a(:,t+1)'*M_Ib));
 
                                           

  % ensure real estimators (could be complex due to numerics)
  if res_norm_times_dt_sqr>=0
    res_norm_times_dt = sqrt(res_norm_times_dt_sqr);
  else
%    keyboard;
    disp('residual < 0')
    res_norm_times_dt = 0;
  end;

  %debug
    res_u(t) = res_norm_times_dt;
  %end debug
  
  if isequal(model.error_norm,'l2')
    Delta(t+1) = res_norm_times_dt + model.L_E_norm_bound * Delta(t);
  else
    % only sum up the squares of the residuals, multiplication with coeff
    % and squareroots are taken at the end.
    keyboard;
    Rkplus1sqr = max(res_norm_sqr/(params.dt.^2), 0);
    Delta(t+1) = Delta(t)+Rkplus1sqr;
  end;
  

  
  
    
  
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  %Calculation of derivative \partial_{\mu}a
  %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  if model.compute_derivative_info
    model.decomp_mode=2;
  
    if (t==1) || (~model.data_const_in_time)
       %[sLi,sLe,sb] = model.rb_derivative_operators_coefficients_ptr(model);
        %sLe = -sLe;
        
        %LL_E_derived=zeros(size(reduced_data.LL_E{1},1),size(reduced_data.LL_E{1},2),nr_indx_mu_i);
        %bb_derived=zeros(length(reduced_data.bb{1}),nr_indx_mu_i);
    
        %LL_E stays the same
        if model.compute_derivative_info
            %[sdL_I_sd,sdL_E_sd,sdb] = model.rb_derivative_operators_coefficients_ptr(model);
            for i=1:nr_indx_mu_i
                if ~isempty(reduced_data.LL_I)
                    %dL_I_sd{i}=zeros(size(reduced_data.dL_I_sd{indx_mu_i(i)}{1},1),size(reduced_data.dL_I_sd{indx_mu_i(i)}{1},2),nr_indx_mu_i);
                    %L_I_dd{i}=zeros(size(reduced_data.L_I_dd{indx_mu_i(i)}{1},1),size(reduced_data.L_I_dd{indx_mu_i(i)}{1},2),nr_indx_mu_i);
                else
                    dL_I_sd{i}=zeros(nRB_der(i),nRB);
                end

                if ~isempty(sK_I) %only do the linear combination if the coefficients sLi are not empty
                    L_I_dd{i}(:,:) = lincomb_sequence(reduced_data.L_I_dd{indx_mu_i(i)}, sL_I_dd(:,:));
                    dL_I_sd{i}(:,:) = lincomb_sequence(reduced_data.dL_I_sd{indx_mu_i(i)}, sdL_I_sd(:,indx_mu_i(i)));                    K_Ibd{i}  = lincomb_sequence(reduced_data.K_Ibd{i} ,sK_Ibd(:,i));
                    K_EId{i}  = lincomb_sequence(reduced_data.K_EId{indx_mu_i(i)} ,sK_EId(:,indx_mu_i(i)));
                    K_EdId{i} = lincomb_sequence(reduced_data.K_EdId{indx_mu_i(i)},sK_EdId(:,indx_mu_i(i)));
                    K_Idbd{i} = lincomb_sequence(reduced_data.K_Idbd{indx_mu_i(i)},sK_Idbd(:,indx_mu_i(i)));
                    K_I{i}  = lincomb_sequence(reduced_data.K_I{indx_mu_i(i)},sK_I);
                    K_II{i} = lincomb_sequence(reduced_data.K_II{indx_mu_i(i)},sK_II);
                    K_IE{i} = lincomb_sequence(reduced_data.K_IE{indx_mu_i(i)},sK_IE);
                    K_IdId{i} = lincomb_sequence(reduced_data.K_IdId{indx_mu_i(i)},sK_IdId(:,indx_mu_i(i)));
                    K_Id{i}   = lincomb_sequence(reduced_data.K_Id{indx_mu_i(i)}  ,sK_Id(:,indx_mu_i(i)));
                    K_IEd{i}  = lincomb_sequence(reduced_data.K_IEd{indx_mu_i(i)} ,sK_IEd(:,indx_mu_i(i)));
                    K_IId{i}  = lincomb_sequence(reduced_data.K_IId{indx_mu_i(i)} ,sK_IId(:,indx_mu_i(i)));
                end

                L_E_dd{i}(:,:) = lincomb_sequence(reduced_data.L_E_dd{indx_mu_i(i)}, sL_E_dd(:,:));
                dL_E_sd{i}(:,:) = lincomb_sequence(reduced_data.dL_E_sd{indx_mu_i(i)}, sdL_E_sd(:,indx_mu_i(i)));
                db{i} = lincomb_sequence(reduced_data.db{indx_mu_i(i)}, sdb(:,indx_mu_i(i)));
                K_E{i}  = lincomb_sequence(reduced_data.K_E{indx_mu_i(i)},sK_E);
                %K_b  = lincomb_sequence(reduced_data.K_b,sK_b);
                K_EE{i} = lincomb_sequence(reduced_data.K_EE{indx_mu_i(i)},sK_EE);
                %K_Eb = lincomb_sequence(reduced_data.K_Eb,sK_Eb);
                %K_bb = lincomb_sequence(reduced_data.K_bb,sK_bb);
                %K_Ib = lincomb_sequence(reduced_data.K_Ib,sK_Ib);
                K_EdEd{i} = lincomb_sequence(reduced_data.K_EdEd{indx_mu_i(i)},sK_EdEd(:,indx_mu_i(i)));
                K_bdbd{i} = lincomb_sequence(reduced_data.K_bdbd{indx_mu_i(i)},sK_bdbd(:,indx_mu_i(i)));
                K_Ed{i}   = lincomb_sequence(reduced_data.K_Ed{indx_mu_i(i)}  ,sK_Ed(:,indx_mu_i(i)));
                K_bd{i}   = lincomb_sequence(reduced_data.K_bd{indx_mu_i(i)}  ,sK_bd(:,indx_mu_i(i)));
                K_EEd{i}  = lincomb_sequence(reduced_data.K_EEd{indx_mu_i(i)} ,sK_EEd(:,indx_mu_i(i)));
                K_Ebd{i}  = lincomb_sequence(reduced_data.K_Ebd{indx_mu_i(i)} ,sK_Ebd(:,indx_mu_i(i)));
                K_Edbd{i} = lincomb_sequence(reduced_data.K_Edbd{indx_mu_i(i)},sK_Edbd(:,indx_mu_i(i)));
                
            end
        end
        
    end  

    % solve d/dt c(:,:,i) = LL_E * c(:,:,i) + LL_E_derived a() +
    % bb_derived
    for i=1:nr_indx_mu_i
        rhs_der = (speye(size(L_E_dd{i})) + model.dt*L_E_dd{i}) * c{i}(:,t) + model.dt*dL_E_sd{i}* a(:,t) ...
                + model.dt*dL_I_sd{i}* a(:,t+1) + model.dt*db{i};
                
         % check whether pure explicit problem:  
        if isequal(LL_I, zeros(size(LL_I))) 
            c{i}(:,t+1) = rhs_der;
        else %solve linear system
            c{i}(:,t+1) = (speye(size(L_I_dd{i})) - model.dt*L_I_dd{i})\rhs_der;
        end
      
      
        %compute error estrimator recuresivly
        res_norm_der_times_dt_sqr = c{i}(:,t+1)'*c{i}(:,t+1) ...
          + c{i}(:,t)'*c{i}(:,t) - 2*c{i}(:,t+1)'*c{i}(:,t) ...
          + 2*model.dt*(-c{i}(:,t+1)'*K_I{i}*c{i}(:,t+1) - c{i}(:,t)'*K_E{i}*c{i}(:,t+1) ...
                        -a(:,t)'*K_Ed{i}*c{i}(:,t+1) - c{i}(:,t+1)'*K_Id{i}*a(:,t+1)...
                        -c{i}(:,t+1)'*K_bd{i}' + c{i}(:,t+1)'*K_I{i}*c{i}(:,t) ...
                        +c{i}(:,t)'*K_E{i}*c{i}(:,t) + a(:,t)'*K_Ed{i}*c{i}(:,t) ...
                        +c{i}(:,t)'*K_Id{i}*a(:,t+1) + c{i}(:,t)'*K_bd{i}' ) ... %13.10.10: bei M_bd aufpassen, nur ein Doppelpunkt?!
          + ((model.dt)^2) * (c{i}(:,t+1)'*K_II{i}*c{i}(:,t+1) + c{i}(:,t)'*K_EE{i}*c{i}(:,t) ...
                              + a(:,t)'*K_EdEd{i}*a(:,t) + a(:,t+1)'*K_IdId{i}*a(:,t+1)...
                              + K_bdbd{i} + 2*c{i}(:,t+1)'*K_IE{i}*c{i}(:,t) ...
                              + 2*c{i}(:,t+1)'*K_IEd{i}*a(:,t) + 2*c{i}(:,t+1)'*K_IId{i}*a(:,t+1)...
                              + 2*c{i}(:,t+1)'*K_Ibd{i} + 2*c{i}(:,t)'*K_EEd{i}*a(:,t) ...
                              + 2*c{i}(:,t)'*K_EId{i}*a(:,t+1) + 2*c{i}(:,t)'*K_Ebd{i} ...
                              + 2*a(:,t)'*K_EdId{i}*a(:,t+1) + 2*a(:,t)'*K_Edbd{i}...
                              + 2*a(:,t+1)'*K_Idbd{i} );                          
   
                          
       
        
    % ensure real estimators (could be complex due to numerics)
    if res_norm_der_times_dt_sqr>=0
        res_norm_der_times_dt = sqrt(res_norm_der_times_dt_sqr);
    else
        res_norm_der_times_dt = 0;
    end;
    
    %debug
    res_u_der(t) = res_norm_der_times_dt;
  %end debug
   
    if isequal(model.error_norm,'l2')
        if model.time_const
            t_old = model.t;
            model.t=0;
        end
       Delta_der(i,t+1) = model.L_E_norm_bound*Delta_der(i,t) + model.L_E_der_norm_bound(model,indx_derivatives(i))*Delta(t) ...
           + model.L_I_der_norm_bound(model,indx_derivatives(i))*Delta(t+1) + res_norm_der_times_dt ;
       if model.time_const
            model.t=t_old;
       end
    end
    
   
    
    end %for i=1:nr_indx_mu
  end %if model.compute_derivative_info
end;

if isequal(model.error_norm,'energy')
  % now perform scaling and squareroot of energy-error-estimate:
  alpha = model.coercivity_bound_ptr(model);
  if max(model.L_E_norm_bound>1) || (alpha == 0)
    % no reasonable estimation possible
    Delta(:) = nan;
  else
    C = (sqrt(1-model.L_E_norm_bound.^2)+1) * 0.5;
    Coeff = model.dt /(4*alpha*C*(1-model.energy_norm_gamma * C));
    Delta = sqrt(Delta * Coeff);
  end;
end;

% return simulation result
simulation_data       = [];
simulation_data.a     = a;
simulation_data.Delta = Delta;
%simulation_data.Delta_rel = Delta./max(u_N_norm);
simulation_data.LL_I  = LL_I;
simulation_data.LL_E  = LL_E;

%debug
simulation_data.res_u = res_u;
simulation_data.res_u_der = res_u_der;
%end debug

if model.compute_derivative_info
    simulation_data.Delta_der = Delta_der;
    simulation_data.c = c;
    %for i=1:size(Delta_der,1)
     %   simulation_data.Delta_der_rel(i,:) = Delta_der(i,:)./max(u_N_der_norm(i,:));
    %end
end

if isfield(model,'name_output_functional')
  if isequal(model.error_norm,'l2')
 
    s = reduced_data.s_RB'*a;
    if isfield(model,'s_l2norm')
        Delta_s = model.s_l2norm * Delta; %war ursprünglich in reduced_data.s_l2norm
        simulation_data.Delta_s = Delta_s(:);
    else
        if (model.verbose >=10)
            disp('warning: no L2_norm for output defined in lin_evol_rb_simulation...')
        end
    end
    simulation_data.s = s(:);
    
    if model.compute_derivative_info
        %derivative output and error estimation of gradient
        %sum=0;%for l2-norm
        for i=1:length(c)
            s_der{i} = c{i}(:,:)'*reduced_data.s_RB_der{indx_mu_i(i)};
            %sum = sum + max(Delta_der(i,:))^2;
        end
        simulation_data.s_der = s_der;
        simulation_data.Delta_s_grad = model.s_l2norm * max(Delta_der,[],2);%sqrt(sum); %Gradient error bound
    
    end
    
  else
    error(['output estimation not implemented concerning energy-norm.' ...
           ' choose l2 as error_norm!']);
  end;
end;