La traduction de cette page n'est pas à jour. Cliquez ici pour voir la dernière version en anglais.

iddata

Données d’entrée-sortie et leurs propriétés pour l’identification de systèmes dans le domaine fréquentiel ou temporel

Description

Utilisez l’objet iddata pour encapsuler les données de mesure d’entrée et de sortie pour le système que vous souhaitez identifier. Les fonctions d’identification de systèmes utilisent ces mesures pour estimer un modèle. Les fonctions de validation de modèle utilisent les mesures d’entrée pour fournir l’entrée pour les simulations, et les mesures de sortie pour comparer si la réponse du modèle estimée correspond bien aux données originales.

Les objets iddata peuvent contenir un seul ensemble de mesures ou plusieurs ensembles. Chaque jeu de données correspond à une expérimentation. Les objets ont les caractéristiques suivantes, qui sont encodées dans les propriétés d’objet :

• Les données peuvent être dans le domaine fréquentiel ou dans le domaine temporel. Vous pouvez convertir des objets d’un domaine à l’autre.

• Dans le domaine temporel, les données peuvent être échantillonnées de manière uniforme ou non uniforme. Pour utiliser l’objet iddata pour une estimation, cependant, les données doivent être échantillonnées de manière uniforme, et les données d’entrée et de sortie pour chaque expérimentation doivent être enregistrées aux mêmes instants.

• Vous pouvez spécifier des propriétés de données, telles que le pas d’échantillonnage, l’heure de début, les points temporels, les points d’échantillonnage de fréquence et le comportement entre les échantillons.

• Vous pouvez fournir des étiquettes et des commentaires pour différencier et annoter les composants de données, les expérimentations et l’objet comme une entité unique.

Pour accéder aux propriétés des objets, utilisez la notation par points. Par exemple, supposons que vous créez un objet iddata avec la commande sys = iddata(ym,um,Tsamp), où ym correspond aux données de sortie mesurées, um correspond aux données d’entrée mesurées et Tsamp est le pas d’échantillonnage. iddata stocke respectivement ces variables dans les propriétés InputData, OutputData et Ts. Vous pouvez afficher ou modifier les données au moyen de sys.InputData, sys.OutputData et sys.Ts. Pour un exemple d’utilisation de la notation par points pour afficher et modifier les propriétés, consultez Afficher et modifier des propriétés.

Création

Syntaxe

data = iddata(y,u,Ts)

data = iddata(y,[],Ts)

data = iddata(tt)

data = iddata(y,u,Ts,'Frequency',W)

data = iddata(___,Name,Value)

Description

Utiliser des données dans le domaine temporel

data = iddata(y,u,Ts) crée un objet iddata qui contient un signal de sortie dans le domaine temporel y et un signal d’entrée dans le domaine temporel u. Ts spécifie le pas d’échantillonnage des données expérimentales.

Vous pouvez utiliser iddata pour créer un objet iddata multi-expérimentations en spécifiant y et u en tant que cell arrays. Sinon, vous pouvez créer des objets iddata à expérimentation unique et utiliser merge (iddata) pour combiner les objets en un objet iddata multi-expérimentations. Pour plus d’informations sur les objets iddata multi-expérimentations, consultez Create Multiexperiment Data at the Command Line.

data = iddata(y,[],Ts) crée un objet iddata pour les données de séries temporelles. L’objet contient un signal de sortie dans le domaine temporel y et un signal d’entrée vide []. Ts spécifie le pas d’échantillonnage des données expérimentales.

data = iddata(tt) crée un objet iddata à partir de la timetable tt.

Le logiciel extrait les noms de variable et le pas d’échantillonnage à partir de tt.

Par défaut, le logiciel interprète la dernière variable de tt comme étant le canal de sortie unique, et toutes les autres variables sont des canaux d’entrée. Pour changer cette interprétation, définissez les propriétés 'InputName' et 'OutputName' au moyen d’arguments nom-valeur.

Utiliser des données dans le domaine fréquentiel

