Kernel.m

classdef Kernel < ARE.GammaCalculation.GammaCalculatorInterface
    
    
    properties
        
        kernel = 'thin_plate';
                
        kernels = struct(...
            'thin_plate', {@(x,y) -sqrt(norm(x-y)^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;

             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 = eye(ntrain);
             f = this.kernels.(this.kernel);
             mus = data.mus;

             for i = 1:ntrain
                 for j = [1:i-1, i+1:ntrain]
                     K(i,j) = f(mus(i,:), mus(j,:));
                 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,:))*weights(k);
                 end
             end
         
         end
        
         function gamma = calculate(model, model_data, sim)
             error('gamma calculation through kernel is not available!')
         end
                
         
    end

end