rbasis/+NonlinEvol/EiRbReducedDataNode.m

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

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

    % `Q_I` reduced matrix for implicit operator `{\cal L}_{h,I}` if it is
    % affinely decomposable.
    %
    % 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_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_I;

    % reduced basis mass matrix.
    %
    % The matrix entries are:
    % ``({ \bf M })_{ij} = \int \varphi_i \varphi_j``
    % for `i,j=1,\ldots,N`
    Nmass;

    % empirical interpolation matrix `{\bf B}`
    %
    % The matrix entries are:
    % ``({\bf B})_{ij} = q_i(x_j)``
    % for `1 \leq i \leq j \leq N` and vanish elsewhere.
    BM;

    % local grid of type .gridbase with added neighbours such that a sparse
    % evaluation of the empirically interpolated operators in the interpolation
    % points is possible on this grid.
    grid_local_ext;

    % synonym for #grid_local_ext of type .gridbase
    grid;

    % indices of grid entities in the #grid_local_ext structure where the
    % interpolation points are situated.
    TM_local;

    % indices of grid entities in the the global grid structure where the
    % interpolation points are situated.
    TM_global;

    % empirical interpolation mass matrix.
    %
    % The matrix entries are:
    % ``({ \bf M })_{ij} = \int q_i q_j``
    % for `i,j=1,\ldots,M`
    Mmass;

  end

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

    % number of collateral reduced basis vectors stored in this data node.
    M;

    % number of collateral reduced basis vectors used for error estimation.
    Mstrich;
  end

  properties
    % handle of object of type NonlinEvol.RbReducedDataNode storing all reduced
    % magnitudes based only on the reduced basis.
    rb_rd;

    % handle of object of type NonlinEvol.EiReducedDataNode storing all reduced
    % magnitudes based only on the collateral reduced basis.
    ei_rd;


    % "transition" mass matrix
    %
    % The matrix entries are:
    % ``({ \bf D })_{ij} = \int q_i \varphi_j``
    % for `i=1,\ldots,M, j=1,\ldots,N`
    DE;

    % empirical interpolation matrix for operator with projection to reduced
    % basis space with `M+M'` basis vectors.
    %
    % This matrix is the solution `{\bf C}`of the equation system
    % ``{ \bf B C } = { \bf D }``
    % with @ref #BM "empirical interpolation matrix" `{ \bf B }` and @ref #DE
    % "transition matrix" `{\bf D}`.
    %
    % In case you have a vector of interpolation evaluations `\bf l` at
    % interpolation points, the interpolation can the be calculated as
    % ``{\bf C l}``.
    CE;

    % empirical interpolation matrix for operator with projection to reduced
    % basis space for the empirical interpolation with only `M` basis vectors.
    %
    % See also: #CE
    CE_red;

    % restriction of the reduced basis vectors to interpolation DOFs of the
    % local grid #grid_local_ext.
    RB_local_ext;
  end

  methods
    function rd = EiRbReducedDataNode(rb_reduced_data, rb_detailed_data, ...
                                      ei_reduced_data, ei_detailed_data)
      % Constructor for the generation of the reduced matrices and vectors.
      %
      % Parameters:
      %  rb_reduced_data: pure reduced basis reduced data structure of type NonlinEvol.RbReducedDataNode
      %  rb_detailed_data: detailed data structure of type Greedy.DataTree.Detailed.RbLeafNode
      %                    storing the reduced basis.
      %  ei_reduced_data: pure EI reduced data structure of type NonlinEvol.EiReducedDataNode
      %  ei_detailed_data: detailed data structure of type Greedy.DataTree.Detailed.EiLeafNode
      %                    storing the collateral reduced basis.
      if isa(rb_reduced_data, 'NonlinEvol.EiRbReducedDataNode')
        copy = rb_reduced_data;
      else
        copy = [];
      end
      rd = rd@Greedy.User.IReducedDataNode(copy);
      if nargin == 0
        error('NonlinEvol.EiRbReducedDataNode constructor needs an argument');
      elseif nargin == 4 && isa(rb_reduced_data, 'IReducedModel') ...
          && isa(rb_detailed_data, 'NonlinEvol.EiRbReducedDataNode')
        rmodel = rb_reduced_data;
        copy   = rb_detailed_data;
        copy_extract(rd, copy, rmodel, ei_reduced_data, ei_detailed_data);
      elseif nargin == 4
        fill_fields(rd, rb_reduced_data, rb_detailed_data, ei_reduced_data, ei_detailed_data);
      else
        error('Did not find constructor for your arguments');
      end
    end

    function conds = get_conds(this)
      conds_rb = get_conds(this.rb_rd);
      conds_ei = get_conds(this.ei_rd);
      if ~isempty(this.CE)
        conds.CE     = condest(this.CE);
      end
      if ~isempty(this.CE_red)
        conds.CE_red = condest(this.CE_red);
      end
      conds = structcpy(conds_rb, conds_ei);
    end

    function c = copy(this)
      c = NonlinEvol.EiRbReducedDataNode(this);
    end
  end

  methods(Access=private)

    function fill_fields(this, rb_red, rb_det, ei_red, ei_det)
      this.rb_rd = rb_red;
      this.ei_rd = ei_red;

      A       = rb_det.model_data.W;
      this.DE = rb_det.RB' * A * ei_det.QM;

      this.RB_local_ext = rb_det.RB(this.ei_rd.TM_global, :);
    end

    function copy_extract(this, copy, rmodel, rb_reduced_data, ei_reduced_data)
      MM                  = rmodel.M + rmodel.Mstrich;
      this.rb_rd = rb_reduced_data;
      this.ei_rd = ei_reduced_data;

      this.DE           = copy.DE(1:rmodel.N, 1:MM);
      if rmodel.M == copy.M && rmodel.Mstrich == copy.Mstrich
        this.RB_local_ext = copy.RB_local_ext(:, 1:rmodel.N);
      else
        eind = compute_TM_global(this.ei_rd, copy.ei_rd.grid, copy.ei_rd.TM_local(1:MM), rmodel);
        this.RB_local_ext = copy.RB_local_ext(eind, 1:rmodel.N);
      end
    end
  end

  methods

    function N  = get.N(this)
      N = this.rb_rd.N;
    end

    function M  = get.M(this)
      M = this.ei_rd.M;
    end

    function Mstrich  = get.Mstrich(this)
      Mstrich = this.ei_rd.Mstrich;
    end

    function BM = get.BM(this)
      BM = this.ei_rd.BM;
    end

