EiReducedDataNode.m

classdef EiReducedDataNode < Greedy.User.IReducedDataNode
  % Implementation of a Greedy.User.IReducedDataNode storing reduced data
  % depending on collateral reduced basis space information only (e.g.
  % interpolation DOFs and a local grid).

  properties
    % @copybrief TwoPhaseFlow.EiRbReducedDataNode.BM
    %
    % @copydetails TwoPhaseFlow.EiRbReducedDataNode.BM
    BM;

    % @copybrief TwoPhaseFlow.EiRbReducedDataNode.grid_local_ext
    %
    % @copydetails TwoPhaseFlow.EiRbReducedDataNode.grid_local_ext
    grid_local_ext;

    % @copybrief TwoPhaseFlow.EiRbReducedDataNode.TM_local
    %
    % @copydetails TwoPhaseFlow.EiRbReducedDataNode.TM_local
    TM_local;

    % @copybrief TwoPhaseFlow.EiRbReducedDataNode.TM_global
    %
    % @copydetails TwoPhaseFlow.EiRbReducedDataNode.TM_global
    TM_global;

    % @copybrief TwoPhaseFlow.EiRbReducedDataNode.Mmass
    %
    % @copydetails TwoPhaseFlow.EiRbReducedDataNode.Mmass
    Mmass;

    % @copybrief TwoPhaseFlow.EiRbReducedDataNode.Mstrich
    %
    % @copydetails TwoPhaseFlow.EiRbReducedDataNode.Mstrich
    Mstrich = 0;

    % an object of type ILocalizedOperator for which the empirical
    % interpolation basis was generated.
    ophandle;

    id;

    gEI;

    gn_edges;

    gn_inner_edges;

    gn_boundary_edges;

    TM_global_args;

    TM_reduction_args = {};
  end

  properties (SetAccess = private, Dependent)
    % @copybrief TwoPhaseFlow.EiRbReducedDataNode.M
    %
    % @copydetails TwoPhaseFlow.EiRbReducedDataNode.M
    M;

    % @copybrief TwoPhaseFlow.EiRbReducedDataNode.grid
    %
    % @copydetails TwoPhaseFlow.EiRbReducedDataNode.grid
    grid;
  end

  methods
    function rd = EiReducedDataNode(rmodel, detailed_data)
      % function rd = EiReducedDataNode(rmodel, detailed_data)
      % constructor for the generation of the reduced data.
      %
      % Parameters:
      %   rmodel: of type TwoPhaseFlow.ReducedModel
      %   detailed_data: of type IDetailedData
      %
      % Alternative synopsis:
      % @code EiReducedDataNode(rmodel, ei_reduced_data_node) @endcode copying
      % a reduced data node and (optionally) extracting smaller matrices.
      if nargin == 0
        error('TwoPhaseFlow.EiReducedDataNode constructor needs an argument');
      elseif nargin == 2 && isa(rmodel, 'IReducedModel') ...
          && isa(detailed_data, 'TwoPhaseFlow.EiReducedDataNode')
        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.Mmass)
        conds.Mmass  = condest(this.Mmass);
      end
      if ~isempty(this.BM)
        conds.BM     = condest(this.BM);
      end
    end
    function grid = get.grid(this)
      grid = this.grid_local_ext;
    end

    function M = get.M(this)
      M = size(this.BM, 2) - this.Mstrich;
    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 TwoPhaseFlow.ReducedModel

      MM = get_by_description(rmodel.M, this.ophandle.id);
      yesno = isempty(MM) || (this.M ~= MM);
    end

  end
  methods(Access=private)

    function fill_fields(this, rmodel, detailed_data)
      model_data = detailed_data.model_data;
      if size(model_data.W, 1) == size(detailed_data.QM, 1)
        A          = model_data.W;
      else
        A          = model_data.diamondW;
      end

      this.ophandle = detailed_data.ophandle;
      MM = get_by_description(rmodel.M, this.ophandle.id);
      this.BM = detailed_data.BM(1:MM,1:MM);

      [nmd, eind, eind_local] = this.ophandle.compute_TM_global(model_data, detailed_data.TM(1:MM));

      this.grid_local_ext    = nmd.grid_local_ext;
      this.TM_global_args    = nmd.TM_global_args;
      this.gEI               = nmd.gEI;
      this.gn_edges          = nmd.gn_edges;
      this.gn_inner_edges    = nmd.gn_inner_edges;
      this.gn_boundary_edges = nmd.gn_boundary_edges;
      this.TM_global         = eind;
      this.TM_local          = eind_local;

      this.Mmass = detailed_data.QM(:,1:MM)' * A * detailed_data.QM(:,1:MM);
    end

    function copy_extract(this, reduced_data, rmodel)
      this.ophandle = reduced_data.ophandle;
      this.id       = reduced_data.id;

      MM = get_by_description(rmodel.M, this.ophandle.id);

      grid                = reduced_data.grid_local_ext;

      % new version with external routine index_ext:
      [nmd, eind, eind_local] = this.ophandle.compute_TM_global(reduced_data, reduced_data.TM_local(1:MM));

      reduced_data_subset.TM_global      = reduced_data.TM_global(1:MM);
      reduced_data_subset.grid_local_ext = nmd.grid_local_ext;
      [this.gEI, this.gn_inner_edges, this.gn_boundary_edges] ...
        = compute_edge_indices(reduced_data_subset.grid_local_ext);
      this.gn_edges = this.gn_inner_edges + this.gn_boundary_edges;

      glob2loc       = zeros(grid.nelements,1);
      glob2loc(eind) = 1:length(eind);
      this.TM_global_args = cell(1, length(nmd.TM_global_args));
      for i = 1:length(nmd.TM_global_args)
        oldTM_global              = reduced_data.TM_global_args{i};
        this.TM_global_args{i}    = oldTM_global(nmd.TM_global_args{i});
        this.TM_reduction_args{i} = nmd.TM_global_args{i};
      end
      this.TM_local = glob2loc(reduced_data.TM_local(1:MM));
      this.BM       = reduced_data.BM(1:MM,1:MM);
      this.Mmass    = reduced_data.Mmass(1:MM,1:MM);

      % get Q^t W Q for M to M+M'
      if rmodel.Mstrich > 0
        QWQ         = this.Mmass(rmodel.M+1:end,MM);
%        this.factor = norm(QWQ);
      else
%        this.factor = NaN;
      end
    end
  end
end