rb_burgers_fem_offline_prep.m

function offline_data = rb_burgers_fem_offline_prep(detailed_data,params)
%function offline_data = rb_burgers_fem_offline_prep(detailed_data,params)
%
% method which produces offline_data, which is the data, that 
% will be passed to an online-algorithm. Therefore, no quantities dependent on 
% the high-dimension H may be included here. Neither may online-data include 
% parameter-dependent mu-quantities. So no complete grid or detailed solutions 
% or reduced basis vectors may be stored here. So online data is
% produced in the offline stage, but may be used in
% online-stages. So the computation time may 
% depend on H, but the results may not depend on this complexity.
%    
% allowed dependency of generated data: Nmax
% not allowed dependency of data: H
% allowed dependency of computation: Nmax, H
% Unknown at this stage: mu, N
%  
% Required fields of params:
%  offline_path: pathname to files outputA_1.bin, outputB_1_1.bin, etc.
%
% optional fields of params:
%  H{q}    : sequence of Nmax-vector components of initial data projection 
%            @f$ \verb|q| = 1 \dots Q_{\mbox{dir}} @f$
%  H1{q}   : sequence of Nmax-vector componentes of udir data projection
%            @f[\verb|q| = 1 \dots Q_{\mbox{dir}} \qquad
%            \verb|H1{q}| = - \int u_{\mbox{dir}}^q \xi_i@f]
%
%  H2{q}   : sequence of Nmax-vector components of u0 initial data projection
%            ``q = 1... Q_dir \qquad
%            H2{q} = \int u_0^q xi_i``
%  M       : matrix of Nmax x Nmax mass matrix entries 
%            `M = \int \xi_i \xi_j`
%  B1{q}   : list of Nmax x Nmax stiffness matrix 
%            ``q = 1... Q_{\eta} \quad
%            \verb|B1{q}| = \int \eta^q (\nabla \xi_i)( \nabla \xi_j)``
%  B2{q1,q2} : array of Nmax x Nmax convection matrices
%            ``q1 = 1... Q_c, q2 = 1.. Q_{dir} \qquad
%            \verb|B2{q1,q2}(i,j)| = \int \nabla \cdot (c^q1 * u_{dir}^q2 * \xi_i) \xi_j``
%  A{q}:     list of Nmax x Nmax x Nmax tensors
%            ``\verb|A{q}(i,j,k)| = \int \nabla \cdot (c^q \xi_i \xi_j) \xi_k \qquad
%            q = 1,... Q_c``
%  G1{q1,q2}: array of Nmax  vectors
%             ``\verb|G1{q1,q2}(i)| =
%               - \int_{\gamma_out} \eta^q1 \cdot \nabla u_{dir}^q2 \cdot n \xi_i \qquad
%            q1 = 1... Q_{\eta}, q2 = 1.. Q_{dir}``
%
%  G2: trivially zero due to missing time dependence
%  G3{q1,q2,q3}: array of Nmax  vectors
%                ``\verb|G3{q1,q2,q3}(i)| = - \int_{\Omega} 2 c^{q1} \cdot
%                                u_{dir}^{q2} \nabla udir^{q3} * \xi_i \qquad
%                q1 = 1... Q_c, q2 = 1.. Q_{dir}, q3 = 1, ..., Q_{(grad)dir}``
%  G4{q1,q2}: array of Nmax  vectors
%             ``\verb|G4{q1,q2}(i)| =  \int_{\Omega} \eta^{q1} \nabla \cdot
%                                      \nabla u_{dir}^{q2} \xi_i \qquad
%             q1 = 1... Q_{\eta}, q2 = 1.. Q_{dir}``
%
% See the detailed-routine for specifications of the fields of detailed_data

