pwelch

Estimation de la densité spectrale de puissance selon Welch

Syntaxe

pxx = pwelch(x)

pxx = pwelch(x,window)

pxx = pwelch(x,window,noverlap)

pxx = pwelch(x,window,noverlap,nfft)

[pxx,w] = pwelch(___)

[pxx,f] = pwelch(___,fs)

[pxx,w] = pwelch(x,window,noverlap,w)

[pxx,f] = pwelch(x,window,noverlap,f,fs)

[___] = pwelch(x,window,___,freqrange)

[___] = pwelch(x,window,___,trace)

[___,pxxc] = pwelch(___,'ConfidenceLevel',probability)

[___] = pwelch(___,spectrumtype)

pwelch(___)

Description

pxx = pwelch(x) renvoie l’estimation de la PSD (densité spectrale de puissance) pxx du signal d’entrée x, telle que déterminée avec la méthode de Welch par moyennage de segments superposés. Lorsque x est un vecteur, il est traité comme un canal unique. Lorsque x est une matrice, la PSD est calculée de manière indépendante pour chaque colonne et stockée dans la colonne correspondante de pxx. Si x contient des valeurs réelles, pxx est une estimation de la PSD unilatérale. Si x contient des valeurs complexes, pxx est une estimation de la PSD bilatérale. Par défaut, x est divisé en segments, aussi longs que possible pour obtenir le plus grand nombre de segments possible sans dépasser 8, avec un chevauchement de 50 %. Chaque segment est fenêtré avec une fenêtre de Hamming. Les périodogrammes modifiés sont moyennés pour obtenir l’estimation de la PSD. S’il est impossible de diviser exactement la longueur de x en un nombre entier de segments avec un chevauchement de 50 %, x est tronqué en conséquence.

pxx = pwelch(x,window) utilise le vecteur ou nombre entier en entrée window, pour diviser le signal en segments. Si window est un vecteur, pwelch divise le signal en segments de longueur égale à celle de window. Les périodogrammes modifiés sont calculés en multipliant les segments de signal par le vecteur window. Si window est un nombre entier, le signal est divisé en segments de longueur window. Les périodogrammes modifiés sont calculés avec une fenêtre de Hamming de longueur window.

pxx = pwelch(x,window,noverlap) utilise un chevauchement de noverlap échantillons entre les segments. noverlap doit être un entier positif inférieur à window si window est un entier. noverlap doit être un entier positif inférieur à la longueur de window si window est un vecteur. Si vous ne spécifiez pas noverlap ou si vous définissez noverlap comme vide, le nombre par défaut d’échantillons qui se chevauchent est égal à 50 % de la longueur de window.

pxx = pwelch(x,window,noverlap,nfft) spécifie le nombre de points de la DFT (transformée de Fourier discrète) à utiliser dans l’estimation de la PSD. La valeur par défaut de nfft est soit 256, soit la prochaine puissance de 2 supérieure à la longueur des segments, selon la valeur la plus élevée des deux.

[pxx,w] = pwelch(___) renvoie le vecteur de fréquences normalisées w. Si pxx est une estimation de la PSD unilatérale, w s’étend sur l’intervalle [0,π] si nfft est pair et sur [0,π) si nfft est impair. Si pxx est une estimation de la PSD bilatérale, w s’étend sur l’intervalle [0,2π).

[pxx,f] = pwelch(___,fs) renvoie un vecteur de fréquences f en nombre de cycles par unité de temps. La fréquence d’échantillonnage fs est le nombre d’échantillons par unité de temps. Si l’unité de temps est la seconde, f est exprimé en cycles/seconde (Hz). Pour les signaux à valeurs réelles, f s’étend sur l’intervalle [0,fs/2] lorsque nfft est pair et sur [0,fs/2) lorsque nfft est impair. Pour les signaux à valeurs complexes, f s’étend sur l’intervalle [0,fs). fs doit être la cinquième entrée de pwelch. Pour indiquer une fréquence d’échantillonnage en entrée et utiliser tout de même les valeurs par défaut des arguments facultatifs précédents, définissez ces arguments comme vides avec [].

[pxx,w] = pwelch(x,window,noverlap,w) renvoie les estimations de Welch de la PSD bilatérale aux fréquences normalisées spécifiées dans le vecteur w. Le vecteur w doit contenir au moins deux éléments. Sinon, la fonction l’interprète comme étant nfft.

