ReducedModel.m

classdef ReducedModel < IReducedModel
  % reduced model for linear stationary problems as given by a
  % LinStatDune.DetailedModel.

  properties
    enable_error_estimator = false;

    mu;
  end

  methods
    function rm = ReducedModel(dmodel, bg_descr)
      % function rm = ReducedModel(detailed_model, basis_generator)
      % Constructor for the reduced model.
      %
      % Parameters:
      %   dmodel: of type LinStatDune.DetailedModel

      rm = rm@IReducedModel(dmodel, bg_descr);
    end

    function rb_sim_data = rb_simulation(rmodel, reduced_data)
    % function rb_sim_data = rb_simulation(rmodel, reduced_data)
    % reduced simulation for linear stationary finite volume schemes
      descr = rmodel.detailed_model.descr;

      rb_sim_data = [];
      cmu = get_mu(rmodel);
      LI_coeff = descr.coeff_ops.LI(cmu);
      f_coeff = descr.coeff_ops.f(cmu);
      
      LIN = lincomb_sequence(reduced_data.AN_comp, LI_coeff);
      fN  = lincomb_sequence(reduced_data.fN_comp, f_coeff);
      
      KII_coeff = kron(LI_coeff, LI_coeff);
      mI_coeff  = kron(LI_coeff, f_coeff);
      m_coeff   = kron(f_coeff, f_coeff);
      KII = lincomb_sequence(reduced_data.KII, KII_coeff);
      mI  = lincomb_sequence(reduced_data.mI, mI_coeff);
      m   = lincomb_sequence(reduced_data.m, m_coeff);
      
      uN = LIN \ fN;
      
      rb_sim_data.uN = uN;
      
      res_norm_sqr = ...
        uN' * KII * uN ...
        - 2 * uN' * mI ...
        + m;
      
      if res_norm_sqr >=0
        res_norm = sqrt(res_norm_sqr);
      else
        res_norm = 0;
      end
      
      Delta = descr.L_I_inv_norm_bound(cmu) * res_norm;
      
      rb_sim_data.Delta = Delta;
    end

    function this         = set_mu(this, mu)
      % function this = set_mu(this, mu, propagate)
      % sets the active parameter vector `\mu \in {\cal M}`
      %
      % The parameter set here, is used by the detailed_simulation() function.
      %
      % The default implementation sets all fieldnames 'descr.mu_names' in the
      % #descr struct.
      %
      % Parameters:
      %   mu: The parameter vector `\boldsymbol\mu`.
      %
      % Return values:
      %  this: handle of type IDetailedModel to the changed DetailedModel

      assert(length(mu) == length(this.descr.mu_names));

      this.mu = mu;
%      this.descr.mexptr('set_mu', mu);
    end

    function mu           = get_mu(this)
      % function mu = get_mu(this)
      % returns the active parameter vector `\boldsymbol\mu \in {\cal M}`
      %
      % The default implementation returns a vector of the values of the fields
      % of the #descr structure with names 'descr.mu_names'.
      %
      % Return values:
      %   mu: The parameter vector `\boldsymbol\mu`


      if isempty(this.mu)
        this.mu = get_mu(this.detailed_model);
      end
      mu = this.mu;

%      mu = this.descr.mexptr('get_mu');
    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 IReducedModel.rb_reconstruction()
    %
    % Parameters:
    %   detailed_data: of type LinEvol.DetailedData
    %   rb_sim_data:   struct holding reduced simulation data returned by
    %                  IReducedModel.rb_simulation() .
    %
    % Return values:
    %   rb_sim_data: struct holding the reduced simulation results and their
    %                reconstructions.
      if isa(detailed_data, 'Greedy.User.IDetailedData')
        dd_leaf = get_leaf(detailed_data, this);
      else
        dd_leaf = detailed_data;
      end
      dune_sim_data = this.descr.mexptr('rb_reconstruction', dd_leaf.model_data, rb_sim_data);
      rb_sim_data = structcpy(rb_sim_data, dune_sim_data);
    end

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

  end
  methods (Static)
    function Delta        = get_estimators_from_sim_data(rb_sim_data)
      % function Delta        = get_estimators_from_sim_data(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(sim_data)
      % @copybrief IReducedModelget_estimator_from_sim_data()
      %
      % @copydetails IReducedModelget_estimator_from_sim_data()
      Delta = rb_sim_data.Delta(end);
    end

  end
end