KernelTest.m

Go to the documentation of this file.

namespace models{
namespace synth{


/* (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 KernelTest
  :public models.BaseFullModel {
    public: /* ( setObservable ) */

        dim;
    public: /* ( setObservable ) */


        KernelTest(dims,pos_flag) {
            
            this.registerProps(" dim ");

            if nargin < 2
                pos_flag = false;
                if nargin < 1
                    dims = 1000;
                end
            end
            this.dim= dims;


            /* % Model settings */
            this.Name= " Kernel test model ";

            this.T= 5;
            this.dt= .08;

            /* % System settings */
            this.System= models.synth.KernelTestSys(this, pos_flag);
            this.System.MaxTimestep= this.dt;

            this.Sampler= sampling.GridSampler;

            /*  This class implements a fake Approx subclass to allow access
             * to the this.Ma property for the error estimator. */
            a = approx.KernelApprox(this.System);
            a.Algorithm= approx.algorithms.Componentwise;
            ec = kernels.config.ParamTimeExpansionConfig;
            ec.StateConfig= kernels.config.GaussConfig(" G ",1);
            ec.ParamConfig= kernels.config.GaussConfig(" G ",1);
            ec.ParamConfig= kernels.config.GaussConfig(" G ",1);
            a.Algorithm.ExpConfig= ec;

            a.TrainDataSelector= data.selection.LinspaceSelector;
            a.TrainDataSelector.Size= 150;
            this.Approx= a;

            s = spacereduction.PODReducer;
            s.UseSVDS= true;
            s.Mode= " abs ";
            s.Value= 1;
            this.SpaceReducer= s;

            /* % ODE Solver */
            this.ODESolver= solvers.ExplEuler;

            /* % Error estimator */
            this.ErrorEstimator= error.IterationCompLemmaEstimator;
        }


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

#endif

      
    public: /* ( Static ) */ /* ( setObservable ) */


        static function res = test_RunKernelTests() {
            t = [];
            for k=1:11
                eval(sprintf(" t = models.synth.KernelTest.getTest%d; ",k))
                fprintf(" --------------- Running test getTest%d ---------------\n ",k);
                models.synth.KernelTest.runTest(t);
            end
            res = true;
        }


        static function r = runTest(models.BaseFullModel model) {
            model.offlineGenerations;
            r = model.buildReducedModel;
            ma = ModelAnalyzer(r);
            pm = ma.analyzeError(model.getRandomParam);
            pm.LeaveOpen= true;
        }


        static function m = getTest1(varargin) {
            m = models.synth.KernelTest(varargin[:]);

            V = ones(m.dim,1)*sqrt(1/m.dim);
            m.SpaceReducer= spacereduction.ManualReduction(V);
        }


        static function m = getTest2(varargin) {
            m = models.synth.KernelTest(varargin[:]);

            m.System.Inputs[1] = @(t)4;
            m.System.B= dscomponents.LinearInputConv(ones(m.dim,1));
            m.DefaultInput= 1;

            V = ones(m.dim,1)*sqrt(1/m.dim);
            m.SpaceReducer= spacereduction.ManualReduction(V);
        }


        static function m = getTest3(varargin) {
            m = models.synth.KernelTest(varargin[:]);
            m.System.x0= dscomponents.ConstInitialValue(rand(m.dim,1));
        }


        static function m = getTest4(varargin) {
            m = models.synth.KernelTest(varargin[:]);
            m.System.x0= dscomponents.ConstInitialValue(rand(m.dim,1));
            V = ones(m.dim,1)*sqrt(1/m.dim);
            m.SpaceReducer= spacereduction.ManualReduction(V);
        }


        static function m = getTest5(varargin) {
            m = models.synth.KernelTest(varargin[:]);

            m.System.B= dscomponents.LinearInputConv(rand(m.dim,1));
            m.System.Inputs[1] = @(t)4;
            m.DefaultInput= 1;
        }


        static function m = getTest6(varargin) {
            m = models.synth.KernelTest(varargin[:]);

            m.System.B= dscomponents.LinearInputConv(rand(m.dim,1));
            m.System.Inputs[1] = @(t)4;
            m.DefaultInput= 1;

            V = ones(m.dim,1)*sqrt(1/m.dim);
            m.SpaceReducer= spacereduction.ManualReduction(V);
        }


        static function m = getTest7(varargin) {
            m = models.synth.KernelTest(varargin[:]);

            m.System.Inputs[1] = @(t)4;
            m.DefaultInput= 1;

            B = ones(m.dim,1);
            B(1:m.dim/2) = -1;
            m.System.B= dscomponents.LinearInputConv(B);
        }


        static function m = getTest8(varargin) {
            m = models.synth.KernelTest(varargin[:]);

            m.System.Inputs[1] = @(t)4;
            m.DefaultInput= 1;

            B = ones(m.dim,1);
            B(1:m.dim/2) = -1;
            m.System.B= dscomponents.LinearInputConv(B);

            V = ones(m.dim,1)*sqrt(1/m.dim);
            m.SpaceReducer= spacereduction.ManualReduction(V);
        }


        static function m = getTest9(varargin) {
            m = models.synth.KernelTest(varargin[:]);

            m.System.Inputs[1] = @(t)4;
            m.DefaultInput= 1;

            m.System.x0= dscomponents.ConstInitialValue((rand(m.dim,1)-.5)*3);

            B = ones(m.dim,1);
            B(1:m.dim/2) = -1;
            m.System.B= dscomponents.LinearInputConv(B);

            V = ones(m.dim,1)*sqrt(1/m.dim);
            m.SpaceReducer= spacereduction.ManualReduction(V);
        }


        static function m = getTest10(varargin) {
            m = models.synth.KernelTest(varargin[:]);
            m.T= 20;

            m.System.Inputs[1] = @(t)sin(2*t);
            m.DefaultInput= 1;

            m.System.x0= dscomponents.ConstInitialValue((rand(m.dim,1)-.5)*3);

            B = ones(m.dim,1);
            B(1:m.dim/2) = -1;
            m.System.B= dscomponents.LinearInputConv(B);

            V = ones(m.dim,1)*sqrt(1/m.dim);
            m.SpaceReducer= spacereduction.ManualReduction(V);
        }


        static function m = getTest11(varargin) {
            m = models.synth.KernelTest(varargin[:]);
            m.T= 20;

            m.System.B= dscomponents.LinearInputConv(rand(m.dim,1));
            m.System.Inputs[1] = @(t)sin(2*t);
            m.DefaultInput= 1;
        }

    
};
}
}