% Bernard Haasdonk 16.5.2007

  
% get number of components  

  params.affine_decomp_mode = 'coefficients';
  
  theta_dir = dirichlet_values([],[],params);  
  Q_dir = length(theta_dir);

  theta_eta = diffusivity([],[],params);  
  Q_eta = length(theta_eta); 
  
  theta_c = velocity([],[],params); 
  Q_c = length(theta_c);
  

offline_data = [];

% read H
for q = 1:Q_dir
  fn = fullfile(params.offline_path, ['outputH_',num2str(q),'.bin']);
  offline_data.H{q} = load_dune_binary(fn);
end;

% read H1
for q = 1:Q_dir
  fn = fullfile(params.offline_path, ['outputH_1_',num2str(q),'.bin']);
  offline_data.H1{q} = load_dune_binary(fn);
end;

% read H2
for q = 1:Q_dir
  fn = fullfile(params.offline_path, ['outputH_2_',num2str(q),'.bin']);
  offline_data.H2{q} = load_dune_binary(fn);
end;

% read M
fn = fullfile(params.offline_path, ['outputM.bin']);
offline_data.M = load_dune_binary(fn);

% read B1
for q = 1:Q_eta
  fn = fullfile(params.offline_path, ['outputB_1_',num2str(q),'.bin']);
  offline_data.B1{q} = load_dune_binary(fn);
end;

% read B2
%  B2{q1,q2} : array of Nmax x Nmax convection matrices
%            B2{q1,q2)(i,j) = \int div 2 (c^q1 * u_dir^q2 * xi_i) xi_j
%            q1 = 1... Q_c, q2 = 1.. Q_dir
for q1 = 1:Q_c
  for q2 = 1:Q_dir
    fn = fullfile(params.offline_path, ['outputB_2_',num2str(q1),...
                    '_',num2str(q2),'.bin']);
    offline_data.B2{q1,q2} = load_dune_binary(fn);%
  end;
end;
%%%keyboard;

% read A
for q = 1:Q_c
  fn = fullfile(params.offline_path, ['outputA_',num2str(q),'.bin']);
  offline_data.A{q} = load_dune_binary(fn);
end;

% read G
%  G1{q1,q2}: array of Nmax  vectors
%             G1{q1,q2}(i) = - \int_gamma_out eta^q1 * grad u_dir^q2 * n xi_i 
%            q1 = 1... Q_eta, q2 = 1.. Q_dir
for q1 = 1:Q_eta
 for q2 = 1:Q_dir
  fn = fullfile(params.offline_path, ['outputG_1_',num2str(q1),'_',num2str(q2),'.bin']);
  offline_data.G1{q1,q2} = load_dune_binary(fn);
 end;
end;

%
%  G2: trivially zero due to missing time dependence
%  G3{q1,q2,q3}: array of Nmax  vectors
%                G3{q1,q2}(i) = - \int_Omage 2 c^q1 * 
%                                u_dir^q2 * grad udir^q3 * xi_i  
%                q1 = 1... Q_c, q2 = 1.. Q_dir, q3 = 1, ..., Q_dir
for q1 = 1:Q_c
 for q2 = 1:Q_dir
   for q3 = 1:Q_dir
  fn = fullfile(params.offline_path, ['outputG_3_',num2str(q1),'_',num2str(q2),'_',num2str(q3),'.bin']);
  offline_data.G3{q1,q2,q3} = load_dune_binary(fn);
   end;
  end;
end;



%  G4{q1,q2}: array of Nmax  vectors
%             G4{q1,q2}(i) = \int_Omega eta^q1 * div grad u_dir^q2 * xi_i  
%             q1 = 1... Q_eta, q2 = 1.. Q_dir
%
for q1 = 1:Q_eta
  for q2 = 1:Q_dir
  fn = fullfile(params.offline_path, ['outputG_4_',num2str(q1),'_',num2str(q2),'.bin']);
  offline_data.G4{q1,q2} = load_dune_binary(fn);
  end;
end;

%disp('implement reading of G!!!!');







% TO BE ADJUSTED TO NEW SYNTAX
%| \docupdate