[pxx,f] = pwelch(x,window,noverlap,f,fs) renvoie les estimations de Welch de la PSD bilatérale aux fréquences spécifiées dans le vecteur f. Le vecteur f doit contenir au moins deux éléments. Sinon, la fonction l’interprète comme étant nfft. Les fréquences de f sont exprimées en nombre de cycles par unité de temps. La fréquence d’échantillonnage fs est le nombre d’échantillons par unité de temps. Si l’unité de temps est la seconde, f est exprimé en cycles/seconde (Hz).

[___] = pwelch(x,window,___,freqrange) renvoie l’estimation de Welch de la PSD dans la plage de fréquences définie par freqrange. Les options valides pour freqrange sont 'onesided', 'twosided' ou 'centered'.

[___] = pwelch(x,window,___,trace) renvoie l’estimation du spectre des valeurs maximales si trace est défini à 'maxhold' et l’estimation du spectre des valeurs minimales si trace est défini à 'minhold'.

[___,pxxc] = pwelch(___,'ConfidenceLevel',probability) renvoie les intervalles de confiance à probability × 100 % pour l’estimation de la PSD dans pxxc.

[___] = pwelch(___,spectrumtype) renvoie l’estimation de la PSD si spectrumtype est défini à 'psd' et le spectre de puissance si spectrumtype est défini à 'power'.

pwelch(___), sans arguments de sortie, trace l’estimation de Welch de la PSD dans la fenêtre de figure courante.

Exemples

Estimation de Welch avec les entrées par défaut

Obtenez l’estimation de Welch de la PSD d’un signal d’entrée composé d’une sinusoïde à temps discret avec une fréquence angulaire de $$\pi /4$$ rad/échantillon et un bruit blanc $$N(0,1)$$ additif.

Créez une onde sinusoïdale avec une fréquence angulaire de $$\pi /4$$ rad/échantillon et un bruit blanc $$N(0,1)$$ additif. Réinitialisez le générateur de nombres aléatoires pour obtenir des résultats reproductibles. Le signal a une longueur de $$N_x=320$$ échantillons.

rng default

n = 0:319;
x = cos(pi/4*n)+randn(size(n));

Obtenez l’estimation de Welch de la PSD en utilisant la fenêtre de Hamming et la longueur de DFT par défaut. La longueur par défaut des segments est de 71 échantillons et celle de la DFT est de 256 points, ce qui donne une résolution en fréquence de $$2\pi /256$$ rad/échantillon. Comme le signal est à valeurs réelles, le périodogramme est unilatéral et comporte 256/2+1 points. Tracez l’estimation de Welch de la PSD.

pxx = pwelch(x);

pwelch(x)

Répétez le calcul.

• Divisez le signal en sections de longueur $$nsc=\lfloor N_x/4.5\rfloor$$. Cette action revient à diviser le signal en segments aussi longs que possible pour obtenir le plus grand nombre de segments possible dans la limite de 8 avec un chevauchement de 50 %.

• Fenêtrez les sections avec une fenêtre de Hamming.

• Spécifiez 50 % de chevauchement entre les sections contiguës.

• Pour calculer la FFT, utilisez $$\max (256,2^p)$$ points, où $$p=\lceil {\log }_{2}nsc\rceil$$.

Vérifiez que les deux approches donnent des résultats identiques.

Nx = length(x);
nsc = floor(Nx/4.5);
nov = floor(nsc/2);
nff = max(256,2^nextpow2(nsc));

t = pwelch(x,hamming(nsc),nov,nff);

maxerr = max(abs(abs(t(:))-abs(pxx(:))))

maxerr = 
0

Divisez le signal en 8 sections de même longueur avec un chevauchement de 50 % entre les sections. Définissez la même longueur de FFT qu’à l’étape précédente. Calculez l’estimation de Welch de la PSD et vérifiez que vous obtenez le même résultat qu’avec les deux procédures précédentes.

ns = 8;
ov = 0.5;
lsc = floor(Nx/(ns-(ns-1)*ov));

t = pwelch(x,lsc,floor(ov*lsc),nff);

maxerr = max(abs(abs(t(:))-abs(pxx(:))))

maxerr = 
0

