tf

Modèle de fonction de transfert

Description

Utilisez tf pour créer des modèles de fonction de transfert à valeurs réelles ou complexes, ou pour convertir des modèles de systèmes dynamiques en modèles de fonction de transfert.

Les fonctions de transfert sont une représentation du domaine fréquentiel des systèmes linéaires invariants dans le temps. Par exemple, considérons un système dynamique SISO en temps continu représenté par la fonction de transfert sys(s) = N(s)/D(s), où s = jw, N(s) et D(s) sont appelés respectivement les polynômes numérateur et dénominateur. L’objet de modèle tf peut représenter des fonctions de transfert SISO ou MIMO en temps continu ou discret.

Vous pouvez créer un objet de modèle de fonction de transfert en spécifiant directement ses coefficients ou en convertissant un modèle d’un autre type (tel qu’un modèle de représentation d’état ss) en modèle de fonction de transfert. Pour plus d’informations, consultez Fonctions de transfert.

Vous pouvez également utiliser tf pour créer des modèles de représentation d’état généralisés (genss) ou incertains (uss (Robust Control Toolbox)).

Création

Syntaxe

sys = tf(numerator,denominator)

sys = tf(numerator,denominator,ts)

sys = tf(numerator,denominator,ltiSys)

sys = tf(m)

sys = tf(___,PropertyName=Value)

sys = tf(ltiSys)

sys = tf(ltiSys,Name=Value)

sys = tf(ltiSys,component)

s = tf('s')

z = tf('z',ts)

Description

Créer un modèle de fonction de transfert

sys = tf(numerator,denominator) crée un modèle de fonction de transfert en temps continu en définissant les propriétés Numerator et Denominator. Par exemple, considérons un système dynamique SISO en temps continu représenté par la fonction de transfert sys(s) = N(s)/D(s). Les arguments en entrée numerator et denominator sont respectivement les coefficients de N(s) et D(s).

sys = tf(numerator,denominator,ts) crée un modèle de fonction de transfert en temps discret en définissant les propriétés Numerator, Denominator et Ts. Par exemple, considérons un système dynamique SISO en temps discret représenté par la fonction de transfert sys(z) = N(z)/D(z). Les arguments en entrée numerator et denominator sont respectivement les coefficients de N(z) et D(z). Pour ne pas spécifier le pas d’échantillonnage, définissez l’argument ts en entrée à -1.

sys = tf(numerator,denominator,ltiSys) crée un modèle de fonction de transfert avec les propriétés héritées du modèle de système dynamique ltiSys, y compris le pas d’échantillonnage.

sys = tf(m) crée un modèle de fonction de transfert représentant le gain statique, m.

sys = tf(___,PropertyName=Value) définit les propriétés du modèle de fonction de transfert au moyen d’un ou plusieurs arguments nom-valeur pour n’importe quelle combinaison entrée-argument précédente.

Convertir en modèle de fonction de transfert

sys = tf(ltiSys) convertit le modèle de systèmes dynamiques ltiSys en un modèle de fonction de transfert.

sys = tf(ltiSys,Name=Value) obtient une représentation de fonction de transfert tronquée du modèle parcimonieux ltiSys en calculant les zéros et les pôles sur la base d’un ou plusieurs arguments nom-valeur spécifiés. Puisque cette méthode calcule les zéros pour chaque paire d’entrée-sortie, elle convient mieux aux modèles ayant de petites tailles d’entrées-sorties. (depuis R2025a)

sys = tf(ltiSys,component) convertit le component spécifié de ltiSys en modèle de fonction de transfert. Vous ne devez utiliser cette syntaxe que lorsque ltiSys est un modèle linéaire identifié invariant dans le temps.

Créer une variable pour une expression rationnelle

s = tf('s') crée une variable spéciale s que vous pouvez utiliser dans une expression rationnelle pour créer un modèle de fonction de transfert en temps continu. Il est parfois plus aisé et plus intuitif de recourir à une expression rationnelle plutôt que de spécifier des coefficients polynomiaux.

z = tf('z',ts) crée une variable spéciale z que vous pouvez utiliser dans une expression rationnelle pour créer un modèle de fonction de transfert en temps discret. Pour ne pas spécifier le pas d’échantillonnage, définissez l’argument ts en entrée à -1.

Arguments en entrée

numerator — Coefficients du numérateur de la fonction de transfert

vecteur ligne | cell array Ny par Nu de vecteurs ligne

Coefficients du numérateur de la fonction de transfert, spécifiés sous les formes suivantes :

• Vecteur ligne de coefficients polynomiaux.

• Cell array Ny par Nu de vecteurs ligne servant à spécifier une fonction de transfert MIMO où Ny désigne le nombre de sorties et Nu, le nombre d’entrées.

Lorsque vous créez la fonction de transfert, spécifiez les coefficients du numérateur dans l’ordre des puissances décroissantes. Par exemple, si le numérateur de la fonction de transfert est 3s^2-4s+5, spécifiez numerator en tant que [3 -4 5]. Dans le cas d’une fonction de transfert en temps discret dotée du numérateur 2z-1, définissez numerator sur [2 -1].

Définissez également une propriété de l’objet tf. Pour plus d’informations, consultez Numerator.

denominator — Coefficients du dénominateur de la fonction de transfert

vecteur ligne | cell array Ny par Nu de vecteurs ligne

Coefficients du dénominateur spécifiés sous les formes suivantes :

• Vecteur ligne de coefficients polynomiaux.

• Cell array Ny par Nu de vecteurs ligne servant à spécifier une fonction de transfert MIMO où Ny désigne le nombre de sorties et Nu, le nombre d’entrées.

Lorsque vous créez la fonction de transfert, spécifiez les coefficients du dénominateur dans l’ordre des puissances décroissantes. Par exemple, si le dénominateur de la fonction de transfert est 7s^2+8s-9, spécifiez denominator en tant que [7 8 -9]. Dans le cas d’une fonction de transfert en temps discret dotée du dénominateur 2z^2+1, définissez denominator sur [2 0 1].

Définissez également une propriété de l’objet tf. Pour plus d’informations, consultez Denominator.

ts — Pas d’échantillonnage

scalaire

Pas d’échantillonnage spécifié en tant que scalaire. Définissez également une propriété de l’objet tf. Pour plus d’informations, consultez Ts.

ltiSys — Système dynamique

modèle de systèmes dynamiques | tableau de modèles

Système dynamique spécifié en tant que modèle de système dynamique SISO or MIMO ou en tant que tableau de modèles de systèmes dynamiques. Parmi les systèmes dynamiques que vous pouvez utiliser, citons :

