ReducedModel.m

classdef ReducedModel < Greedy.User.IReducedModel
  % reduced model for non-linear evolution problems as given by a
  % TwoPhaseFlow.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 = false;

    impes = false;
  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')}}...
      );

  end

  methods
    function rm = ReducedModel(dmodel, bg_descr)
      % function rm = ReducedModel(dmodel, bg_descr)
      % Constructor for the reduced model.
      %
      % Parameters:
      %   dmodel: of type TwoPhaseFlow.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, 'TwoPhaseFlow.ReducedModel'))

        descr = dmodel.descr;

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

      end

    end

    function N = get_N(this, id)
      if isequal(id, 'u0')
        id = 'saturation';
      end
      N = get_by_description(this.N, id);
    end

    function set_N(this, id, val)
      set(this.N, get_index(this.N, id), val);
    end

    function M = get_M(this, id)
      M = get_by_description(this.M, id);
    end

    function set_M(this, id, val)
      set(this.M, get_index(this.M, id), val);
    end


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

    function rb_sim_data = rb_simulation(rmodel, reduced_data, sim_data, dd)
      % function rb_sim_data = rb_simulation(rmodel, reduced_data)
      % forwards the reduced simulation to the method rb_simulation_impl()
      % after getting a suitable reduced data leaf element.
      %
      % Parameters:
      %   reduced_data: of type Greedy.User.ReducedData
      %   sim_data:     structure holding simulation data, i.e. Dof-vectors with
      %                 fields 'S', 'U', 'P' for the saturation, velocity and
      %                 pressure field concentrations. This can be used for
      %                 reference computations. @default []
      %   dd:           object of type IDetailedData which can be used for
      %                 reference computations. @default []
      %
      % Return values:
      %  rb_sim_data:  structure holding the coefficient vectors of the reduced
      %                simulations and optional error estimators.
      reduced_data_leaf = get_leaf(reduced_data, rmodel);
      if rmodel.impes
        if nargin == 2
          rb_sim_data = rb_simulation_impes_impl(rmodel, reduced_data_leaf);
        else
          rb_sim_data = rb_simulation_impes_impl(rmodel, reduced_data_leaf, sim_data, dd);
        end
      else
        if nargin == 2
          rb_sim_data = rb_simulation_impl(rmodel, reduced_data_leaf);
        else
          rb_sim_data = rb_simulation_impl(rmodel, reduced_data_leaf, sim_data, dd);
        end
      end
    end

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

    %
    %
    % Parameters:
    %   reduced_data: of type TwoPhaseFlow.EiRbReducedDataNode
    rb_sim_data = rb_simulation_impes_impl(this, reduced_data, sim_data, dd);

    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


    %
    %
    % Parameters:
    %   detailed_data: of type TwoPhaseFlow.DetailedData
    rb_sim_data = rb_reconstruction(this, detailed_data, rb_sim_data);

  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

  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