Estimation de Welch avec une longueur de segment donnée

Obtenez l’estimation de Welch de la PSD d’un signal d’entrée composé d’une sinusoïde à temps discret avec une fréquence angulaire de $$\pi /3$$ rad/échantillon et un bruit blanc $$N(0,1)$$ additif.

Créez une onde sinusoïdale avec une fréquence angulaire de $$\pi /3$$ rad/échantillon et un bruit blanc $$N(0,1)$$ additif. Réinitialisez le générateur de nombres aléatoires pour obtenir des résultats reproductibles. Le signal contient 512 échantillons.

rng default

n = 0:511;
x = cos(pi/3*n)+randn(size(n));

Obtenez l’estimation de Welch de la PSD en divisant le signal en segments de 132 échantillons de longueur. Les segments de signal sont multipliés par une fenêtre de Hamming de 132 échantillons de longueur. Comme le nombre d’échantillons qui se chevauchent n’est pas spécifié, il est défini à 132/2 = 66. La longueur de la DFT est de 256 points, ce qui donne une résolution en fréquence de $$2\pi /256$$ rad/échantillon. Comme le signal est à valeurs réelles, l’estimation de la PSD est unilatérale et comporte 256/2+1 = 129 points. Tracez la PSD en fonction de la fréquence normalisée.

segmentLength = 132;
[pxx,w] = pwelch(x,segmentLength);

plot(w/pi,10*log10(pxx))
xlabel('\omega / \pi')

Estimation de Welch avec un chevauchement de segments donné

Obtenez l’estimation de Welch de la PSD d’un signal d’entrée composé d’une sinusoïde à temps discret avec une fréquence angulaire de $$\pi /4$$ rad/échantillon et un bruit blanc $$N(0,1)$$ additif.

Créez une onde sinusoïdale avec une fréquence angulaire de $$\pi /4$$ rad/échantillon et un bruit blanc $$N(0,1)$$ additif. Réinitialisez le générateur de nombres aléatoires pour obtenir des résultats reproductibles. Le signal a une longueur de 320 échantillons.

rng default

n = 0:319;
x = cos(pi/4*n)+randn(size(n));

Obtenez l’estimation de Welch de la PSD en divisant le signal en segments de 100 échantillons de longueur. Les segments de signal sont multipliés par une fenêtre de Hamming de 100 échantillons de longueur. Le nombre d’échantillons qui se chevauchent est de 25. La longueur de la DFT est de 256 points, ce qui donne une résolution en fréquence de $$2\pi /256$$ rad/échantillon. Comme le signal est à valeurs réelles, l’estimation de la PSD est unilatérale et comporte 256/2+1 points.

segmentLength = 100;
noverlap = 25;
pxx = pwelch(x,segmentLength,noverlap);

plot(10*log10(pxx))

Estimation de Welch avec une longueur de DFT donnée

Obtenez l’estimation de Welch de la PSD d’un signal d’entrée composé d’une sinusoïde à temps discret avec une fréquence angulaire de $$\pi /4$$ rad/échantillon et un bruit blanc $$N(0,1)$$ additif.

Créez une onde sinusoïdale avec une fréquence angulaire de $$\pi /4$$ rad/échantillon et un bruit blanc $$N(0,1)$$ additif. Réinitialisez le générateur de nombres aléatoires pour obtenir des résultats reproductibles. Le signal a une longueur de 320 échantillons.

rng default

n = 0:319;
x = cos(pi/4*n) + randn(size(n));

Obtenez l’estimation de Welch de la PSD en divisant le signal en segments de 100 échantillons de longueur. Utilisez le chevauchement par défaut de 50 %. Définissez une longueur de DFT de 640 points pour que la fréquence de $$\pi /4$$ rad/échantillon corresponde à une bin de la DFT (bin 81). Comme le signal est à valeurs réelles, l’estimation de la PSD est unilatérale et comporte 640/2+1 points.

segmentLength = 100;
nfft = 640;
pxx = pwelch(x,segmentLength,[],nfft);

plot(10*log10(pxx))
xlabel('rad/sample')
ylabel('dB / (rad/sample)')

Estimation de Welch de la PSD d’un signal avec une fréquence en hertz

