RiemannBurgers.m

Go to the documentation of this file.

namespace models{
namespace rbmatlab{


/* (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 RiemannBurgers
  :public models.rbmatlab.RBMatlabModel {
    public:

        RiemannBurgers(xnum,ynum,T) {
            this = this@models.rbmatlab.RBMatlabModel;

            /*  Setup rbmatlab param struct */
            params = struct;
            if nargin < 3
                T = .5;
                if nargin < 2
                    if nargin < 1
                         xnum = 100;    
                    end
                    ynum = 20;
                end
            end
            params.xnumintervals= xnum;
            params.ynumintervals= ynum;

            /*  Get rbmatlab model */
            m = riemann_burgers_model(params);
            m.newton_regularisation= 0;
            m.T= T;
            m.nt= 100;
            /*  for a detailed simulation we do not need the affine parameter
             * decomposition */
            m.decomp_mode= 0;
            this.RBMModel= m;

            this.RBMDataCont= models.rbmatlab.RBMDataContainer(gen_model_data(m));

            /* this.ComputeParallel = false; */

            /*  Times */
            this.T= m.T;
            this.dt= m.T / m.nt;

            /*  System setup */
            this.System= models.rbmatlab.RiemBurgSys_Fun(this);

            /*  Solver */
            this.ODESolver= solvers.ExplEuler(this.dt);

            /*  Sampling */
            this.Sampler= sampling.GridSampler;

            aa = approx.algorithms.Componentwise;
            aa.ComputeParallel= false;
            a = approx.KernelApprox(this.System);
            a.Algorithm= aa;
            a.Kernel= kernels.GaussKernel(60);
            a.TimeKernel= kernels.GaussKernel(10*m.T/m.nt);
            a.ParamKernel= kernels.NoKernel;
            this.Approx= a;
            this.preApproximationTrainingCallback= @this.preApproxCallback;
            this.postApproximationTrainingCallback= @this.postApproxCallback;

            /*  Space reduction; choose only first row for subspace as the
             * problem repeats in y-direction. */
            V = repmat(eye(params.xnumintervals),...
                params.ynumintervals,1)*sqrt(1/params.ynumintervals);
            this.SpaceReducer= spacereduction.ManualReduction(V,V);
        }
        function  plot(double t,matrix<double> y) {
            sd.U= y;
            ppar.no_lines= 1;
            plot_sim_data(this.RBMModel, this.RBMDataCont.RBMData, sd, ppar);
        }


    
    private:

        function  preApproxCallback() {
            xnum = this.RBMModel.xnumintervals;
            /* this.Data.ApproxTrainData = this.Data.ApproxTrainData(1:xnum+3,:); */
            this.Data.ApproxTrainData.fxi= this.Data.ApproxTrainData.fxi(1:xnum,:);
        }


        function  postApproxCallback() {
            ynum = this.RBMModel.ynumintervals;
            this.Data.ApproxTrainData.fxi= repmat(this.Data.ApproxTrainData.fxi,ynum,1);
            this.Approx.Ma= repmat(this.Approx.Ma,ynum,1);
            this.Approx.off= repmat(this.Approx.off,ynum,1);
        }

    

};
}
}