BaseEstimator.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 BaseEstimator
  :public KerMorObject,
   public ICloneable {
    public: /* ( Dependent ) */

        Enabled;
    public:

        StateError = "[]";
        ExtraODEDims = 0;
    public:

        OutputError = "[]";
        models.ReducedModel ReducedModel = "[]";
    public: /* ( Transient ) */

        mu;

        
    private:

        fEnabled = true;

        e0Comp;

        
    public:


        function  offlineComputations(models.BaseFullModel model) {

            if isa(model.System.x0," dscomponents.AffineInitialValue ")
                this.e0Comp= error.initial.AffineParametric;
            else
                this.e0Comp= error.initial.Constant;
            end
        }
        function doublect = postProcess(unused1,rowvec t,unused2) {

            if all(this.StateError == 0)
                warning(" BaseEstimator:postProcess "," State error is all zero. Attention! ");
            end

            st = tic;
            /*  Tranform to output error estimation (if used) */
            fs = this.ReducedModel.FullModel.System;
            C = fs.C;
            if ~isequal(fs.StateScaling,1)
                fd = size(this.ReducedModel.V,1);
                C = C*spdiags(fs.StateScaling,0,fd,fd);
            end
            if ~isempty(C)
                /*  Get error */
                if C.TimeDependent
                    e = this.StateError;
                    for idx=1:length(t)
                        e(idx) = norm(m.System.C.evaluate(t(idx),this.mu))*e(idx);
                    end
                else
                    Ce = C.evaluate([],this.mu);
                    if issparse(Ce)
                        Cn = normest(Ce);
                    else
                        Cn = norm(Ce);
                    end
                    this.OutputError= Cn*this.StateError;
                end
            else
                this.OutputError= this.StateError;
            end
            ct = toc(st);
        }
        function  clear() {
            this.StateError= [];
            this.OutputError= [];
        }
        function copy = clone(copy) {
            if nargin < 2
                error(" Clone to this method can only be called from subclasses. ");
            end
            copy.ExtraODEDims= this.ExtraODEDims;
            copy.StateError= this.StateError;
            copy.OutputError= this.OutputError;
            copy.Enabled= this.Enabled;
            /*  no cloning; components are only used in reduced models. */
            copy.e0Comp= this.e0Comp; 
            /*  No cloning of the associated reduced model. */
            copy.ReducedModel= this.ReducedModel;
            copy.mu= this.mu;
        }
        function e0 = getE0(colvec<double> mu) {
            e0 = this.e0Comp.getE0(mu);
        }
        function ct = prepareConstants(colvec<double> mu,unused1) {
            this.mu= mu;
            ct = 0;
        }


        function prepared = prepareForReducedModel(models.ReducedModel rmodel) {
            prepared = this.clone;
            if ~isa(rmodel," models.ReducedModel ")
                error(" The given value has to be a models.ReducedModel instance. ");
            end
            prepared.ReducedModel= rmodel;
            this.e0Comp.prepareForReducedModel(rmodel);
        }
        /* % Getter & Setter */
    public:


        
#if 0 //mtoc++: 'set.StateError'
function  StateError(value) {
            this.StateError= value;
        }

#endif


        
#if 0 //mtoc++: 'set.ExtraODEDims'
function  ExtraODEDims(value) {
            if (~isscalar(value) || value < 0) && value ~= 0
                error(" The value must be 0 or positive integer ");
            end
            this.ExtraODEDims= value;            
        }

#endif


        
#if 0 //mtoc++: 'set.Enabled'
function  Enabled(value) {
            if ~islogical(value)
                error(" Enabled property must be a boolean flag ");
            elseif ~value
                this.StateError= [];
            end
            this.fEnabled= value;
        }

#endif


        
#if 0 //mtoc++: 'get.Enabled'
function value = Enabled() {
            value = this.fEnabled;
        }

#endif

    
    public: /* ( Abstract ) */

        virtual function eint = evalODEPart(colvec x,double t,double ut) = 0;
    public: /* ( Static ) */

        static function est = getEstimator(models.BaseFullModel model) {
            if isempty(error.IterationCompLemmaEstimator.validModelForEstimator(model))
                est = error.IterationCompLemmaEstimator;
/*              elseif isempty(error.TPWLLocalLipEstimator.validModelForEstimator(model))
 *                 est = error.TPWLLocalLipEstimator(model); */
            elseif isempty(error.DEIMEstimator.validModelForEstimator(model))
                est = error.DEIMEstimator;
            elseif isempty(error.GLEstimator.validModelForEstimator(model))
                est = error.GLEstimator;
            else
                est = error.DefaultEstimator;
                fprintf(" BaseEstimator.getEstimator: No suitable error estimator found for given model. Using the default estimator (disabled).\n ");
            end
        }
    public: /* ( Abstract, Static ) */

        static function errmsg = validModelForEstimator(models.ReducedModel rmodel) = 0;
};
}