Créez un signal composé d’une sinusoïde de 100 Hz et d’un bruit blanc N(0,1) additif. Réinitialisez le générateur de nombres aléatoires pour obtenir des résultats reproductibles. La fréquence d’échantillonnage est de 1 kHz et le signal dure 5 secondes.

rng default

fs = 1000;
t = 0:1/fs:5-1/fs;
x = cos(2*pi*100*t) + randn(size(t));

Obtenez l’estimation de la PSD du signal précédent avec la méthode de Welch de moyennage par chevauchement de segments. Utilisez une longueur de segment de 500 échantillons avec un chevauchement de 300 échantillons. Utilisez 500 points de DFT pour que la fréquence 100 Hz tombe directement dans une bin de la DFT. Indiquez la fréquence d’échantillonnage en entrée pour générer un vecteur de fréquences en Hz en sortie. Tracez le résultat.

[pxx,f] = pwelch(x,500,300,500,fs);

plot(f,10*log10(pxx))

xlabel('Frequency (Hz)')
ylabel('PSD (dB/Hz)')

Spectres des valeurs maximales et des valeurs minimales

Créez un signal composé de trois sinusoïdes bruitées et d’un chirp échantillonné à 200 kHz pendant 0,1 seconde. Les fréquences des sinusoïdes sont de 1 kHz, 10 kHz et 20 kHz. Les sinusoïdes ont des amplitudes et des niveaux de bruit différents. Le chirp non bruité a une fréquence de départ de 20 kHz qui augmente de manière linéaire jusqu’à 30 kHz pendant l’échantillonnage.

Fs = 200e3; 
Fc = [1 10 20]'*1e3; 
Ns = 0.1*Fs;

t = (0:Ns-1)/Fs;
x = [1 1/10 10]*sin(2*pi*Fc*t)+[1/200 1/2000 1/20]*randn(3,Ns);
x = x+chirp(t,20e3,t(end),30e3);

Calculez l’estimation de Welch de la PSD ainsi que les spectres des valeurs maximales et des valeurs minimales du signal. Tracez les résultats.

[pxx,f] = pwelch(x,[],[],[],Fs);
pmax = pwelch(x,[],[],[],Fs,'maxhold');
pmin = pwelch(x,[],[],[],Fs,'minhold');

plot(f,pow2db(pxx))
hold on
plot(f,pow2db([pmax pmin]),':')
hold off
xlabel('Frequency (Hz)')
ylabel('PSD (dB/Hz)')
legend('pwelch','maxhold','minhold')

Répétez la procédure, cette fois en calculant les estimations du spectre de puissance centré.

[pxx,f] = pwelch(x,[],[],[],Fs,'centered','power');
pmax = pwelch(x,[],[],[],Fs,'maxhold','centered','power');
pmin = pwelch(x,[],[],[],Fs,'minhold','centered','power');

plot(f,pow2db(pxx))
hold on
plot(f,pow2db([pmax pmin]),':')
hold off
xlabel('Frequency (Hz)')
ylabel('Power (dB)')
legend('pwelch','maxhold','minhold')

Limites supérieures et inférieures des limites de confiance à 95 %

Cet exemple illustre l’utilisation de limites de confiance avec l’estimation WOSA (méthode de Welch de moyennage par chevauchement de segments) de la PSD. Bien que cela ne soit pas une condition indispensable pour obtenir une signification statistique, les fréquences de l’estimation de Welch pour lesquelles la limite de confiance inférieure dépasse la limite de confiance supérieure des estimations voisines de la PSD indiquent clairement d’importantes oscillations dans la série temporelle.

Créez un signal composé d’ondes sinusoïdales superposées de 100 Hz et 150 Hz et d’un bruit blanc N(0,1) additif. L’amplitude des deux ondes sinusoïdales est de 1. La fréquence d’échantillonnage est de 1 kHz. Réinitialisez le générateur de nombres aléatoires pour obtenir des résultats reproductibles.

rng default
fs = 1000;
t = 0:1/fs:1-1/fs;
x = cos(2*pi*100*t)+sin(2*pi*150*t)+randn(size(t));

Obtenez l’estimation WOSA avec des limites de confiance à 95 %. Définissez une longueur de segment de 200 avec un chevauchement de 50 % (100 échantillons) entre les segments. Tracez l’estimation WOSA de la PSD ainsi que l’intervalle de confiance. Zoomez sur la région d’intérêt des fréquences approchant 100 et 150 Hz.

