BaseCoreFun.m

Go to the documentation of this file.

namespace models{
namespace pcd{


/* (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 BaseCoreFun
  :public dscomponents.ACompEvalCoreFun {
    public: /* ( Constant ) */

        static const .double ActivationTransitionTime = 10;
            static const .double MaxActivationTime = 400;
    public: /* ( Dependent ) */

        integer ActivationFunType;
    private:

        gaussian;

        fAFT = 1;

        
    public:

        BaseCoreFun(dynsys) {
            this = this@dscomponents.ACompEvalCoreFun(dynsys);
            this.TimeDependent= true;

            this.ActivationFunType= 1;
        }


        function copy = clone(copy) {
            copy = clone@dscomponents.ACompEvalCoreFun(this, copy);
            /*  Sets gaussian etc */
            copy.ActivationFunType= this.ActivationFunType;
        }
        function  evaluateCoreFun() {
            error(" dont call me (direct overload of evaluate for efficiency ");
        }


        function  plotActivationFun(colvec<double> mu,pm) {
            if nargin < 3
                pm = PlotManager;
                pm.LeaveOpen= true;
                if nargin < 2
                    mu = this.System.Model.getRandomParam;

                end
            end

            h = pm.nextPlot(" activation_fun "," External input activation function "," time "," factor ");
            t = linspace(0,min(this.System.Model.T,this.MaxActivationTime*1.2),2000);
            plot(h,t,this.activationFun(t/this.System.Model.tau,mu));

            if nargin < 3
                pm.done;
            end
        }


        
#if 0 //mtoc++: 'set.ActivationFunType'
function  ActivationFunType(value) {
            if value == 1
                /*  \gamma=28 is such that we have K(0,27)~<.4 (27=150/tau) */
                k = kernels.GaussKernel(28.206364723698);
            else
                k = kernels.GaussKernel;
                k.setGammaForDistance(this.ActivationTransitionTime/this.System.Model.tau,.001);
            end
            this.gaussian= k;
            this.fAFT= value;
        }

#endif

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

#endif

    
    protected:

        function f = activationFun(double t,colvec<double> mu) {
            g = this.gaussian;
            if this.ActivationFunType == 1
                f = (g.evaluateScalar(t-27)-.4).*(t<=54)/.6;
            else
                tau = this.System.Model.tau;
                ts = this.ActivationTransitionTime/tau;
                te = ts+(mu(3,:)*(this.MaxActivationTime-2*this.ActivationTransitionTime))/tau;
                f = (g.evaluateScalar(t-ts)-.001).*(t<=ts)/.999 ...
                    + (t>ts).*(t<=te) ...
                    + (g.evaluateScalar(t-te)-.001).*(t>te).*(t<=te+ts)/.999;
            end
        }

    
    protected: /* ( Static ) */

        static function obj = loadobj(obj,from) {
            if nargin == 2
                if isfield(from," System ")
                    obj.System= from.System;
                end
                /*  Sets gaussian etc */
                if isfield(from," fAFT ")
                    AFT = from.fAFT;
                else
                    AFT = 1;
                end
                obj.ActivationFunType= AFT;
                obj = loadobj@dscomponents.ACompEvalCoreFun(obj, from);
            else
                obj = loadobj@dscomponents.ACompEvalCoreFun(obj);
            end
        }

    
};
}
}