• Modèles LTI numériques en temps continu ou discret, tels que les modèles tf, zpk, ss ou pid.

  Si ltiSys est un modèle de représentation d’état parcimonieux (sparss ou mechss), le logiciel calcule une approximation de fonction de transfert tronquée en calculant les pôles et les zéros dans une bande de fréquence d’attention spécifiée. Pour les modèles parcimonieux, utilisez les arguments nom-valeur pour spécifier les options de calcul. Si vous ne spécifiez aucune option, le logiciel calcule jusqu’aux 1 000 premiers pôles et zéros avec la plus petite amplitude. De plus, obtenir cette approximation est applicable uniquement pour les modèles ayant une représentation sparss valide. (depuis R2025a)

• Modèles LTI généralisés ou incertains tels que les modèles genss ou uss (Robust Control Toolbox). (Pour pouvoir utiliser les modèles incertains, le software Robust Control Toolbox™ est nécessaire.)

  La fonction de transfert résultante s'appuie sur

  • les valeurs actuelles des composants réglables pour les blocs de design de systèmes de contrôle réglables.

  • les valeurs de modèle nominales pour les blocs de design de systèmes de contrôle incertains.

• Modèles LTI identifiés tels que les modèles idtf (System Identification Toolbox), idss (System Identification Toolbox), idproc (System Identification Toolbox), idpoly (System Identification Toolbox) et idgrey (System Identification Toolbox). Pour sélectionner la composante du modèle identifié à convertir, spécifiez component. Si vous ne spécifiez pas component, tf convertit la composante mesurée du modèle identifié par défaut. (Pour pouvoir utiliser les modèles identifiés, le software System Identification Toolbox™ est nécessaire)

m — Gain statique

scalaire | matrice

Gain statique spécifié en tant que scalaire ou matrice. Le gain statique ou le gain à l'état stable d’un système représente le rapport sortie/entrée en présence d’un état stable.

component — Composante du modèle identifié

'measured' (par défaut) | 'noise' | 'augmented'

Composante du modèle identifié à convertir, spécifiée sous l’une des formes suivantes :

• 'measured' : convertit la composante mesurée de sys.

• 'noise' : convertit la composante de bruit de sys

• 'augmented' : convertit à la fois la composante mesurée et la composante de bruit de sys.

component ne s’applique que lorsque sys est un modèle LTI identifié.

Pour plus d’informations sur les modèles LTI identifiés et leurs composantes mesurée et de bruit, voir Identified LTI Models.

Arguments nom-valeur

Spécifiez des paires d’arguments optionnelles sous la forme Name1=Value1,...,NameN=ValueN, où Name est le nom de l’argument et Value est la valeur correspondante. Les arguments nom-valeur doivent apparaître après les autres arguments, mais l’ordre des paires n’a pas d’importance.

Exemple : sys = tf(sparseSys,Focus=[0 100],Display="off")

UseParallel — Utiliser le calcul parallèle

0 ou false (par défaut) | 1 ou true

Depuis R2025a

Utilisez le calcul parallèle pendant le calcul des pôles et des zéros, spécifié sous la forme numérique ou logique 0 (false) ou 1 (true).

Quand UseParallel est défini sur true, vous pouvez choisir explicitement de mettre à l’échelle de votre environnement parallèle privilégié. Activer le calcul parallèle peut se traduire par une performance améliorée pendant le calcul des zéros et des pôles. Cependant, même avec UseParallel défini sur false, l’algorithme peut utiliser le multithreading prédéfini pour utiliser les ressources locales de manière optimale. Pour plus d’informations, consultez MATLAB Multicore.

Cette option nécessite une licence Parallel Computing Toolbox™.

RollOff — Pente d’atténuation

0 (par défaut) | scalaire non positif | matrice

Depuis R2025a

Pente d’atténuation, spécifiée en tant que scalaire non positif ou matrice.

• Utilisez une valeur scalaire pour les modèles SISO ou quand la pente est uniforme pour toutes les paires d’entrée-sortie pour les modèles MIMO.

• Utilisez une matrice quand la pente est différente pour chaque paire d’entrée-sortie pour les modèles MIMO.

Cette option vous permet de spécifier explicitement comment l’approximation devrait décroître après la plage de fréquences spécifiée. Par exemple, Slope de -2 garantit la décroissance du gain à une vitesse d’au moins –40 dB/décade (la vitesse d’atténuation de 1/s²) au-delà de fmax.

Focus — Plage de fréquences d’intérêt

[0 Inf] (par défaut) | vecteur

Depuis R2025a

Plage de fréquences d’intérêt, spécifiée en tant que vecteur de forme [0,fmax]. Quand vous spécifiez une plage de fréquences d’attention, le logiciel ne calcule que les pôles à fréquence naturelle dans cette plage. Pour les modèles en temps discret, le logiciel estime la fréquence naturelle équivalente via la transformation de Tustin.

Puisque tf calcule tous les pôles et zéros dans la plage de fréquences spécifiée, vous spécifiez généralement une plage basse fréquence pour éviter de calculer un grand nombre de pôles et de zéros. Par défaut, l’attention est non spécifiée ([0 Inf]) et l’algorithme calcule jusqu’à MaxNumber pôles et zéros.

MaxNumber — Nombre maximal de pôles et de zéros à calculer

1000 (par défaut) | entier positif

Depuis R2025a

Nombre maximal de pôles et de zéros à calculer, spécifié en tant qu’entier positif. Cette valeur limite le nombre de pôles et de zéros calculés par l’algorithme et l’ordre d’approximation du modèle parcimonieux original.

Shift — Décalage spectral

0 (par défaut) | scalaire fini

Depuis R2025a

Décalage spectral, spécifié en tant que scalaire fini.

Le logiciel calcule les pôles avec la fréquence naturelle dans la plage spécifiée [0,fmax] au moyen d’itérations de puissance inverse pour A-sigma*E, ce qui obtient les valeurs propres les plus proches du décalage sigma. Quand A est singulier et sigma est zéro, l’algorithme échoue car aucune inverse n’existe. Par conséquent, pour les modèles parcimonieux avec action intégrale (s = 0 ou à z = 1 pour les modèles en temps discret), vous pouvez utiliser cette option pour décaler implicitement des pôles ou des zéros à la valeur la plus proche de cette valeur de décalage. Spécifiez une valeur de décalage qui n’est pas égale à une valeur existante de pôle ou de zéro du modèle original.

Tolerance — Précision des pôles et des zéros calculés

1e-12 (par défaut) | scalaire fini positif

Depuis R2025a

Tolérance pour la précision des pôles et des zéros calculés, spécifiée en tant que scalaire fini positif. Cette valeur contrôle la convergence des valeurs propres calculées dans les itérations de puissance inverse.

Display — Afficher ou masquer un rapport d’avancement

"on" (par défaut) | "off"

Depuis R2025a

Afficher ou masquer un rapport d’avancement, spécifié en tant que "off" ou "on".

Arguments en sortie

sys — Modèle de système en sortie

Objet de modèle tf | Objet de modèle genss | Objet de modèle uss

Modèle de système en sortie renvoyé sous la forme suivante :

