lin_stat_gen_reduced_data.m

function reduced_data = lin_stat_gen_reduced_data(model,detailed_data)
%function reduced_data = lin_stat_gen_reduced_data(model,detailed_data)
%
% function computing reduced data.

% B. Haasdonk 22.2.2011

reduced_data = [];

%Q_A = length(detailed_data.A_comp);
Q_A = size(detailed_data.A_comp,2);
reduced_data.Q_A = Q_A;
%Q_f = length(detailed_data.f_comp);
Q_f = size(detailed_data.f_comp,2);
H = size(detailed_data.f_comp,1); % number of DOFs
reduced_data.Q_f = Q_f;
N = model.get_rb_size(model,detailed_data);
reduced_data.N = N;

% for error estimation:
Q_r = Q_f + N * Q_A;
K_v_r = zeros(H,Q_r);
K_v_r(:,1:Q_f) = detailed_data.f_comp;

% store reduced system matrix components as column vector
reduced_data.AN_comp = zeros(N^2,Q_A);
%Aq_times_RB = zeros(H,Q_A);
for q = 1:Q_A
  % reconstruct sparse system matrix from coeffs+sparsity-pattern:
  Aq_vec = detailed_data.A_comp(:,q);
  i = detailed_data.A_row_indices;
  j = detailed_data.A_column_indices;
  siz = detailed_data.A_size;
  Aq = sparse(i,j,Aq_vec, siz(1), siz(2));
  AqRB = Aq*detailed_data.RB;
  AN_comp_q = detailed_data.RB'*AqRB;
  reduced_data.AN_comp(:,q) = AN_comp_q(:); 
  col_ind = Q_f+(q-1)*N+1;
  K_v_r(:,(col_ind):(col_ind+N-1)) = AqRB;
end;

reduced_data.fN_comp = zeros(N,Q_f);
for q = 1:Q_f
  reduced_data.fN_comp(:,q) = ...
      detailed_data.RB' * detailed_data.f_comp(:,q);
end;

if model.compute_output_functional
%  l_comp = ...
%      model.operators_output(model,detailed_data);
  Q_l = length(detailed_data.l_comp);
  reduced_data.lN_comp = detailed_data.RB' * detailed_data.l_comp;
end;

K = model.get_inner_product_matrix(detailed_data);
v_r = K \ K_v_r;
G = v_r' * K_v_r; 

%%% If we implement improvement of Stephan Rave: 
%v = VecMat.gram_schmidt_reiterate(v_r, K, 1e-12);
%G = v' * K_v_r; 
%%% then also in rb_simulation a change must be applied:
% %without orthonormalization: 

reduced_data.G = G;

% plus error estimation quantities
% G = (v_r^q, v_r^q) = v_r^q' * K * v_r^q
% with {v_r^q}_q = (v_f^q, v_a^q'n)_{q'n}
% G = [Gff, Gfa; Gfa', Gaa];
%
% (v_f^q,v_f^q') = v_f^q' * K * v_f^q
% matrices of coefficient vectors of Riesz-representers:
% K * v_f^q = f^q      (coefficient vector equations)

% old:
%v_f = zeros(size(detailed_data.RB,1),Q_f);
%K_v_f = zeros(size(detailed_data.RB,1),Q_f);
%for q = 1:Q_f
%  K_v_f(:,q) = f_comp{q};
%  v_f(:,q) = K \ f_comp{q};
%end;
%v_a = cell(N,1);
%K_v_a = cell(N,1);
%for n = 1:N
%  K_v_a{n} = zeros(size(K,1),Q_A);
%  v_a{n} = zeros(size(K,1),Q_A);
%  for q = 1:Q_A
%    K_v_a{n}(:,q) = (A_comp{q}*detailed_data.RB(:,n));
%    v_a{n}(:,q) = K \ K_v_a{n}(:,q);
%  end;
%end;
% compute matrix G components = [G_ff, G_fa{n}; G_fa{n}', G_aa{n}];
%reduced_data.Gff = v_f' * K_v_f;
%reduced_data.Gfa = cell(1,N);
%for n = 1:N
%  reduced_data.Gfa{n} = v_f' * K_v_a{n};
%end;
%reduced_data.Gaa = cell(N,N);
%for n1 = 1:N
%  for n2 = 1:N
%    reduced_data.Gaa{n1,n2} = v_a{n1}' * K_v_a{n2};
%  end;
%end;
% finally assemble G = [G_ff, G_fa{n}; G_fa{n}', G_aa{n}];
%Q_r = Q_f + N * Q_A;
%G = zeros(N,N);
%G(1:Q_f,1:Q_f) = reduced_data.Gff;
%for n = 1:N
%  G(1:Q_f,Q_f+(n-1)*Q_A +(1:Q_A)) = ...
%      reduced_data.Gfa{n};
%  G(Q_f+(n-1)*Q_A +(1:Q_A),1:Q_f) = ...
%      reduced_data.Gfa{n}';
%end;
%for n1 = 1:N
%  for n2 = 1:N
%    G(Q_f+(n1-1)*Q_A+(1:Q_A),Q_f+(n2-1)*Q_A +(1:Q_A)) = ...
%       reduced_data.Gaa{n1,n2};
%  end;
%end;
%reduced_data.G = G;

if model.use_scm % when scm shall be used generate offline data here
  if ~isfield(detailed_data, 'A_comp')
    error('The components are required for the SCM to work.');
    %        detailed_data.A_comp = A_comp; % the components are required for the SCM to work
  end
  % Note by Dominik Garmatter 20.09 2012 regarding a problem with this
  % implementation:
  % It makes sense to compute the scm_offline_data in gen_reduced_data, but
  % when generating a reduced basis there might be a call of gen_reduced_data
  % in every step of the basis generation. This will result in multiple
  % generations of scm_offline_data but scm_offline_data is not dependant on
  % the reduced basis and therefore it would be sufficient to compute it only
  % once. But there is no real solution to this problem yet, because one
  % might need the SCM while basis generation (i.e. to compute the error
  % indicators). Otherwise one could disable the SCM while basis generation
  % (model.use_scm = 0) and enable it after basis generation.
  reduced_data.scm_offline_data = scm_offline(model, detailed_data);
end