BaseCompLemmaEstimator.m

Go to the documentation of this file.

namespace error{


/* (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 BaseCompLemmaEstimator
  :public error.BaseEstimator {
    protected: /* ( Transient ) */

        StepNr;
    public:

        EstimationData = "[]";
    public:

        aComp;

        
    private: /* ( Transient ) */

        lstPreSolve;
    public: /* ( Transient ) */

        BaseCompLemmaEstimator() {
            this = this@error.BaseEstimator;
            this.ExtraODEDims= 1;
        }


        function  offlineComputations(models.BaseFullModel model) {

            /*  Call superclass */
            offlineComputations@error.BaseEstimator(this, model);
        }
         function prepared = prepareForReducedModel(models.ReducedModel rm) {
            prepared = prepareForReducedModel@error.BaseEstimator(this, rm);

            if isa(rm.FullModel.System.B," dscomponents.AffLinInputConv ")
                prepared.aComp= error.alpha.AffineParametric(rm);
            else
                prepared.aComp= error.alpha.Constant(rm);
            end

            prepared.lstPreSolve= addlistener(rm.ODESolver," PreSolve ",@prepared.cbPreSolve);
         }
        function e = evalODEPart(colvec x,double t,double ut) {
            phi = this.ReducedModel.System.f.Expansion.getKernelVector(x(1:end-1), t, this.mu);

            a = this.aComp.getAlpha(phi, ut, t, this.mu);
            b = this.getBeta(x, t);
            e = b*x(end) + a;

            this.EstimationData(:,this.StepNr) = [t; a; b];
            this.StepNr= this.StepNr + 1;
        }
        function ct = prepareConstants(colvec<double> mu,integer inputidx) {
            st = tic;
            if isempty(this.lstPreSolve)
                this.lstPreSolve= addlistener(this.ReducedModel.ODESolver," PreSolve ",@this.cbPreSolve);
            end
            this.lstPreSolve.Enabled= true;
            this.StepNr= 1;
            ct = toc(st) + prepareConstants@error.BaseEstimator(this, mu, inputidx);
        }


        function copy = clone(copy) {
            copy = clone@error.BaseEstimator(this, copy);
            copy.EstimationData= this.EstimationData;
            copy.aComp= this.aComp;
            copy.StepNr= this.StepNr;
            if ~isempty(copy.ReducedModel)
                copy.lstPreSolve= addlistener(copy.ReducedModel.ODESolver," PreSolve ",@copy.cbPreSolve);
                copy.lstPreSolve.Enabled= this.lstPreSolve.Enabled;
            end
        }


        function  clear() {
            clear@error.BaseEstimator(this);
            this.EstimationData= [];
        }


        function a = getAlpha(colvec<double> x,double t,colvec<double> ut) {
            phi = this.ReducedModel.System.f.getKernelVector(x, t, this.mu);
            a = this.aComp.getAlpha(phi, ut, t, this.mu);
        }
        function ct = postProcess(colvec<double> x,double t,integer inputidx) {
            if ~isempty(this.lstPreSolve)
                this.lstPreSolve.Enabled= false;
            end
            ct = postProcess@error.BaseEstimator(this, x, t, inputidx);
        }
    public: /* ( Abstract ) */ /* ( Transient ) */

        virtual function b = getBeta(colvec x,double t) = 0;
    private: /* ( Transient ) */

        function  cbPreSolve(sender,data) {
            if isempty(this.EstimationData) || size(this.EstimationData,2) ~= length(data.Times)
                this.EstimationData= zeros(3,length(data.Times));
            end
        }
    public: /* ( Static ) */ /* ( Transient ) */

        static function errmsg = validModelForEstimator(models.BaseFullModel model) {
            errmsg = [];
            if ~isempty(model.Approx) 
                if ~isa(model.Approx," approx.KernelApprox ")
                    errmsg = " The full model "" s approx function must be a subclass of approx.KernelApprox for this error estimator. "; 
                    return;
                end
            elseif ~isa(model.System.f," dscomponents.ParamTimeKernelCoreFun ")
                    errmsg = " If no approximation is used, the full model "" s core function must be a subclass of kernels.ParamTimeKernelCoreFun for this error estimator. "; 
                    return;
            end
            if ~isa(model.System.C," dscomponents.LinearOutputConv ")
                errmsg = " Local Lipschitz estimators work only for constant linear output conversion. ";
                return;
            elseif model.System.C.TimeDependent
                errmsg = " Output error estimation for time dependent output not implemented yet. ";
                return;
            end
            if ~isa(model.ODESolver," solvers.BaseCustomSolver ");
                errmsg = " The reduced models ODE solver must be a subclass of BaseCustomSolver. ";
            end
        }
};
}