DetailedModel.m

classdef DetailedModel < Greedy.User.FVDetailedModelDefault
  % IDetailedModel implementation for a non linear evolution problem
  %
  % This is a detailed model for a problem of this type
  % @f{align}
  %   \partial_t u(x;t,\mu) - {\cal L}(t,\mu)[u(x,t;\mu)] &= 0 \qquad &\text{in }& \Omega \times [0, T], \\\\
  %   u(x;0,\mu) &= u_0(x;\mu) \qquad &\text{in }& \Omega \times \{0\}
  % @f}
  %  with suitable boundary conditions and (non-linear) operators `{\cal
  %  L}(t,\mu) : {\cal W} \to {\cal W}` parametrized over the Time-parameter
  %  domain `[0,T] \times {\cal M}`.
  %
  % The numerical scheme for the numerical solution of this problem is assumed
  % to be of the
  % -# following type: 
  % @f{align*}
  % u_h(\cdot;t^0,\mu) &= {\cal M}_h[u_0] \\\\
  % \left(\text{Id} - \Delta t^k {\cal L}_{h, I}(t^{k+1},\mu)\right)[u_h(\cdot;t^{k+1},\mu)]
  %    &=
  % \left(\text{Id} + \Delta t^k {\cal L}_{h, E}(t^{k},\mu)\right)[u_h(\cdot;t^{k},\mu)]
  %  @f}
  % -# or with a Newton solver for non-linearities in the implicit case: 
  % ``
  % u_h(\cdot;t^0,\mu) = {\cal M}_h[u_0],
  % ``
  % where the equation
  % ``
  % F[u_h(\cdot;t^{k+1},\mu), u_h(\cdot;t^k,\mu)] =0
  % ``
  % is solved subsequently for the operator `F:V_h\times V_h \to V_h` defined by
  % ``
  % F[u_h;v_h] :=
  % \left(\text{Id} + \Delta t^k {\cal L}_{h, I}(t^{k+1},\mu)\right)[u_h]
  %    -
  % \left(\text{Id} + \Delta t^k {\cal L}_{h, E}(t^{k},\mu)\right)[v_h]
  % ``
  % with a Newton scheme, minimizing defects `\| \delta_h^{k+1,\nu+1}\| \leq
  % R_{\text{Newton}}` by solving
  % ``
  % D_1 F|_{u_h^{k+1,\nu}}[\delta_h^{k+1,\nu+1};u_h^k] = -F[u_h^{k+1,\nu};u_h^k]
  % ``
  % with `u_h^{k+1,\nu+1} := u_h^{k+1,\nu}`, `u_h^{k,0}:=u_h^k`,
  % `u_h^{k+1}:=u_h^{k+1, \nu_{\max}(k)}` and
  % `\nu_{\max}(k) = \min_{\nu} \| \delta_h^{k+1,\nu} \| \leq R_{\text{Newton}}`
  %
  % Furthermore the discretization consists of
  %   - a time discretization `0 = t^0 \leq t^1 = t^0 + \Delta t^0 \leq \ldots
  %   \leq t^{K+1} = t^{K} + \Delta t^{K} = T`,
  %   - discrete space operators `{\cal L}_{h, I}(t,\mu):{\cal W}_h \to {\cal
  %   W}_h` and `{\cal L}_{h, E}(t,\mu):{\cal W}_h \to {\cal W}_h` parametrized
  %   over the Time-Parameter domain `[0,T] \times {\cal M}` and
  %   - a projection operator `{\cal M}_h : {\cal W} \to {\cal W}_h`
  %
  %

  properties(Constant)
    % This constant is used for a consistency check of the model descr with
    % help of DetailedModelBaseIf.struct_check()
    model_checks = struct(...
      'fv_impl_diff_weight',          {{@isscalar}},...
      'fv_expl_diff_weight',          {{@isscalar}},...
      'fv_impl_conv_weight',          {{@isscalar}},...
      'fv_expl_conv_weight',          {{@isscalar}},...
      'newton_solver',                {{@isscalar}},...
      'implicit_nonlinear',           {{@isscalar}},...
      'L_E_local_ptr',                {{@(x) isequal(class(x), 'function_handler')}},...
      'L_I_local_ptr',                {{@(x) isequal(class(x), 'function_handler')}}...
    );

    % This constant is used for a consistency check of the model descr with
    % help of DetailedModelBaseIf.struct_check()
    %
    % This check is only executed if we use a Newton scheme
    newton_checks = struct(...
      'newton_steps',                 {{@isscalar}},...
      'implicit_operators_algorithm', {{@(x) isequal(class(x), 'function_handler')}},...
      'implicit_gradient_operators_algorithm',...
                                      {{@(x) isequal(class(x), 'function_handler')}},...
      'newton_epsilon',               {{@isscalar}}...
    );
  end

  properties (Dependent)
    % current time instance
    t;

    % current time step
    tstep;
  end

  properties
    % boolean flag indicating whether conditions of system matrices shall be computed.
    compute_conditions = false;
  end

  methods
    function dm = DetailedModel(descr)
    % function dm = DetailedModel(descr)
    % constructor
    %
    % This checks and stores the model description structure
    %
    % Required fields of descr:
    %   newton_solver:  boolean flag indicating whether we are using a Newton
    %                   scheme for the discretization.
      dm = dm@Greedy.User.FVDetailedModelDefault(descr);
      if ~IDetailedModel.struct_check(descr, NonlinEvol.DetailedModel.model_checks)
        error('Consistency check of description for nonlinear evolution problems failed!');
      end
      if descr.newton_solver && ~IDetailedModel.struct_check(descr, NonlinEvol.DetailedModel.newton_checks)
        error('Consistency check of description for Newton solver problems failed!');
      end
    end

    sim_data   = detailed_simulation(model, model_data);

    model_data = gen_model_data(model);

    p          = plot_sim_data(dmodel, model_data, sim_data, plot_params);
  end

  methods (Static)

    function U = get_dofs_from_sim_data(sim_data)

      U = sim_data.U;

    end

    function snapshot = get_dofs_at_time(sim_data, time_index)

      snapshot = sim_data(:,time_index);
    end

  end

  methods
    function t = get.t(this)
      t = this.descr.t;
    end

    function set.t(this, t)
      this.descr.t = t;
    end

    function tstep = get.tstep(this)
      tstep = this.descr.tstep;
    end

    function set.tstep(this, tstep)
      this.descr.tstep = tstep;
    end
  end

end