• Objet de modèle de fonction de transfert (tf) où les arguments en entrée numerator et denominator sont des tableaux numériques. sys est toujours un objet de modèle tf lors de la conversion de ltiSys en type de modèle tf.

• Objet de modèle de représentation d’état généralisé (genss) lorsque l’argument en entrée numerator ou denominator comprend des paramètres réglables, tels que les paramètres realp ou les matrices généralisées (genmat). Pour un exemple, voir Filtre passe-bas réglable.

• Objet de modèle de représentation d’état incertain (uss) lorsque l‘argument en entrée numerator ou denominator comprend des paramètres incertains. Pour pouvoir utiliser les modèles incertains, le software Robust Control Toolbox est nécessaire. Pour un exemple, voir Transfer Function with Uncertain Coefficients (Robust Control Toolbox).

Propriétés

Numerator — Coefficients du numérateur

vecteur ligne | cell array Ny par Nu de vecteurs ligne

Coefficients du numérateur spécifiés sous les formes suivantes :

• Vecteur ligne de coefficients polynomiaux organisé par ordre de puissances décroissantes (pour les valeurs Variable 's', 'z', 'p' ou 'q') ou par ordre de puissances croissantes (pour les valeurs Variable 'z^-1' ou 'q^-1').

• Cell array Ny par Nu de vecteurs ligne servant à spécifier une fonction de transfert MIMO où Ny désigne le nombre de sorties et Nu, le nombre d’entrées. Chaque élément du cell array spécifie les coefficients du numérateur pour une paire entrée/sortie donnée. Si vous spécifiez Numerator et Denominator en tant que cell arrays, ils doivent présenter les mêmes dimensions.

Les coefficients du Numerator peuvent présenter des valeurs réelles ou complexes.

Denominator — Coefficients du dénominateur

vecteur ligne | cell array Ny par Nu de vecteurs ligne

Coefficients du dénominateur spécifiés sous les formes suivantes :

• Vecteur ligne de coefficients polynomiaux par ordre de puissances décroissantes (pour les valeurs Variable 's', 'z', 'p', ou 'q') ou par ordre de puissances croissantes (pour les valeurs Variable 'z^-1' ou 'q^-1').

• Cell array Ny par Nu de vecteurs ligne servant à spécifier une fonction de transfert MIMO où Ny désigne le nombre de sorties et Nu, le nombre d’entrées. Chaque élément du cell array spécifie les coefficients du numérateur pour une paire entrée/sortie donnée. Si vous spécifiez Numerator et Denominator en tant que cell arrays, ils doivent présenter les mêmes dimensions.

Si toutes les entrées SISO d’une fonction de transfert MIMO présentent le même dénominateur, vous pouvez spécifier Denominator en tant que vecteur ligne tout en spécifiant Numerator en tant que cell array.

Les coefficients du Denominator peuvent présenter des valeurs réelles ou complexes.

Variable — Variable d’affichage de la fonction de transfert

's' (par défaut) | 'z' | 'p' | 'q' | 'z^-1' | 'q^-1'

Variable d’affichage de la fonction de transfert spécifiée sous l’une des formes suivantes :

• 's' : valeur par défaut des modèles en temps continu

• 'z' : valeur par défaut des modèles en temps discret

• 'p' : équivalent de 's'

• 'q' : équivalent de 'z'

• 'z^-1' : inverse de 'z'

• 'q^-1' : équivalent de 'z^-1'

La valeur de Variable apparaît dans l'affichage et affecte également l'interprétation des vecteurs de coefficient Numerator et Denominator pour les modèles en temps discret.

• Pour les valeurs Variable 's', 'z', 'p' ou 'q', les coefficients sont classés dans l’ordre des puissances décroissantes de la variable. Par exemple, considérons le vecteur ligne [ak ... a1 a0]. L’ordre polynomial est spécifié sous la forme $$a_k{z}^k+\mathrm{...}+a_{1}z+a_0$$.

• Pour les valeurs Variable 'z^-1' ou 'q^-1', les coefficients sont classés dans l’ordre des puissances croissantes de la variable. Par exemple, considérons le vecteur ligne [b0 b1 ... bk]. L’ordre polynomial est spécifié sous la forme $$b_0+b_1{z}^{-1}+\mathrm{...}+b_k{z}^{-k}$$.

Pour consulter des exemples, voir Spécification de l’ordre polynomial dans la fonction de transfert en temps discret, Modèle de fonction de transfert utilisant une expression rationnelle et Modèle de fonction de transfert en temps discret utilisant une expression rationnelle.

IODelay — Retard de transport

0 (par défaut) | scalaire | Tableau Ny par Nu

Retard de transport spécifié sous l’une des formes suivantes :

• Scalaire : spécifiez le retard de transport pour un système SISO ou le même retard de transport pour toutes les paires entrée/sortie d'un système MIMO.

• Tableau Ny par Nu : spécifiez des retards de transport distincts pour chaque paire entrée/sortie d'un système MIMO. Ici, Ny désigne le nombre de sorties et Nu, le nombre d’entrées.

Pour les systèmes en temps continu, spécifiez les retards de transport dans l'unité temporelle spécifiée par la propriété TimeUnit. Pour les systèmes en temps discret, spécifiez les retards de transport en tant qu’entiers multiples du pas d’échantillonnage, Ts.

InputDelay — Retard en entrée

0 (par défaut) | scalaire | Vecteur Nu par 1

Retard en entrée pour chaque canal d’entrée spécifié sous l’une des formes suivantes :

• Scalaire : spécifiez le retard en entrée pour un système SISO ou le même retard pour toutes les entrées d'un système à entrées multiples.

• Vecteur Nu par 1 : spécifiez des retards d’entrée distincts pour l’entrée d’un système à entrées multiples où Nu désigne le nombre d’entrées.

Pour les systèmes en temps continu, spécifiez les retards en entrée dans l'unité temporelle spécifiée par la propriété TimeUnit. Pour les systèmes en temps discret, spécifiez les retards en entrée en tant qu’entiers multiples du pas d’échantillonnage, Ts.

Pour plus d’informations, consultez Time Delays in Linear Systems.

OutputDelay — Retard en sortie

0 (par défaut) | scalaire | Vecteur Ny par 1

Retard en sortie pour chaque canal de sortie spécifié sous l’une des formes suivantes :

• Scalaire : spécifiez le retard en sortie pour un système SISO ou le même retard pour toutes les sorties d'un système à sorties multiples.

• Vecteur Ny par 1 : spécifiez des retards de sortie distincts pour la sortie d’un système à sorties multiples où Ny désigne le nombre de sorties.

Pour les systèmes en temps continu, spécifiez les retards en sortie dans l'unité temporelle spécifiée par la propriété TimeUnit. Pour les systèmes en temps discret, spécifiez les retards en sortie en tant qu’entiers multiples du pas d’échantillonnage, Ts.

