SeparableOperatorNode.m

classdef SeparableOperatorNode < Greedy.User.IReducedDataNode

  properties (SetAccess = private)

    bb;

    sohandle;
  end

  properties (SetAccess = private, Dependent)
    id;

    LL;

    N;
  end

  properties (Access=private)
    siz;
    LL_int;
  end

  methods
    function sfn = SeparableOperatorNode(rmodel, detailed_data, sohandle)
      if nargin == 0
        error('Greedy.DataTree.Reduced.SeparableOperatorNode needs three constructor arguments');
      elseif nargin == 2 && isa(rmodel, 'IReducedModel') ...
          && isa(detailed_data, 'Greedy.DataTree.Reduced.SeparableOperatorNode')
        copy = detailed_data;
        copy_extract(sfn, copy, rmodel);
      elseif nargin == 3
        sfn.sohandle = sohandle;
        fill_fields(sfn, rmodel, detailed_data);
      else
        error('Wrong constructor arguments');
      end
    end

    function yesno = needs_subset_copy(this, rmodel)
      % function yesno = needs_subset_copy(this, rmodel)
      % @copybrief ::GreedyUser.IReducedDataNode.needs_subset_copy()
      %
      % @copydetails ::GreedyUser.IReducedDataNode.needs_subset_copy()
      %
      % Parameters:
      %   rmodel: of type TwoPhaseFlow.ReducedModel
      rn = get_by_description(rmodel.N, this.id);
      yesno = this.N ~= rn;

    end

    function N = get.N(this)
      N = size(this.LL{1},1);
    end

    function LL = get.LL(this)
      len = size(this.LL_int, 2);
      LL = cell(1, len);
      for i = 1:len
        LL{i} = reshape(this.LL_int, this.siz);
      end
    end

    function id = get.id(this)
      id = this.sohandle.id;
    end

    function conds = get_conds(this)
      conds = cellfun(@condest, this.LL, 'UniformOutput', false);
    end

    function [LL_c, bb_c] = lincomb_sequence(this, descr)
      [L_coeffs, b_coeffs] = this.sohandle.coefficients(descr);
      LL_c = reshape(this.LL_int * L_coeffs, this.siz);
      bb_c = this.bb * b_coeffs;

    end
  end

  methods(Access=private)

    function fill_fields(this, rmodel, detailed_data)
      [LL, bbret] = this.sohandle.gram_project_components(rmodel, detailed_data);
      this.bb = cat(1, bbret{:});
      this.siz = size(LL{1});
      LL = cellfun(@(X) X(:), LL, 'UniformOutput', false);
      this.LL_int = cat(1, LL{:});
    end

    function copy_extract(this, reduced_data, rmodel)
      this.sohandle = reduced_data.sohandle;
      rn = get_by_description(rmodel.N, this.id);

      if rn > this.N
        error('N too large for current size of reduced data!');
      end

      this.bb = reduced_data.bb(1:rn, :);
      if isempty(this.sohandle.ret_vars)
        nmask = 1:size(this.siz,1);
        this.siz(2) = rn;
      else
        this.siz = [rn, rn];
        nmask = 1:rn;
      end
      subset = zeros(rn, rn);
      subset(nmask, 1:rn) = 1;
      this.LL_int = this.LL_int(subset(:), :);
    end
  end
end