L = 200;
noverlap = 100;
[pxx,f,pxxc] = pwelch(x,hamming(L),noverlap,200,fs,...
    'ConfidenceLevel',0.95);

plot(f,10*log10(pxx))
hold on
plot(f,10*log10(pxxc),'-.')
hold off

xlim([25 250])
xlabel('Frequency (Hz)')
ylabel('PSD (dB/Hz)')
title('Welch Estimate with 95%-Confidence Bounds')

La limite de confiance inférieure à proximité immédiate de 100 et 150 Hz dépasse sensiblement la limite de confiance supérieure des fréquences qui sont éloignées de 100 et 150 Hz.

Spectre de puissance centré sur la composante continue

Créez un signal composé d’une sinusoïde de 100 Hz et d’un bruit blanc $$N(0,1/4)$$ additif. Réinitialisez le générateur de nombres aléatoires pour obtenir des résultats reproductibles. La fréquence d’échantillonnage est de 1 kHz et le signal dure 5 secondes.

rng default

fs = 1000;
t = 0:1/fs:5-1/fs;

noisevar = 1/4;
x = cos(2*pi*100*t)+sqrt(noisevar)*randn(size(t));

Obtenez le spectre de puissance centré sur la composante continue avec la méthode de Welch. Utilisez une longueur de segment de 500 échantillons avec un chevauchement de 300 échantillons et une longueur de DFT de 500 points. Tracez le résultat.

[pxx,f] = pwelch(x,500,300,500,fs,'centered','power');

plot(f,10*log10(pxx))
xlabel('Frequency (Hz)')
ylabel('Magnitude (dB)')
grid

Nous voyons que la puissance à -100 et 100 Hz est proche de la puissance attendue de 1/4 pour une onde sinusoïdale à valeurs réelles avec une amplitude égale à 1. L’écart par rapport à 1/4 est dû au bruit additif.

Estimation de Welch de la PSD d’un signal multicanal

Générez 1 024 échantillons d’un signal multicanal composé de trois sinusoïdes et d’un bruit blanc gaussien $$N(0,1)$$ additif. Les fréquences des sinusoïdes sont de $$\pi /2$$, $$\pi /3$$ et $$\pi /4$$ rad/échantillon. Estimez la PSD du signal avec la méthode de Welch puis tracez-la.

N = 1024;
n = 0:N-1;

w = pi./[2;3;4];
x = cos(w*n)' + randn(length(n),3);

pwelch(x)

Arguments d'entrée

x — Signal d’entrée

vecteur | matrice

Signal d’entrée, défini par un vecteur ligne ou colonne ou par une matrice. Si x est une matrice, ses colonnes sont traitées comme des canaux indépendants.

Exemple : cos(pi/4*(0:159))+randn(1,160) est un signal monocanal défini par un vecteur ligne.

Exemple : cos(pi./[4;2]*(0:159))'+randn(160,2) est un signal bicanal.

Types de données : single | double
Support des nombres complexes : Oui

window — Fenêtre

entier | vecteur | []

Fenêtre, définie par un vecteur ligne ou colonne ou par un entier. Si window est un vecteur, la fonction pwelch divise x en segments qui se chevauchent et dont la longueur est égale à celle de window. Elle multiplie ensuite chaque segment de signal par le vecteur défini dans window. Si window est un nombre entier, pwelch divise le signal en segments de longueur égale à cette valeur entière et utilise une fenêtre de Hamming de même longueur. S’il est impossible de diviser exactement la longueur de x en un nombre entier de segments avec le nombre d’échantillons qui se chevauchent défini par noverlap, x est tronqué en conséquence. Si vous définissez window comme vide, la fenêtre de Hamming par défaut est utilisée pour obtenir huit segments de x avec noverlap échantillons qui se chevauchent.

Remarque

La fenêtre de Hamming par défaut présente une atténuation de lobe secondaire de 42,5 dB. Il est donc possible que le contenu spectral en dessous de cette valeur soit masqué (par rapport au contenu spectral de crête). Le choix de fenêtres différentes vous permet de trouver des compromis entre la résolution (par ex. en utilisant une fenêtre rectangulaire) et l’atténuation de lobe secondaire (par ex. en utilisant une fenêtre de Hann). Pour plus de précisions, veuillez consulter Window Designer.

