ReducedModel.m

Go to the documentation of this file.

namespace models{


/* (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 ReducedModel
  :public models.BaseModel {
    public:

        models.BaseFullModel FullModel;
        matrix<double> V;
        matrix<double> W;
        matrix<double> ParamSamples;
    public: /* ( Dependent ) */

        error.BaseEstimator ErrorEstimator;
    private:

        error.BaseEstimator fErrorEstimator;
    public:


        ReducedModel(fullmodel) {
            this = this@models.BaseModel;
            this.FullModel= fullmodel;
        }


        function  delete() {
            this.ErrorEstimator= [];
            this.V= [];
            this.W= [];
            /*  Delete the full model with it's ModelData instance at last (V, W might have data
             * there) */
            this.FullModel= [];
        }


    
    public: /* ( Sealed ) */


        function  build(varargin) {

            disp(" Building reduced model... ");
            fullmodel = this.FullModel;
            fd = fullmodel.Data;
            if isempty(fullmodel.Approx) && isempty(fullmodel.SpaceReducer)
                error(" No reduction methods found on full model. No use in building a reduced model from it. ");
            end


            /*  Update name */
            this.Name= [" Reduced:  " fullmodel.Name];

            /* % Copy common values from the full model */
            this.T= fullmodel.T;
            this.dt= fullmodel.dt;
            this.tau= fullmodel.tau;
            this.isStatic= fullmodel.isStatic;
            this.DefaultMu= fullmodel.DefaultMu;
            this.DefaultInput= fullmodel.DefaultInput;
            this.G= fullmodel.G;

            /* % Get projection matrix */
            [this.V, this.W] = fullmodel.assembleProjectionMatrices(varargin[:]);
            this.ParamSamples= fd.ParamSamples;

            /* % Create a new reducedSystem passing this reduced model */
            fsys = fullmodel.System;
            this.System= fsys.getReducedSystemInstance(this);
            this.System.build;

            /* % Solver stuff */
            fms = fullmodel.ODESolver;
            if isa(fms," solvers.SemiImplicitEuler ")
                this.ODESolver= solvers.SemiImplicitEuler(this);
            elseif isa(fms," solvers.FullyImplEuler ")
                this.ODESolver= solvers.FullyImplEuler(this);
            else
                this.ODESolver= fms;
            end

            /*  Use the error estimator that has been precomputed in 
             * the full model */
            if ~isempty(fullmodel.ErrorEstimator)
                this.ErrorEstimator= fullmodel.ErrorEstimator.prepareForReducedModel(this);
            end
        }
        function [rowvec<double>t , matrix<double>x , doublectime ] = computeTrajectory(colvec mu,integer inputidx) {

            /*  Call constat pre-computations */
            cpre = 0;
            if ~isempty(this.ErrorEstimator)
                this.ErrorEstimator.clear;
                if this.ErrorEstimator.Enabled
                    cpre = this.ErrorEstimator.prepareConstants(mu, inputidx);
                end
            end

            /*  Call inherited method (actual work) */
            [t, xext, ctime] = computeTrajectory@models.BaseModel(this, mu, inputidx);

            /*  Split up results; the last rows of the ode solution contain
             * any online-computable errors */
            cpost = 0;
            if ~isempty(this.ErrorEstimator) && this.ErrorEstimator.Enabled
                x = xext(1:end-this.ErrorEstimator.ExtraODEDims,:);
                cpost = this.ErrorEstimator.postProcess(xext, t, inputidx);
            else
                x = xext;
            end
            ctime = ctime + cpre + cpost;
            fprintf(" Finished after %gs\n ",ctime);
        }
        function  saveFinal(filename) {
            a = this.FullModel.Approx;
            d = this.FullModel.Data;

            this.FullModel.Approx= [];
            this.FullModel.Data= [];

            save(filename, " this ");

            this.FullModel.Approx= a;
            this.FullModel.Data= d;
        }
    protected: /* ( Sealed ) */


