ReducedModel.m

classdef ReducedModel < Greedy.User.IReducedModel
  % reduced model for non-linear evolution problems as given by a
  % NonlinEvol.DetailedModel.
  %
  % This is compatible with Greedy.User.IReducedModel and can therefore make
  % use of @ref Greedy.User.IDetailedData "detailed data objects" created by
  % Greedy algorithms.

  properties
    enable_error_estimator = true;

%  properties (Constant) @code
%    nl_checks = struct('Mstrich',                {{@isscalar, 'minmax', [0, inf]}},...
%                       'enable_error_estimator', {{@isscalar, 'own', ...
%                                                  @(model) ~model.enable_error_estimator || model.Mstrich > 0, ...
%                                                  'model.Mstrich needs to be positive if error estimator is enabled'}} ...
%                      );
%  @endcode

    % copybrief NonlinEvol.DetailedModel.compute_conditions
    compute_conditions = false;

    % defines how the stencil of the local grid is computed
    %
    % Two possibilities:
    %   - 'edge' for all neighbours over edges
    %   - 'vertex' for all neighbours of a grid cell's vertices
    %
    % See also: #local_stencil_size
    stencil_mode       = 'edge';

    % defines the number of neighbors that shall be added to the stencil of the
    % local grid created for efficient empirical interpolation evalutations.
    %
    % See also: stencil_mode
    local_stencil_size = 1;
  end

  properties (Dependent)
    % current time instance
    t;

    % current time step
    tstep;
  end

  properties(Constant)
    % This constant is used for a consistency check of the model descr with
    % help of IModel.struct_check()
    ddescr_checks = struct(...
      'init_values_algorithm', {{@(x) isequal(class(x), 'function_handle')}},...
      'error_norm',            {{@ischar, 'values', {'l2', 'energy'} }},...
      'stencil_mode',          {{@ischar, 'values', {'edge', 'vertex'} }},...
      'local_stencil_size',    {{@isnumeric}}...
      );

  end

  methods
    function rm = ReducedModel(dmodel, bg_descr)
      % function rm = ReducedModel(dmodel, bg_descr)
      % Constructor for the reduced model.
      %
      % Parameters:
      %   dmodel: of type NonlinEvol.DetailedModel
      %
      if nargin == 1 || isempty(bg_descr)
        bg_descr = [];
      end
      % this implements a copy constructor if necessary...
      rm = rm@Greedy.User.IReducedModel(dmodel, bg_descr);
      % are we NOT a copy constructor?
      if ~(isempty(bg_descr) || isa(dmodel, 'NonlinEvol.ReducedModel'))

        descr = dmodel.descr;

        if ~IModel.struct_check(descr, ...
                                NonlinEvol.ReducedModel.ddescr_checks);
          error('Consistency check for NonlinEvol.ReducedModel failed.');
        end

        rm.stencil_mode       = descr.stencil_mode;
        rm.local_stencil_size = descr.local_stencil_size;

        rm.Mstrich     = 1;
        rm.crb_enabled = true;
      end

    end

    function M = get_current_M(this, id)
      % function M = get_current_M(this[, id])
      % returns the collateral reduced basis size for the current parameter and
      % time instant
      %
      % Parameters:
      %   id: an optional id in case there are many collateral reduced basis
      %       spaces for one parameter and time instant combination.
      %
      % Return values:
      %   M: the size of the collateral reduced basis space

      if nargin < 2
        id = [];
      end

      if isa(this.M, 'DataTree.INode')
        M = get_active_leaf(this.M, this, id);
        M = M.value;
      else
        M = this.M;
      end
    end

    function c = copy(this)
      % function c = copy(this)
      % @copybrief IReducedModelcopy()
      %
      % Return values:
      %   c:   an object of type NonlinEvol.ReducedModel which is a deep copy of this object.
      c = NonlinEvol.ReducedModel(this);
    end

%    function reduced_data = gen_reduced_data(this, detailed_data)
%      rd_creator                    = NonlinEvol.ReducedDataCreator;
%      if isfield(this.descr, 'stencil_mode')
%        rd_creator.stencil_mode       = this.descr.stencil_mode;
%        rd_creator.local_stencil_size = this.descr.local_stencil_size;
%      end

