rb_operators.m

function [LL_I, bb_I] = rb_operators(rmodel, detailed_data, decomp_mode)
%function [LL_I, bb_I] = rb_operators(rmodel, detailed_data, decomp_mode)
% function computing the time-dependent reduced basis operator and
% vector. If the decomposition mode is 'coefficients' (2), the detailed data
% are superfluous, can (and should for `H`-independence) be empty.
%
% required fields of descr:
%   implicit_operators_algorithm: function_handle for computing the
%                 'L_I','b_I'-operators with arguments '(grid, params)'.
%                 c.f. for example fv_operators_implicit()
%   inner_product_name: name of inner-product function for
%                     discrete function l2-scalar-product
%
% Return values:
%   LL_I: matrix, components or coefficients for implicit operator.
%   bb_I: vector, components or coefficients for affine shift of implicit operator.
%
% Parameters:
%   detailed_data: of type ::GreedyDataTreeDetailed.RBLeafNode

% Bernard Haasdonk 23.7.2006

% determine affine_decomposition_mode as integer
%decomp_mode = get_affine_decomp_mode(model);

model = rmodel.descr;
model.decomp_mode = decomp_mode;

if decomp_mode == 2

  [L_I, b_I] = model.implicit_operators_algorithm(model, []);

  % rb-operator coefficients can simply be forwarded
  LL_I = L_I;
  bb_I = b_I;

else

  model_data = detailed_data.model_data;

  if decomp_mode == 0 % complete: simple projection on RB

    A = model_data.W;

    RBtranspA = detailed_data.RB' * A;

  %  if isequal(params.model_type, 'implicit_nonaffine_linear')
  %    L_I = detailed_data.implicit_operator;
  %    b_I = detailed_data.implicit_constant;
  %  else
    [L_I, b_I] = model.implicit_operators_algorithm(model, model_data);
  %  end

    % apply all operator contributions to RB:
    L_I_RB = L_I * detailed_data.RB;

    % fill output quantities
    %    LL_I    :  matrix
    LL_I = RBtranspA * L_I_RB;

    %    bb      :  vector
    bb_I = RBtranspA * b_I;

  elseif decomp_mode == 1

    if model.newton_solver || model.implicit_nonlinear
      %      disp('what is the use of the flag implicit_nonlinear ??');
      %    [dummy, b_I{1}] = fv_operators_diff_implicit(model, detailed_data, [], []);
      L_I = cell(0,1);
      b_I = cell(0,1);
    else
      [L_I, b_I] = model.implicit_operators_algorithm(model, ...
                                                      model_data);
    end

    Q_L_I = size(L_I,1);
    Q_b_I = length(b_I);

    RB = detailed_data.RB;
    Nmax = size(RB,2);
    A = model_data.W;

    RBtranspA = RB' * A;

    % init output quantities
    % vectors:
    bb_I = cell(Q_b_I,1);
    bb_I(:) = {zeros(Nmax,1)};
    % matrices:
    LL_I = cell(Q_L_I,1);
    LL_I(:) = {zeros(Nmax,Nmax)};

    % apply all operator contributions to RB:
    L_I_RB = cell(Q_L_I,1);
    L_I_RB(:) = {zeros(size(RB))};
    for q=1:Q_L_I
      L_I_RB{q}(:,:)= L_I{q} * RB;
    end;

    % fill output quantities
    %    LL_I    :  matrices
    for q = 1:Q_L_I;
      LL_I{q} = RBtranspA * L_I_RB{q};
    end;

    %    bb_I      :  vectors
    for q = 1:Q_b_I;
      bb_I{q} = RBtranspA * b_I{q};
    end;

  end
end;

%| \docupdate