Pour plus d’informations, consultez Time Delays in Linear Systems.

Ts — Pas d’échantillonnage

0 (par défaut) | scalaire positif | -1

Pas d’échantillonnage spécifié en tant que :

• 0 pour les systèmes en temps continu.

• Scalaire positif représentant la période d’échantillonnage d’un système en temps discret. Spécifiez Ts dans l'unité temporelle définie par la propriété TimeUnit.

• -1 pour un système en temps discret avec un pas d’échantillonnage non spécifié.

Remarque

La modification de Ts ne discrétise pas ou ne rééchantillonne pas le modèle. Pour effectuer des conversions entre les représentations en temps continu et en temps discret, utilisez c2d et d2c. Pour modifier le pas d’échantillonnage d’un système en temps discret, utilisez d2d.

TimeUnit — Unités temporelles variables

'seconds' (par défaut) | 'nanoseconds' | 'microseconds' | 'milliseconds' | 'minutes' | 'hours' | 'days' | 'weeks' | 'months' | 'years' | ...

Unités temporelles variables spécifiées sous l’une des formes suivantes :

• 'nanoseconds'

• 'microseconds'

• 'milliseconds'

• 'seconds'

• 'minutes'

• 'hours'

• 'days'

• 'weeks'

• 'months'

• 'years'

La modification de TimeUnit n’a aucune incidence sur les autres propriétés mais change l’ensemble du comportement du système. Utilisez chgTimeUnit pour faire des conversions entre les unités temporelles sans modifier le comportement du système.

InputName — Noms des canaux en entrée

