DetailedData.m

classdef DetailedData < AbstractModel.DetailedData & matlab.mixin.Copyable
% Implementation of the detailed data interface for the ARE
%
% This class keeps the reduced basis and the information about the
% calculation of \gamma.
%
% Andreas Schmidt, 2016
    
    properties
        % Store the reduced basis:
        RB_V;
        RB_W;
        
        % The size of the reduced basis
        RB_size;
        
        % Information that was returned by the basis generation algorithm
        info;
        
        % Handler for the norm of the inverse operator norm ||L^{-1}||
        % The field gamma is filled by the corresponding gamma_calculation
        gamma = {};         % Information returned by gen_detailed_data from the gamma interface
        gamma_mode;         % Name of the gamma mode, stored within this detailed data instance
        
        % Model data handle, just for the easier calculation of the reduced
        % matrices:
        model_data;
    end
    
    properties(SetAccess=protected)
        % This is a handle to the gamma calculation interface. This can be
        % any class that implements the GAMMACALCULATORINTERFACE class. 
        algorithm;
        
        gamma_initialized = false;
        gamma_calculation;
    end
    
    methods
        function this = DetailedData(model, model_data)
            % DETAILEDATA Constructor for the DetailedData class
            this.model_data = model_data;
            this.algorithm = Greedy.LRFG.Algorithm(model, model_data);
            
            if ~isempty(model.RB_gamma_mode)
                this.set_gamma_mode(model);
            end
        end
        
        function s = get_rb_size(this)
            % GET_RB_SIZE returns the size of the reduced basis
            s = this.RB_size;
        end
        
        function set_gamma_mode(this, model)
            % SET_GAMMA_CALCULATION set the mode for the gamma calculation
            % If you change the gamam mode, the state will be set to
            % uninitialized, which means you first have to run
            % INITIAILIZE_GAMMA in order to be able to calculate
            mode = model.RB_gamma_mode;
            if isempty(mode) || strcmp(mode, 'none')
                this.gamma_calculation = [];
                this.gamma_initialized = true;
                return
            end
            
            this.gamma_calculation = eval([model.problem_type(), ...
                '.GammaCalculation.', mode, '()']);
            
            this.gamma_initialized = false;
            this.gamma_mode = mode;
        end
        
        function this = initialize_gamma(this, model, model_data)
            % INITIALIZE_GAMMA Call the gen_detailed_data method in the
            % gamma calculation interface and populate the data to the
            % field in detailed_data
            if isempty(this.gamma_calculation)
                error('Cannot initialize since no gamma calculation is defined');
            end
            
            this.gamma = this.gamma_calculation.gen_detailed_data(model, ...
                model_data, this);
            this.gamma_initialized = true;
        end
        
        function dd = extract_subbasis(this, N)
            % EXTRACT_SUBBASIS Extract a part of the basis
            if length(N) == 1
                N = 1:N;
            end
            
            dd = copy(this);
            dd.RB_V = dd.RB_V(:, N);
            dd.RB_W = dd.RB_W(:, N);
        end
    end
    
    methods(Static)
        function this = initialize_with_bgen(model, model_data)
            % This function is used in the gen_detailed_data function and
            % creates an instance of the DetailedData class and
            % instantiates the basis building procedure:
            pt = model.problem_type();
            this = eval([pt,'.DetailedData(model, model_data)']);
            
            % Set the parameters, if there are any:
            if ~isempty(model.RB_M_train)
                M_train = model.RB_M_train;
                if isa(M_train, 'char')
                    M_train = eval(['ParameterSampling.',M_train,'()']);
                elseif isa(M_train, 'ParameterSampling.Interface')
                elseif ismatrix(M_train)
                    M_train = ParameterSampling.Prescribed(M_train);
                else
                    error(['Please set the property RB_M_train to a valid ', ...
                        'value!']);
                end
                % And finally, set the M_train value
                this.algorithm.M_train = M_train;
            end
            
            % Run the actual algorithm
            [V,W,info] = this.algorithm.run();
            
            this.RB_V = V;
            this.RB_W = W;
            this.RB_size = size(V,2);
            this.info = info;
            
            % Initialize the gamma stuff:
            this.set_gamma_mode(model);
            if ~this.gamma_initialized
                this.initialize_gamma(model, model_data);
            end
        end
        
    end
    
end