LinspaceSelector.m

Go to the documentation of this file.

namespace data{
namespace selection{


/* (Autoinserted by mtoc++)
 * This source code has been filtered by the mtoc++ executable,
 * which generates code that can be processed by the doxygen documentation tool.
 *
 * On the other hand, it can neither be interpreted by MATLAB, nor can it be compiled with a C++ compiler.
 * Except for the comments, the function bodies of your M-file functions are untouched.
 * Consequently, the FILTER_SOURCE_FILES doxygen switch (default in our Doxyfile.template) will produce
 * attached source files that are highly readable by humans.
 *
 * Additionally, links in the doxygen generated documentation to the source code of functions and class members refer to
 * the correct locations in the source code browser.
 * However, the line numbers most likely do not correspond to the line numbers in the original MATLAB source files.
 */

class LinspaceSelector
  :public data.selection.ASelector {
    public: /* ( setObservable ) */

        Size = Inf;
        MaxMemPerc = .4;

        
    public: /* ( setObservable ) */


        LinspaceSelector() {
            this.registerProps(" Size ");
        }


        function copy = clone() {
            copy = data.selection.LinspaceSelector;
            /* copy = clone@data.selection.ASelector(this, copy); */
            copy.Size= this.Size;
        }


        
#if 0 //mtoc++: 'set.Size'
function  Size(value) {
            if ~isposintscalar(value) && ~isinf(value)
                error(" The value must be a positive integer. ");
            end
            this.Size= value;
        }

#endif

    
    protected: /* ( Sealed ) */ /* ( setObservable ) */

        function [matrixxi , rowvecti , matrixmui , matrixfxi ] = select(models.BaseFullModel model) {

            md = model.Data;
            td = md.TrajectoryData;
            hasfxi = false;
            if ~isempty(md.TrajectoryFxiData) && td.getNumTrajectories == md.TrajectoryFxiData.getNumTrajectories
                hasfxi = true;
            end
            nt = td.getNumTrajectories;

            /*  The trajectory length */
            tl = length(model.Times);
            /*  The total size of all trajectories
             * If nonuniform data is allowed, we need to iterate over all
             * data in order to determine the different lengths */
            if isa(td," data.FileTrajectoryData ") && ~td.UniformTrajectories
                sizes = zeros(1,nt);
                pi = ProcessIndicator(" Possibly non-uniform trajectories. Gathering %d trajectory sizes ",nt,false,nt);
                for n = 1:nt
                    x = td.getTrajectoryNr(n);
                    sizes(n) = size(x,2);
                    pi.step;
                end
                pi.stop;
            else
                sizes = ones(1,nt) * tl;
            end

            linpos = [1 cumsum(sizes)];
            ts = linpos(end);

            /*  Select maximal as many as are there! */
            s = min(this.Size,ts);
            idx = round(linspace(1,ts,s));

            [xd, mud] = td.getTrajectoryDoFs;
            /*  Use 512 MB chunks for approx train data */
            xi = data.FileMatrix(xd,s," Dir ",md.DataDirectory);
            ti = zeros(1,s);
            mui = zeros(mud,s);
            fxi = [];
            if hasfxi
                fxi = data.FileMatrix(xd,s," Dir ",md.DataDirectory);
            end

            pi = ProcessIndicator(" Selecting %d approximation training data samples from %d trajectories ",nt,false,this.Size,nt);
            atdpos = 0;
            for k=1:nt
                sel = idx(idx >= linpos(k) & idx < linpos(k+1));
                if ~isempty(sel)
                    sel = sel - min(sel) + 1;
                    [x, mu] = td.getTrajectoryNr(k);
                    atdpos = atdpos(end) + (1:length(sel));
                    xi(:,atdpos) = x(:,sel);
                    ti(atdpos) = model.Times(sel);
                    mui(:,atdpos) = repmat(mu,1,length(atdpos));

                    if hasfxi
                        [fx, fxmu] = md.TrajectoryFxiData.getTrajectoryNr(k);
                        if ~isequal(mu,fxmu)
                            hasfxi = false;
                        else
                            fxi(:,atdpos) = fx(:,sel);/* #ok */

                        end
                    end
                end
                pi.step;
            end
            pi.stop;
        }
    public: /* ( Static ) */ /* ( setObservable ) */

        static function res = test_LinSpaceSelector() {
            [res, m] = models.burgers.Tests.testBurgers_DEIM_versions(50,2);
            m.Approx.TrainDataSelector= data.selection.LinspaceSelector;
            m.Approx.TrainDataSelector.Size= 300;
            m.off4_genApproximationTrainData;
            m.ComputeTrajectoryFxiData= true;
            m.off2_genTrainingData;
            m.off4_genApproximationTrainData;
            res = res & true;
        }

};
}
}