script_detailled_simulation.m

Go to the documentation of this file.

% detailed_simulation_refined

dbstop if error

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%% RESUME SIMULATION ?!?!?! %%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%% Falls Simulation mit vorher gespeicherten Daten fortgesetzt wird:
%%%% Variable resume_simulation = 1 setzen und
%%%% hier den Name der zu ladenden Datei eingeben:
if exist('resume_simulation', 'var') && resume_simulation == 1
        
    %falls automatisch gespeicherte daten vorhanden und geladen werden
    %sollen: tue dies hier und verwerfe die bisher geladenen daten:
    if exist('loaded_automatically', 'var') && loaded_automatically == 1
        %Daten müssen hier nicht mehr geladen werden, wurde schon in
        %"DAS_UEBERSKRIPT" gemacht
        cone_stop = c; %nur diesen einen cone_wert_berechnen
    else %falls von hand geldane werden soll: gehe hier rein
        load_saved_results = 'sicher_bernard_c8_216simsdone';
        %load_saved_results = 'sicher_oli_c1_2done';
        load_string = ['load ', load_saved_results];
        eval(load_string)
    end
    
    resume_simulation = 1; %wird durch das laden der daten auf 0 gesetzt --> muss ich heir von hand wieder auf 1 setzen
    cone_start = c;
end


  
if (~exist('resume_simulation', 'var')) || (resume_simulation == 0) 
    % If a calculation is resumed (that means if there exists a variable resume_simulation=1),
    % use the loaded data instead of creating new data, i.e. this part is
    % leapfroged and a new simulation is started
    
    clear
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %%%% NEW SIMULATION !!! %%%%%%%%%%
    %%%% Change here the details of the calculation
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    %used_basis_load = ['Greedy_basis_coarse1_100_adapt'];
    
    params.coarse_factor=4;
    model = advection_fv_output_opt_model(params);
    model_data = gen_model_data(model);
    
    
    refinement_stop = 5; % Refinement_stop sets the meximal refinement_level,
                         % that means the level of subdivision of vx_weight and vy_weight 
                         % 1 means 3 points per direction, 2 means 5
                         % points, 9 means 9 points...
    cone_weight_nbrs = 33; 

    % IN JEWEILGER VERSION (MARKUS; DANIEL; BERNARD; OLI)ANPASSEN!!!
    % CONE WEIGHT LÄUFT VON 1 bis 17!!!
    %Oli:
    cone_start = 1;
    cone_stop = 33;
    
    % Markus:
    %cone_start = 3;
    %cone_stop = 4;
    % 
    % Bernard:
    %cone_start = 5;
    %cone_stop = 10;
    % 
    % Daniel:
    % cone_start = 11;
    % cone_stop = 17;
    % END: IN JEWEILGER VERSION (MARKUS; DANIEL; BERNARD; OLI) ANPASSEN!!!


    % load the basis from *.mat file
    %used_basis=[used_basis_load,'.mat'];
    %load(used_basis);
        
    %change some fields in the model
    model.compute_derivative_info=1;
    model.optimization.params_to_optimize = [1 1 1];
    model.L_I_inv_norm_bound = 1;
    model.L_E_norm_bound     = 1;
    model.L_E_der_norm_bound = [0,1.25, 1]; 
    model.L_I_der_norm_bound = [0,0,0];
        
    %reduced_data = gen_reduced_data(model, detailed_data);

    nr_params = length(model.mu_names);

    cone_weight = linspace(model.mu_ranges{1}(1),model.mu_ranges{1}(2),cone_weight_nbrs); 
    resume_simulation=0;
    time=0;
end

backup_nr = 30; % do a backup after (save workspace) after "backup_nr" simulations

