Kernel.m

classdef Kernel < ARE.GammaCalculation.GammaCalculatorInterface
    
    properties
       
        kernel = 'gaussian';
        kernel_parameters = [1];
        
        kernels = struct(...
            'gaussian', {@(x,y,p) exp(-norm(x-y)^2/p(1)^2), [1]} ...
            );
        
    end
    
    methods
        function data = gen_detailed_data(this, model, model_data, detailed_data)
            % Store some additional data for the online calculation
            reduced_data = eval([model.problem_type(), '.ReducedData(model, detailed_data);']);
      
            % TODO: Think about the training set strategy
            mus = detailed_data.info.M_train.sample(detailed_data.info.chosen_mu, :);
 
            nmus = size(mus, 1);
            times = zeros(nmus, 1);
            values = zeros(nmus, 1);
            
            % Perform all the expensive calculations of gamma in the
            % offline step and store the results in the detailed_data.gamma
            % structure.
            display(['Calculating ', num2str(nmus), ' gamma values'])
            parfor_progress(nmus);
            tmpModel = copy(model);
            tmpModel.enable_error_estimator = false;
            tmpModel.calc_residual = false;
            
            for j = 1:nmus
                parfor_progress;
                tmpModel.set_mu(mus(j, :));
                timer = tic();
                rbsim = rb_simulation(tmpModel, reduced_data);
                rbrec = rb_reconstruction(tmpModel, detailed_data, rbsim);
                values(j) = tmpModel.gamma(model_data, rbrec);
                times(j) = toc(timer);
            end
            
            data.mus = mus;
            data.values = values;
            data.times = times;
        end
        
        function fun = gen_reduced_data(this, model, detailed_data, reduced_data)
            % Build all components for the assembly of the 
            data = detailed_data.gamma;
            ntrain = length(data.values);
            
            K = zeros(ntrain);
            f = this.kernels.(this.kernel);
            p = this.kernel_parameters;
            mus = data.mus;

            for i = 1:ntrain
                for j = 1:ntrain
                    K(i,j) = f(mus(i,:), mus(j,:), p);
                end
            end

            weights = K\data.values(1:ntrain);

            fun = @tmpFunction;
            function g = tmpFunction(model, reduced_data, sim)
                g = 0;
                mu = model.get_mu();
                for k = 1:ntrain
                    g = g + f(mu, mus(k,:), p)*weights(k);
                end
            end
        end
        
        function gamma = calculate(model, model_data, sim)
            error('gamma calculation through kernel is not available!')
        end

    end
    
end