Types de données : single | double

noverlap — Nombre d’échantillons qui se chevauchent

entier positif | []

Nombre d’échantillons qui se chevauchent, défini par un entier positif inférieur à la longueur de window. Si vous ne spécifiez pas noverlap ou si vous définissez noverlap comme vide, la fonction utilise une valeur permettant d’obtenir un chevauchement de 50 % entre les segments.

nfft — Nombre de points de la DFT

max(256,2^nextpow2(length(window))) (par défaut) | entier | []

Nombre de points de la DFT, défini par un entier positif. Pour un signal d’entrée x à valeurs réelles, l’estimation de la PSD pxx a une longueur égale à (nfft/2 + 1) si nfft est pair et à (nfft + 1)/2 si nfft est impair. Pour un signal d’entrée x à valeurs complexes, l’estimation de la PSD a toujours une longueur égale à nfft. Si nfft est défini comme vide, la valeur par défaut de nfft est utilisée.

Si nfft est supérieur à la longueur de segment, les données sont comblées avec des zéros. Si nfft est inférieur à la longueur de segment, le segment est raccourci avec datawrap pour que sa longueur soit égale à nfft.

Types de données : single | double

fs — Fréquence d'échantillonnage

scalaire positif

Fréquence d’échantillonnage, définie par un scalaire positif. La fréquence d’échantillonnage est le nombre d’échantillons par unité de temps. Si l’unité de temps est la seconde, la fréquence d’échantillonnage est exprimée en Hz.

w — Fréquences normalisées

vecteur

Fréquences normalisées, définies par un vecteur ligne ou colonne contenant au moins deux éléments. Les fréquences normalisées sont exprimées en rad/échantillon.

Exemple : w = [pi/4 pi/2]

Types de données : double | single

f — Fréquences

vecteur

Fréquences, définies par un vecteur ligne ou colonne contenant au moins deux éléments. Les fréquences sont exprimées en nombre de cycles par unité de temps. L’unité de temps est indiquée par la fréquence d’échantillonnage fs. Si fs est exprimé en échantillons/seconde, f est exprimé en Hz.

Exemple : fs = 1000; f = [100 200]

Types de données : double | single

freqrange — Plage de fréquences pour l’estimation de la PSD

'onesided' | 'twosided' | 'centered'

Plage de fréquences pour l’estimation de la PSD, définie par 'onesided', 'twosided' ou 'centered'. La valeur par défaut est 'onesided' pour les signaux à valeurs réelles et 'twosided' pour ceux à valeurs complexes. Les plages de fréquences correspondant à chaque option sont les suivantes :

• 'onesided' : renvoie l’estimation de la PSD unilatérale d’un signal d’entrée à valeurs réelles x. Si nfft est pair, pxx a une longueur égale à nfft/2 + 1 et est calculé sur l’intervalle [0,π] rad/échantillon. Si nfft est impair, la longueur de pxx est égale à (nfft + 1)/2 et l’intervalle est [0,π) rad/échantillon. Lorsque fs est spécifié (facultatif), les intervalles correspondants sont respectivement [0,fs/2] cycles/unité de temps et [0,fs/2) cycles/unité de temps time pour une longueur nfft paire et impaire.

  La fonction multiplie la puissance par 2 à toutes les fréquences sauf à 0 et à la fréquence de Nyquist pour conserver la puissance totale.

• 'twosided' : renvoie l’estimation de la PSD bilatérale pour l’entrée à valeurs réelles ou complexes x. Dans ce cas, pxx a une longueur égale à nfft et est calculé sur l’intervalle [0,2π) rad/échantillon. Lorsque fs est spécifié (facultatif), l’intervalle est [0,fs) cycles/unité de temps.

• 'centered' : renvoie l’estimation de la PSD bilatérale centrée pour l’entrée à valeurs réelles ou complexes x. Dans ce cas, pxx a une longueur égale à nfft et est calculé sur l’intervalle (–π,π] rad/échantillon pour une longueur nfft paire et (–π,π) rad/échantillon pour une longueur nfft impaire. Lorsque fs est spécifié (facultatif), les intervalles correspondants sont respectivement (–fs/2, fs/2] cycles/unité de temps et (–fs/2, fs/2) cycles/unité de temps pour une longueur nfft paire et impaire.