data = iddata(y,u,Ts,'Frequency',W) crée un objet iddata qui contient des données dans le domaine fréquentiel. W définit la propriété iddata de Frequency sur un vecteur de fréquences. Généralement, y et u sont la transformée de Fourier discrète des signaux dans le domaine temporel.

Configurer des propriétés supplémentaires

data = iddata(___,Name,Value) définit des propriétés supplémentaires au moyen d’arguments nom-valeur. Spécifiez Name,Value après n’importe quelle combinaison d’arguments d’entrée des syntaxes précédentes.

Arguments en entrée

y — Signal de sortie à partir d’un système

vecteur colonne | matrice | cell array | []

Signal de sortie à partir d’un système, spécifié sous l’une des formes suivantes :

• Un vecteur de N par 1 pour un système à sortie unique, où N désigne le nombre d’observations

• Une matrice de N par Ny pour un système à sorties multiples, où Ny désigne le nombre de canaux de sortie

• Un cell array d’éléments N_e pour un jeu de données multi-expérimentations, où N_e désigne le nombre d’expérimentations et chaque cellule contient les signaux de sortie pour une expérimentation

• [] pour un système qui n’a pas de signal de sortie, comme quand seul le signal d’entrée est enregistré

y doit être dans le même domaine que les données d’entrée u. Si les données sont dans le domaine temporel, y et u doivent être enregistrés aux mêmes instants.

Si vous utilisez l’objet iddata pour une estimation, y et u doivent être échantillonnés de manière uniforme. Si la non-uniformité est petite, vous pourrez peut-être convertir vos données en un jeu échantillonné de manière uniforme avec assez d’intégrité pour que les données converties supportent l’estimation. Pour plus d’informations sur les techniques que vous pouvez essayer, consultez interp1 et Missing Data in MATLAB.

y définit la propriété OutputData de l’objet iddata.

u — Signal d’entrée vers un système

vecteur colonne | matrice | cell array | []

Signal d’entrée vers un système, spécifié sous l’une des formes suivantes :

• Un vecteur de N par 1 pour un système à entrée unique, où N désigne le nombre d’observations

• Une matrice de N par N_u pour un système à entrées multiples, où N_u désigne le nombre de canaux d’entrée

• Un cell array d’éléments N_e pour un jeu de données multi-expérimentations, où N_e désigne le nombre d’expérimentations et chaque cellule contient les signaux d’entrée pour une expérimentation

• [] pour un système qui n’a pas de signal d’entrée, tel que des séries temporelles

u doit être dans le même domaine que les données de sortie y. Si les données sont dans le domaine temporel, y et u doivent être enregistrés aux mêmes instants.

Si vous utilisez l’objet iddata pour une estimation, y et u doivent être échantillonnés de manière uniforme. Si la non-uniformité est petite, vous pourrez peut-être convertir vos données en un jeu échantillonné de manière uniforme avec assez d’intégrité pour que les données converties supportent l’estimation. Pour plus d’informations sur les techniques que vous pouvez essayer, consultez interp1 et Missing Data in MATLAB.

u définit la propriété InputData de l’objet iddata.

tt — Timetable de signaux d’entrée et de sortie

timetable | cell array de timetables

Timetable de signaux d’entrée et de sortie, spécifiée en tant que timetable qui utilise un vecteur temps régulièrement espacé.

Pour les données multi-expérimentations, spécifiez tt en tant que cell array de Ne par 1, où Ne désigne le nombre d’expérimentations.

Pour identifier quelles variables sont des signaux d’entrée et lesquelles sont des signaux de sortie, ou extraire un sous-ensemble de variables pour la conversion, définissez les propriétés 'InputName' et 'OutputName' au moyen d’arguments nom-valeur.

Ts — Pas d’échantillonnage

1 (par défaut) | scalaire | 0 | []

Pas d’échantillonnage des unités spécifiées par la propriété TimeUnit, spécifié sous l’une des formes suivantes :

• Un scalaire quand y et u sont échantillonnés de manière uniforme.

• 0 pour les données en temps continu dans le domaine fréquentiel.

