DetailedData.m

classdef DetailedData < Greedy.User.IDetailedData
  % class generating the reduced basis space for the LinEvol problem with a
  % Greedy algorithm.
  %
  % Parameters given by the constructor argument 'bg_descr' of type
  % BasisGenDescr can control the
  %   - trainings sample (#train_sample_mode, #train_num_intervals, #train_seed)
  %   - trainings sample refinement (#refinement_mode, #val_size, #val_seed,
  %                 #stop_max_val_train_ratio)
  %   - the error indicator (#indicator_mode)
  %   - general greedy controls (#Nmax, #stop_timeout, #stop_epsilon)

  properties (Dependent, SetAccess=private)
    % a basis generation algorithm of type Greedy.Interface used to generated
    % the reduced basis space.
    bg_algorithm;
  end

  properties (Access=private)
    rb_generator;
  end

  properties

    % flag indicating whether the parameter sampling for the training set
    % `M_{\text{train}}` type.
    %
    % Possible values:
    %   - 'uniform': (default) for a ParameterSampling.Uniform
    %   - 'random':  for a ParameterSampling.Random
    train_sample_mode        = 'uniform';

    % number of intervals in the ParameterSampling.Uniform for the training
    % set `M_{\text{train}}` of the parameter space `{\cal M}`.
    train_num_intervals      = 3;

    % If 'train_sample_mode == random',  a ParameterSampling.Random is generated
    % for the training set `M_{\text{val}}` with size 'train_num_intervals' and
    % seed 'train_seed'.
    train_seed               = 1234;

    % If this value is non-zero, a ParameterSampling.Random is generated for the
    % validation set `M_{\text{val}}` with size 'val_size' and seed 'val_seed'.
    val_size                 = 100;

    % If the value of 'val_size' is non-zero,  a ParameterSampling.Random is
    % generated for the validation set `M_{\text{val}}` with size 'val_size'
    % and seed 'val_seed'.
    val_seed                 = 1234;

    % @copybrief Greedy.Plugin.POD.stop_Nmax
    Nmax                     = 20;

    % error indicator used for the Greedy.Plugin.POD algorithm.
    %
    % @copydoc Greedy.Plugin.Default.indicator_mode
    indicator_mode           = 'estimator';

    % @copybrief Greedy.Algorithm.stop_timeout
    stop_timeout             = 60*60;

    % @copybrief Greedy.Algorithm.stop_epsilon
    stop_epsilon             = 1e-9;

    % @copybrief Greedy.Algorithm.stop_max_val_train_ratio
    %
    % If this value is set to something less than 'inf', parameter sampling
    % adaptation should be activated, by setting the 'refinement_mode' to
    % 'adaptive' or 'uniform'.
    stop_max_val_train_ratio = 1;

    % @copybrief Greedy.TrainingSetAdaptation.refinement_mode
    %
    % Possible values are:
    %  - 'uniform': the parameter sampling is refined uniformly
    %  - 'adaptive': the parameter sampling is refined adaptively, such that
    %                only regions of the parameter space with high estimated
    %                errors are refined.
    %  - 'none':     no Greedy.TrainingSetAdaptation object is created
    refinement_mode          = 'adaptive';

    dune_mode = false;
  end

  methods
    function dd = DetailedData(rmodel, model_data)
      % function dd = DetailedData(rmodel, model_data)
      % constructor constructing the reduced basis spaces and storing it in a
      % DataTree.
      %
      % Parameters:
      %   rmodel: of type LinEvol.ReducedModel

      dd              = dd@Greedy.User.IDetailedData(rmodel.bg_descr, model_data);

      dd.rb_generator = SnapshotsGenerator.Trajectories(rmodel.detailed_model);

      if isa(rmodel, 'LinEvolDune.ReducedModel')
        dd.dune_mode = true;
      end

      dd.datatree     = gen_detailed_data(dd.bg_algorithm, rmodel, model_data);

    end

  end

  methods

    function basis_gen = get.bg_algorithm(this)
    % generates a default @ref Greedy.Interface "basis generation object" for
    % linear evolution problems as given by a DetailedModel.
    %
    % This function generates a Greedy.Interface implementation, with at least
    % a POD-Greedy extension algorithm for the reduced basis.
    %

      if isequal(this.train_sample_mode, 'uniform')
        M_train = ParameterSampling.Uniform(this.train_num_intervals);
      elseif isequal(this.train_sample_mode, 'random')
        M_train = ParameterSampling.Random(this.train_num_intervals, this.train_seed);
      else
        error('unknown train_sample_mode');
      end
      if this.val_size > 0
        M_val = ParameterSampling.Random(this.val_size, this.val_seed);
      else
        M_val = [];
      end

      if this.dune_mode
        rb_extension = Greedy.Plugin.PODDune(this.rb_generator);
      else
        rb_extension = Greedy.Plugin.POD(this.rb_generator);
      end
      rb_extension.stop_Nmax      = this.Nmax;
      % decide, whether estimator or true error is error-indicator for greedy
      rb_extension.indicator_mode = this.indicator_mode; %'estimator'; % Delta from rb_simulation

      pod_greedy   = Greedy.Algorithm(rb_extension, M_train, M_val);
      pod_greedy.stop_timeout = this.stop_timeout; % 60*60;
      pod_greedy.stop_epsilon = this.stop_epsilon; % 1e-9;  % 0.003 is already realized by init data!!
      pod_greedy.stop_max_val_train_ratio = this.stop_max_val_train_ratio; % 1.00;

      if ~isequal(this.refinement_mode, 'none')
        basis_gen = Greedy.TrainingSetAdaptation(pod_greedy);
        basis_gen.refinement_mode = this.refinement_mode;
      else
        basis_gen = pod_greedy;
      end

    end

    function rb_size = get_rb_size(this, rmodel)
      leaf_dd = get_leaf(this, rmodel);
      rb_size = get_rb_size(leaf_dd);
    end

  end
end