Si vous spécifiez un vecteur de fréquences w ou f ainsi que freqrange en entrée, pwelch ignore freqrange.

Types de données : char | string

spectrumtype — Mise à l’échelle du spectre de puissance

'psd' (par défaut) | 'power'

Mise à l’échelle du spectre de puissance, définie par 'psd' ou par 'power'. L’omission de spectrumtype ou la spécification de 'psd' renvoie la densité spectrale de puissance. La spécification de 'power' met à l’échelle chaque estimation de la PSD selon la bande passante de bruit équivalente de la fenêtre. Utilisez l’option 'power' pour obtenir une estimation de la puissance à chaque fréquence.

trace — Mode de trace

'mean' (par défaut) | 'maxhold' | 'minhold'

Mode de trace, défini par 'mean', 'maxhold' ou 'minhold'. La valeur par défaut est 'mean'.

• 'mean' : renvoie l’estimation spectrale de Welch de chaque canal d’entrée. pwelch calcule l’estimation spectrale de Welch à chaque bin de fréquences en calculant la moyenne des estimations du spectre de puissance de tous les segments.

• 'maxhold' : renvoie le spectre des valeurs maximales de chaque canal d’entrée. pwelch calcule le spectre des valeurs maximales à chaque bin de fréquences en conservant la valeur la plus élevée des estimations du spectre de puissance de tous les segments.

• 'minhold' : renvoie le spectre des valeurs minimales de chaque canal d’entrée. pwelch calcule le spectre des valeurs minimales à chaque bin de fréquences en conservant la valeur la plus faible des estimations du spectre de puissance de tous les segments.

probability — Intervalle de confiance pour l’estimation de la PSD

0.95 (par défaut) | scalaire dans la plage (0,1)

Probabilité de couverture pour la PSD réelle, définie par un scalaire dans la plage (0,1). La sortie pxxc contient les limites inférieure et supérieure de l’estimation de l’intervalle à probability × 100 % pour la PSD réelle.

Arguments de sortie

pxx — Estimation de la PSD

vecteur | matrice

Estimation de la PSD, renvoyée sous la forme d’un vecteur colonne ou d’une matrice à valeurs réelles non négatives. Chaque colonne de pxx est l’estimation de la PSD de la colonne correspondante de x. L’estimation de la PSD est exprimée en unités d’amplitude au carré des données de séries temporelles par unité de fréquence. Par exemple, si les données d’entrée sont en volts, l’estimation de la PSD est en volts carrés par unité de fréquence. Pour une série temporelle en volts, si vous supposez une résistance de 1 Ω et spécifiez la fréquence d’échantillonnage en hertz, l’estimation de la PSD est en watts par hertz.

w — Fréquences normalisées

vecteur

Fréquences normalisées, renvoyées sous la forme d’un vecteur colonne à valeurs réelles. Si pxx est une estimation de la PSD unilatérale, w s’étend sur l’intervalle [0,π] si nfft est pair et [0,π) si nfft est impair. Si pxx est une estimation de la PSD bilatérale, w s’étend sur l’intervalle [0,2π). Pour une estimation de la PSD centrée sur la composante continue, w s’étend sur l’intervalle (–π,π] si nfft est pair et (–π,π) si nfft est impair.

f — Fréquences cycliques

vecteur

Fréquences cycliques, renvoyées sous la forme d’un vecteur colonne à valeurs réelles. Pour une estimation de la PSD unilatérale, f s’étend sur l’intervalle [0,fs/2] lorsque nfft est pair et [0,fs/2) lorsque nfft est impair. Pour une estimation de la PSD bilatérale, f s’étend sur l’intervalle [0,fs). Pour une estimation de la PSD centrée sur la composante continue, f s’étend sur l’intervalle (–fs/2, fs/2] cycles/unité de temps pour une longueur nfft paire et (–fs/2, fs/2) cycles/unité de temps pour une longueur nfft impaire.

pxxc — Limites de confiance

matrice

