BurgersF.m

Go to the documentation of this file.

namespace models{
namespace burgers{


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

        A;

        Ax;

        
    public:

        BurgersF(sys) {
            this = this@dscomponents.ACompEvalCoreFun(sys);
            this.CustomProjection= false;
            this.TimeDependent= false;
        }


        function fx = evaluate(colvec<double> x,unused1) {
            fx = bsxfun(@times,this.A*x,this.mu(1,:)) - x.*(this.Ax*x);
        }


        function  evaluateCoreFun() {
            error(" Evaluate is overridden directly ");
        }


        function fx = evaluateMulti(colvec<double> x,unused1,colvec<double> mu) {
            fx = bsxfun(@times,this.A*x,mu(1,:)) - x.*(this.Ax*x);
        }


        function J = getStateJacobian(colvec<double> x,unused1) {
            hlp = bsxfun(@times,this.Ax,x);
            hlp = hlp + spdiags(this.Ax*x,0,size(x,1),size(x,1));
            J = this.mu(1)*this.A - hlp;
        }


        function  newDim() {
            m = this.System.Model;
            n = m.Dimension;
            dx = (m.Omega(2) - m.Omega(1))/(n+1);
            e = ones(n,1);
            d1 = e/(2*dx);
            d2 = e/(dx^2);
            this.A= spdiags([d2 -2*d2  d2], -1:1, n, n); 
            this.Ax= spdiags([-d1 0*d1  d1], -1:1, n, n);
            this.JSparsityPattern= spdiags([e e  e], -1:1, n, n);
            this.xDim= n;
            this.fDim= n;
        }


        function copy = clone() {
            copy = clone@dscomponents.ACompEvalCoreFun(this, models.burgers.BurgersF(this.System));
            copy.A= this.A;
            copy.Ax= this.Ax;
        }

    
    protected:

        function fxj = evaluateComponents(rowvec<integer> pts,rowvec<integer> ends,rowvec<integer> argidx,rowvec<integer> self,matrix<double> X,unused1) {
            fxj = zeros(length(pts),size(X,2));
            for idx=1:length(pts)
                pt = pts(idx);
                if idx == 1
                    st = 0;
                else
                    st = ends(idx-1);
                end
                /*  Select the elements of x that are effectively used in f */
                xidx = (st+1):ends(idx);
                x = X(xidx);
                fxj(idx) = this.mu(1).*(this.A(pt,argidx(xidx))*x) - x(self(xidx)).*(this.Ax(pt,argidx(xidx))*x);
            end
        }
        function fxj = evaluateComponentsMulti(pts,ends,argidx,self,X,unused1,colvec<double> mu) {
            fxj = zeros(length(pts),size(X,2));
            for idx=1:length(pts)
                pt = pts(idx);
                if idx == 1
                    st = 0;
                else
                    st = ends(idx-1);
                end
                /*  Select the elements of x that are effectively used in f */
                xidx = (st+1):ends(idx);
                x = X(xidx,:);
                fxj(idx,:) = mu(1,:).*(this.A(pt,argidx(xidx))*x) - x(self(xidx),:).*(this.Ax(pt,argidx(xidx))*x);
            end
        }


};
}
}