Problem mit Pyhton3 truth value of an array with more than one element is ambiguous

[Skullcleaver]

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter

# bei der Wahl des Wertes für delta t orientieren wir uns an dem Kehrwert der Frequenz (in s)
dt=1e-11

#c in m/s
c=3e8

#Länge des Beschleunigermoduls in m
l=3.05

#e in C
e=1.6e-19

#Masse des Positrons in kg
m0=9.1e-31
#Ruheenergie in J
Er=511e3*e

#Frequenz in Hz
f=2856e6
#Wellenzahl in 1/m
k=2*np.pi*f/c
#E-Feld in V/m
E0= 12e6


s=0
t=0

#Funktion der Streckenänderung von der Zeit
#Funktion der Änderung der Phasenlage
#def ds(v):
#    return v*dt

#Funktion der Änderung der Phasenlage
#def dp(ds, v):
#    return k*(v-c)*ds/v

#Funktion der Änderung der kinetischen Energie in J
#def dEk(p, ds):
#    return e*E0*np.cos(p)*ds

#Funktion der Geschwindigkeit
#def v(Ek):
#    return c*(1-((m0*c**2)/(Ek+m0*c**2))**2)**0.5

#Es wird ein Array der Anfangsphase pa und der Anfangsenergie Ea erstellt
pa=np.linspace(-np.pi,np.pi,100)
Ea=np.linspace(0.1*Er,15*Er,100)


#jetzt werden die Funktionen der Reihenfolge nach aufgerufen, bis die Strecke komplett durchlaufen ist oder die Zeit den Abbruchwert erreicht hat. 
#Der Abbruchwert der Zeit orientiert sich an der Zeit die das langsamste Teilchen ohne Beschleunigung für die Strecke brauchen würde (ca. 2,275e-8 s).

def Ek(p, E):
	s=0
	t=0
	v=c*(1-((m0*c**2)/(E+m0*c**2))**2)**0.5
	ds=v*dt
[B]	while s < 3.05 and t < 1e-7 :[/B]
		E=E+e*E0*np.cos(p)*ds
		s=s+ds
		t=t+dt
		v=c*(1-((m0*c**2)/(E+m0*c**2))**2)**0.5
		p=p+k*(v-c)*ds/v
		ds=v*dt
	return(E)


def ve(p, E, v, ds):
	s=0
	t=0
	while s < 3.05 and t < 1e-7 :
		E=E+e*E0*np.cos(p)*ds
		s=s+ds
		t=t+dt
		v=c*(1-((m0*c**2)/(E+m0*c**2))**2)**0.5
		p=p+k*(v-c)*ds/v
		ds=v*dt
	return(v)

def pe(p, E, v, ds):
	s=0
	t=0
	while s < 3.05 and t < 1e-7 :
		E=E+e*E0*np.cos(p)*ds
		s=s+ds
		t=t+dt
		v=c*(1-((m0*c**2)/(E+m0*c**2))**2)**0.5
		p=p+k*(v-c)*ds/v
		ds=v*dt
	return(p)


#Plot der Energie

X, Y = np.meshgrid(pa, Ea)
Z = Ek(X, Y)

fig = plt.figure()
ax = plt.axes(projection='3d')
ax.contour3D(X, Y, Z, 50, cmap='binary')
ax.set_xlabel('Anfangsphase')
ax.set_ylabel('kinetische Anfangsenergie [J]')
ax.set_zlabel('kinetische Endenergie [J]');
plt.title(u'Energie')

ax.view_init(60, 35)
fig
plt.show()

#Plot der Gescwindigkeit

X, Y = np.meshgrid(pa, Ea)
Z = ve(X, Y)

fig = plt.figure()
ax = plt.axes(projection='3d')
ax.contour3D(X, Y, Z, 50, cmap='binary')
ax.set_xlabel('Anfangsphase')
ax.set_ylabel('kinetische Anfangsenergie [J]')
ax.set_zlabel('Geschwindigkeit [m/s]');
plt.title(u'Geschwindigkeit')

ax.view_init(60, 35)
fig
plt.show()

#Plot der Energie

X, Y = np.meshgrid(pa, Ea)
Z = pe(X, Y)

fig = plt.figure()
ax = plt.axes(projection='3d')
ax.contour3D(X, Y, Z, 50, cmap='binary')
ax.set_xlabel('Anfangsphase')
ax.set_ylabel('kinetische Anfangsenergie [J]')
ax.set_zlabel('Phase');
plt.title(u'Energie')

ax.view_init(60, 35)
fig
plt.show()

Beklagt bei Zeile 67 (fett)

truth value of an array with more than one element is ambiguous

Jemand eine Idee?

 

[flxmmr]

numpy.any NumPy v1.15 Manual und numpy.all NumPy v1.15 Manual sind deine Freunde .

 

[Skullcleaver]

Sind sie nicht weil ich keine Arrays verwende. Es wird nur an irgendeiner Stelle zu einem Array umgewandelt obwohl es skalar bleiben sollte. Da liegt das Problem.

 

[Novastar]

Du übergibst der Funktion Ek in der Variable E einen Wert, die mit np.meshgrid erzeugt wurden, welches Arrays zurückgibt. Dieses E verwendest du in der Berechnung von v, und das benutzt du für die Berechnung von ds, und das für die Berechnung für s, wodurch bei der Abfrage dann mit einem Array verglichen wird, was aber so nicht direkt geht.

Falls du selber rausfinden willst, wo bei sowas das Problem liegt, kannst du mit print(type(variable)) dir ausgeben lassen, was für ein Typ eine Variable hat. Dadurch kann man dann zurückverfolgen, wo die von dir erwartete Typ von den Tatsachen abweicht.

 

[flxmmr]

alternativ einfach einen Debugger verwenden. Ich verwende emacs+realgud, das ist allerdings ziemlich lahm (bei größeren Sachen). Visual Studio Code mit der MS-Python-Extension ist da vermutlich das Mittel der Wahl, da gibt es einen wirklich schönen Debugger.