ConstMassMatrix.m

Go to the documentation of this file.

namespace dscomponents{


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

        M;

        
    private:

        l;

        u;

        q;

        p;

        
    public:


        ConstMassMatrix(M,varargin) {
            this = this@dscomponents.AMassMatrix(varargin[:]);
            if nargin > 0
                this.M= M;
                this.TimeDependent= false;
                if issparse(M)
                    [this.l, this.u, this.q, this.p] = lu(M);
                else
                    [this.l, this.u] = lu(M);
                    this.q= [];
                    this.p= [];
                end
                /*  Compute sparsity pattern straight away */
                [i, j] = find(M);
                s = size(M,1);
                if issparse(M) || length(i) < numel(M)
                    this.SparsityPattern= sparse(i,j,ones(size(i)),s,s);
                end
            end
        }


        function M = evaluate(unused1,unused2) {
            M = this.M;
        }


        function [L , U , q , p ] = getLU(unused1,unused2) {
            L = this.l;
            U = this.u;
            q = this.q;
            p = this.p;
        }


        function projected = project(V,W) {
            algdims_correctedoffset = [];
            if ~isempty(this.AlgebraicEquationDims)
                nalgdims = length(this.AlgebraicEquationDims);
                algdims_correctedoffset = size(V,2)-nalgdims+1:size(V,2);
            end
            projected = dscomponents.ConstMassMatrix(W^t*(this.M*V),algdims_correctedoffset);
            /*  Dont store V,W due to hard drive space saving (not really needed here)
             *projected = project@general.AProjectable(this, V, W, projected); */
        }


        function copy = clone() {
            copy = clone@dscomponents.AMassMatrix(this, ...
                dscomponents.ConstMassMatrix);
            copy.l= this.l;
            copy.u= this.u;
            copy.q= this.q;
            copy.p= this.p;
            copy.M= this.M;
        }

    

};
}