%      reduced_data               = gen_reduced_data(detailed_data, this, rd_creator);
%    end

%    function reduced_data = extract_reduced_data_subset(this, reduced_data)
%      rd_creator                    = NonlinEvol.ReducedDataCreator;
%      if isfield(this.descr, 'stencil_mode')
%        rd_creator.stencil_mode       = this.descr.stencil_mode;
%        rd_creator.local_stencil_size = this.descr.local_stencil_size;
%      end
%
%      reduced_data               = extract_reduced_data_subset(reduced_data, this, rd_creator);
%    end

    %
    %
    % Parameters:
    %   reduced_data: of type NonlinEvol.EiRbReducedDataNode
    rb_sim_data = rb_simulation_impl(this, reduced_data);

%    function [LL_I, bb_I] = rb_operators(model, detailed_data)
%      [LL_I, bb_I] = NonlinEvol.ReducedDataCreator.rb_operators(model, detailed_data);
%    end

    function a0 = rb_init_values(this, detailed_data, decomp_mode)
      % function a0 = rb_init_values(this, detailed_data, decomp_mode)
      % @copybrief rb_init_values_separable()
      %
      % This calls rb_init_values_separable().
      %
      % Parameters:
      %   detailed_data: detailed data tree leaf object of type GreedyDataTreeDetailed.PODEILeafNode.
      %
      % Return values:
      %   a0: coefficient vector of size 'N x 1' for the initial values.
      a0 = rb_init_values_separable(this, detailed_data, decomp_mode);
    end

    function rb_sim_data = rb_reconstruction(this, detailed_data, rb_sim_data)
      % function rb_sim_data = rb_reconstruction(this, detailed_data, rb_sim_data)
      % @copybrief rb_reconstruction_default()
      %
      % This calls rb_reconstruction_default().
      %
      % Parameters:
      %   detailed_data: of type NonlinEvol.DetailedData
      %   rb_sim_data:   struct holding reduced simulation data returned by
      %                  ReducedModel.rb_simulation().
      %
      % Return values:
      %   rb_sim_data: struct holding the reduced simulation results and their
      %                reconstructions.
      
      dd=get_active_leaf(detailed_data, this, 'rb');
      rb_sim_data = rb_reconstruction_default(this, dd, rb_sim_data);
    end

    function enable_error_estimator = get.enable_error_estimator(this)
      if this.enable_error_estimator && this.Mstrich == 0
        error('Mstrich needs to be positive if error estimator is enabled!')
      elseif ~this.enable_error_estimator && this.Mstrich > 0
        warning('RBMatlab:error_estimator', 'Mstrich is larger than zero, but error_estimator is disabled!');
      end
      enable_error_estimator = this.enable_error_estimator;
    end

  end

  methods(Static)
    function Delta        = get_estimators_from_sim_data(rb_sim_data)
      % function Delta        = get_estimators_from_sim_data(rb_sim_data)
      % @copybrief IReducedModelget_estimators_from_sim_data()
      %
      % @copydetails IReducedModelget_estimators_from_sim_data()
      Delta = rb_sim_data.Delta;
    end

    function Delta        = get_estimator_from_sim_data(rb_sim_data)
      % function Delta        = get_estimator_from_sim_data(rb_sim_data)
      % @copybrief IReducedModelget_estimator_from_sim_data()
      %
      % @copydetails IReducedModelget_estimator_from_sim_data()
      Delta = rb_sim_data.Delta(end);
    end

%    function U            = get_dofs_from_sim_data(sim_data)
%      if isfield(sim_data, 'U')
%        U = sim_data.U;
%      else
%        U = [];
%        warning('RBMatlab:NonlinEvolReducedModel:ReconstructionMissing', 'No reconstructed data found in sim_data, execute rb_reconstruct() first');
%      end
%    end
  end

  methods
    function t = get.t(this)
      t = this.descr.t;
    end

    function set.t(this, t)
      this.detailed_model.t = t;
    end

    function tstep = get.tstep(this)
      tstep = this.descr.tstep;
    end

    function set.tstep(this, tstep)
      this.detailed_model.tstep = tstep;
    end
  end
end