Das deutsche Python-Forum

Code: Alles auswählen

>>> import numpy as np
>>> a = np.array([1, 2, 3])
>>> b = np.array([4])
>>> c = np.array([[1, 2], [3, 4]])
>>> a.item()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: can only convert an array of size 1 to a Python scalar
>>> b.item()
4
>>> c.item()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: can only convert an array of size 1 to a Python scalar

Code: Alles auswählen

import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
from scipy.optimize import curve_fit

 ############Datei-Import##################

data = np.loadtxt("./TEST1.txt",skiprows = 4)

 ###########Schreibe Daten in Listen###########

t        = data[:,0]-0
signal_t = data[:,1]-0

t        = t[0:6000]
signal_t = signal_t[0:6000]

dt = t[1]-t[0]     #Zeitschritt
fa=1/dt            #Abtastfrequenz
print('dt=%.5fs (Zeitschritte)' % dt)
print('fa=%.2fHz (Abtastfrequenz)' % fa)

 #######Detrending des Signals######

s=signal.detrend(signal_t)
 #s=signal_t

sos = signal.butter(1,1, 'hp', fs=fa, output='sos')
signal_t = signal.sosfilt(sos, signal_t)
sos = signal.butter(4, 21, 'lp', fs=fa, output='sos')
signal_t = signal.sosfilt(sos, signal_t)
s = signal_t
 ################Fensterfunktion##############

hann=np.hanning(len(s)) 
f_t=list(hann*s)

 ##############ZeroPadding####################

Zeropadding=2**2*len(t)
print(Zeropadding)

zpy=np.zeros(shape=(1,Zeropadding+1),dtype=float)
zpx=np.arange(t[-1],t[-1]+Zeropadding*dt,dt,float)

t_1 = np.append(t, zpx) #gepaddete Zeitachse
f_t_1 = np.append(f_t, zpy) #gepaddete Funktion

 ##########Fourier-Transformation##############

Y =np.fft.fft(f_t_1)

N_0 =len(f_t)
N_1 =len(f_t_1)

print('NO= ', N_0)
print('N1= ', N_1)

X  = np.linspace(0,fa/2,int(N_1/2+1),endpoint=True)

 ##########PLOTS##############

fig, axes  = plt.subplots(2, 1, figsize=(8, 8))

 #Diagramm Zeit-Verschiebung
axes[0].plot(t,signal_t,lw=1,color='b', label='Verschiebung im Schw.bauch')
axes[0].grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
axes[0].autoscale(enable=True, axis='y')
axes[0].autoscale(enable=True, axis='x')
 #axes[0].set_xlim([0, 1])
axes[0].set_title("a(t)")
axes[0].axvline(0.646,lw=0.7, linestyle='dashed')

 #Diagramm Amplitudenspektrum
axes[1].plot(X,2*np.abs(Y[:int(N_1/2+1)])/int(N_1/2+1),lw=1,color='r')
axes[1].grid(color='k', alpha=1, linestyle='dashed', linewidth=0.5)
 #axes[1].axis('tight')
axes[1].set_title("Amplitudenspektrum")
axes[1].set_ylim([0, 0.2*10**-8])
axes[1].autoscale(enable=True, axis='y')
axes[1].set_xlim([0, 20])
axes[1].set_ylabel('Amplitude')
axes[1].set_xlabel('Frequenz')


 ###############Auswertung des Amplitudenspektrums################


d=10/(X[1]-X[0])    #Distance(Abstand zwischen Peaks)
bound=(None)        #Grenzen(obere und untere Grenzen für Peaks =NONE wenn keine Grenzen benötigt)

psignal=2*np.abs(Y[:int(N_1/2+1)])/int(N_1/2+1)
peaks, _= signal.find_peaks(psignal,distance=d,height=bound,prominence=2*10**-4)
print('Peakhöhe=' , X[peaks])
print('Frequenz bei Peak= ', psignal[peaks])
print('Versuch= ',X[1]-X[0])


axes[1].scatter(X[peaks],psignal[peaks],marker='o',color='green', label='f=%5.2f Hz' % X[peaks])


 #############Curve-Fit Zeitverschiebungskurve#############

peaks_u = signal.find_peaks(signal_t,height=0.0,distance=40,)
axes[1].scatter(t[peaks_u],signal_t[peaks_u],marker='x',color='red')

def fitfunc(t,a,delta): #Definition der Fitfunktion
 return a* np.exp(-delta*t)

xdata=t[peaks_u]
ydata=signal_t[peaks_u]

popt, pcov = curve_fit(fitfunc, xdata, ydata) #Curvfitting
print('a= ',popt[0], ' delta=',popt[1])
D= popt[1:2]/(np.sqrt((2*np.pi*X[peaks[0]])**2+popt[1:2]**2))*100
 #Dämpfungsberechnung
print('Lehrsches Dämpfungsmaß= ',D)
print((X[peaks[0]]))
a_1=popt[0:1]
b_1=popt[1:2]
xi_1=b_1/2/3.14/10.3*100
print(xi_1)
print(popt[1])

axes[0].plot(t, fitfunc(t, *popt), color='green', lw=1, label='Fitkurve: D=%5.2f Prozent' % D)
 #axes[0].plot(xdata, 1.2558*10**-6*np.exp(-0.9755345*xdata))

legend= axes[0].legend(loc='lower right', shadow=True, fontsize='medium')
legend.get_frame().set_edgecolor('C5')

legend= axes[1].legend(loc='lower right', shadow=True, fontsize='medium')

Code: Alles auswählen

runfile('F:/Python/FFT.py', wdir='F:/Python')
dt=0.00010s (Zeitschritte)
fa=10000.00Hz (Abtastfrequenz)
24000
NO=  6000
N1=  30001
Peakhöhe= []
Frequenz bei Peak=  []
Versuch=  0.3333333333333333
Traceback (most recent call last):

  File "F:\Python\FFT.py", line 99, in <module>
    axes[1].scatter(X[peaks],psignal[peaks],marker='o',color='green', label='f=%5.2f Hz' % X[peaks])

TypeError: only size-1 arrays can be converted to Python scalars

Code: Alles auswählen

Peakhöhe= []

Code: Alles auswählen

print('Peakhöhe=' , X[peaks])

Code: Alles auswählen

axes[1].scatter(X[peaks],psignal[peaks],marker='o',color='green', label='f=%5.2f Hz' % X[peaks])

Code: Alles auswählen

peaks, _= signal.find_peaks(psignal,distance=d,height=bound,prominence=2*10**-8)

Code: Alles auswählen

peaks_u = signal.find_peaks(signal_t,height=1.5*10**-5,distance=1,)
axes[1].scatter(t[peaks_u],signal_t[peaks_u],marker='x',color='red')

Code: Alles auswählen

  File "F:\Python\FFT.py", line 105, in <module>
    axes[1].scatter(t[peaks_u],signal_t[peaks_u],marker='x',color='red')

IndexError: only integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indices