IDetailedModel.m

classdef IDetailedModel < IDetailedModel
  % This is and IDetailedModel interface specialization for detailed models
  % that shall be suitable for Greedy algorithms.
  %
  % A default implementation of the newly introduced methods for @ref fv
  % functions is Greedy.User.IDetailedModel which can be used by most @ref fv
  % models without any extensions or adaptations.

  methods
    function dmei = IDetailedModel(descr)
      % constructor
      %
      % stores and analyzises the description strucutre
      %
      % Parameters:
      %  descr:  structure describing the paramerized problem and the
      %          disretization.
      dmei = dmei@IDetailedModel(descr);
    end
  end

  methods (Abstract)

    % function UON          = orthonormalize(this, model_data, U);
    % orthonormalizes a set of discrete functions `\{ v_h^l \}_{l=1}^L`
    %
    % Parameters:
    %  U: The Dof vectors for the set of discrete functions
    %
    % Return values:
    %  UON: The Dof vectors of the orthonormalized set of discrete functions.
    UON          = orthonormalize(this, model_data, U);

    % function U0           = init_values_algorithm(model, model_data);
    % computes the Dof vectors for the initial value function
    % `u_h^0(\cdot;t\mu) = {\cal P}_h[u_0(\mu)]`
    %
    % Return values:
    %  U0:  the Dof vector of the initial value projection
    U0           = init_values_algorithm(model, model_data);

    % function UV           = inner_product(this, model_data, U, V);
    % computes the inner project between the Dof vectors of two discrete
    % functions
    %
    % Parameters:
    %  U: Dof vector of first discrete function `u_h`
    %  V: Dof vector of second discrete function `v_h`
    %
    % Return values:
    %  UV: Dof vector of innter product `\langle u_h, v_h \rangle_{{\cal W}_h}`
    UV           = inner_product(this, model_data, U, V);
  end

  methods (Static, Abstract)
    % function errs         = l2_error_sequence_algorithm(U, Uapprox, W);
    % computes the `L^2(\Omega)` error for each "snapshot" of a trajectories
    % and returns the sequence of these errors.
    %
    % Parameters:
    %   U:          first sequence of Dof vectors of discrete functions
    %               `\{u_h^k\}_{k=0}^K` stored in a 'H x K+1' matrix
    %   Uapprox:    second sequence of Dof vectors of functions
    %               `\{v_h^k\}_{k=0}^K` stored in a 'H x K+1' matrix
    %
    % Return values:
    %   errs:       sequence of errors
    %               `\{ \| u_h^k - v_h^k \|_{L^2(\Omega)} \}_{k=0}^{K}` stored
    %               in a 'K+1 x 1' vector
    %
    errs         = l2_error_sequence_algorithm(U, Uapprox, model_data);

    % function errs         = linfty_error_sequence_algorithm(U, Uapprox[, model_data]);
    % computes the `L^{\infty}(\Omega)` error for each "snapshot" of a
    % trajectories and returns the sequence of these errors.
    %
    % Parameters:
    %   U:          first sequence of Dof vectors of discrete functions
    %               `\{u_h^k\}_{k=0}^K` stored in a 'H x K+1' matrix
    %   Uapprox:    second sequence of Dof vectors of functions
    %               `\{v_h^k\}_{k=0}^K` stored in a 'H x K+1' matrix
    %
    % Return values:
    %   errs:       sequence of errors
    %               `\{ \| u_h^k - v_h^k \|_{L^{\infty}(\Omega)} \}_{k=0}^{K}` stored
    %               in a 'K+1 x 1' vector
    %
    errs         = linfty_error_sequence_algorithm(U, Uapprox, model_data);

    % function W            = get_inner_product_matrix(model_data);
    % returns the inner product matrix for efficient computation of
    % inner products on `{\cal W}_h`
    %
    % The matrix `W` returned can be used to compute an inner product
    % ``\langle u_h, v_h\rangle_{{\cal W}_h} = U^t W V``
    % where `U, V` are the Dof vectors of the discrete functions `u_h, v_h\in
    % {\cal W}_h`.
    %
    % Return values:
    %  W: The matrix `W`
    W            = get_inner_product_matrix(model_data);

    U = get_dofs_from_sim_data(sim_data);

    snapshot = get_dofs_at_time(sim_data, time_index);

  end

end