ReducedData.m

classdef ReducedData < Greedy.User.IReducedDataNode
  % Reduced data implementation for linear evolution problems with finite
  % volume discretizations
  %
  % See @ref HO08a for details on the implementation of the reduced matrices
  % and vectors.


  properties
    % Dof vectors of projections `\left\{{ \cal P }_{\text{red}}[u_0^q]
    % \right\}_{q=1}^{Q_{u_0}}`.
    %
    % @sa LinEvol.ReducedModel.rb_init_values() for details.
    a0;

    % `Q_I` reduced matrix for implicit operator `{\cal L}_{h,I}`
    %
    % The matrix entries are:
    % ``({ \bf L}_I^q)_{ij} = \int \varphi_i {\cal L}^q_{h,I}[\varphi_j]``
    % for `i,j=1,\ldots,N` and `q=1,\ldots,Q_I`.
    LL_I;

    % `Q_E`-sequence of reduced matrices for explicit operator `{\cal L}_{h,E}`
    %
    % The matrix entries are:
    % ``({ \bf L}_E^q)_{ij} = \int \varphi_i {\cal L}^q_{h,E}[\varphi_j]``
    % for `i,j=1,\ldots,N` and `q=1,\ldots,Q_E`.
    LL_E;

    % `Q_b`-sequence of reduced vectors for constant contributions `b_h`
    %
    % The matrix entries are:
    % ``({ \bf b})_{i} = \int \varphi_i b^q_h``
    % for `i=1,\ldots,N` and `q=1,\ldots,Q_b`.
    bb;

    % `Q_I \cdot Q_I`-sequence of gram matrices
    %
    % The matrix entries are:
    % ``({ \bf K}_{II}^{q_1,q_2})_{ij} = \int {\cal L}^{q_1}_{h,I}[\varphi_i] {\cal L}^{q_2}_{h,I}[\varphi_j]``
    % for `i,j=1,\ldots,N` and `q_1,q_2=1,\ldots,Q_I`.
    K_II;

    % `Q_I \cdot Q_E`-sequence of gram matrices
    %
    % The matrix entries are:
    % ``({ \bf K}_{IE}^{q_1,q_2})_{ij} = \int {\cal L}^{q_1}_{h,I}[\varphi_i] {\cal L}^{q_2}_{h,E}[\varphi_j]``
    % for `i,j=1,\ldots,N` and `q_1=1,\ldots,Q_I, q_2=1,\ldots,Q_E`.
    K_IE;

    % `Q_E \cdot Q_E`-sequence of gram matrices
    %
    % The matrix entries are:
    % ``({ \bf K}_{EE}^{q_1,q_2})_{ij} = \int {\cal L}^{q_1}_{h,E}[\varphi_i] {\cal L}^{q_2}_{h,E}[\varphi_j]``
    % for `i,j=1,\ldots,N` and `q_1,q_2=1,\ldots,Q_E`.
    K_EE;

    % `Q_I \cdot Q_b`-sequence of vectors
    %
    % The vector entries are:
    % ``({ \bf m}_I^{q_1,q_2})_i = \int {\cal L}^{q_1}_{h,I}[\varphi_i] b_h^{q_2}``
    % for `i=1,\ldots,N` and `q_1=1,\ldots,Q_I, q_2=1,\ldots,Q_b`.
    m_I;

    % `Q_E \cdot Q_b`-sequence of vectors
    %
    % The vector entries are:
    % ``({ \bf m}_E^{q_1,q_2})_i = \int {\cal L}^{q_1}_{h,E}[\varphi_i] b_h^{q_2}``
    % for `i=1,\ldots,N` and `q_1=1,\ldots,Q_E, q_2=1,\ldots,Q_b`.
    m_E;

    % `Q_b \cdot Q_b`-sequence of scalars
    %
    % The scalars are:
    % ``{ \bf m}^{q_1,q_2} = \int b_h^{q_1} b_h^{q_2}``
    %  and `q_1,q_2=1,\ldots,Q_b`.
    m;

    % in case of output functional this is a `Q_s`-sequence of vectors.
    %
    % The vector entries are:
    % ``({ \bf s}^q)_i = s(\varphi_i)``
    % for `i=1,\ldots,N` and `q_1=1,\ldots,Q_s`
    s_RB;

    % in case of output functional this is a `Q_s`-sequence of scalars.
    %
    % The scalars are:
    % ``{ \bf s}_{l^2}^q = \|s(\varphi_1), \ldots, s(\varphi_N)\|_{l^2}``
    % for `q_1=1,\ldots,Q_s`
    s_l2norm;
  end

  properties (SetAccess = private, Dependent)
    % number of reduced basis vectors stored in this data node.
    N;
  end

  properties (SetAccess = private)
    % number of collateral reduced basis vectors stored in this data node.
    M = 0;
    % number of collateral reduced basis vectors used for error estimation
    Mstrich = 0;
  end

  methods

    function rd = ReducedData(rmodel, detailed_data)
      % Constructor for the generation of the reduced matrices and vectors.
      %
      % Parameters:
      %  rmodel: of type LinEvol.ReducedModel
      %  detailed_data: of type IDetailedData
      %
      %
      if nargin == 0
        error('LinEvol.ReducedData constructor needs an argument');
      elseif nargin == 2 && isa(rmodel, 'IReducedModel') ...
          && isa(detailed_data, 'LinEvol.ReducedData')
        copy = detailed_data;
        copy_extract(rd, copy, rmodel);
      elseif nargin == 2 && isa(rmodel, 'IReducedModel') && isa(detailed_data, 'IDetailedData')
        fill_fields(rd, rmodel, detailed_data);
      else
        error('Did not find constructor for your arguments');
      end
    end

    function N = get.N(this)
      if ~isempty(this.a0)
        N = size(this.a0{1},2);
      else
        N = 0;
      end
    end

    function yesno = needs_subset_copy(this, rmodel)
      % function yesno = needs_subset_copy(this, rmodel)
      % @copybrief .Greedy.User.IReducedDataNode.needs_subset_copy()
      %
      % @copydetails .Greedy.User.IReducedDataNode.needs_subset_copy()
      %
      % Parameters:
      %   rmodel: of type LinEvol.ReducedModel

      yesno = this.N ~= rmodel.N;
    end


    function conds = get_conds(this)
      disp('get_conds needs to be implemented for LinEvol.ReducedData');
      conds = [];
    end

  end

  methods (Access=private)
    function fill_fields(this, rmodel, detailed_data)
      % function fill_fields(this, rmodel, detailed_data)

      this.a0 = rb_init_values_separable(rmodel, detailed_data, 1);
      [this.LL_I, this.LL_E, this.bb, ...
       this.K_II, this.K_IE, this.K_EE, ...
       this.m_I, this.m_E, this.m ] ...
        = LinEvol.ReducedData.rb_operators(rmodel, detailed_data, 1);
      if isfield(rmodel.descr,'output_function_ptr')
        d = rmodel.descr;
        md = detailed_data.model_data;
        [OO, this.s_l2norm] = d.operators_output(d, md);
        this.s_RB = OO' * detailed_data.RB;
      end
    end

    function copy_extract(this, copy, rmodel)
      % function copy_extract(this, copy, rmodel)
      % @copybrief IReducedModelextract_reduced_data_subset()
      %
      % Parameters:
      %  rmodel: reduced model of type LinEvol.ReducedModel indicating the
      %          number of reduced basis vectors to be used in the
      %          'reduced_data_subset'

      % extract correct N-sized submatrices and subvectors from reduced_data
      if rmodel.N > copy.N
        error('N too large for current size of reduced basis!');
      end

      N = rmodel.N;
      this.a0   = subblock_sequence(copy.a0,1:N);
      this.LL_I = subblock_sequence(copy.LL_I,1:N,1:N);
      this.LL_E = subblock_sequence(copy.LL_E,1:N,1:N);
      this.bb   = subblock_sequence(copy.bb,1:N);
      this.K_EE = subblock_sequence(copy.K_EE,1:N,1:N);
      this.K_IE = subblock_sequence(copy.K_IE,1:N,1:N);
      this.K_II = subblock_sequence(copy.K_II,1:N,1:N);
      this.m_I  = subblock_sequence(copy.m_I,1:N);
      this.m_E  = subblock_sequence(copy.m_E,1:N);
      this.m    = copy.m;
      %        if ~isempty(copy.T)
      %          this.T    = copy.T(1:N,1:N);
      %        end

      model = rmodel.detailed_model;
      if isfield(model,'name_output_functional')
        this.s_RB = copy.s_RB(1:N);
        this.s_l2norm = copy.s_l2norm;
      end

    end
  end

  methods(Static)
    %
    %
    % Parameters:
    %   rmodel        : of type LinEvol.ReducedModel
    %   detailed_data : of type Greedy.DataTree.Detailed.RBLeafNode
    [LL_I, LL_E, bb, K_II, K_IE, K_EE, m_I, m_E, m] = rb_operators(rmodel, detailed_data, decomp_mode);
  end
end