• [] quand y et u ne sont pas échantillonnés de manière uniforme et que vous spécifiez les valeurs temporelles dans la propriété SamplingInstants. Pour l’échantillonnage non uniforme, y et u doivent être dans le domaine temporel.

Ts définit la propriété Ts de l’objet iddata.

Propriétés

Domain — Domaine temporel ou fréquentiel des données

'Time' (par défaut) | 'Frequency'

Domaine temporel ou fréquentiel des données, spécifié en tant que :

• 'Time' — Les données sont dans le domaine temporel

• 'Frequency' — Les données sont dans le domaine fréquentiel

ExperimentName — Nom de chaque jeu de données

{'Exp1';'Exp2';…} (par défaut) | cell array

Nom de chaque jeu de données contenu dans l’objet iddata, spécifié en tant que cell array de vecteurs de caractères de N_e par 1, où N_e désigne le nombre d’expérimentations. Chaque cellule contient le nom de l’expérimentation correspondante. Par exemple, {'MyMeas1';'MyMeas2';'MyMeas3'} contient les noms d’expérimentation pour un objet iddata de trois expérimentations.

Frequency — Valeurs de fréquence

vecteur colonne | cell array

Les valeurs de fréquences pour les données dans le domaine fréquentiel, spécifiées en tant que :

• Vecteur de N par 1, où N désigne le nombre de valeurs de fréquence dans une seule expérimentation

• Cell array de 1 par N_e, où N_e désigne le nombre d’expérimentations et chaque cellule contient le vecteur de fréquence pour l’expérimentation correspondante. Les vecteurs de fréquence doivent tous être dans les mêmes unités.

FrequencyUnit — Unités de fréquence pour les données dans le domaine fréquentiel

'rad/TimeUnit' (par défaut) | 'cycles/TimeUnit' | 'rad/s' | 'Hz' | 'kHz' | 'MHz' | 'GHz' | 'rpm'

Unités de fréquence pour les données dans le domaine fréquentiel, spécifiées en tant que scalaire. Cette propriété s’applique à tous les éléments du jeu de données.

Changer cette propriété ne met pas les données à l’échelle et ne les convertit pas. Modifier la propriété ne change que l’interprétation des données existantes.

InputData — Valeurs de signal d’entrée

vecteur | matrice | cell array de matrices

Valeurs de signal d’entrée vers le système, spécifiées sous l’une des formes suivantes :

• Pour une expérimentation unique, une matrice de N par N_u, où N désigne le nombre d’échantillons de données et N_u, le nombre de canaux d’entrée

• Pour des expérimentations multiples, un cell array contenant N_e matrices à expérimentation unique, où N_e désigne le nombre d’expérimentations

Lorsque vous accédez à InputData depuis la ligne de commande, vous pouvez utiliser la forme abrégée u. Par exemple, u1 = data.InputData est équivalent à u1 = data.u.

InputName — Noms des canaux en entrée

{'u1';'u2';…} (par défaut) | cell array de vecteurs de caractères

Noms des canaux d’entrée, spécifiés en tant que cell array de N_u par 1, où N_u désigne le nombre de canaux d’entrées.

InputUnit — Unités des canaux en entrée

cell array

Unités des canaux d’entrée, spécifiés en tant que cell array de N_u par 1, où N_u désigne le nombre de canaux d’entrées. Chaque cellule contient les unités du canal d’entrée correspondant.

Exemple : {'rad';'rad/s'}

InterSample — Comportement entre les échantillons

'zoh' (par défaut) | 'foh' | 'bl' | cell array de vecteurs de caractères

Comportement entre les échantillons pour les transformations entre temps discret et temps continu, spécifié en tant que vecteur de caractères ou cell array de vecteurs de caractères. Pour chaque expérimentation, les valeurs possibles pour chaque canal d’entrée sont les suivantes :

• zoh — Le bloqueur d’ordre zéro préserve un signal d’entrée constant par morceaux entre les échantillons.

• foh — Le bloqueur de premier ordre préserve un signal d’entrée linéaire par morceaux entre les échantillons.

