ReducedSecondOrderSystem.m

Go to the documentation of this file.

namespace models{


/* (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 ReducedSecondOrderSystem
  :public models.ReducedSystem,
   public models.BaseSecondOrderSystem {
    public:

        
    public:

        ReducedSecondOrderSystem(models.ReducedModel rmodel) {
            this = this@models.BaseSecondOrderSystem(rmodel);
            this = this@models.ReducedSystem(rmodel);
        }
        function  build() {
            build@models.ReducedSystem(this);
            rm = this.Model;
            fullsys = rm.FullModel.System; 
            /*  Additional steps
             * Project damping matrix */
            if ~isempty(fullsys.D)
                this.D= fullsys.D.project(rm.V,rm.W);
            end
        }


        function J = getJacobian(double t,x_xdot_c) {
            td = this.NumTotalDofs;
            sd = this.NumStateDofs;
            dd = this.NumDerivativeDofs;
            ad = this.NumAlgebraicDofs;
            xdotpos = sd+(1:dd);
            xpos = 1:sd;
            cpos = sd+dd+(1:ad);
            x = x_xdot_c(xpos);
            xdot = x_xdot_c(xdotpos);
            J = sparse(td,td);
            I = speye(sd);
            I(:,this.DerivativeDirichletPosInStateDofs) = [];
            J(xpos,:) = [sparse(sd,sd) I sparse(sd,ad)];
            if ~isempty(this.A)
                J(xdotpos,xpos) = J(xdotpos,xpos) + this.A.getStateJacobian(x, t);
            end
            if ~isempty(this.D)
                J(xdotpos,xdotpos) = J(xdotpos,xdotpos) + this.D.getStateJacobian(xdot, t);
            end
            if ~isempty(this.f)
                J(xdotpos,:) = J(xdotpos,:) + this.f.getStateJacobian(x_xdot_c, t);
            end
            if ~isempty(this.g)
                J(cpos,:) = this.g.getStateJacobian(x_xdot_c,t);
            end
        }
        function dx = ODEFun(double t,colvec<double> x) {
            est = this.Model.ErrorEstimator;
            haveest = ~isempty(est) && est.Enabled;
            if haveest
                xall = x;
                x = x(1:end-est.ExtraODEDims,:);    
            end

            dx = ODEFun@models.BaseSecondOrderSystem(this,t,x);

            if haveest
                dx = [dx; est.evalODEPart(xall, t, this.u(t))];
            end
        }


        function z_zdot_c0 = getX0(colvec<double> mu) {

            z_c0 = getX0@models.BaseFirstOrderSystem(this, mu);
            num_z_dof = this.NumStateDofs;
            num_zdot_dof = this.NumDerivativeDofs;
            z_zdot_c0 = zeros(this.NumTotalDofs,1);

            /*  Insert state initial values */
            z_zdot_c0(1:num_z_dof) = z_c0(1:num_z_dof);

            /*  Insert zero derivative initial values (xdot0) between */
            z_zdot_c0(num_z_dof+(1:num_zdot_dof)) = zeros(num_zdot_dof,1);

            /*  Insert alg cond initial values */
            z_zdot_c0(num_z_dof+num_zdot_dof+1:end) = z_c0(num_z_dof+1:end);

            m = this.Model;
            if ~isempty(m.ErrorEstimator) && m.ErrorEstimator.Enabled
                z_zdot_c0 = [z_zdot_c0; m.ErrorEstimator.getE0(mu)];
            end
        }
        function  updateSparsityPattern() {
            updateSparsityPattern@models.ReducedSystem(this);
        }


    
    protected:


        function R = compileReconstructionMatrix(V) {
            R = blkdiag(V,V,eye(this.NumAlgebraicDofs));
        }


        function  updateDimensions() {
            updateDimensions@models.ReducedSystem(this);
            this.NumDerivativeDofs= this.NumStateDofs;
            this.NumTotalDofs= 2*this.NumStateDofs + this.NumAlgebraicDofs;
        }


        function val = getDerivativeDirichletValues(double t) {
            val = getDerivativeDirichletValues@models.BaseSecondOrderSystem(this, t);
        }


        function  validateModel(models.BaseFullModel model) {
            validateModel@models.ReducedSystem(this, model);
        }

    

};
}