        function [JacFun , JPattern ] = getJacobianInfo() {
            est = this.fErrorEstimator;
            [JacFun, JPattern] = getJacobianInfo@models.BaseModel(this);
            /*  Need extra care if we have an error estimator set */
            if ~isempty(est) && est.Enabled
                edims = est.ExtraODEDims;
                sys = this.System;
                if ~isempty(sys.A) && ~isempty(sys.f)
                    JacFun_ = @(t, x)sys.A.getStateJacobian(x(1:end-edims), t) + sys.f.getStateJacobian(x(1:end-edims), t);
                elseif ~isempty(sys.A)
                    JacFun_ = @(t, x)sys.A.getStateJacobian(x(1:end-edims), t);
                elseif ~isempty(sys.f)
                    JacFun_ = @(t, x)sys.f.getStateJacobian(x(1:end-edims), t);
                end
                /*  Simply pad with zero entries for the error estimator -
                 * not ideal, but must do for the moment. */
                pad = zeros(edims,edims);
                JacFun = @(t, x)blkdiag(JacFun_(t,x),pad);
            end
        }

    
    public: /* ( Sealed ) */

        function [f , ax ] = plot(double t,matrix<double> y,varargin) {
            [f,ax] = this.FullModel.plot(t, y, varargin[:]);
        }


        function [f , ax ] = plotState(double t,matrix<double> y,varargin) {
            [f,ax] = this.FullModel.plotState(t, y, varargin[:]);
        }


        function [f , ax ] = plotSingle(double t,matrix<double> y,varargin) {
            [f,ax] = this.FullModel.plotSingle(t, y, varargin[:]);
        }

    
    public:


        function [file , folder ] = createImage() {

            n = this.Name;
            h = KerMorLogo;
            text(-6,5,1.05,n," FontSize ",14," FontWeight "," bold ");
            folder = KerMor.App.TempDirectory;
            file = " modelimage ";
            Utils.saveFigure(h, fullfile(folder,file)," png ");
            file = [file " .png "];
            close(h);
        }
#if 0 //mtoc++: 'get.ErrorEstimator'
function e = ErrorEstimator() {
            e = this.fErrorEstimator;
        }

#endif


        
#if 0 //mtoc++: 'set.ErrorEstimator'
function  ErrorEstimator(error.BaseEstimator value) {
            if ~isempty(value)
                if ~isa(value," error.BaseEstimator ")
                    error(" The ErrorEstimator property must be a subclass of the error.BaseEstimator class. ");
                end
                msg = value.validModelForEstimator(this.FullModel);
                if ~isempty(msg)
                    error(msg);
                end
            end
            this.fErrorEstimator= value;
        }

#endif


        
#if 0 //mtoc++: 'set.FullModel'
function  FullModel(value) {
            if ~isempty(value) && ~isa(value," models.BaseFullModel ")
                error(" ReducedModel instances require a full model to build from. ");
            end
            this.FullModel= value;
        }

#endif

    
/* /*      methods(Static,Access=protecte*/
     methods(Static,Access=protected)
 *         function obj = loadobj(s)
 *             % Creates a new reduced model instance and loads its properties
 *             % from the given struct. 
 *             %
 *             % This method is only implemented as the property assignment
 *             % order is important for a reduced model (example: cannot set
 *             % an error estimator before having set the models system)
 *             obj = models.ReducedModel;
 *             
 *             % Load BaseModel's properties
 *             obj = loadobj@models.BaseModel(s, obj);
 *             
 *             % Load local properties
 *             di = ALoadable.getObjectDict;
 *             ex = di(s.FullModel.ID);
 *             if ~isempty(ex)
 *                 obj.FullModel = ex;
 *             else
 *                 obj.FullModel = s.FullModel;
 *             end
 *             obj.V = s.V; obj.W = s.W;
 *             obj.ParamSamples = s.ParamSamples;
 *             obj.ErrorEstimator = s.ErrorEstimator;
 *         end
 *     end */
    
};
}