'' (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Noms des canaux en entrée spécifiés sous l'une des formes suivantes :

• Vecteur de caractères pour les modèles à entrée unique.

• Cell array de vecteurs de caractères pour les modèles à entrées multiples.

• '', pas de nom spécifié pour les canaux en entrée.

Sinon, vous pouvez attribuer des noms aux entrées pour les modèles à entrées multiples au moyen de l'expansion vectorielle automatique. Par exemple, si sys est un modèle à deux entrées, saisissez ce qui suit :

sys.InputName = 'controls';

Les noms en entrée s’étendent automatiquement à {'controls(1)';'controls(2)'}.

Vous pouvez utiliser la notation abrégée u pour faire référence à la propriété InputName. Par exemple, sys.u est équivalent à sys.InputName.

Utilisez InputName pour :

• Identifier des canaux sur l’affichage et les tracés du modèle.

• Extraire des sous-systèmes de systèmes MIMO.

• Spécifier des points de connexion au moment d’interconnecter les modèles.

InputUnit — Unités des canaux en entrée

'' (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Unités des canaux en entrée spécifiées sous l’une des formes suivantes :

• Vecteur de caractères pour les modèles à entrée unique.

• Cell array de vecteurs de caractères pour les modèles à entrées multiples.

• '', pas d'unité spécifiée pour les canaux en entrée.

Utilisez InputUnit pour spécifier les unités des signaux en entrée. InputUnit n'a aucune incidence sur le comportement du système.

InputGroup — Groupes de canaux en entrée

structure

Groupes de canaux en entrée spécifiés en tant que structure. Utilisez InputGroup pour attribuer les canaux en entrée des systèmes MIMO à des groupes et faire référence à chaque groupe par son nom. Les noms des champs de InputGroup correspondent aux noms des groupes tandis que les valeurs des champs sont les canaux en entrée pour chaque groupe. Par exemple, saisissez ce qui suit pour créer des groupes d’entrée nommés controls et noise comprenant respectivement les canaux d’entrée 1, 2, 3 et 5.

sys.InputGroup.controls = [1 2];
sys.InputGroup.noise = [3 5];

Vous pouvez alors extraire le sous-système des entrées controls vers toutes les sorties en utilisant la commande suivante.

sys(:,'controls')

Par défaut, InputGroup est une structure dépourvue de champs.

OutputName — Noms des canaux en sortie

'' (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Noms des canaux en sortie spécifiés sous l’une des formes suivantes :

• Vecteur de caractères pour les modèles à sortie unique.

• Cell array de vecteurs de caractères pour les modèles à sorties multiples.

• '', pas de nom spécifié pour les canaux en sortie.

Sinon, vous pouvez attribuer des noms de sortie pour les modèles à sorties multiples au moyen de l'expansion vectorielle automatique. Par exemple, si sys est un modèle à deux sorties, saisissez ce qui suit :

sys.OutputName = 'measurements';

Les noms de sortie s’étendent automatiquement à {'measurements(1)';'measurements(2)'}.

Vous pouvez également utiliser la notation abrégée y pour faire référence à la propriété OutputName. Par exemple, sys.y est équivalent à sys.OutputName.

Utilisez OutputName pour :

• Identifier des canaux sur l’affichage et les tracés du modèle.

• Extraire des sous-systèmes de systèmes MIMO.

• Spécifier des points de connexion au moment d’interconnecter les modèles.

OutputUnit — Unités des canaux en sortie

'' (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Unités des canaux en sortie spécifiées sous l’une des formes suivantes :

• Vecteur de caractères pour les modèles à sortie unique.

• Cell array de vecteurs de caractères pour les modèles à sorties multiples.

• '', pas d'unité spécifiée pour les canaux en sortie.

Utilisez OutputUnit pour spécifier les unités des signaux en sortie. OutputUnit n'a aucune incidence sur le comportement du système.

OutputGroup — Groupes de canaux en sortie

structure

Groupes de canaux en sortie spécifiés en tant que structure. Utilisez OutputGroup pour attribuer les canaux en sortie des systèmes MIMO à des groupes et faire référence à chaque groupe par son nom. Les noms des champs de OutputGroup correspondent aux noms des groupes tandis que les valeurs des champs sont les canaux en sortie pour chaque groupe. Par exemple, créez des groupes de sortie nommés temperature et measurement et comprenant respectivement les canaux de sortie 1, 3 et 5.

sys.OutputGroup.temperature = [1];
sys.OutputGroup.measurement = [3 5];

Vous pouvez alors extraire le sous-système de toutes les entrées vers les sorties measurement en utilisant la commande suivante.

sys('measurement',:)

Par défaut, OutputGroup est une structure dépourvue de champs.

Name — Nom du système

'' (par défaut) | vecteur de caractères

Nom du système spécifié en tant que vecteur de caractères. Par exemple, 'system_1'.

Notes — Texte spécifié par l’utilisateur

{} (par défaut) | vecteur de caractères | cell array de vecteurs de caractères

Texte spécifié par l’utilisateur, que vous souhaitez associer au système, spécifié en tant que vecteur de caractères ou cell array de vecteurs de caractères. Par exemple, 'System is MIMO'.

UserData — Données spécifiées par l’utilisateur

[] (par défaut) | tout type de données MATLAB^®

Données spécifiées par l’utilisateur, que vous souhaitez associer au système, spécifié en tant que type de données MATLAB.

SamplingGrid — Grille d’échantillonnage pour tableaux de modèles

tableau de structures

Grille d’échantillonnage pour les tableaux de modèles, spécifiés en tant que structure array.

Utilisez SamplingGrid pour effectuer le suivi des valeurs variables associées à chaque modèle dans un tableau de modèles, y compris les tableaux de modèles linéaires identifiés fixes dans le temps (IDLTI).

Définissez les noms des champs de la structure sur les noms des variables d'échantillonnage. Définissez les valeurs des champs sur les valeurs variables échantillonnées associées à chaque modèle du tableau. Toutes les variables d'échantillonnage doivent être des scalaires numériques et tous les tableaux de valeurs échantillonnées doivent correspondre aux dimensions du tableau de modèles.

Par exemple, vous pouvez créer un tableau 11 par 1 de modèles linéaires, sysarr, en prenant des snapshots d'un système linéaire variant dans le temps à des moments t = 0:10. Le code suivant stocke les pas d’échantillonnage avec les modèles linéaires.

 sysarr.SamplingGrid = struct('time',0:10)

De la même manière, vous pouvez créer un tableau de modèles 6 par 9, M, en échantillonnant indépendamment deux variables, zeta et w. Le code suivant fait correspondre les valeurs (zeta,w) à M.

[zeta,w] = ndgrid(<6 values of zeta>,<9 values of w>)
M.SamplingGrid = struct('zeta',zeta,'w',w)

Lorsque vous affichez M, chaque entrée du tableau comprend les valeurs zeta et w correspondantes.

M

M(:,:,1,1) [zeta=0.3, w=5] =
 
        25
  --------------
  s^2 + 3 s + 25
 

M(:,:,2,1) [zeta=0.35, w=5] =
 
         25
  ----------------
  s^2 + 3.5 s + 25
 
...

Pour les tableaux de modèles générés par linéarisation d'un modèle Simulink^® à valeurs de paramètres ou points de fonctionnement multiples, le software remplit automatiquement SamplingGrid avec les valeurs de variables qui correspondent à chaque entrée du tableau. Par exemple, les commandes Simulink Control Design™ linearize (Simulink Control Design) et slLinearizer (Simulink Control Design) remplissent automatiquement SamplingGrid.

Par défaut, SamplingGrid est une structure dépourvue de champs.

Fonctions d'objet

Les listes suivantes contiennent un sous-ensemble représentatif des fonctions que vous pouvez utiliser avec les modèles tf. En règle générale, toute fonction applicable à Modèles de systèmes dynamiques est applicable à un objet tf.

Analyse linéaire

step	Réponse indicielle d’un système dynamique
impulse	Impulse response plot of dynamic system; impulse response data
lsim	Compute time response simulation data of dynamic system to arbitrary inputs
bode	Réponse en fréquence de Bode d'un système dynamique
nyquist	Nyquist response of dynamic system
nichols	Réponse de Black-Nichols d’un système dynamique
bandwidth	Frequency response bandwidth

Analyse de stabilité

pole	Poles of dynamic system
zero	Zéros et gain d’un système dynamique SISO
pzplot	Plot pole-zero map of dynamic system
margin	Marges de gain et de phase, et fréquences de crossover

Transformation des modèles

zpk	Modèle zéro-pôle-gain
ss	Modèle de représentation d'état
c2d	Conversion de modèle du temps continu au temps discret
d2c	Convert model from discrete to continuous time
d2d	Resample discrete-time model

Interconnexion des modèles

feedback	Connexion rétroactive de plusieurs modèles
connect	Block diagram interconnections of dynamic systems
series	Connexion en série de deux modèles
parallel	Parallel connection of two models

Design de contrôleurs

pidtune	PID tuning algorithm for linear plant model
rlocus	Lieu des racines d’un système dynamique
lqr	Design d'un régulateur linéaire quadratique (LQR, Linear Quadratic Regulator)
lqg	Linear-Quadratic-Gaussian (LQG) design
lqi	Contrôle linéaire quadratique intégral
kalman	Design Kalman filter for state estimation

Exemples

Modèle de fonction de transfert SISO

Pour cet exemple, considérons le modèle de fonction de transfert SISO suivant :

$$sys(s)=\frac{1}{2s^2+3s+4}.$$

Spécifiez les coefficients du numérateur et du dénominateur classés dans l’ordre des puissances décroissantes de s, et créez le modèle de fonction de transfert.

numerator = 1;
denominator = [2,3,4];
sys = tf(numerator,denominator)

sys =
 
         1
  ---------------
  2 s^2 + 3 s + 4
 
Continuous-time transfer function.
Model Properties

Modèle de fonction de transfert SISO en temps discret

Pour cet exemple, considérons le modèle de fonction de transfert SISO en temps discret suivant :

$$sys(z)=\frac{2z}{4z^3+3z-1}.$$

Spécifiez les coefficients du numérateur et du dénominateur classés dans l’ordre des puissances décroissantes de z, et un pas d’échantillonnage de 0,1 s. Créez le modèle de fonction de transfert en temps discret.

numerator = [2,0];
denominator = [4,0,3,-1];
ts = 0.1;
sys = tf(numerator,denominator,ts)

sys =
 
        2 z
  ---------------
  4 z^3 + 3 z - 1
 
Sample time: 0.1 seconds
Discrete-time transfer function.
Model Properties

Fonction de transfert de deuxième ordre issue de l’amortissement et de la fréquence naturelle

Pour cet exemple, considérons un modèle de fonction de transfert qui représente un système de deuxième ordre avec la fréquence naturelle et l’amortissement connus.

Voici la fonction de transfert d’un système de deuxième ordre, exprimée en fonction de son amortissement $$\zeta$$ et de la fréquence naturelle $${\omega }_0$$ :

$$sys\left(s\right)=\frac{{\omega }_0^2}{s^2+2\zeta {\omega }_{0}s+{\omega }_0^2}.$$

Sur la base d'un amortissement $$\zeta$$ = 0,25 et d’une fréquence naturelle $${\omega }_0$$ = 3 rad/s, créez la fonction de transfert de deuxième ordre.

zeta = 0.25;
w0 = 3;
numerator = w0^2;
denominator = [1,2*zeta*w0,w0^2];
sys = tf(numerator,denominator)

sys =
 
         9
  ---------------
  s^2 + 1.5 s + 9
 
Continuous-time transfer function.
Model Properties

Examinez la réponse de cette fonction de transfert à une entrée indicielle.

stepplot(sys)

Le tracé indique l’appel en aval attendu d’un système de deuxième ordre avec un faible amortissement.

Modèle de fonction de transfert MIMO en temps discret

Créez une fonction de transfert pour le modèle MIMO en temps discret :

$$sys\left(z\right)=\left[\begin{array}{cc}\frac{1}{z+0.3}& \frac{z}{z+0.3}\\ \frac{-z+2}{z+0.3}& \frac{3}{z+0.3}\end{array}\right]$$

avec un pas d’échantillonnage de ts = 0.2 secondes.

Spécifiez les coefficients du numérateur sous la forme d’une matrice 2 par 2.

numerators = {1 [1 0];[-1 2] 3};

Spécifiez les coefficients du dénominateur commun en tant que vecteur ligne.

denominator = [1 0.3];

Créez le modèle de fonction de transfert MIMO en temps discret.

ts = 0.2;
sys = tf(numerators,denominator,ts)

sys =
 
  From input 1 to output...
          1
   1:  -------
       z + 0.3
 
       -z + 2
   2:  -------
       z + 0.3
 
  From input 2 to output...
          z
   1:  -------
       z + 0.3
 
          3
   2:  -------
       z + 0.3
 
Sample time: 0.2 seconds
Discrete-time transfer function.
Model Properties

Pour plus d'informations sur la création de fonctions de transfert MIMO, voir Fonctions de transfert MIMO.

Concaténation de fonctions de transfert SISO dans un modèle de fonction de transfert MIMO

Dans cet exemple, vous créez un modèle de fonction de transfert MIMO en concaténant des modèles de fonction de transfert SISO. Considérons la fonction de transfert SISO suivante :

$$sys(s)=\left[\begin{array}{c}\frac{s-1}{s+1}\\ \frac{s+2}{s^2+4s+5}\end{array}\right].$$

Spécifiez le modèle de fonction de transfert MIMO en concaténant les entrées SISO.

sys1 = tf([1 -1],[1 1]);		
sys2 = tf([1 2],[1 4 5]);
sys = [sys1;sys2]

sys =
 
  From input to output...
       s - 1
   1:  -----
       s + 1
 
           s + 2
   2:  -------------
       s^2 + 4 s + 5
 
Continuous-time transfer function.
Model Properties

Pour plus d'informations sur la création de fonctions de transfert MIMO, voir Fonctions de transfert MIMO.

Modèle de fonction de transfert utilisant une expression rationnelle

Pour cet exemple, créez un modèle de fonction de transfert en temps continu avec des expressions rationnelles. Il est parfois plus aisé et plus intuitif de recourir à une expression rationnelle plutôt que de spécifier les coefficients polynomiaux du numérateur et du dénominateur.

Considérons le système suivant :

$$sys(s)=\frac{s}{s^2+2s+10}.$$

Pour créer le modèle de fonction de transfert, commencez par spécifier s en tant qu’objet tf.

s = tf('s')

s =
 
  s
 
Continuous-time transfer function.
Model Properties

Créez le modèle de fonction de transfert en utilisant s dans l’expression rationnelle.

sys = s/(s^2 + 2*s + 10)

sys =
 
        s
  --------------
  s^2 + 2 s + 10
 
Continuous-time transfer function.
Model Properties

Modèle de fonction de transfert en temps discret utilisant une expression rationnelle

Pour cet exemple, créez un modèle de fonction de transfert en temps discret au moyen d’une expression rationnelle. Il est parfois plus aisé et plus intuitif de recourir à une expression rationnelle plutôt que de spécifier des coefficients polynomiaux.

Considérons le système suivant :

$$sys(z)=\frac{z-1}{z^2-1.85z+0.9}.$$

Pour créer le modèle de fonction de transfert, commencez par spécifier z en tant qu’objet tf et le pas d’échantillonnage Ts.

ts = 0.1;
z = tf('z',ts)

z =
 
  z
 
Sample time: 0.1 seconds
Discrete-time transfer function.
Model Properties

Créez le modèle de fonction de transfert en utilisant z dans l’expression rationnelle.

sys = (z - 1) / (z^2 - 1.85*z + 0.9)

sys =
 
        z - 1
  ------------------
  z^2 - 1.85 z + 0.9
 
Sample time: 0.1 seconds
Discrete-time transfer function.
Model Properties

Modèle de fonction de transfert aux propriétés héritées

Pour cet exemple, créez un modèle de fonction de transfert avec les propriétés héritées d’un autre modèle du même type. Considérons les deux fonctions de transfert suivantes :

$$sys1(s)=\frac{2s}{s^2+8s}andsys2(s)=\frac{s-1}{7s^4+2s^3+9}.$$

Pour cet exemple, créez sys1 en configurant les propriétés TimeUnit et InputDelay en minutes.

numerator1 = [2,0];
denominator1 = [1,8,0];
sys1 = tf(numerator1,denominator1,'TimeUnit','minutes','InputUnit','minutes')

sys1 =
 
     2 s
  ---------
  s^2 + 8 s
 
Continuous-time transfer function.
Model Properties

propValues1 = [sys1.TimeUnit,sys1.InputUnit]

propValues1 = 1×2 cell
    {'minutes'}    {'minutes'}

Créez le deuxième modèle de fonction de transfert avec les propriétés héritées de sys1.

numerator2 = [1,-1];
denominator2 = [7,2,0,0,9];
sys2 = tf(numerator2,denominator2,sys1)

sys2 =
 
        s - 1
  -----------------
  7 s^4 + 2 s^3 + 9
 
Continuous-time transfer function.
Model Properties

propValues2 = [sys2.TimeUnit,sys2.InputUnit]

propValues2 = 1×2 cell
    {'minutes'}    {'minutes'}

Comme vous pouvez le constater, le modèle de fonction de transfert sys2 comporte les mêmes propriétés que sys1.

Tableau des modèles de fonction de transfert

Vous pouvez utiliser une boucle for pour spécifier un tableau de modèles de fonction de transfert.

Commencez par pré-attribuer le tableau des fonctions de transfert avec des zéros.

sys = tf(zeros(1,1,3));

Les deux premiers indices représentent le nombre de sorties et d'entrées pour les modèles, tandis que le troisième indice correspond au nombre de modèles figurant dans le tableau.

Créez le tableau de modèles de fonction de transfert en utilisant une expression rationnelle dans la boucle for.

s = tf('s');                                                  
for k = 1:3                                                             
    sys(:,:,k) = k/(s^2+s+k);                                          
end
sys

sys(:,:,1,1) =
 
       1
  -----------
  s^2 + s + 1
 

sys(:,:,2,1) =
 
       2
  -----------
  s^2 + s + 2
 

sys(:,:,3,1) =
 
       3
  -----------
  s^2 + s + 3
 
3x1 array of continuous-time transfer functions.
Model Properties

Conversion d’un modèle de représentation d’état en fonction de transfert

Pour cet exemple, calculez la fonction de transfert du modèle de représentation d’état suivant :

$$A=\left[\begin{array}{cc}-2& -1\\ 1& -2\end{array}\right],B=\left[\begin{array}{cc}1& 1\\ 2& -1\end{array}\right],C=\left[\begin{array}{cc}1& 0\end{array}\right],D=[\begin{array}{cc}0& 1\end{array}].$$

Créez le modèle de représentation d’état au moyen des matrices de représentation d’état.

A = [-2 -1;1 -2];
B = [1 1;2 -1];
C = [1 0];
D = [0 1];
ltiSys = ss(A,B,C,D);

Convertissez le modèle de représentation d’état ltiSys en une fonction de transfert.

sys = tf(ltiSys)

sys =
 
  From input 1 to output:
        s
  -------------
  s^2 + 4 s + 5
 
  From input 2 to output:
  s^2 + 5 s + 8
  -------------
  s^2 + 4 s + 5
 
Continuous-time transfer function.
Model Properties

Extraction des fonctions de transfert d’un modèle identifié

Pour cet exemple, extrayez la composante mesurée et la composante de bruit d’un modèle polynomial identifié vers deux fonctions de transfert distinctes.

Chargez le modèle polynomial de Box-Jenkins ltiSys dans identifiedModel.mat.

load('identifiedModel.mat','ltiSys');

ltiSys est un modèle identifié en temps discret du type : $$y(t)=\frac{B}{F}u(t)+\frac{C}{D}e(t)$$ où $$\frac{B}{F}$$ représente la composante mesurée et $$\frac{C}{D}$$, la composante de bruit.

Extrayez la composante mesurée et la composante de bruit en tant que fonctions de transfert.

sysMeas = tf(ltiSys,'measured') 

sysMeas =
 
  From input "u1" to output "y1":
            -0.1426 z^-1 + 0.1958 z^-2
  z^(-2) * ----------------------------
           1 - 1.575 z^-1 + 0.6115 z^-2
 
Sample time: 0.04 seconds
Discrete-time transfer function.
Model Properties

sysNoise = tf(ltiSys,'noise')

sysNoise =
 
  From input "v@y1" to output "y1":
           0.04556 + 0.03301 z^-1
  ----------------------------------------
  1 - 1.026 z^-1 + 0.26 z^-2 - 0.1949 z^-3
 
Input groups:        
    Name     Channels
    Noise       1    
                     
Sample time: 0.04 seconds
Discrete-time transfer function.
Model Properties

La composante mesurée peut servir de modèle de système physique tandis que la composante de bruit peut être utilisée en tant que modèle de perturbations pour le design du système de contrôle.

Spécification des noms des entrées et des sorties pour un modèle de fonction de transfert MIMO

Les objets de modèle de fonction de transfert comportent des données de modèle qui vous aident à assurer le suivi de ce que représente le modèle. Par exemple, vous pouvez attribuer des noms aux entrées et sorties de votre modèle.

Considérons le modèle de fonction de transfert MIMO en temps continu suivant :

$$sys(s)=\left[\begin{array}{c}\frac{s+1}{s^2+2s+2}\\ \frac{1}{s}\end{array}\right]$$

Le modèle comporte une entrée $$-$$ et deux sorties $$-$$, le couple et la vitesse angulaire.

Commencez par spécifier les coefficients du numérateur et du dénominateur du modèle.

numerators = {[1 1] ; 1};
denominators = {[1 2 2] ; [1 0]};

Créez le modèle de fonction de transfert en spécifiant le nom de l'entrée et les noms des sorties.

sys = tf(numerators,denominators,'InputName','Current',...
        'OutputName',{'Torque' 'Angular Velocity'})

sys =
 
  From input "Current" to output...
                s + 1
   Torque:  -------------
            s^2 + 2 s + 2
 
                      1
   Angular Velocity:  -
                      s
 
Continuous-time transfer function.
Model Properties

Spécification de l’ordre polynomial dans la fonction de transfert en temps discret

Pour cet exemple, spécifiez l’ordre polynomial dans la fonction de transfert en temps discret au moyen de la propriété Variable.

Considérons les fonctions de transfert en temps discret suivantes avec un pas d’échantillonnage de 0,1 s :

$$sys1(z)=\frac{z^2}{z^2+2z+3}sys2(z^{-1})=\frac{1}{1+2z^{-1}+3z^{-2}}.$$

Créez la fonction de transfert en temps discret en spécifiant les coefficients z.

numerator = [1,0,0];
denominator = [1,2,3];
ts = 0.1;
sys1 = tf(numerator,denominator,ts)

sys1 =
 
       z^2
  -------------
  z^2 + 2 z + 3
 
Sample time: 0.1 seconds
Discrete-time transfer function.
Model Properties

Les coefficients de sys1 sont classés dans l’ordre des puissances décroissantes de z.

tf change de convention sur la base de la valeur de la propriété Variable. Étant donné que sys2 est le modèle de fonction de transfert inverse de sys1, spécifiez Variable en tant que z^-1 et utilisez les mêmes coefficients pour le numérateur et le dénominateur.

sys2 = tf(numerator,denominator,ts,'Variable','z^-1')

sys2 =
 
           1
  -------------------
  1 + 2 z^-1 + 3 z^-2
 
Sample time: 0.1 seconds
Discrete-time transfer function.
Model Properties

Les coefficients de sys2 sont à présent classés dans l’ordre des puissances croissantes de z^-1.

Sur la base des différentes conventions, vous pouvez spécifier l’ordre polynomial dans les modèles de fonction de transfert au moyen de la propriété Variable.

Filtre passe-bas réglable

Dans cet exemple, vous allez créer un filtre passe-bas avec un seul paramètre réglable, a :

$$F=\frac{a}{s+a}$$

Étant donné que les coefficients du numérateur et du dénominateur d’un bloc tunableTF sont indépendants, vous ne pouvez pas utiliser tunableTF pour représenter F. Au lieu de cela, construisez F avec l’objet de paramètre réel réglable realp.

Créez un paramètre réglable réel avec une valeur initiale de 10.

a = realp('a',10)

a = 
       Name: 'a'
      Value: 10
    Minimum: -Inf
    Maximum: Inf
       Free: 1

Real scalar parameter.

Utilisez tf pour créer le filtre passe-bas réglable F.

numerator = a;
denominator = [1,a];
F = tf(numerator,denominator)

Generalized continuous-time state-space model with 1 outputs, 1 inputs, 1 states, and the following blocks:
  a: Scalar parameter, 2 occurrences.
Model Properties

Type "ss(F)" to see the current value and "F.Blocks" to interact with the blocks.

F est un objet genss doté du paramètre réglable a dans sa propriété Blocks. Vous pouvez connecter F avec d’autres modèles réglables ou numériques afin de créer des modèles de systèmes de contrôle plus complexes. Pour un exemple, voir Control System with Tunable Components.

Modèles de fonction de transfert MIMO à gain statique

Dans cet exemple, vous allez créer un modèle de fonction de transfert MIMO à gain statique.

Considérons la matrice de gain statique suivante à deux entrées et deux sorties m :

$$m=\left[\begin{array}{cc}2& 4\\ 3& 5\end{array}\right]$$

Spécifiez la matrice de gain et créez le modèle de fonction de transfert à gain statique.

m = [2,4;...
    3,5];
sys1 = tf(m)

sys1 =
 
  From input 1 to output...
   1:  2
 
   2:  3
 
  From input 2 to output...
   1:  4
 
   2:  5
 
Static gain.
Model Properties

Vous pouvez utiliser le modèle de fonction de transfert à gain statique sys1 obtenu précédemment et l’organiser en cascade avec un autre modèle de fonction de transfert.

Pour cet exemple, créez un autre modèle de fonction de transfert à deux entrées et deux sorties, et utilisez la fonction series pour connecter les deux modèles.

numerators = {1,[1,0];[-1,2],3};
denominator = [1,0.3];
ts = 0.2;
sys2 = tf(numerators,denominator,ts)

sys2 =
 
  From input 1 to output...
          1
   1:  -------
       z + 0.3
 
       -z + 2
   2:  -------
       z + 0.3
 
  From input 2 to output...
          z
   1:  -------
       z + 0.3
 
          3
   2:  -------
       z + 0.3
 
Sample time: 0.2 seconds
Discrete-time transfer function.
Model Properties

sys = series(sys1,sys2)

sys =
 
  From input 1 to output...
       3 z^2 + 2.9 z + 0.6
   1:  -------------------
       z^2 + 0.6 z + 0.09
 
       -2 z^2 + 12.4 z + 3.9
   2:  ---------------------
        z^2 + 0.6 z + 0.09
 
  From input 2 to output...
       5 z^2 + 5.5 z + 1.2
   1:  -------------------
       z^2 + 0.6 z + 0.09
 
       -4 z^2 + 21.8 z + 6.9
   2:  ---------------------
        z^2 + 0.6 z + 0.09
 
Sample time: 0.2 seconds
Discrete-time transfer function.
Model Properties

Calculer l’approximation de fonction de transfert tronquée d’un modèle parcimonieux

Depuis R2025a

Cet exemple indique comment obtenir un modèle de fonction de transfert tronqué d’un modèle de représentation d’état parcimonieux. Cet exemple utilise un modèle parcimonieux obtenu à partir de la linéarisation d’un modèle thermique de distribution de la chaleur dans une tige de vérin circulaire.

Chargez les données du modèle.

load cylindricalRod.mat
sys = sparss(A,B,C,D,E);
w = logspace(-7,-1,20);
size(sys)

Sparse state-space model with 3 outputs, 1 inputs, and 7522 states.

Analysez la réponse en fréquence du modèle.

sigmaplot(sys,w)

Pour obtenir une approximation tronquée, utilisez tf et spécifiez la bande de fréquence d’attention. Pour ce modèle, vous pouvez utiliser une plage de fréquence de 0 rad/s à 0,01 rad/s pour obtenir l’approximation d’ordre faible.

tsys = tf(sys,Focus=[0 1e-2],Display="off");

Comparez la réponse en fréquence.

sigmaplot(sys,tsys,w)

Ce modèle thermique présente une atténuation très abrupte sous 0,001 rad/s. Par défaut, le modèle réduit obtenu au moyen de tf ne fournit pas de bonne correspondance à cette atténuation. Pour atténuer cela, vous pouvez utiliser l’argument RollOff de tf et spécifier une valeur d’atténuation minimale au-delà de la bande de fréquence d’attention. Spécifiez une valeur de pente d’atténuation de -45, qui correspond à une vitesse d’au moins –900 dB/décade.

tsys2 = tf(sys,Focus=[0 1e-2],RollOff=-45,Display="off");
sigmaplot(sys,tsys2,w)

Le modèle réduit fournit maintenant une bien meilleure approximation de la valeur d’atténuation. Cependant, dans cet exemple, réajuster la pente d’atténuation au moyen de tf nécessite de recalculer les zéros et les pôles. Cela pourrait devenir coûteux en calcul dans le cas de modèles à grande échelle. Comme alternative, vous pouvez utiliser la méthode de troncature zéro-pôle de reducespec et ajuster l’atténuation sans coût de calcul supplémentaire, après que le logiciel a calculé les pôles et les zéros. Pour un exemple, voir Zero-Pole Truncation of Thermal Model.

Limitations

• Les modèles de fonction de transfert sont mal adaptés aux calculs numériques. Une fois créés, convertissez-les en modèles de représentation d’état avant de les associer à d'autres modèles ou de les transformer. Vous pouvez alors reconvertir les modèles obtenus en fonctions de transfert à des fins d’inspection

• Un modèle non linéaire identifié ne peut pas être converti directement en modèle de fonction de transfert au moyen de tf. Pour obtenir un modèle de fonction de transfert :

  1. Convertissez le modèle non linéaire identifié en un modèle LTI identifié au moyen de linapp (System Identification Toolbox), de idnlarx/linearize (System Identification Toolbox) ou de idnlhw/linearize (System Identification Toolbox).

  2. Convertissez ensuite le modèle obtenu en un modèle de fonction de transfert au moyen de tf.

Algorithmes

Pour convertir des modèles parcimonieux, tf utilise l’algorithme de Krylov-Schur [1] pour les itérations de puissance inverse pour calculer les pôles et les zéros dans la bande de fréquence.

Références

[1] Stewart, G. W. “A Krylov--Schur Algorithm for Large Eigenproblems.” SIAM Journal on Matrix Analysis and Applications 23, no. 3 (January 2002): 601–14. https://doi.org/10.1137/S0895479800371529.

Historique des versions

Introduit avant R2006a

R2025a: Calculer l’approximation de fonction de transfert tronquée de modèles parcimonieux

Vous pouvez maintenant utiliser tf pour convertir des modèles de représentation d’état parcimonieux et obtenir une approximation de fonction de transfert tronquée. tf calcule un sous-ensemble des zéros et des pôles des modèles parcimonieux, généralement dans une bande basse fréquence spécifique [0 f_max]. Cela permet d’obtenir de meilleures approximations basse fréquence que la réduction d’ordre de modèle par troncature modale au prix de calculs supplémentaires. tf fournit également un contrôle direct sur la pente d’atténuation après la fréquence f_max. Utilisez la nouvelle syntaxe tsys = tf(sparseSys,Name=Value) pour obtenir une approximation basée sur les options spécifiées, telles que la plage de fréquences d’attention. Pour un exemple, voir Calculer l’approximation de fonction de transfert tronquée d’un modèle parcimonieux.

Voir aussi

filt | frd | get | set | ss | tfdata | zpk | genss | realp | genmat | tunableTF

Rubriques

• What Are Model Objects?
• Fonctions de transfert
• Discrete-Time Numeric Models
• Fonctions de transfert MIMO
• Using the Right Model Representation
• Utilisation de la commande FEEDBACK pour fermer les boucles de rétroaction

Sites web externes

• Analyse de la fonction de transfert des systèmes dynamiques (ressources d’enseignement MathWorks)