ReducedData.m

classdef ReducedData < IReducedData & DataTree.CreatorDefault
  % a default reduced data implementation which stores a
  % @ref .DataTree.INode "data tree" object copying the structure of a
  % Greedy.User.IDetailedData.datatree as returned by the
  % @ref Greedy.Interface "greedy algorithm objects".
  %
  % This is also a .DataTree.CreatorDefault object which copies the tree
  % structure of detailed data tree. The user only needs to define how the leaf
  % elements of this reduced data tree storing the actual reduced matrices and
  % vectors shall be constructed. Such leaf elements should be derived from
  % Greedy.User.IReducedDataNode.
  %
  % See also: Greedy.DataTree.Detailed.INode for more details on the
  %           detailed data tree.

  properties(Dependent, SetAccess=private)
    % number of reduced basis vectors stored in this data node.
    N;

    % number of collateral reduced basis vectors stored in this data node.
    M;

    % number of collateral reduced basis vectors used for error estimation.
    Mstrich;
  end

  properties
    % the actual data tree of type .DataTree.INode
    %
    % The leaf elements have are objects of the class type
    % Greedy.User.IReducedDataNode
    datatree;
  end

  properties(Transient, Hidden=true)
    % struct with transient options for the create_leaf_node() method.
    create_tree_opts;
  end

  methods
    function rd = ReducedData(rmodel, detailed_data)
      % function rd = ReducedData(rmodel, detailed_data)
      % constructor either constructing a reduced data object from a
      % @ref Greedy.User.IDetailedData "detailed data" object or copying a
      % @ref Greedy.User.ReducedData "reduced data" object and extracting
      % smaller reduced vectors and matrices.
      %
      % The two possible synopsis for this functions:
      %   -# 'reduced_data = Greeedy.User.ReducedData(rmodel, detailed_data)' and
      %   -# 'rd_subset    = Greeedy.User.ReducedData(rmodel, reduced_data)'
      %
      % Parameters:
      %   rmodel: an object of type Greedy.User.IReducedModel describing the
      %           reduced numerical scheme.
      %            - For synopsis (1) it defines via the option
      %              @ref IReducedModel.bg_descr "bg_descr.reduced_data_constructor"
      %              the type of the leaf elements in the reduced data tree and
      %            - for synopsis (2) it defines the size of the reduced
      %              matrices and vectors in the copied object by the member
      %              variables @ref IReducedModel.N "N", and in case of
      %              @ref IReducedModel.crb_enabled "enabled empirical interpolation"
      %              also by @ref IReducedModel.M "M" and
      %              @ref IReducedModel.Mstrich "Mstrich".
      %            .
      %   detailed_data: By default, this is a detailed data object of type .Greedy.User.IDetailedData
      %                  @b or in case of synposis (2) a
      %                  .Greedy.User.ReducedData object to be copied.

      if nargin == 0
        error('Greedy.ReducedData constructor two arguments');
      elseif nargin == 2 && isa(detailed_data, 'IReducedData')
        copy = detailed_data;
        fns = properties(copy);
        fns = setdiff(fns, {'datatree', 'create_tree_opts', 'N', 'M', 'Mstrich'});

        for i = 1:length(fns)
          rd.(fns{i}) = copy.(fns{i});
        end
        rd.create_tree_opts.rmodel = rmodel;
        rd.create_tree_opts.mode   = 'copy_extract';
        rd.datatree = create_tree(copy.datatree, rd);

      elseif nargin == 2
        fill_data(rd, rmodel, detailed_data);
      else
        error('Did not find constructor for your arguments.');
      end
    end

    function subset_reduced_data = extract_reduced_data_subset(this, rmodel)
      % function subset_reduced_data = extract_reduced_data_subset(this, rmodel)
      % @copybrief .IReducedData.extract_reduced_data_subset()
      %
      % @copydetails .IReducedData.extract_reduced_data_subset()
      %
      % Parameters:
      %   rmodel: of type .Greedy.User.ReducedData
      %
      % Return values:
      %   subset_reduced_data: a copy of type Greedy.User.ReducedData of
      %               this object with (possibly) smaller reduced matrices and
      %               vectors. If the reduced magnitudes are unchanged, the
      %               leaf elements are not copied but are references to the
      %               original leafs.

      subset_reduced_data = Greedy.User.ReducedData(rmodel, this);
    end

    function conds = get_conds(this)
      warning('RBmatlab:Greedy:general', 'You should call get_conds on a leaf of the reduced data tree');
      conds = [];
    end

    function reduced_data_leaf = get_leaf(this, rmodel)
      % function reduced_data_leaf = get_leaf(this, rmodel)
      % returns the @ref .Greedy.User::IReducedDataNode "reduced data tree leaf node"
      % for a specific combination of parameters and time indices given by the
      % @ref ::IReducedModel "reduced model".
      %
      % Parameters:
      %   rmodel: of type .Greedy.User::IReducedModel
      %
      % Return values:
      %   reduced_data_leaf: object of type .Greedy.User::IReducedDataNode which
      %                       actually stores the reduced vectors and matrices
      %                       needed for online simulations.

      dmodel = rmodel.detailed_model;

      if isfield(dmodel.descr, 'nt')
        nt = dmodel.descr.nt;
      else
        nt = [];
      end

      reduced_data_leaf = get_by_description(this.datatree, [], get_mu(rmodel), nt);
    end

  end

  methods

    function node = create_leaf_node(this, arg_node, basepath, mu_cube, tslice)
      % function create_leaf_node(this, arg_node, basepath, mu_cube, tslice)
      % This creates the actual reduced data leafs implementing the
      % .Greedy.User::IReducedDataNode interface.
      %
      % @copydetails .DataTree.ICreator.create_leaf_node()
      %
      % Return values:
      %   node: of type .Greedy.User::IReducedDataNode
      %
      % @note The 'arg_node' argument can be either a
      % .Greedy.User::IDetailedData implementation @b or a
      % .Greedy.User::IReducedDataNode object. (c.f.
      % @ref Greedy.User::ReducedDataReducedData() "constructor description"
      % for more information on these two variants)

      rmodel = this.create_tree_opts.rmodel;
      % NOTE: detailed_data can also be a reduced data node... In this case,
      % the mode should be 'copy_extract'
      if isequal(this.create_tree_opts.mode, 'copy_extract') ...
          && ~needs_subset_copy(arg_node, rmodel)
        node = arg_node;
      else
        node = rmodel.bg_descr.reduced_data_constructor(rmodel, arg_node);
      end
    end

    function N = get.N(this)

      N = this.datatree.N;
    end

    function M = get.M(this)

      M = this.datatree.M;
    end

    function Mstrich = get.Mstrich(this)

      Mstrich = this.datatree.Mstrich;
    end


  end

  methods (Access = protected)
    function fill_data(this, rmodel, detailed_data)
      % function fill_data(this, rmodel, detailed_data)
      % defines how the #datatree member is being filled with data.
      %
      % If not overwritten, this method copies the tree structure of the given
      % detailed data object and computes the reduced matrices and vectors in
      % the leaf elements.
      %
      % @note The second arguments does not need to wrap a detailed data tree,
      % as the .Greedy.User.IDetailedData objects do. If no tree is given, a
      % reduced data tree with only a root element is created.
      %
      % Parameters:
      %   rmodel: of type .Greedy.User.IReducedModel
      %
      % Optional fields of detailed_data:
      %   datatree: @copybrief .Greedy.User.IDetailedData.datatree

      this.create_tree_opts.rmodel = rmodel;
      this.create_tree_opts.mode   = 'normal';

      if isa(detailed_data, 'Greedy.User.IDetailedData')
        dd = detailed_data.datatree;
        if isa(dd, 'Greedy.DataTree.Detailed.IdMapNode')
          dd = get_by_description(dd, 'rb');
        end
        this.datatree = create_tree(dd, this);
      else
        this.datatree = create_leaf_node(this, detailed_data);
      end

    end
  end

end