BaseCoreFun.m

Go to the documentation of this file.

namespace models{
namespace pcdi{


/* (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;
    protected:

        nodes;


        hlp;


        idxmat;


        Ji;

        Jj;

        
    private:

        gaussian;

        fAFT = 1;

        fTau;

        
    public:

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

            this.fTau= dynsys.Model.tau;

            this.ActivationFunType= 2;
        }


        function copy = clone(copy) {
            copy = clone@dscomponents.ACompEvalCoreFun(this, copy);
            copy.gaussian= this.gaussian.clone;
            copy.fTau= this.fTau;
            copy.fAFT= this.fAFT;
        }
        function fx = evaluateCoreFun(colvec<double> x,double t) {
            error(" This model overrides evaluate directly. ");
        }


        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 idx = nodepos(nr) {
            n = this.nodes;
            idx = zeros(1,n*length(nr));
            for k=1:length(nr)
                idx((k-1)*n+1:k*n) = (nr(k)-1)*this.nodes+1:nr(k)*this.nodes;
            end
        }


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

    
};
}
}