[an error occurred while processing this directive]   Suche  
 

Subsysteme: Initialisierung

Beispiel 1:

Wir betrachten ein Problem mit einer vorgegebenen Anzahl von Anfangswertproblemen mit lineaeren Differentialgleichungssystemen. Die Anwender wählen eines davon aus und simulieren dieses dann. Ein derartiges Problem tauchte z.B. in Übung 6 auf.

Ausgangsmodell

Man kann nun auf die Idee kommen, bis auf die Ausgabe-Blöcke, das gesamte System als Subsystem zu schreiben und über die Block-Parameter jeweils nur das jeweils zu simulierende System auszuwählen.

Modell mit Subsystem

Beim Subsystem Block wurden die Ausgänge im obigem Subsystem entsprechend beschriftet und keine Icon-Maskierung verwendet. Der Block erscheint dann, wie hier, mit den beschrifteten Ports.

Subsystem mit beschrifteten Ports

Der Scope-Block zur Ausgabe der Lösungskurven wurde so eingerichtet, dass er zwei unterschiedliche Fenster ausgibt, ausser dem trennen der beiden Signale durch einen Demux-Block ist dazu noch erforderlich, bei den Scope' Properties dem Parameter 'Number of axes' den Wert 2 zu geben. Das Fenster 'Scope' Properties' erreicht man über den sechsten Knopf im Scope-Fenster.

Was zu tun bleibt ist, die Matrix im Matrix Gain-Block variabel zu besetzen. Der naheliegende Weg ist der, die Matrix im Parameterfenster des Matrix Gain-Blockes mit einem Variablennamen zu besetzen, etwa M, und diesem Namen dann im Parameterfenster des Subsystems eine Matrix als Wert zuzuweisen, wie wir dies bisher mit Skalaren gemacht haben. Das geht allerdings nicht. Simulink interpretiert die Variable im Matrix Gain-Block als skalare Variable und moniert einen 'Port mismatch' im System.

Subsystem mit Port mismatch

Bei dieser Gelegenheit sieht man auch, dass der Matrix-Gain Block einen 'Stat Space-Block' als Subsystem umfasst.

Das Problem der Fehlinterpretation der Variablen kann man beheben, indem man sie in der Form M(1:2,1:2) angibt, woraus hervorgeht, dass der Matrix-Gain-Block ein Signal u(t) mit 2 Komponenten erwartet und ein anderes y(t) mit 2 Komponenten ausgibt. Das Modell läßt sich jetzt problemlos simulieren.

Lästig ist allerdings, dass man im Parameterfenster des Subsystem Blockes immer die ganze Matrix angeben muss, bei großen Matrizen ist das mühsam und fehleranfällig.

Parameterbesetzung

Bequemer ist hier die Verwendung von 'Initialization commands' zum Subsystem Block. Wir vereinbaren im 'Initialization-Fenster' des Masken-Editors eine Variable n mit dem Prompt Problemnummer. Die möglichen Variablenwerte sind 1,2,3 und 4 und sollen den Benutzern in einem Popup-Menue angeboten werden. Je nach Eingabe der Benutzer, soll eine andere Matrix verwendet werden. Die Zuordnung zwischen Problemnummer und Matrix legen wir in den 'Initialization commands' fest, das sind Matlab-Kommandos, die jedesmal vor Ausführung der Simulation ausgeführt werden.

Diese Kommandos werden im Feld 'Initialization commands' abgelegt. Wir geben dort ein: 

   switch n
    case 1
     M=[-1,0;0,-1];
    case 2
     M=[-1,0;0,-25];
    case 3
     M=[-1,0;+24,-25];
    case 4
     M=[-25,0;-24,-1];
    end

Initialization Fenster

Die Lösungen haben wir in den Übungen 6 schon kennengelernt.

Beispiel 2:

Das Verhalten von Subsystemen lässt sich auf vielfältige Weise steuern. Wir betrachten dazu noch einmal das Problem, den Höhenlinienplot einer Funktion: 
   f1(x,y) = x^2 - 4*y;
   f2(x,y) = 4*x - y^2;
zu erzeugen, wobei die Höhenlinien zur L2-Norm: 
   h(x,y) = sqrt( (x^2 - 4*y)^2 + (4*x - y^2)^2 );
ausgegeben werden sollen. Diese Funktion hat eine Nullstelle in [0;0]. Der Höhenlinienplot soll um diese Nullstelle herum jeweils von -1.5*Radius bis +1.5*Radius gezeichnet werden, wobei Radius ein vom Benutzer vorzugebender Parameterwert ist.

In den Höhenlinienplot sollen dann einzelne Newtonschritte eingezeichnet werden, die jeweils von einem Wert Radius*[cos(phi);sin(phi)] ausgehen, wobei phi in Schritten von pi/8 von 0 bis 2*pi läuft.

Wir beginnen die Modellierung diesesmal mit einem Subsystem-Block aus der Signal- & Systems Bibliothek (Simulink 3):

Subsystem-Block

