PODEI.m

classdef PODEI < Greedy.Plugin.Interface
  % Greedy.Plugin.Interface implementation that extends in each basis extension step,
  % the reduced basis space and/or the collateral reduced basis space(s).
  %
  % As an error indicator it uses the error indicator of the reduced numerical
  % scheme, with the ambition to "optimize" all spaces for best output in the
  % final solutions `u_{\text{red}}(\mu)`.

  properties(Constant, Hidden=true)

    % cell array of field names whose values shall be copied to the generated
    % Greedy.DataTree.Detailed.PODEILeafNode instance.
    info_fields = { ...
      'Mmax_small', 'error_differences_for_extension', ...
      'M_by_N_ratio', 'bad_extension_on_explosion', ...
      'maximum_temporary_error_growth_factor', 'discard_last_rb_after_bad_extension', ...
      'skip_rb_after_bad_extension', 'skip_ei_after_bad_extension' ...
        };

  end

  properties(Dependent)
    % @copybrief Greedy.Plugin.Interface.needs_preparation
    %
    % @copydetails Greedy.Plugin.Interface.needs_preparation
    needs_preparation;

    % @copybrief Greedy.Plugin.Default.use_l2_error
    %
    % @copydetails Greedy.Plugin.Default.use_l2_error
    use_l2_error;

  end

  properties
    % @copybrief Greedy.Plugin.Interface.indicator_mode
    %
    % @copydetails Greedy.Plugin.Interface.indicator_mode
    indicator_mode;

    % @copybrief Greedy.Plugin.Interface.relative_error
    %
    % @copydetails Greedy.Plugin.Interface.relative_error
    relative_error = [];
  end

  properties
    % number of collateral reduced of the initial collateral reduced basis.
    %
    % In order to use the estimator of a nonlinear evolution equation for a
    % basis extension with a greedy search in the parameter space, a collateral
    % reduced basis space for all existing operators needs to be present. For
    % this reason at the beginning of the basis generation algorithm, a
    % collateral reduced bases of size at most 'Mmax_small' is generated
    Mmax_small;

    % boolean flag indicating to use largest error difference over time steps
    % in order to select snapshot for collateral reduced basis extension.
    %
    % In order to extend the collateral reduced basis spaces, we need to select
    % one snapshot indexed by `k_{\max}` from the sequence of possible vectors
    % `v_h(t^{k},\mu_{\max}) \in {\cal W}_h`. If this flag is set to 'true',
    % `k_{\max} = \arg \max_{k=1,\ldots,K} \eta^k(\mu_{\max}) -
    % \eta^{k-1}(\mu_{\max})`.
    %
    % Otherwise `k_{\max}` is determind as the time step of the maximum error
    % returned by Greedy.Plugin.EI.compute_error()
    error_differences_for_extension = false;

    % forced ratio between the sizes of the colletaral and the regular reduced
    % basis space
    %
    % If the ratio is too low before a basis extension, only the collateral
    % reduced basis space is extended.
    %
    % Its purpose is to make the collateral reduced basis space more refined
    % than the reduced basis space. This is necessary as the best possible
    % error for the basis generation of the reduced basis space @em depends on
    % the quality of the collateral reduced basis space.
    M_by_N_ratio                    = 0;

    % boolean flag indicating whether in an @em explosion is a bad extension.
    %
    % See also: indicate_bad_basis_extension() for details.
    bad_extension_on_explosion            = false;

    % maximum factor between the current maximum indicator and the smallest
    % maximum error indicator during previous extensions
    %
    % See indicate_bad_basis_extension() for details.
    maximum_temporary_error_growth_factor = 0;

    % boolean flag specifying whether the last generated reduced basis vector
    % should be discarded after a bad extension is indicated by
    % indicate_bad_basis_extension().
    %
    % See indicate_bad_basis_extension() and basis_extension() for details.
    discard_last_rb_after_bad_extension = true;

    % boolean flag specifying whether the current reduced basis extension
    % should be skipped after a bad extension is indicated by
    % indicate_bad_basis_extension().
    %
    % See indicate_bad_basis_extension() and basis_extension() for details.
    skip_rb_after_bad_extension     = true;

    % boolean flag specifying whether the current collateral reduced basis
    % extension should be skipped after a bad extension is indicated by
    % indicate_bad_basis_extension().
    %
    % See indicate_bad_basis_extension() and basis_extension() for details.
    skip_ei_after_bad_extension     = false;
  end

  properties(Constant)
    % @copybrief Greedy::Interfacegenerated_basis_type
    %
    % This is set to 'eirb'.
    %
    % @sa Greedy::Interfacegenerated_basis_type
    generated_basis_type = 'eirb';
  end

  properties(Access = public)
    % object of type Greedy.Plugin::PODCommon used for extension of the reduced basis space.
    rb_ext;

    % object of type Greedy.Plugin::EICommon used for extension of the collateral reduced
    % basis space(s) and providing an error estimator
    ei_ext;

    % object of type Greedy::Algorithm used for initial creation of
    % collateral reduced basis space(s)
    %
    % See #Mmax_small for details
    ei_init_greedy;
  end

  methods
    function crbeie = PODEI(rb_extension, ei_extension, ei_init_greedy, Mmax_small)
      % function crbeie = PODEI(rb_extension, ei_extension, ei_init_greedy, Mmax_small)
      % constructor for a combined extension algorithm for reduced and
      % collateral reduced basis spaces.
      %
      % Parameters:
      %   rb_extension: an object of type Greedy.Plugin.PODCommon specifying how to
      %                 extend the reduced basis space and providing an error
      %                 indicator.
      %   ei_extension: an object of type Greedy.Plugin.EICommon specifying how to
      %                 extend the collateral reduced basis space(s).
      %   ei_init_greedy: an object of type Greedy.Algorithm used for
      %                   initial creation of collateral reduced basis space(s)

      assert(isa(rb_extension, 'Greedy.Plugin.PODCommon'));
      assert(isa(ei_extension, 'Greedy.Plugin.EICommon'));
      crbeie = crbeie@Greedy.Plugin.Interface(rb_extension.generator);
      crbeie.rb_ext = rb_extension;
      crbeie.ei_ext = ei_extension;
      crbeie.ei_init_greedy = ei_init_greedy;
      crbeie.Mmax_small     = Mmax_small;
    end

    function needs_prepare = get.needs_preparation(this)
      needs_prepare = this.rb_ext.needs_preparation;
    end

    function ret = get.indicator_mode(this)
      ret = this.rb_ext.indicator_mode;
    end

    function ret = get.use_l2_error(this)
      ret = this.rb_ext.use_l2_error;
    end

    function ret = get.relative_error(this)
      ret = this.rb_ext.relative_error;
    end

    function this=set.indicator_mode(this, value)
      this.ei_ext.indicator_mode=value;
      this.rb_ext.indicator_mode=value;
    end

    function this=set.use_l2_error(this, value)
      this.ei_ext.use_l2_error=value;
      this.rb_ext.use_l2_error=value;
    end

    function this=set.relative_error(this, value)
      this.ei_ext.relative_error=value;
      this.rb_ext.relative_error=value;
    end

    function detailed_data = init_basis(this, rmodel, model_data, M_train)
      % function detailed_data = init_basis(this, rmodel, model_data, M_train)
      % @copybrief Greedy.Plugin::Interfaceinit_basis()
      %
      % @copydetails Greedy.Plugin::Interfaceinit_basis()
      %
      % Parameters:
      %   rmodel: object of type IReducedModel
      %
      % Return values:
      %   detailed_data: object of type Greedy.DataTree.Detailed.PODEILeafNode
      %
      % This function
      %   -# starts Greedy.Algorithm.gen_detailed_data() on the
      %      #ei_init_greedy member in order to compute initial collateral
      %      reduced basis space(s)
      %   -# creates a history Greedy.DataTree.Detailed.INode.snapshot() afterwards
      %   -# calls Greedy.Plugin.PODCommon.init_basis() on the 'rb_ext' instance
      detailed_data     = Greedy.DataTree.Detailed.PODEILeafNode(model_data, true);
      set_fields(detailed_data, this, Greedy.Plugin.PODEI.info_fields);

      assert(rmodel.crb_enabled);

      if isfield(rmodel.bg_descr, 'stop_Mmax')
        Mmax_backup       = rmodel.bg_descr.stop_Mmax;
      else
        Mmax_backup       = Inf;
      end
      this.ei_init_greedy.detailed_extension.stop_Mmax = this.Mmax_small;
      detailed_data.ei  = gen_detailed_data(this.ei_init_greedy, rmodel, model_data, []);
      snapshot(detailed_data.ei, 'ei_init_basis', ...
        sprintf(['Initialization of empirical interpolation basis on a coarse parameter grid\n',...
                 'and small epsilon tolerance or maximum basis size']),...
        'EI initialized' );
      % clear all stop flags, because they might lead to wrong behavior
      % later
      detailed_data.ei.stop_flags = {};

      if ~isempty(Mmax_backup)
        rmodel.bg_descr.stop_Mmax = Mmax_backup;
        detailed_data.ei.fields.stop_Mmax = Mmax_backup;
      end

      % update the value for M! Now we need to subtract the Mstrich value
      if isa(rmodel.M, 'DataTree.INode')
        if isa(reduced_data.M, 'DataTree.INode')
          rmodel.M = create_scalar_tree(reduced_data.M, @(x) get(x,1) - rmodel.Mstrich);
        else
          assert(rmodel.Mstrich == 0 || rmodel.M > rmodel.Mstrich);
          rmodel.M = reduced_data.M - rmodel.Mstrich;
        end
      end

      tree_descr = get_leaf_description(detailed_data.ei);
      for leaf_descr = tree_descr
        leaf = get(detailed_data.ei, leaf_descr.basepath);
        set_field(leaf, 'target_error_external', true);
      end

      detailed_data.rb = init_basis(this.rb_ext, rmodel, model_data, M_train);
    end

    function prepare_reduced_data(this, rmodel, detailed_data)
      % function prepare_reduced_data(this, rmodel, detailed_data)
      % @copybrief Greedy.Plugin::Interfaceprepare_reduced_data()
      %
      % @copydetails Greedy.Plugin::Interfaceprepare_reduced_data()

      prepare_reduced_data(this.rb_ext, rmodel, detailed_data);