• bl — Le comportement à bande limitée spécifie que le signal d’entrée en temps continu n’a aucune puissance au-dessus de la fréquence de Nyquist.

Pour une expérimentation unique avec un canal d’entrée unique, InterSample contient l’une des valeurs de la liste précédente. Pour des expérimentations multiples, InterSample est un cell array de N_u par N_e, où N_u désigne le nombre de canaux d’entrées et N_e, le nombre d’expérimentations. Chaque cellule contient la valeur de comportement associée à l’expérimentation et au canal d’entrée que la cellule représente.

Name — Nom du jeu de données

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

Nom du jeu de données, spécifié en tant que vecteur de caractères.

Exemple : 'dryer data'

Notes — Commentaires à propos du jeu de données

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

Commentaires à propos du jeu de données, spécifiés en tant que vecteur de caractères, ou, pour les jeux de données multi-expérimentations, en tant que cell array de vecteurs de caractères de N_e par 1, où N_e désigne le nombre d’expérimentations.

Exemple : {'data from experiment 1';data from experiment 2'}

OutputData — Valeurs de signal de sortie

vecteur | matrice

Valeurs de signal de sortie à partir du système, spécifiées sous l’une des formes suivantes :

• Pour une expérimentation unique, une matrice de N par N_y, où N désigne le nombre d’échantillons de données et N_y, le nombre de canaux de sortie

• Pour des expérimentations multiples, un cell array contenant N_e matrices à expérimentation unique, où N_e désigne le nombre d’expérimentations

Lorsque vous accédez à OutputData depuis la ligne de commande, vous pouvez utiliser la forme abrégée y. Par exemple, y1 = data.InputData est équivalent à y1 = data.y.

OutputName — Noms des canaux en sortie

{'y1';'y2';…} (par défaut) | cell array de vecteurs de caractères

Noms des canaux de sortie, spécifiés en tant que cell array de N_y par 1, où N_y désigne le nombre de canaux de sortie.

OutputUnit — Unités des canaux en sortie

cell array

Unités des canaux de sortie, spécifiés en tant que cell array de N_y par 1, où N_u désigne le nombre de canaux de sortie. Chaque cellule contient les unités du canal d’entrée correspondant.

Exemple : {'rad';'rad/s'}

Period — Période du signal d’entrée

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

Période du signal d’entrée, spécifié en tant que double pour chaque expérimentation. La valeur est soit Inf pour les signaux d’entrée non périodiques, soit la période des unités spécifiée par la propriété TimeUnit pour les signaux d’entrée périodiques.

• Pour une expérimentation unique avec un canal d’entrée unique, Period contient une valeur unique.

• Pour un système à entrées multiples, Period est un vecteur de N_u par 1, où N_u désigne le nombre de canaux d’entrée et la ke entrée contient la période de la ke entrée.

• Pour les données multi-expérimentations, Period est un cell array de 1 par N_e, où N_e désigne le nombre d’expérimentations et chaque cellule contient un scalaire ou un vecteur de périodes pour l’expérimentation correspondante.

SamplingInstants — Valeurs de temps pour les données dans le domaine temporel

vecteur | cell array

Valeurs de temps pour les données dans le domaine temporel en unités spécifiées par TimeUnit, spécifiées en tant que :

• Vecteur de N par 1, où N désigne le nombre de points de données

• Cell array de 1 par N_e, où N_e désigne le nombre d’expérimentations et chaque cellule contient les instants d’échantillonnage pour l’expérimentation correspondante.

Les valeurs de SamplingInstants peuvent être uniformes ou non uniformes. Si vous spécifiez la propriété Ts, le logiciel calcule les valeurs de temps uniformes de SamplingInstants depuis Ts et Tstart. Si vous avez des points d’échantillonnage non uniformes, spécifiez les valeurs de temps de SamplingInstants. Le logiciel définit ensuite la propriété Ts sur vide. Les fonctions d’estimation ne supportent pas l’échantillonnage non uniforme.

TimeUnit — Unités pour la variable de temps et le pas d’échantillonnage Ts

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

Unités pour la variable de temps et le pas d’échantillonnage, spécifiées en tant que scalaire. Cette propriété s’applique à toutes les expérimentations du jeu de données.

Changer cette propriété ne rééchantillonne pas les données et ne les convertit pas. Modifier la propriété ne change que l’interprétation des données existantes.

Ts — Pas d’échantillonnage

1 (par défaut) | scalaire positif | 0 | [] | cell array

Pas d’échantillonnage en unités spécifiées par TimeUnit, spécifié en tant que scalaire ou cell array. Pour chaque expérimentation, la valeur est l’une des suivantes :

• Un scalaire, quand y et u sont échantillonnés de manière uniforme

• 0 pour les données en temps continu dans le domaine fréquentiel

• [] quand y et u ne sont pas échantillonnés de manière uniforme et dans le domaine temporel, car la propriété SamplingInstants définit les valeurs de temps pour ces données.

Pour une expérimentation unique, Ts est un scalaire. Pour les données multi-expérimentations, Ts est un cell array de 1 par N_e, où N_e désigne le nombre d’expérimentations et chaque cellule contient le pas d’échantillonnage pour l’expérimentation correspondante.

Pour les données dans le domaine fréquentiel, le logiciel utilise Ts pour interpréter les données.

• Si Ts est de 0, le logiciel interprète les entrées et les sorties comme des transformées de Fourier en temps continu (CTFT) des signaux correspondants.

• Si Ts est un scalaire, le logiciel interprète les entrées et les sorties comme des transformées de Fourier en temps discret (DTFT) des signaux correspondants avec Ts comme pas d’échantillonnage.

Tstart — Heure de début pour les données dans le domaine temporel

scalaire | cell array

Heure de début pour les données dans le domaine temporel, spécifiée en tant que :

• Scalaire pour une expérimentation unique

• Cell array de 1 par N_e pour des expérimentations multiples, où N_e désigne le nombre d’expérimentations et chaque cellule contient l’heure de début pour l’expérimentation correspondante

La valeur par défaut de Tstart est Ts pour les données échantillonnées de manière uniforme et [] pour les données échantillonnées de manière non uniforme.

UserData — Autres commentaires

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

Autres commentaires sur le jeu de données, spécifiés en tant que n’importe quel type de données MATLAB.

Fonctions d'objet

En règle générale, toute fonction applicable aux données d’identification de systèmes est applicable à un objet iddata. Ces fonctions sont de trois types généraux.

1. Les fonctions, qui opèrent sur des objets iddata et en renvoient, vous permettent de manipuler et de traiter des objets iddata.

   • Utilisez fft et ifft pour transformer des objets iddata existants vers et à partir de domaines temporels et fréquentiels. Par exemple :

     datafd = fft(Data);
     datatd = ifft(Dataf);

   • Utilisez merge (iddata) pour fusionner des objets iddata en un seul objet iddata contenant plusieurs expérimentations. Pour extraire une expérimentation d’un objet iddata multi-expérimentations, utilisez getexp. Par exemple :

     data123 = merge(data1,data2,data3);
     data2 = getexp(data123,2);
     

     Pour consulter un exemple plus détaillé, voir Extract and Model Specific Data Segments.

   • Utilisez des fonctions de prétraitement telles que detrend ou idfilt pour filtrer les données des objets iddata et pour supprimer les mauvaises données. Par exemple :

     data_d = detrend(data);
     data_f = idfilt(data,filter);

2. Les fonctions qui effectuent du traitement analytique sur des objets iddata et créent des tracés ou renvoient des paramètres ou des valeurs spécifiques vous permettent d’analyser des données et de déterminer les entrées à utiliser pour l’estimation.

   • Utilisez des fonctions d’analyse telles que delayest et spa pour calculer des variables telles que le retard et le spectre de puissance.

3. Les fonctions qui utilisent les données dans les objets iddata pour estimer, simuler et valider les modèles, vous permettent de créer des modèles dynamiques et d’évaluer à quel point la réponse du modèle correspond aux données de validation.

   • Utilisez des fonctions d’estimation telles que ssest et tfest pour estimer des modèles avec des structures spécifiques.

   • Utilisez des fonctions de validation telles que compare et sim pour simuler des modèles estimés et comparer les sorties simulées avec les données de validation et avec d’autres modèles.

   Les listes suivantes contiennent un sous-ensemble représentatif des fonctions que vous pouvez utiliser avec les objets iddata.

Visualisation de données

idplot

Plot input and output channels of estimation data

Sélection des données

getexp	Get specific experiments from multiple-experiment data set
merge (iddata)	Merge data sets into iddata object

Prétraitement des données

detrend	Subtract offset or trend from time-domain signals contained in iddata objects
retrend	Add offsets or trends to time-domain data signals stored in iddata objects
idfilt	Filter data using user-defined passbands, general filters, or Butterworth filters
diff	Signaux différentiels dans les objets iddata
misdata	Reconstruct missing input and output data
idresamp	Resample time-domain data by decimation or interpolation

Transformation des données

fft	Fast Fourier transform (FFT) of iddata object
ifft	Transform iddata objects from frequency to time domain

Analyse de données

realdata	Determine whether iddata is based on real-valued signals
delayest	Estimate time delay (dead time) from data
isreal	Determine whether model parameters or data values are real
impulseest	Nonparametric impulse response estimation
pexcit	Level of excitation of input signals
checkFeedback	Identify possible feedback data
etfe	Estimate empirical transfer functions and periodograms
spafdr	Estimate frequency response and spectrum using spectral analysis with frequency-dependent resolution
spa	Estimate frequency response with fixed frequency resolution using spectral analysis
dataPlotOptions	Option set for idplot when plotting input/output estimation data contained in a timetable, numeric matrices, or an iddata object

Estimation, simulation et validation de modèles

ssest	Estimate state-space model using time-domain or frequency-domain data
tfest	Estimate transfer function model
ar	Estimate parameters when identifying AR model or ARI model for scalar time series
sim	Simulate response of identified model
findstates	Estimate initial states of model
compare	Compare identified model output with measured output
predict	Predict identified model K-step-ahead output
goodnessOfFit	Goodness of fit between test and reference data for analysis and validation of identified models
procest	Estimate process model using time-domain or frequency-domain data
resid	Compute and test residuals

Exemples

Données dans le domaine temporel

Créez un objet iddata au moyen de données dans le domaine temporel à entrée unique et sortie unique (SISO). L’entrée et la sortie contiennent chacune 1 000 échantillons avec un pas d’échantillonnage de 0,08 seconde.

load dryer2_data output input;
data = iddata(output,input,0.08)

data = 
Time domain data set with 1000 samples.
Sample time: 0.08 seconds              
                                       
Outputs      Unit (if specified)       
   y1                                  
                                       
Inputs       Unit (if specified)       
   u1                                  
                                       
Data Properties

Le logiciel attribue le nom de canal par défaut 'y1' au premier et unique canal de sortie. Quand le signal de sortie contient plusieurs canaux, le logiciel attribue les noms par défaut 'y1','y2',...,'yn'. De même, le logiciel attribue le nom de canal par défaut 'u1' au premier et unique canal d’entrée. Pour plus d’informations sur l’attribution de noms aux canaux, consultez Naming, Adding, and Removing Data Channels.

Tracer les données.

idplot(data)

Les tracés adjacents affichent les données de sortie et les données d’entrée.

Données de séries temporelles

Créez un objet iddata à partir des données de séries temporelles. Les données de séries temporelles n’ont pas de canal d’entrée.

Chargez le canal de sortie d’un jeu de données et créez un objet iddata ayant un pas d’échantillonnage de 0,08 seconde.

load dryer2_data output
data = iddata(output,[],0.08)

data = 
Time domain data set with 1000 samples.
Sample time: 0.08 seconds              
                                       
Outputs      Unit (if specified)       
   y1                                  
                                       
Data Properties

Tracer les données.

idplot(data)

Vous pouvez utiliser data pour l’estimation de modèles de séries temporelles.

Convertir la timetable en objet iddata

Chargez les données de timetable tt7 et affichez les quatre premières lignes.

load sdata7 tt7
head(tt7,4)

      t      u1      u2           y    
    _____    __    _______    _________

    1 sec     1     0.2749    -0.091981
    2 sec    -1    0.25148      0.22567
    3 sec    -1     1.2381     -0.28617
    4 sec    -1    -1.2216       1.4581

tt7 a deux entrées, avec pour noms de variable u1 et u2, et une sortie avec pour nom de variable y. Convertissez tt7 en objet iddata.

z7conv = iddata(tt7)

z7conv =

Time domain data set with 400 samples.
Sample time: 1 seconds                 
                                       
Outputs      Unit (if specified)       
   y                                   
                                       
Inputs       Unit (if specified)       
   u1                                  
   u2                                  
                                       

z7conv.OutputName

ans = 1×1 cell array
    {'y'}

z7conv.InputName

ans = 2×1 cell
    {'u1'}
    {'u2'}

z7conv conserve le pas d’échantillonnage et stocke les noms de variable dans les propriétés OutputName et InputName.

Données dans le domaine fréquentiel

Créez et examinez un objet iddata à partir de données d’entrée-sortie dans le domaine fréquentiel à valeurs complexes. Convertissez l’objet dans le domaine temporel.

Les données d’entrée et de sorties sont parfois exprimées sous la forme de transformées de Fourier de signaux d’entrée-sortie dans le domaine temporel. Vous pouvez encapsuler ces données dans un objet iddata dans le domaine fréquentiel.

Chargez les données, composées des données dans le domaine fréquentiel d’entrée-sortie à valeurs complexes U et Y, du vecteur de fréquence W et du pas d’échantillonnage Ts.

load demofr1 U Y W Ts

Créez l’objet iddata dans le domaine fréquentiel data_fr.

data_fr = iddata(Y,U,Ts,'Frequency',W)

data_fr = 
Frequency domain data set with responses at 501 frequencies.
Frequency range: 0 to 31.416 rad/seconds
Sample time: 0.1 seconds                                                                             
                                                                                                     
Outputs      Unit (if specified)                                                                     
   y1                                                                                                
                                                                                                     
Inputs       Unit (if specified)                                                                     
   u1                                                                                                
                                                                                                     
Data Properties

Examinez les propriétés. Les objets iddata du domaine fréquentiel comprennent des propriétés spécifiques de la fréquence, telles que Frequency pour le vecteur de fréquence et FrequencyUnit pour les unités de fréquence. En revanche, les objets iddata du domaine temporel comprennent des propriétés spécifiques du temps telles que Tstart et SamplingInstants pour les données dans le domaine temporel.

get(data_fr)

ans = struct with fields:
            Domain: 'Frequency'
              Name: ''
        OutputData: [501×1 double]
        OutputName: {'y1'}
        OutputUnit: {''}
         InputData: [501×1 double]
         InputName: {'u1'}
         InputUnit: {''}
            Period: Inf
       InterSample: 'zoh'
                Ts: 0.1000
     FrequencyUnit: 'rad/TimeUnit'
         Frequency: [501×1 double]
          TimeUnit: 'seconds'
    ExperimentName: 'Exp1'
             Notes: [0×1 string]
          UserData: []

Attribuez le contenu de la propriété de fréquence à la variable F.

F = data_fr.Frequency;

Obtenez les unités de fréquence des données. La propriété TimeUnit définit les unités du pas d’échantillonnage.

frequ = data_fr.FrequencyUnit

frequ = 
'rad/TimeUnit'

timeu = data_fr.TimeUnit

timeu = 
'seconds'

Reconvertissez data_fr dans le domaine temporel au moyen de la fonction de la transformée de Fourier inverse ifft.

data_t = ifft(data_fr)

data_t = 
Time domain data set with 1000 samples.
Sample time: 0.1 seconds               
                                       
Outputs      Unit (if specified)       
   y1                                  
                                       
Inputs       Unit (if specified)       
   u1                                  
                                       
Data Properties

get(data_t)

ans = struct with fields:
              Domain: 'Time'
                Name: ''
          OutputData: [1000×1 double]
          OutputName: {'y1'}
          OutputUnit: {''}
           InputData: [1000×1 double]
           InputName: {'u1'}
           InputUnit: {''}
              Period: Inf
         InterSample: 'zoh'
                  Ts: 0.1000
              Tstart: 0.1000
    SamplingInstants: [1000×1 double]
            TimeUnit: 'seconds'
      ExperimentName: 'Exp1'
               Notes: [0×1 string]
            UserData: []

Afficher et modifier des propriétés

Affichez les propriétés d’un objet iddata. Modifiez les propriétés aussi bien pendant qu’après la création d’objet.

Chargez des données d’entrée et de sortie.

load dryer2_data input output

Créez un objet iddata.

data = iddata(output,input,0.08)

data = 
Time domain data set with 1000 samples.
Sample time: 0.08 seconds              
                                       
Outputs      Unit (if specified)       
   y1                                  
                                       
Inputs       Unit (if specified)       
   u1                                  
                                       
Data Properties

Affichez toutes les propriétés de l’objet iddata.

get(data)

ans = struct with fields:
              Domain: 'Time'
                Name: ''
          OutputData: [1000×1 double]
          OutputName: {'y1'}
          OutputUnit: {''}
           InputData: [1000×1 double]
           InputName: {'u1'}
           InputUnit: {''}
              Period: Inf
         InterSample: 'zoh'
                  Ts: 0.0800
              Tstart: 0.0800
    SamplingInstants: [1000×1 double]
            TimeUnit: 'seconds'
      ExperimentName: 'Exp1'
               Notes: [0×1 string]
            UserData: []

Vous pouvez spécifier des propriétés quand vous créez un objet iddata au moyen de paires d’arguments nom-valeur. Créez un objet iddata à partir des mêmes données d’entrée, mais changez le nom de l’expérimentation de son paramètre par défaut à Dryer2.

data = iddata(output,input,0.08,'ExperimentName','Dryer2')

data = 
Time domain data set with 1000 samples.
Sample time: 0.08 seconds              
                                       
Outputs      Unit (if specified)       
   y1                                  
                                       
Inputs       Unit (if specified)       
   u1                                  
                                       
Data Properties

Pour changer les valeurs de propriété d’un objet iddata existant, utilisez la notation par points. Changez la propriété de pas d’échantillonnage Ts pour 0,05 seconde.

data.Ts = 0.05

data = 
Time domain data set with 1000 samples.
Sample time: 0.05 seconds              
                                       
Outputs      Unit (if specified)       
   y1                                  
                                       
Inputs       Unit (if specified)       
   u1                                  
                                       
Data Properties

Les noms de propriétés ne sont pas sensibles à la casse. De plus, si les premières lettres identifient la propriété de manière unique, vous n’avez pas besoin d’écrire le nom de propriété en entier.

data.exp = "Dryer2 January 2015"

data = 
Time domain data set with 1000 samples.      
Sample time: 0.05 seconds                    
                                             
Outputs                   Unit (if specified)
   y1                                        
                                             
Inputs                    Unit (if specified)
   u1                                        
                                             
Data Properties

Vous pouvez utiliser data.y comme abréviation pour que data.OutputData accède aux valeurs de sortie ou utiliser data.u comme abréviation pour que data.InputData accède aux valeurs d’entrée.

y_data = data.y;
u_data = data.u;

Historique des versions

Introduit avant R2006a

R2023a: iddata ajoute la fonctionnalité de conversion de timetables en objets iddata

Dans le cadre de l’expansion des formats de données d’estimation du System Identification Toolbox™ aux timetables et aux paires de matrices séparées par des virgules, iddata peut maintenant convertir des timetables en objets iddata.

Pour convertir des objets iddata en timetables, utilisez iddata2timetable.

Voir aussi

idfrd | idinput

Rubriques

• Representing Data in MATLAB Workspace
• Create Multiexperiment Data at the Command Line
• Representing Time- and Frequency-Domain Data Using iddata Objects
• Managing iddata Objects