%Start Simulation
for c = cone_start:cone_stop % OBEN IN JEWEILIGER VERSION ANPASSEN: Laufindex für cone_weight
    model.cone_weight = cone_weight(c);
    
    if resume_simulation ~= 1 
        clear value_calculated sim_data_J sim_data_s
    end
    
    %if saved data are loaded to resume a calculation where the
    %refinement_level has already been higher than 1, this refinement_level
    %must be set here again...
    if resume_simulation == 1
        refinement_start = refinement_level;
    else
        refinement_start = 1;
    end
    
    
    for refinement_level = refinement_start:refinement_stop;
        
        dots_vx_vy = 2^refinement_level+1;
        
        
        %create matrices in first loop
        if ~exist('value_calculated','var')
            value_calculated = zeros(dots_vx_vy); 
        end
        if ~exist('sim_data_J','var')
            sim_data_J = cell(dots_vx_vy, dots_vx_vy);
        end
        if ~exist('sim_data_s','var')
            sim_data_s = cell(dots_vx_vy, dots_vx_vy);
        end
        
        vx_weight = linspace(model.mu_ranges{2}(1),model.mu_ranges{2}(2),dots_vx_vy);
        vy_weight = linspace(model.mu_ranges{3}(1),model.mu_ranges{3}(2),dots_vx_vy);
        
        %%%%%%%%%%%%
        % simulation
        %%%%%%%%%%%%
        for x=1:dots_vx_vy
            model.vx_weight=vx_weight(x);
            for y=1:dots_vx_vy
                model.vy_weight=vy_weight(y);
                
                if value_calculated(x,y) ~= 1
                   
                    %perform detailed_simulation
                    tic;
                    model.detailed_simulation = @lin_evol_opt_detailed_der_simulation;
                    %model.detailed_simulation = @test_det_der_sim_dummy; %IN CASE OF TESTING OF SOME CHANGES
                    sim_data = detailed_simulation(model, model_data);
                    sim_data_J{x,y} = sim_data.y;
                    sim_data_s{x,y} = sim_data.y_der;
                    
                    value_calculated(x,y) = 1;
                    
                    % Calculate the needed time for display
                    sim_time=toc/60; %Zeit für die letzte Simulation
                    time = time + sim_time; %bisher vergangene Zeit in Minuten
                    nr_sims_per_cone = (2^refinement_stop +1)^2;
                    nr_sims_done = length(find(value_calculated)) +  ...
                        + (c - cone_start) * nr_sims_per_cone; %Anzahl der schon berechneten Simulationen
                    nr_sims_total = (2^refinement_stop + 1)^2 * (cone_stop - cone_start +1); %Gesamtanzahl der Simulationen (abh. vom Refinement Stop)
                    nr_sims_left_cone = nr_sims_per_cone - length(find(value_calculated));
                    nr_sims_left_refinement = mod(dots_vx_vy^2 - mod(nr_sims_per_cone - nr_sims_left_cone,dots_vx_vy^2),dots_vx_vy^2);
                    nr_sims_left_total = nr_sims_total - nr_sims_done; %insgesamt noch benötigte Simulationen
                    average_time = time/nr_sims_done; %Durchschnittszeit pro Simulation in Minuten
                    expected_time_left_cone = average_time * nr_sims_left_cone;  %Vorr. verbleibende Zeit in Minuten auf diesem Refinement-Level
                    expected_time_left_total = average_time * nr_sims_left_total;  %Vorr. verbleibende Zeit in Minuten auf diesem Refinement-Level
                    
                    %Display some status results
                    disp(['Insgesamt Durchgeführte Simulationen: ' num2str(nr_sims_done) ' (von ' num2str(nr_sims_total) ' gesamt)']);
                    disp('---');
                    disp(['Aktueller cone_weight Wert = ' num2str(model.cone_weight) ...
                        ' (zu berechnender Cone Wert Nr.' num2str(c - cone_start + 1) ' von ' num2str(cone_stop-cone_start+1) ')']);
                    disp(['Anzahl der durchgeführten Simulationen für diesen Cone Wert: ' num2str(length(find(value_calculated))) ...
                        ' von ' num2str(nr_sims_per_cone) ' (' num2str(nr_sims_left_cone) ' noch zu berechnen)']);
                    disp(['+ aktuelles Refinement Level für diesen Cone-Wert = ' num2str(refinement_level) ' (entspricht ' ...
                        num2str(dots_vx_vy^2) ' Punkten)']);
                    disp(['+ maximales Refinement Level = ' num2str(refinement_stop) ' (entspricht '...
                        num2str(nr_sims_per_cone) ' Punkten)']);
                    disp(['+ Anzahl der noch zu berechnenden Punkte für dieses Refinement-Level: ' num2str(nr_sims_left_refinement)]);
                    disp('---');
                    disp(['Gesamtzeit nach diesem Durchlauf: ' num2str(time) ' Minuten / ' num2str(time/60) ' Stunden']);
                    disp(['durchschnittliche Zeit pro Durchlauf: ' num2str(average_time) ' Minuten']);
                    disp(['Vorraussichtlich verbleibende Zeit für diesen Cone-Wert: ' num2str(expected_time_left_cone) ...
                        ' Minuten / ' num2str(expected_time_left_cone/60) ' Stunden']);
                    disp(['Vorraussichtlich verbleibende Gesamtzeit: ' num2str(expected_time_left_total) ' Minuten / '...
                        num2str(expected_time_left_total/60) ' Stunden']);
                    disp('--------------------------------------------------------------------------');
                    disp('--------------------------------------------------------------------------');
                    
                    resume_simulation = 0;
                    
                    % Backup from time to time...
                    if mod(nr_sims_done,backup_nr) == 0; 
                        backup_string=['save backup_cone', num2str(c), '_', num2str(cone_weight_nbrs), ...
                            '_simsdonecone', num2str(length(find(value_calculated))), ...
                            '_reflvl', num2str(refinement_level), '_simsleftreflvl', num2str(nr_sims_left_refinement)];
                        eval(backup_string)
                    end
                end
            end 
        end
        
        used_cone_weight = cone_weight(c);
        save_string=['save new_det_sim_cone', num2str(c), '_', num2str(cone_weight_nbrs), '_vx',...
            num2str(dots_vx_vy),'_vy',num2str(dots_vx_vy), '_', ...
            ' sim_data_J', ' sim_data_s', ' used_cone_weight', ' value_calculated', ' vx_weight', ' vy_weight'...
            ' cone_weight', ' refinement_level'];
        eval(save_string)
        
        %falls letzte simulation vorbei: speichere kompletten workspace
        %bevors ans neue cone geht! auch wichtig für automatisches laden in
        % DAS_UEBERSCRIPT
        if length(find(value_calculated)) == nr_sims_per_cone
            save_string_cone = ['save finished_det_sim_cone', num2str(c), '_refstop', num2str(refinement_stop),'coarse4'];
            eval(save_string_cone)
        end
        
        
        % Blowup the result-matrices and cells
        value_calculated = blowup_matrix(value_calculated);
        sim_data_J = blowup_cell(sim_data_J);
        sim_data_s = blowup_cell(sim_data_s);
        
       
    end

end