%      if this.ei_ext.needs_preparation
%        prepare_reduced_data(this.ei_ext, rmodel, detailed_data);
%      end
    end

    function [max_errs, max_err_seq, max_mu_index] = error_indicators(this, rmodel, detailed_data, parameter_set, reuse_reduced_data)
      % function [max_errs, max_err_seq, max_mu_index] = error_indicators(this, rmodel, detailed_data, parameter_set, reuse_reduced_data)
      % @copybrief Greedy.Plugin::Interfaceerror_indicators()
      %
      % @copydetails Greedy.Plugin::Interfaceerror_indicators()
      %
      % Parameters:
      %   rmodel: an object of type IReducedModel
      %   detailed_data: an object of type Greedy.DataTree.Detailed.PODEILeafNode
      %
      % This function calls the Greedy.Plugin::Interfaceerror_indicators() method of the
      % #rb_ext member.
      if nargin < 5
        reuse_reduced_data = [];
      end
      [max_errs, max_err_seq, max_mu_index] = error_indicators(this.rb_ext, rmodel, detailed_data, parameter_set, reuse_reduced_data);
    end

    function errs = compute_error(this, rmodel, reduced_data, detailed_data)
      % function errs = compute_error(this, rmodel, detailed_data)
      % @copybrief Greedy.Plugin.Interface.compute_error()
      %
      % @copydetails Greedy.Plugin.Interface.compute_error()
      %
      % Parameters:
      %   rmodel: an object of type IReducedModel
      %   detailed_data: an object of type Greedy.DataTree.Detailed.PODEILeafNode
      %
      % This function calls the Greedy.Plugin.Interface.compute_error() method of
      % the #rb_ext member.
      errs = compute_error(this.rb_ext, rmodel, reduced_data, detailed_data);
    end

    function Uapprox = generate_reduced(this, rmodel, reduced_data, detailed_data, U)
      % function Uapprox = generate_reduced(this, rmodel, reduced_data, detailed_data, U)
      % @copybrief Greedy.Plugin.Interface.generate_reduced()
      %
      % @copydetails Greedy.Plugin.Interface.generate_reduced()
      %
      % Parameters:
      %   rmodel: an object of type IReducedModel
      %   detailed_data: an object of type Greedy.DataTree.Detailed.PODEILeafNode
      %
      % This function calls the Greedy.Plugin.Interface.generate_reduced() method of the
      % #rb_ext member.
      Uapprox = generate_reduced(this.rb_ext, rmodel, reduced_data, detailed_data);
    end

    function [breakloop, reason] = pre_check_for_end(this, rmodel, detailed_data)
      % function [breakloop, reason] = pre_check_for_end(this, rmodel, detailed_data)
      % @copybrief Greedy.Plugin.Interface.pre_check_for_end()
      %
      % @copydetails Greedy.Plugin.Interface.pre_check_for_end()
      %
      % Parameters:
      %   detailed_data: an object of type Greedy.DataTree.Detailed.PODEILeafNode
      %
      % This function only indicates a basis extension stop if both parts are
      % ready.

      max_err_sequence = get_field(detailed_data, 'max_err_sequence');
      ext_step = length(max_err_sequence);

      [breakloop_rb, reason_rb] = pre_check_for_end(this.rb_ext, rmodel, detailed_data.rb);
      [breakloop_ei, reason_ei] = pre_check_for_end(this.ei_ext, rmodel, detailed_data.ei);

      breakloop = breakloop_rb & breakloop_ei;

      % special case: EI skipped for two small residual, and RB could not be
      % extended => no strategy to get away...
      ei_skip_small_residual = get_field(detailed_data.ei, 'ei_skipped_for_too_small_residual', 0);
      if breakloop_rb && ~breakloop_ei ...
          && ei_skip_small_residual(end) == ext_step-1
        breakloop = true;
        set_stop_flag(detailed_data.ei, 'stopping_on_too_small_residual');
        reason_ei = 'EI extension skipped because of too small residual.';
      end
      reason = [reason_rb, ' ', reason_ei];
    end

    function detailed_data = basis_extension(this, rmodel, detailed_data, max_err_seq, mu)
      % function detailed_data = basis_extension(this, rmodel, detailed_data, max_err_seq, mu)
      % @copybrief Greedy.Plugin.Interface.basis_extension()
      %
      % @copydetails Greedy.Plugin.Interface.basis_extension()
      %
      % This function first extends the collateral reduced basis space unless
      %   -# Greedy.Plugin.EI.pre_check_for_end() returned 'false'
      %   -# the last extension was "bad" as indicated by
      %      indicate_bad_basis_extension() and #skip_ei_after_bad_extension is
      %      enabled
      %   -# the extension fails (e.g. because of
      %      Greedy.Plugin::EIminimum_residual)
      %
      % Afterwards, this function extends the reduced basis space unless
      %   -# Greedy.Plugin.PODCommon.pre_check_for_end() returned 'false'
      %   -# the last extension was "bad" as indicated by
      %      indicate_bad_basis_extension() and #skip_rb_after_bad_extension of
      %      #discard_last_rb_after_bad_extension are enabled
      %   -# the 'M/N'-ratio condition as described in #M_by_N_ratio failed
      %   -# reduced simulations returned 'NaN' error indicators
      %
      % In the second case and with enabled
      % #discard_last_rb_after_bad_extension option the last generated reduced
      % basis is discarded if
      %   -# since the last discard at least two extensions have been
      %      processed.
      %
      % Parameters:
      %   rmodel: an object of type IReducedModel
      %   detailed_data: an object of type Greedy.DataTree.Detailed.PODEILeafNode
      %
      % Return values:
      %   detailed_data: an object of type Greedy.DataTree.Detailed.PODEILeafNode


      max_extension_errs = get_field(detailed_data, 'max_extension_errs', 0);
      last_extension_bad = indicate_bad_basis_extension(this, detailed_data);

      % extension step number
      ext_step = length(max_extension_errs);

      % check whether the ei extension is ready
      [ei_breakloop, ei_reason] = pre_check_for_end(this.ei_ext, rmodel, detailed_data.ei);

      Msize = get_ei_size(detailed_data.ei);

      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
      % EI extension checks start                                         %
      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

      % only update basis spaces if end check is negative
      ei_ext_steps = get_field(detailed_data, 'ei_ext_steps', 0);
      if ei_breakloop
        if rmodel.verbose > 1
          disp('[1]> Skipping EI extension step, because pre_check_for_end() returned true');
        end
        if rmodel.verbose > 5
          disp(['[5]> ', ei_reason]);
        end
        append_field(detailed_data.ei, 'ei_skipped_for_check_end', ext_step);

      % do not update basis space if last extension was bad and skipping is requested
      elseif last_extension_bad && get_field(detailed_data, 'skip_ei_after_bad_extension') ...
          && ei_ext_steps(end) == ext_step - 1

        if rmodel.verbose > 1
          disp('[1]> Skipping EI extension step after bad extension');
        end
        append_field('ei_skipped_for_bad_extension', ext_step);
      else

        % compute error indicator for snapshot selection
        if get_field(detailed_data, 'error_differences_for_extension') && ~any(isnan(max_err_seq));
          ei_errs = max_err_seq(2:end) - max_err_seq(1:end-1);
        else
          % recompute ei error
          prepare_reduced_data(this.ei_ext, rmodel, detailed_data.ei);
          set_mu(rmodel, mu);
          ei_errs = compute_error(this.ei_ext, rmodel, [], detailed_data.ei);
        end

        %%%%%%%%%%%%%%%%%%%%%% extend EI basis %%%%%%%%%%%%%%%%%%%%%
        append_field(detailed_data, 'ei_errs', ei_errs);
        append_field(detailed_data, 'ei_max_err', max(ei_errs));

        this.ei_ext.target_error_external = 1;
        detailed_data.ei = basis_extension(this.ei_ext, rmodel, detailed_data.ei, ei_errs, mu);
        newMsize         = get_ei_size(detailed_data.ei);

        % skip ei if residual is too small
        if newMsize == Msize
          append_field(detailed_data, 'ei_skipped_for_too_small_residual', ext_step);
          ei_breakloop = true;
          if rmodel.verbose > 1
            disp('[1]> Skipping EI extension because of too small residual.');
          end
        else

          append_field(detailed_data, 'ei_ext_count', newMsize - Msize);
          % update the info structure
          Msize = newMsize;
          append_field(detailed_data, 'ei_ext_steps', ext_step);
        end
      end

      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
      % EI extension checks end                                           %
      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%


      % reduced basis extension
      Nsize = get_rb_size(detailed_data);
      M_by_N = Msize / Nsize;

      [rb_breakloop, rb_reason] = pre_check_for_end(this.rb_ext, rmodel, detailed_data.rb);


      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
      % RB extension checks start                                         %
      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
      rb_ext_steps                   = get_field(detailed_data, 'rb_ext_steps');
      rb_discarded_for_bad_extension = get_field(detailed_data, 'rb_discarded_for_bad_extension', []);
      if rb_breakloop
        if rmodel.verbose > 1
          disp('[1]> Skipping RB extension step, because pre_check_for_end() returned true');
        end
        if rmodel.verbose > 5
          disp(['[5]> ',rb_reason]);
        end
        append_field(detailed_data, 'rb_skipped_for_check_end', ext_step);
      else
        % on error increase only update the rb space
        if last_extension_bad
          if get_field(detailed_data, 'discard_last_rb_after_bad_extension') ...
              && rb_ext_steps(end) == ext_step -1 ...
              && length(rb_ext_steps) > 2 ...
              && (isempty(rb_discarded_for_bad_extension) ...
                  || rb_ext_steps(end-1) > rb_discarded_for_bad_extension(end))

            append_field(detailed_data, 'rb_discarded_for_bad_extension', ext_step);
            delete_rb(detailed_data, Nsize);
            if rmodel.verbose > 1
              disp('[1]> Discarding last RB vector after bad extension step');
            end
          elseif this.skip_rb_after_bad_extension
            append_field(detailed_data, 'rb_skipped_for_bad_extension', ext_step);
            if rmodel.verbose > 1
              disp('[1]> Skipping RB extension after bad extension step');
            end
          end
        % only update rb basis space if the M_by_N_ratio is fulfilled
        elseif ~ei_breakloop && M_by_N < get_field(detailed_data, 'M_by_N_ratio')
          append_field(detailed_data, 'rb_skipped_for_M_by_N_ratio_restriction', ext_step);

          if rmodel.verbose > 1
            disp('[1]> Skipping RB extension because of M_by_N_ratio');
          end
        % if reduced simulations failed we have a big problem! :(
        elseif any(isnan(max_err_seq))
          append_field(detailed_data, 'rb_skipped_for_failed_simulation', ext_step);
          if ei_breakloop
            error('Can''t extend either EI nor RB reduced basis space');
          end

        % otherwise: Do a normal basis extension
        else
          detailed_data    = basis_extension(this.rb_ext, rmodel, detailed_data, max_err_seq, mu);
          append_field(detailed_data, 'rb_ext_steps', ext_step);
        end
      end
      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
      % RB extension checks end                                           %
      %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    end

    function detailed_data = finalize(this, rmodel, detailed_data)
      % function detailed_data = finalize(this, rmodel, detailed_data)
      % @copybrief Greedy.Plugin::Interfacefinalize()
      %
      % @copydetails Greedy.Plugin::Interfacefinalize()
      %
      % Parameters:
      %   rmodel: an object of type IReducedModel
      %   detailed_data: an object of type Greedy.DataTree.Detailed.PODEILeafNode
      %
      % Return values:
      %   detailed_data: an object of type Greedy.DataTree.Detailed.PODEILeafNode
      %
      % This method calls
      %   -# the finalize() method of the #ei_ext member and
      %   -# the finalize() method of the #rb_ext member

      detailed_data.ei = finalize(this.ei_ext, rmodel, detailed_data.ei);
      detailed_data.rb = finalize(this.rb_ext, rmodel, detailed_data.rb);
    end

  end

  methods(Access=public)

    function isbad = indicate_bad_basis_extension(this, detailed_data)
      % function isbad = indicate_bad_basis_extension(this, detailed_data)
      % indicates whether the last basis extension was bad
      %
      % The last basis extension is bad if the maximum error indicator is
      % larger than in the step before.
      %
      % Furthermore, we test if the maximum error indicator is `f` times larger
      % than the minimum error indicated at any extension step before. In this
      % case we say, the event @em explosion has occured.
      %
      % If #maximum_temporary_error_growth_factor equals '0', the explosion
      % test is disabled.
      %
      % The explosion test can affect the the assessment of a @em bad @em
      % extension in the following way dependent on the option
      % #bad_extension_on_explosion: 
      %    - If #bad_extension_on_explosion is set to true, an @em explosion is
      %    also an indicator for a bad extension.
      %    - If #bad_extension_on_explosion is set to false, for an @em
      %    explosion true is returned.
      %
      % The latter option assumes that an explosion of the error indicates that
      % lately introduced complexity by more accurate empirical interpolation
      % operators is not captured by the current reduced basis yet.
      %
      % In the @em explosion test the factor `f` is defined by
      %   ``f = c_{\text{max\_temp\_err\_growth}} \cdot \frac{1}{n_{\text{no\_rb\_ext}}}``
      % with a constant `c_{\text{max\_temp\_err\_growth}}` given by
      % #maximum_temporary_error_growth_factor and a weighting factor
      % determined by the number of extension steps withouth reduced
      % basis extension `n_{\text{no\_rb\_ext}}`.
      %
      % Return values:
      %   isbad: a boolean value indicating whether the last extension was bad.

      max_extension_errs = get_field(detailed_data, 'max_err_sequence');

      ext_step = length(max_extension_errs);

      isbad = (length(max_extension_errs) > 1 && (max_extension_errs(end) > max_extension_errs(end-1)));

      max_temp_error_growth_factor = get_field(detailed_data, 'maximum_temporary_error_growth_factor');
      rb_ext_steps                 = get_field(detailed_data, 'rb_ext_steps', 0);
      if max_temp_error_growth_factor > 0
        is_explosion = length(max_extension_errs) > 1 && max_extension_errs(end) < ...
          max_temp_error_growth_factor/(ext_step - rb_ext_steps(end)) ...
          * min(max_extension_errs);
        if get_field(detailed_data, 'bad_extension_on_explosion')
          isbad = isbad | is_explosion;
        else
          isbad = isbad & is_explosion;
        end
      end
    end

  end

end