(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 each of

• 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...

Namespaces
	NonlinEvol
	Reduced basis implementation for non-linear evolution equations.
	LinStat
	Reduced basis implementation for linear stationary PDEs.
	LinEvol
	Reduced basis implementation for linear evolution equations.
	ARE
	Implementation of the parametric algebraic Riccati equation.