DetailedModel.m

classdef DetailedModel < IDetailedModel
  % Detailed model for a linear stationary problem with a discretization
  % implemented in Dune-RB
  %
  % This is a detailed model for a problem type 'rb_problem_type' =
  % "LinStatDune"
  %
  % It solves discretization of the form
  % `` A u = r, ``
  % with a matrix `A` and a right hand side `r` returned by 
  % '[A,r] = descr.operators(descr, model_data)'
  %
  % Furthermore, an output fuctional can be defined by the description field
  % 'descr.operators_output(descr, model_data);'

  methods
    function dm = DetailedModel(descr)
      % function dm = DetailedModel(descr)
      % constructor based on problem description
      %
      % Parameters:
      %  descr: structure describing the problem and the descretization
      dm = dm@IDetailedModel(descr);
    end

    function this         = set_mu(this, mu)
      % function this = set_mu(this, mu, propagate)
      % sets the active parameter vector `\mu \in {\cal M}`
      %
      % The parameter set here, is used by the detailed_simulation() function.
      %
      % The default implementation sets all fieldnames 'descr.mu_names' in the
      % #descr struct.
      %
      % Parameters:
      %   mu: The parameter vector `\boldsymbol\mu`.
      %
      % Return values:
      %  this: handle of type IDetailedModel to the changed DetailedModel

      assert(length(mu) == length(this.descr.mu_names));

      this.descr.mexptr('set_mu', mu);
    end

    function mu           = get_mu(this)
      % function mu = get_mu(this)
      % returns the active parameter vector `\boldsymbol\mu \in {\cal M}`
      %
      % The default implementation returns a vector of the values of the fields
      % of the #descr structure with names 'descr.mu_names'.
      %
      % Return values:
      %   mu: The parameter vector `\boldsymbol\mu`

      mu = this.descr.mexptr('get_mu');
    end
    function sim_data   = detailed_simulation(this, model_data)
      sim_data = this.descr.mexptr('detailed_simulation');
    end

    function model_data = gen_model_data(this)
      model_data.id     = this.descr.mexptr('gen_model_data');
      model_data.mexptr = this.descr.mexptr;
    end

    function p          = plot_sim_data(this, model_data, sim_data, plot_params)

      if ~isfield(plot_params, 'gcf') || isempty(plot_params.gcf)
        ud.descr = this.descr;
        ud.dmodel = this;
        ud.sim_data = sim_data;
        fig_handle = lin_stat_plot_control;
        set(fig_handle, 'UserData', ud);
      else
        fig_handle = plot_params.gcf;
      end
      fig_ud     = get(fig_handle, 'UserData');
      if ~isempty(fig_ud) && isfield(fig_ud, 'plot_dir')
        plot_dir = fig_ud.plot_dir;
      else
        outdir = fullfile(this.descr.run_dir, sim_data.outdir);
        args = ['-c ', sim_data.cell_array_name, ' ', outdir, ' ', sim_data.prefix];
        [status, res] = system([fullfile(rbmatlabhome, 'dune', 'lin_stat_visualize.sh'), ' ', args]);
        plot_dir = strtrim(res);
        set(fig_handle, 'CloseRequestFcn', @LinEvolDune.DetailedModel.close_figure_and_vtk_plot);
        fig_ud.plot_dir = plot_dir;
        set(fig_handle, 'UserData', fig_ud);
        pause(1);
      end

      if ~isfield(plot_params, 'angle')
        plot_params.angle = 0;
      end

      if isfield(plot_params, 'reload_required') && plot_params.reload_required
        LinStatDune.DetailedModel.issue_plot_command(plot_dir, ['reload ', num2str(plot_params.angle)]);
      else
        LinStatDune.DetailedModel.issue_plot_command(plot_dir, ['update ', num2str(plot_params.angle)]);
      end
      p = fig_handle;
    end
  end

  methods (Static)

    function U = get_dofs_from_sim_data(sim_data)

      U = sim_data.uN;
    end

%     function U = get_dofs_at_time(sim_data, time)
%       U = sim_data.a;
%     end
  end

  methods (Static, Hidden=true)

    function issue_plot_command(plot_dir, command)
      f = fopen(fullfile(plot_dir, 'control.cfg'), 'w');
      fprintf(f, command);
      fclose(f);
      system(['kill -SIGINT $(cat ', fullfile(plot_dir, 'tsv.pid'), ')']);
    end

    function close_figure_and_vtk_plot(src, event)
      fig_ud = get(gcf, 'UserData');
      if ~isempty(fig_ud) && isfield(fig_ud, 'plot_dir')
        plot_dir = fig_ud.plot_dir;
        try
          LinEvolDune.DetailedModel.issue_plot_command(plot_dir, 'exit');
          pause(0.5);
        catch me
          disp('Could not issue the exit command to the Paraview renderer');
          disp(me.message);
        end
        if exist(fullfile(plot_dir, 'tsv.pid'), 'file')
          system(['rm -rf ', plot_dir]);
        end
      end
      closereq
    end
  end

end