und definieren dazu eine Maske mit dem Parameter Radius und dem 'Initialization commands' Niveau(Radius), wobei letzteres eine M-Function ist, die den Höhenlinienplot anlegen soll und die noch formuliert werden muss.

Initialization Fenster

Wir setzen voraus, dass alle benötigten Bibliotheken, Subsysteme und M-Files jeweils im aktuellen Arbeitsverzeichnis stehen, anderenfalls müssen Sie über den MATLAB-Path erreichbar sein, was gegebenenfalls mit dem Kommando addpath erreicht werden kann. Die Function Niveau lautet: 
   function Niveau(Radius)
   % Anlegen des Achsenkreuzes
   axis(1.5*[-Radius,+Radius,-Radius,+Radius]);
   % stets vorhandenes Achsenkreuz
   hold on;
   % Gitterpunkte definieren
   [Xx,Yy] = meshgrid(-1.5*Radius:Radius/4:+1.5*Radius);
   % L2-Norm der Funktionswerte
   Z = sqrt((Xx.^2-4*Yy).^2 + (4*Xx - Yy.^2).^2);
   % Zeichnung ausgeben
   title('Parabelschnitt');
   xlabel('Newton Verfahren');
   contourf(Xx,Yy,Z,12);
Die Kommentare in dieser Datei, die jeweils mit % beginnen, sollten zur Erklärung weitgehend ausreichen.
Die hold on Anweisung verhindert, dass die nachfolgende contourf Anweisung, das vorhandene Achsenkreuz mit einem eigenen Achsenkreuz überschreibt.
[Xx,Yy] = meshgrid(-1.5*Radius:Radius/4:+1.5*Radius); erzeugt zwei 13*13 Felder mit den x- und y-Koordinaten, jeweils 13 Koordinaten in diesen Feldern sind gleich.

Wir können unser Subsystem schon in diesem Zustand ausprobieren, erhalten allerdings eine Warnung, dass das Subsystem noch leer ist. Der Höhenlinienplot wird allerdings schon erzeugt. Beachten Sie, dass der Parameterwert von Radius als Argument von der Initialisierungsroutine Niveau verwendet wird.

Höhenlinienplot

Wir formulieren nun das Subsystem. Dazu müssen wir, das der Subsystem-Block schon maskiert ist, das Subsystem-Fenster mit Look under Mask öffnen. In das erscheinende leere Fenster modellieren wir:

Subsystem zur Iteration

und setzen die folgenden Parameter:
  • Stop time = 16 im Modellierfenster unter Simulation -> Parameters
  • Gain = pi/8 im Block-Parameter Fenster zum Gain-Block im Subsystem
  • MATLAB function = Iteration(u,Radius) und Output width im Block-Parameter Fenster zum MATLAB Fcn-Block im Subsystem. Iteration ist ein M-File, das wir noch schreiben müssen und das die einzelnen Iterationsschritte in den Höhenlinienplot einzeichnet. Beachten Sie, dass mit u das Eingangssignal in diesen Block bezeichnet wird, welches wir anderweitig mit phi bezeichnet haben. Der Name u ist hier aber vorgeschrieben.
Als M-File Iteration verwenden wir zunächst: 
   function Iteration(phi,Radius)
   plot(Radius*cos(phi),Radius*sin(phi),'ro');
Wir können an dieser Stelle wieder den vertrauten Namen phi für das erste Funktionsargument verwenden und sind nicht gezwungen, einen vorgegebenen Namen zu verwenden, wie das im Parameter-Fenster des MATLAB Fcn-Blockes der Fall war.
Das erste Argument im plot-Kommando gibt das x-Argument, das zweite das y-Argument des zu zeichnenden Punktes an, normalerweise stehen hier Vektoren, da viele Punkte auf einmal dargestellt werden. Das dritte Argument legt fest, wie diese Punkte darzustellen sind. Wir haben angegeben: r=rot und o=kleiner Kreis.
Wir erhalten damit:

Höhenlienienplot mit Startpunkten

Da die roten Kreise gut erkennbar sind, bleibt nichts zu ändern und wir formulieren das M-File Iteration fertig: 
   function Iteration(phi,Radius)
   x = Radius*cos(phi);
   y = Radius*sin(phi);
   plot(x,y,'ro');
   f = [ x^2 - 4*y; 4*x - y^2];
   J = [ 2*x, -4; +4, -2*y];
   z = [x;y] - J\f;
   plot([z(1),x],(z(2),y],'r');
dabei sind:
  • f der Vektor der Funktionswerte an der Stelle [x;y],
  • J die Jacobi-Matrix zu f an der Stelle [x;y],
  • -J\f die resultierende Newton-Korrektur,
  • z der jeweilige Endpunkt der Newton-Korrektur
Die endgültige Bilder sehen wie folgt aus:

Radius = 10 Höhenlienienplot mit Iterationsschritten, Radius=10
Radius = 0.1 Höhenlienienplot mit Iterationsschritten, Radius=0.1

Man sieht, dass die Qualität der Newton-Schritte besser wird, je näher man an der Nullstelle startet.