FileTrajectoryData.m

Go to the documentation of this file.

namespace data{


/* (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 FileTrajectoryData
  :public data.ATrajectoryData,
   public data.FileDataCollection {
    public:

        logical ReplaceExisting = false;
        logical UniformTrajectories = true;
    private:

        sizes = "[]";
        bbmin = "[]";
        bbmax = "[]";
        trajlen = "[]";


        width = 0;
    public:

        FileTrajectoryData(datadir) {
            if ~usejava(" jvm ")
                error(" FileTrajectoryData cannot be used as java is not enabled. ");
            end
            if nargin < 1
                data_dir = fullfile(KerMor.App.TempDirectory,sprintf(" temp_ftd_%s ",...
                    IDGenerator.generateID));
            elseif ischar(datadir)
                data_dir = datadir;
            else
                error(" Invalid argument: %s ",class(datadir));
            end
            this = this@data.FileDataCollection(data_dir);
            this.clearTrajectories;
        }
        function [colvec<double>x , doublectime ] = getTrajectory(colvec<double> mu,integer inputidx) {

            if nargin < 3
                inputidx = [];
                if nargin < 2
                    mu = [];
                end
            end
            x = []; ctime = Inf;
            s = this.getData([mu; inputidx]," x "," ctime ");
            if ~isempty(s)
                ctime = s.ctime;
                x = s.x;
            end
        }
        function n = getNumTrajectories() {
           n = this.getCollectionSize;
        }


        function [colvec<double>x , colvec<double>mu , integerinputidx , doublectime ] = getTrajectoryNr(nr) {
            s = this.getDataNr(nr," x "," mu "," inputidx "," ctime ");
            x = s.x;
            mu = s.mu;
            inputidx = s.inputidx;
            ctime = s.ctime;
        }
        function  addTrajectory(colvec<double> x,colvec<double> mu,integer inputidx,double ctime) {

            if nargin < 4
                inputidx = [];
                if nargin < 3 
                    mu = [];
                end
            end

            newd = size(x,1); newmu = length(mu);
            if isempty(this.sizes) || all(this.sizes == 0)
                this.sizes= [newd newmu];
            elseif newd ~= this.sizes(1)
                error(" Invalid trajectory dimension. Existing: %d, new: %d ",this.sizes(1),newd);
            end

            exists = this.hasData([mu; inputidx]);
            if this.UniformTrajectories
                if isempty(this.trajlen)
                    this.trajlen= size(x,2);
                elseif this.trajlen ~= size(x,2)
                    error(" Invalid trajectory length. Existing: %d, new: %d ",this.trajlen,size(x,2));
                end    
            else
                if ~exists
                    this.width= this.width + size(x,2);
                end
            end

            if ~this.ReplaceExisting && exists
                warning(" KerMor:FileTrajectoryData "," Trajectory already present and replacing is disabled. ");
                return;
            end
            traj.x= x;
            traj.ctime= ctime;
            traj.inputidx= inputidx;
            traj.mu= mu;
            this.addData([mu; inputidx], traj);
            this.updateBB(x);
        }
        function l = getTotalLength() {
            if this.UniformTrajectories
                l = this.getNumBlocks * this.trajlen;
            else
                l = this.width;
            end
        }


        function  clearTrajectories() {
            this.clear;
            this.bbmin= [];
            this.bbmax= [];
            this.sizes= [];
            this.trajlen= [];
        }


        function  consolidate(models.BaseFullModel model) {
            this.bbmin= [];
            this.bbmax= [];

            ni = max(model.TrainingInputCount,1);
            ns = model.Data.SampleCount;
            pi = ProcessIndicator(" Consolidating FileTrajectoryData ",ni*ns);
            for u=1:ni
                ui = u;
                if model.TrainingInputCount == 0
                    ui = [];
                end
                for n=1:ns
                    mu = model.Data.ParamSamples(:,n);
                    /*  GetData has a "backup" feature to also find files if
                     * not enlisted in the hash map; if so, the hash map is
                     * updated automatically! */
                    s = this.getData([mu; ui]);
                    if ~isempty(s)
                        this.updateBB(s.x);
                        if this.UniformTrajectories && isempty(this.trajlen)
                            this.trajlen= size(s.x,2);
                        end
                    end
                    pi.step;
                end
            end
            pi.stop;
        }
        function [colvec<double>x , X ] = getBoundingBox() {
            x = this.bbmin;
            X = this.bbmax;
        }
        function [d , mud ] = getTrajectoryDoFs() {
            if isempty(this.sizes)
                if this.getNumTrajectories > 0
                    [x,mu] = this.getTrajectoryNr(1);
                    d = size(x,1);
                    mud = length(mu);
                else
                    d = 0; mud = 0;
                end
                this.sizes= [d mud]; 
            end
            d = this.sizes(1);
            mud = this.sizes(2);
        }

    
    private:

        function  updateBB(colvec<double> x) {
            [m,M] = Utils.getBoundingBox(x);
            if isempty(this.bbmin)
                this.bbmin= m;
                this.bbmax= M;
            else
                this.bbmin= min(this.bbmin,m);
                this.bbmax= max(this.bbmin,M);
            end
        }
    protected: /* ( Static ) */

        static function this = loadobj(this,initfrom) {

            created = false;
            if ~isa(this," data.FileTrajectoryData ")
                initfrom = this;
                this = data.FileTrajectoryData(initfrom.DataDirectory);
                created = true;
            end
            if nargin == 2 || created
                this.sizes= initfrom.sizes;
                this.bbmin= initfrom.bbmin;
                this.bbmax= initfrom.bbmax;
                this.trajlen= initfrom.trajlen;
                this.UniformTrajectories= initfrom.UniformTrajectories;
                this.ReplaceExisting= initfrom.ReplaceExisting;
                /*  property from ABlockedData */
                this.MinRelSingularValueSize= initfrom.MinRelSingularValueSize;
                this = loadobj@data.FileDataCollection(this, initfrom);
            else
               this = loadobj@data.FileDataCollection(this);
            end
        }
    public: /* ( Static ) */

        static function res = test_FileTrajectoryData() {
            
            m = data.FileTrajectoryData;

            T = 10;
            res = true;
            for i=1:T;
                tr(:,:,i) = rand(30,50);/* #ok */

                p(:,i) = rand(4,1);/* #ok */

                in(i) = i;/* #ok */

            end

            /*  Params only */
            for i=1:T;
                m.addTrajectory(tr(:,:,i),p(:,i),[],1);
            end
            res = res && m.getNumTrajectories == T;

            pos = false(1,1,T);
            ppos = false(1,T);
            for i=1:T;
                [x, pi] = m.getTrajectoryNr(i);
                pos = pos | sum(sum(repmat(x,[1 1 T]) - tr,1),2) == 0;
                ppos = ppos | sum(repmat(pi,1,T) - p,1) == 0;

                x = m.getTrajectory(p(:,i),[]);
                res = res && isequal(x,tr(:,:,i));
            end
            res = res && all(pos) && all(ppos);
            m.clearTrajectories;

            /*  Inputs only */
            for i=1:T;
                m.addTrajectory(tr(:,:,i),[],in(i),1);
            end
            res = res && m.getNumTrajectories == T;

            pos = false(1,1,T);
            ipos = false(1,T);
            for i=1:T
                [x, ~, ini] = m.getTrajectoryNr(i);
                pos = pos | sum(sum(repmat(x,[1 1 T]) - tr,1),2) == 0;
                ipos = ipos | repmat(ini,1,T)-in == 0;

                x = m.getTrajectory([],in(i));
                res = res && isequal(x,tr(:,:,i));
            end
            res = res && all(pos) && all(ipos);
            m.clearTrajectories;

            /*  Both */
            for i=1:T;
                m.addTrajectory(tr(:,:,i),p(:,i),in(i),1);
            end
            res = res && m.getNumTrajectories == T;

            pos = false(1,1,T);
            ppos = false(1,T);
            ipos = false(1,T);
            for i=1:T
                [x, pi, ini] = m.getTrajectoryNr(i);
                pos = pos | sum(sum(repmat(x,[1 1 T]) - tr,1),2) == 0;
                ppos = ppos | sum(repmat(pi,1,T) - p,1) == 0;
                ipos = ipos | repmat(ini,1,T)-in == 0;

                x = m.getTrajectory(p(:,i),in(i));
                res = res && isequal(x,tr(:,:,i));
            end
            res = res && all(pos) && all(ppos) && all(ipos);
            m.clearTrajectories;
        }

    

};
}