RbReducedDataNode.m

classdef RbReducedDataNode < Greedy.User.IReducedDataNode
  % Implementation of a Greedy.User.IReducedDataNode storing reduced data
  % depending on reduced basis space information only. (e.g. reduced matrices
  % of operators)

  properties
    % @copybrief NonlinEvol.EiRbReducedDataNode.Nmass
    %
    % @copydetails NonlinEvol.EiRbReducedDataNode.Nmass
    Nmass;

    % @copybrief NonlinEvol.EiRbReducedDataNode.a0
    %
    % @copydetails NonlinEvol.EiRbReducedDataNode.a0
    a0;

    % @copybrief NonlinEvol.EiRbReducedDataNode.LL_I
    %
    % @copydetails NonlinEvol.EiRbReducedDataNode.LL_I
    LL_I;

    % @copybrief NonlinEvol.EiRbReducedDataNode.bb_I
    %
    % @copydetails NonlinEvol.EiRbReducedDataNode.bb_I
    bb_I;
  end

  properties (SetAccess = private, Dependent)
    % @copybrief NonlinEvol.EiRbReducedDataNode.N
    %
    % @copydetails NonlinEvol.EiRbReducedDataNode.N
    N;
  end

  methods
    function rd = RbReducedDataNode(rmodel, detailed_data)
      % function rd = RbReducedDataNode(rmodel, detailed_data)
      % constructor for the generation of the reduced data.
      %
      % Parameters:
      %   rmodel: of type NonlinEvol.ReducedModel
      %   detailed_data: of type IDetailedData
      %
      % Alternative synopsis:
      % @code RbReducedDataNode(rmodel, ei_reduced_data_node) @endcode copying
      % a reduced data node and (optionally) extracting smaller matrices.
      if nargin == 0
        error('NonlinEvol.RbReducedDataNode constructor needs an argument');
      elseif nargin == 2 && isa(rmodel, 'IReducedModel') ...
          && isa(detailed_data, 'NonlinEvol.RbReducedDataNode')
        copy   = detailed_data;
        copy_extract(rd, copy, rmodel);
      elseif nargin == 2
        fill_fields(rd, rmodel, detailed_data);
      else
        error('Did not find constructor for your arguments');
      end
    end

    function conds = get_conds(this)
      if ~isempty(this.Nmass)
        conds.Nmass = condest(this.Nmass);
      end
      if ~isempty(this.LL_I)
        conds.LL_I  = condest(this.LL_I);
      end
    end

    function N = get.N(this)
      N = size(this.a0{1},2);
    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 = this.N ~= rmodel.N;
    end

  end
  methods(Access=private)

    function fill_fields(this, rmodel, detailed_data)

      model_data = detailed_data.model_data;
      A          = model_data.W;

      this.a0 = rb_init_values(rmodel, detailed_data, 1);
      [this.LL_I, this.bb_I] = NonlinEvol.ReducedData.rb_operators(rmodel, detailed_data, 1);
      this.Nmass = detailed_data.RB' * A * detailed_data.RB;

    end

    function copy_extract(this, reduced_data, rmodel)

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

      N = rmodel.N;

      this.a0    = subblock_sequence(reduced_data.a0,1:N);
      this.LL_I  = subblock_sequence(reduced_data.LL_I,1:N,1:N);
      this.bb_I  = subblock_sequence(reduced_data.bb_I,1:N);
      if ~isempty(reduced_data.Nmass)
        this.Nmass = reduced_data.Nmass(1:N,1:N);
      end

    end
  end

end