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

        dim;
    public: /* ( setObservable ) */


        AffParamKernelTest(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;

            this.Sampler= sampling.GridSampler;

            /*  This class implements a fake Approx subclass to allow access
             * to the this.Ma property for the error estimator. */
            this.Approx= [];

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

            this.ODESolver= solvers.ExplEuler;

            /* % System settings */
            this.System= models.synth.AffParamKernelTestSys(this, pos_flag);
            this.DefaultInput= 1;
            this.TrainingInputs= 1;

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


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

#endif

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


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


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


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

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


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

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

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


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


        static function m = getTest4(varargin) {
            m = models.synth.AffParamKernelTest(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.AffParamKernelTest(varargin[:]);

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


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

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

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


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

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

            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.AffParamKernelTest(varargin[:]);

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

            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.AffParamKernelTest(varargin[:]);

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

            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.AffParamKernelTest(varargin[:]);
            m.T= 20;

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

            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.AffParamKernelTest(varargin[:]);
            m.T= 20;

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

    
};
}
}