(M3) Reduced model implementations

---

Detailed Description

Implementation of reduced models for specific problem types.

This module includes interface classes for the implementation of a complete reduced basis procedure, i.e. offline and online phase and several packages implementing these interfaces for specific problem types.

The interface classes and their interconnections are described in the next section.

Interface classes

A user who wants to implement a reduced basis procedure must implement four classes derived from the interface classes

• IDetailedModel,
• IDetailedData,
• IReducedData and
• IReducedModel.

The graph below depicts, how the classes are interconnected and shows some of the classes' most important methods:

• The IDetailedModel implementation defines how a detailed simulation snapshot for a single parameter can be computed, it can be seen as a wrapper around a discretization implementation, as described in Module (M1).
• The IDetailedData implementation actually defines how the reduced basis is created. Its constructor probably calls an implementation from the Module (M2).
• The IReducedData implementation is constructed out of the DetailedData object and contains all low dimensional offline matrices and vectors needed for an efficient reduced simulation.
• The IReducedModel implementation finally defines how the reduced simulation is actually computed from the reduced matrices and vectors stored in the IReducedData object. Note, that the IReducedModel object also initiates the generation of the IDetailedData and the IReducedData object by its methods IReducedModel.gen_detailed_data() and IReducedModel.gen_reduced_data(), respectively.

Example usage of a reduced model implementation

In this section we want to show the steps that need to be undertaken in order to execute a reduced simulation for a convection diffusion equation problem.

The ModelDescr struct for this problem is stored in convdiff_model(). The struct returned by this function also includes fields of the BasisGenDescr struct, so we get the IDetailedModel and the IReducedModel object by the following call of the convenience function gen_models().

  model_descr      = convdiff_model();
  [dmodel, rmodel] = gen_models(model_descr);

We check the types of these models

  disp(['Detailed model is of type: ', class(dmodel)]);
  disp(['Reduced model is of type: ', class(rmodel)]);

and find them to be LinEvol.DetailedModel and LinEvol.ReducedModel.

Now, we can compute the ModelData structure and compute a single detailed simulation snapshot:

  model_data = gen_model_data(dmodel);
  set_mu(dmodel, mu);
  sim_data   = detailed_simulation(dmodel, model_data);

The offline phase preparation including the generation of the reduced basis and the computation of the reduced matrices consists of the following two commands:

  detailed_data = gen_detailed_data(rmodel, model_data);
  reduced_data  = gen_reduced_data(rmodel, detailed_data);

Again, we can check the types of the generated data objects

  disp(['Detailed data is of type: ', class(detailed_data)]);
  disp(['Reduced data is of type: ', class(reduced_data)]);

and find them to be LinEvol.DetailedData and LinEvol.ReducedData.

Now, it is possible to compute the reduced simulations:

  set_mu(rmodel, mu);
  rb_sim_data = rb_simulation(rmodel, reduced_data);

Further description structs can be found in the models/ directory.

Collaboration diagram for (M3) Reduced model implementations:

Classes
class	BasisGenDescr
	Struct with control fields for the reduced basis generation. More...
class	IDetailedData
	Interface class for the generation and storage of reduced basis spaces as described in Module (M2). More...
class	IDetailedModel
	This is the interface for a detailed model providing methods to compute high dimensional simulation snapshots. More...
class	IModel
	This is the common interface for all models, detailed and reduced ones. More...
class	IReducedData
	Interface class for the generation and storage of offline matrices and vectors as described in Module (M3). More...
class	IReducedModel
	This is the interface for a reduced model providing methods to compute low dimensional reduced simulations based on a priori generated reduced basis spaces. More...
Packages
package	NonlinEvol
	Reduced basis implementation for non-linear evolution equations.
package	LinStat
	Reduced basis implementation for linear stationary PDEs.
package	LinEvol
	Reduced basis implementation for linear evolution equations.
Files
file	gen_detailed_model.m
	generates an IDetailedModel instance from a description structure.
file	gen_models.m
	generates an IDetailedModel and an IReducedModel instance from description structures.
file	gen_reduced_model.m
	generates an IReducedModel instance from a description structure.