Limites de confiance, renvoyées sous la forme d’une matrice contenant des éléments à valeur réelle. La taille de ligne de la matrice est égale à la longueur de l’estimation de la PSD pxx. pxxc contient deux fois plus de colonnes que pxx. Les colonnes impaires contiennent les limites inférieures des intervalles de confiance. Les colonnes paires contiennent les limites supérieures. Ainsi, pxxc(m,2*n-1) est la limite de confiance inférieure et pxxc(m,2*n) est la limite de confiance supérieure de l’estimation pxx(m,n). La probabilité de couverture des intervalles de confiance dépend de la valeur de l’entrée probability.

Types de données : single | double

En savoir plus

Estimation spectrale avec la méthode de Welch de moyennage par chevauchement de segments

Le périodogramme n’est pas un estimateur cohérent de la densité spectrale de puissance réelle d’un processus stationnaire au sens large. La technique de Welch consiste à réduire la variance du périodogramme en divisant la série temporelle en segments qui en général se chevauchent.

La méthode de Welch calcule un périodogramme modifié pour chaque segment puis calcule la moyenne de ces estimations pour produire l’estimation de la densité spectrale de puissance. Comme le processus est stationnaire au sens large et comme la méthode de Welch utilise les estimations de la PSD de différent segments de la série temporelle, les périodogrammes modifiés représentent de manière approximative des estimations non corrélées de la PSD réelle. Le moyennage réduit la variabilité.

Les segments sont généralement multipliés par une fonction de fenêtrage telle qu’une fenêtre de Hamming. Ainsi, la méthode de Welch revient à moyenner les périodogrammes modifiés. Comme en général, les segments se chevauchent, les valeurs des données au début et à la fin d’un segment tronqué par la fenêtre sont éloignées des extrémités des segments adjacents. Vous évitez ainsi toute perte d’informations due au fenêtrage.

Références

[1] Hayes, Monson H. Statistical Digital Signal Processing and Modeling. New York: John Wiley & Sons, 1996.

[2] Stoica, Petre, and Randolph Moses. Spectral Analysis of Signals. Upper Saddle River, NJ: Prentice Hall, 2005.

Capacités étendues

Tall arrays

Calculer avec des arrays possédant plus de rangées que la mémoire ne peut en contenir.

La fonction pwelch supporte les tall arrays avec les notes d’usage et limitations suivantes :

• L’entrée x ne doit pas être un vecteur ligne de type tall.

• L’argument window doit toujours être spécifié.

Pour plus d’informations, veuillez consulter Tall array.

Génération de code C/C++
Générez du code C et C++ avec MATLAB® Coder™.

Génération de code GPU
Générez du code CUDA® pour les GPU NVIDIA® avec GPU Coder™.

Environnement basé sur les threads

Exécutez du code en arrière-plan avec MATLAB® backgroundPool ou accélérez le code avec Parallel Computing Toolbox™ ThreadPool.

Notes d'usage et limitations :

• La syntaxe sans arguments de sortie n’est pas supportée.

Pour plus d’informations, veuillez consulter Run MATLAB Functions in Thread-Based Environment.

GPU Arrays

Accélérez le code en exécutant les calculs sur une unité de traitement graphique (GPU) avec Parallel Computing Toolbox™.

Cette fonction supporte complètement les GPU arrays. Pour plus d’informations, veuillez consulter Exécuter les fonctions MATLAB sur un GPU (Parallel Computing Toolbox).

Historique des versions

Introduit avant R2006a

R2024b: pwelch supporte la génération de code GPU

La fonction pwelch supporte la génération de code pour les processeurs graphiques (GPU). Vous devez avoir installé MATLAB^® Coder™ et GPU Coder™ pour générer du code CUDA^®.

R2024a: Support de la génération de code pour les fenêtres simple précision de taille variable en entrée

La fonction pwelch supporte les fenêtres simple précision de taille variable en entrée pour la génération de code.

R2023b: Utiliser des données simple précision

La fonction pwelch supporte les entrées simple précision.

R2023a: Visualiser les sorties de la fonction avec la tâche Create Plot du Live Editor

Vous pouvez désormais utiliser la tâche Create Plot du Live Editor pour visualiser la sortie de pwelch de manière interactive. Vous pouvez sélectionner différents types de diagrammes et définir des paramètres facultatifs. La tâche génère automatiquement du code qui est intégré dans votre live script.

Voir aussi

Applications

• Signal Analyzer

Fonctions

• periodogram | pmtm | pspectrum

Rubriques

• Bias and Variability in the Periodogram
• Spectral Analysis