def plot_zeitentwicklung(ax, ew, ef, x, V, coeff, hquer, fak, zeiten):
"""Berechne und plotte die Zeitentwicklung eines Wellenpakets.
Das Wellenpakets ist bestimmt durch die Entwicklungskoeffizienten 'coeff'.
Uebergeben werden der Plotbereich 'ax', die Eigenwerte 'ew',
die Eigenfunktionen 'ef', das Potential 'V' an den Orten 'x',
das effektive 'hquer', der Skalierungsfaktor 'fak'
und das Zeitarray 'zeiten'.
"""
ax.lines = [] # entfernt alle Linien
E0_qm = dot(abs(coeff)**2, ew) # qm. Energieerwartung
phi_t0 = dot(ef, coeff) # Anfangswellenpaket
prop_coeff = abs(coeff)**2 # Anregungswahrscheinlichkeit
prop_coeff = prop_coeff/max(prop_coeff) # ... normiert auf Maximum
phi_t0_scaled = E0_qm + fak*abs(phi_t0)**2 # skaliertes Wellenpaket
# Plot mit Transparenz proportional zur Anregungsstaerke
qm.plot_eigenfunktionen(ax, ew, ef, x, V, width=2, fak=fak,
betragsquadrat=True, alpha=prop_coeff)
# plotte initial Wellenpaket
wellenpaket = plt.plot(x, phi_t0_scaled, linewidth=4, c='k')
plt.draw()
print "Energieerwartungswert des Wellenpakets:", E0_qm
print "Zeitentwicklung laeuft ..."
# Zeitentwicklung des Gausswellenpakets:
for t in zeiten[1:]:
phi = dot(ef, coeff*exp(-1j*ew*t/hquer)) # Berechnung von phi(t)
plt.setp(wellenpaket[0],
ydata=E0_qm + fak*abs(phi)**2) # plot |phi(t)|^2
plt.draw()
print "fertig!"
print
print "Linksklick startet neues Wellenpaket."
def main():
"""Hauptprogramm."""
global x, ew, ef, p0, V, hquer, zeiten, delta_x_gauss, ax, fak
p0 = 0 # Impuls des WP
A = 0.04 # Potentialparameter
L = 2.0 # x-Bereich ist [-L,L]
N = 500 # Zahl der Gitterpkte
hquer = 0.05 # effektives hquer
delta_x_gauss = 0.1 # Breite Gauss
zeiten = linspace(0.0, 4, 200) # Zeiten f. Zeitentw.
fak = 0.01 # Plot-Skalierungsfak.
Emax = 0.1 # Maximalenergie fuer Darstellung
x = qm.diskretisierung(-L, L, N)
V = potential(x, A)
ew, ef = qm.diagonalisierung(hquer, x, V)
print "Energiedifferenz E_1 - E_0:", ew[1] - ew[0]
ax = plt.subplot(111, autoscale_on=False)
qm.plot_eigenfunktionen(ax, ew, ef, x, V, Emax=Emax,
fak=fak, betragsquadrat=True)
plt.setp(ax, title="Zeitentwicklung im asymm. Doppelmuldenpotential")
print __doc__
print "Linksklick startet neues Wellenpaket."
plt.connect('button_press_event', wp_neu)
plt.show()
def zeitentwicklungs_plot(ax, ew, ev, x, V, koeff, h_eff, fak, zeiten):
"""Berechnung der Zeitentwicklung eines Wellenpaketes.
Uebergebene Variablen:
ax - Plottbereich in dem geplottet wird
ew - Energieeigenwert
ev - Eigenvektor
x - Array der Ortsdiskretisierung
V - Potential
koeff - Entwicklungskoeffizienten
h_eff - Effektives h-quer
fak - Skalierungsfaktor der Plotausgabe
zeiten- Array der Zeiten
"""
ax.lines = [] # Plotfenster aufraeumen
E0_erwartet = np.dot(np.abs(koeff)**2, ew) # Energieerwartung
phi_start = np.dot(ev, koeff) # Ausgangswellenpaket
# Energieerwarung ausgeben
print("Energieerwartungswert des Wellenpakets: ", E0_erwartet)
# Normierte Anregungswahrscheinlichkeiten (Normierung auf Maximum)
ws_koeff = np.abs(koeff)**2 / np.max(np.abs(koeff)**2)
# skaliertes Startpaket
phi_start_skaliert = E0_erwartet + fak * np.abs(phi_start)**2
# Plot mit Transparenz proportional zur Anregungsstaerke der Eigenfktn
plot_eigenfunktionen(ax,
ew,
ev,
x,
V,
width=1.5,
fak=fak,
betragsquadrat=True,
alpha=ws_koeff,
title="Zeitentwicklung eines Wellenpakets")
# Startpaket plotten
wellenpaket_entwicklung = plt.plot(x,
phi_start_skaliert,
linewidth=3,
c='k')
plt.draw()
# Zeitentwicklung:
for t in zeiten[1:]:
phi = np.dot(ev, koeff *
np.exp(-1j * ew * t / h_eff)) # Berechnung von phi(t)
# plot abs(phi)**2
plt.setp(wellenpaket_entwicklung[0],
ydata=E0_erwartet + fak * np.abs(phi)**2)
plt.draw()
# Benutzerfuehrung
print("Neues Wellenpaket zum Entwickeln mit Linksklick starten.")
print()
print()
def ef_plot(ax, ew, ef, x, V, A):
V_aktuell = V(x, A)
plot_eigenfunktionen(
ax,
ew,
ef,
x,
V_aktuell,
width=1.5,
betragsquadrat=True,
alpha=0.5,
title="asymmetrische Doppelmulde, Wellenpaket mit Zeitentwicklung")
def main():
"""Hauptprogramm"""
print(__doc__)
#Paramter für quantenmechanik.py
L = 1.5 #Intervallgrenzen
N = 300 #Matrixgröße
h_eff = 0.07 #effektives Plack.-
#Wirkungsquantum
p_0 = 0.0 #Anfangsmpuls
A = 0.06 #gegebener Paramter
#im Doppelmuldenpot.
D_x = 0.1 #Breite des Wellenpaket
t_max = 100 #maximale Zeit für Zeitarray
T = np.linspace(0, t_max, 100) #Zeitenarray
skalierung = 0.01 #Skalierung zur besseren
#Darstellung
#Berechnugn der diskreten Ortswerte und des Ortsgitterabstand mithilfe
#quantenmechanik.py
x, delta_x = qm.diskretisierung(-L, L, N, True)
#Definition des Doppelmuldenpotentials
V = functools.partial(potential_DM, A=A)
#Berechnung des Eigenwerte und -funktionen mithilfe quantenmechanik.py
EW, EV = qm.diagonalisierung(h_eff, x, V)
#Erstellung des Plotfensters
fig = plt.figure(figsize=(10, 8))
ax = plt.subplot(111)
#Plot der Eigenfunktionen durch quantenmechanik.py
qm.plot_eigenfunktionen(ax,
EW,
EV,
x,
V,
betragsquadrat=True,
fak=skalierung)
#Übergabe der Parameter an wenn_maus_geklickt
klick_funktion = functools.partial(wenn_maus_geklickt,
ax=ax,
x=x,
D_x=D_x,
h_eff=h_eff,
p_0=p_0,
delta_x=delta_x,
EW=EW,
EV=EV,
skalierung=skalierung,
T=T)
fig.canvas.mpl_connect("button_press_event", klick_funktion)
plt.show()
def main():
print
# Einige Globale Variablen (noetig da event verwendet)
global L, N, x, V, h_eff, Emax, fak, p0, dx_paket, zeiten, ew, ev, ax
L = 1.5 # Betrachtetes x-Intervall [-L, L]
N = 1000 # Anzahl der Ortspunkte
x = diskretisierung(-L, L, N) # ...Ortspunkte
V = potential(x) # Zu betrachtendes Potential
h_eff = 0.05 # Effektives h-quer
Emax = 0.1 # Maximal betrachtete Eigenenergie
fak = 0.01 # Plot-Skalierungsfaktor
p0 = 0 # Impuls des Pakets
dx_paket = 0.1 # Breite des Pakets
zeiten = np.linspace(0, 10, 500) # Zeiten fuer Zeitentwicklung
ew, ev = diagonalisierung(h_eff, x, V)
# Plotbereich erstellen
ax = plt.subplot(111, autoscale_on=False)
# Eigenfunktionen plotten und Diagramm benennen
plot_eigenfunktionen(ax,
ew,
ev,
x,
V,
Emax=Emax,
fak=fak,
betragsquadrat=True)
plt.setp(ax,
title="Asymmetrisches Doppelmuldenpotential mit Eigenfunktionen")
# Benutzerfuehrung
print(__doc__)
# Bereitstellung des Mausklicks und Ausgabe der Zeitentwicklung
plt.connect('button_press_event', neues_wellenpaket)
plt.show()
# Parameter initialisieren:
N = 100
Heff = 0.05
L = 1.2
A = 0.04
sigmaX = 0.1
x0 = 0.1
tmax = 25
# Plot initialisieren
plt.figure(1)
ax = plt.subplot(111)
plt.connect("button_press_event", OnClick)
ew, ef, x, dx, V = diagonalisierung(Heff, L, N, A=A)
plot_eigenfunktionen(ax, ew, ef, x, V, betragsquadrat=True)
plt.show()
""" Beobachtungen:
Bewegungen:
Start bei einem der beiden Minima: Gausspaket schwingt innerhalb der Mulde des
Minimums etwas hin und her, behaelt aber seine Form. Das laesst sich mit der
Oszillatiornaeherung der Mulde erklaeren, die vorhersagt, dass ein Gausspaket
seine Form behaelt.
Die Energieerwartungswerte liegen leicht ueber den Eigenenergien. Das liegt
daran dass die beiden Komponenten ef[0] und ef[1] den groessen Beitrag liefern
(Cn[0] und Cn[1] gross) und der Rest der Entwicklung vernachlaessigbar ist.
Daraus folgt eine Frequenz von (ew[0]-ew[1])/(Heff*2*pi)
Start im Maximum: Gausspaket zerfliesst sehr schnell, es entstehen mehrere
A = 0.04 # 'Schiefheitsparameter' des Potentials
p0 = 0.0 # Impuls des Wellenpakets
heff = 0.05 # effektives hquer
dx = 0.1 # Ortsgenauigkeit des Wellenpakets
L = 1.3 # Intervall der x-Werte [-L, L]
N = 100 # Anzahl der x-Werte
t_end = 15 # letzter Zeitpunkt der Zeitentwicklung
t_steps = 75 # Anzahl der Zeitschritte fuer die Darstellung
scale = 0.01 # Skalierungsfaktor der dyn. Wellenfkt.
Emax = 0.25 # Energie, bis zu der Eigenwerte berechnet werden
x_disk = qm.diskretisierung(-L, L, N) # Ortsdiskretisierung
V = potential(x_disk, A) # Potential
ew, ev = qm.diagonalisierung(heff, x_disk, V) # Loesung des Eigenwertproblems
# Ploteinstellungen
plt.figure(figsize=(10, 8))
ax = plt.subplot(111)
# Eigenfunktionen und bei Mausklick Zeitentw. plotten
qm.plot_eigenfunktionen(ax, ew, ev, x_disk, V,\
betragsquadrat=True, Emax=Emax)
plt.connect('button_press_event', OnClick)
# Benutzerinformation
print __doc__
plt.show()
print __doc__
# Ortsraumdiskretisierung
x_arr = diskretisierung(-L, L, N)
# Berechnung von Eigenwerten /-funktionen des Potentials
ew, ev = diagonalisierung(heff, x_arr, potential(x_arr, A))
# Plotbereich erstellen + vorbereiten
fig = plt.figure(figsize=(9, 9))
ax = plt.subplot(111)
plt.connect('button_press_event', maus_klick)
graph, = plt.plot([],[])
# Eigenfunktionen und Potential grafisch darstellen
plot_eigenfunktionen(ax, ew, ev, x_arr, potential(x_arr, A), \
betragsquadrat=True, Emax=Emaximal)
plt.show() # Plotfenster anzeigen
# Auftretende Bewegungen:
# - Bei einem Start im Minimum befinden sich Beitraege zur Wellenfunktion
# nur in einer Mulde. Das Teilchen wird sich bei einer Messung des Ortes
# also wie erwartet mit sehr hoher Wahrscheinlichkeit in dieser Mulde
# befinden. Die Wellenfunktion entspricht etwa der niedrigsten Eigen-
# funktion, die Eigenenergie ist nur geringfuegig hoeher.
# - Bei einem Start im Maximum hat die Wellenfunktion Beitraege in beiden
# Mulden. Das Teilchen wird bei einer Messung des Ortes also in
# einer zufaelligen Mulde lokalisiert.
# p0 = 0,3:
# - Durch den Impuls des Wellenpaketes ist der Energieerwartungswert bei
