Model.m

classdef Model < AbstractModel.Model & Greedy.LRFG.ModelInterface
% MODEL
% Class that defines the assemble method which is used by both, the
% DetailedModel and the ReducedModel.
%
% Andreas Schmidt, 2016

    properties
        enable_error_estimator = false;
        calc_residual = true;
        
        % Additional fields for basis generation:
        RB_gamma_mode     = 'Kernel';
        RB_gamma_enabled  = 1;
        RB_gamma_settings = {};
        
        % The number of measurement outputs
        p;
        % The number of control inputs and measurements
        m;
        n;
        
        model_data;
    end
    
    methods(Abstract)
        A = A_coeff(this);
        A = A_comp(this,model_data);
        B = B_comp(this,model_data);
    end
    
    methods(Access=public)
        
        function [E,A,B,C,Q,R] = assemble(this, md)
            % ASSEMBLE Assembles all the data matrices. 
            %   This function works for both, the reduced and the 
            %   full model.
            
            A = lincomb_sequence(md.A_comp, this.A_coeff());
            B = lincomb_sequence(md.B_comp, this.B_coeff());
            C = lincomb_sequence(md.C_comp, this.C_coeff());
            E = lincomb_sequence(md.E_comp, this.E_coeff());
            R = lincomb_sequence(md.R_comp, this.R_coeff());
            Q = lincomb_sequence(md.Q_comp, this.Q_coeff());
        end
        
        function E = mass_matrix(this, md)
            % MASS_MATRIX Get the mass matrix of the problem
            %    This function is used by the LRFG algorithm for the
            %    orthogonalization procedure
            Ecoeff = this.E_coeff();
            E = lincomb_sequence(md.E_comp, Ecoeff);
        end
        
        function g = gamma(this, model_data, dsim)
            % GAMMA 
            %    Calculate the value of gamma. This is used by applying
            %    the Lyapunov equation method.
            % 
            calculator = ARE.GammaCalculation.Lyapunov();
            g = calculator.gamma(this, model_data, dsim);
        end
        
        function R = R_coeff(this)
            R = 1;
        end
        function Q = Q_coeff(this)
            Q = 1;
        end
        function E = E_coeff(this)
            E = 1;
        end
        function C = C_coeff(this)
            C = 1;
        end
        function B = B_coeff(this)
            B = 1; 
        end
        
        function R = R_comp(this, model_data)
            if isempty(this.m), error('Please define the m property'), end
            R = {eye(this.m)};
        end
        function Q = Q_comp(this, model_data)
            if isempty(this.p), error('Please define the p property'), end
            Q = {eye(this.p)};
        end
        function E = E_comp(this, model_data)
            if isempty(this.n), error('Please define the dimension n property'), end
            E = {speye(this.n)};
        end
        function C = C_comp(this, model_data)
            C = cellfun(@transpose, this.C_comp());
        end
        
        function [T,y,x] = simulate(this, model_data, dsim)
            % SIMULATE This function simulates the underlying LTI model
            % If you provide dsim, the closed-loop simulation will be
            % performed.
        end
    end
    
end