%    function this = set.BM(this, BM)
%      this.ei_rd.BM = BM;
%    end

    function Mmass = get.Mmass(this)
      Mmass = this.ei_rd.Mmass;
    end

%    function this = set.Mmass(this, Mmass)
%      this.ei_rd.Mmass = Mmass;
%    end

    function grid_local_ext = get.grid_local_ext(this)
      grid_local_ext = this.ei_rd.grid_local_ext;
    end

%    function this = set.grid_local_ext(this, grid_local_ext)
%      this.ei_rd.grid_local_ext = grid_local_ext;
%    end

    function grid_local_ext = get.grid(this)
      grid_local_ext = this.ei_rd.grid_local_ext;
    end

%    function this = set.grid(this, grid_local_ext)
%      this.ei_rd.grid_local_ext = grid_local_ext;
%    end

    function TM_local = get.TM_local(this)
      TM_local = this.ei_rd.TM_local;
    end

    function TM_global = get.TM_global(this)
      TM_global = this.ei_rd.TM_global;
    end

    function a0 = get.a0(this)
      a0 = this.rb_rd.a0;
    end

    function Nmass = get.Nmass(this)
      Nmass = this.rb_rd.Nmass;
    end

    function LL_I = get.LL_I(this)
      LL_I = this.rb_rd.LL_I;
    end

    function bb_I = get.bb_I(this)
      bb_I = this.rb_rd.bb_I;
    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 NonlinEvol.ReducedModel

      yesno = needs_subset_copy(this.rb_rd, rmodel) || needs_subset_copy(this.ei_rd, rmodel);
    end


  end
end