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 koeff(V, A, hbar, N, xmin, xmax, wellenpaket, x0, dx, p0):
x_i = diskretisierung(xmin, xmax, N)
phi_0 = wellenpaket(x_i, x0, dx, hbar, p0)
ew, ef = diagonalisierung(hbar, x_i, V(x_i, A))
c = np.abs(x_i[0] - x_i[1]) * np.dot(np.conjugate(np.transpose(ef)), phi_0)
phi_tilde = np.dot(ef, c)
#dp = (np.abs(x_i[0]-x_i[1])*np.sum(np.abs(phi0-phi_tilde)**2))**0.5
return ew, ef, c, phi_tilde, x_i
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()
ydata=(abs(phi_t**2)*scale) + energy)
plt.draw()
# Parameterdeklarationen
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__
L = 1.2 # Intervall der x-Werte [-L, L]
N = 200 # Anzahl der x-Werte
skal = 0.01 # Skalierung der Eigenvektor-Plots
delta_x = 0.1 # Ortsunschaerfe des gaussschen Wellenpaketes
p0 = 0.0 # Impuls des Wellenpaketes
t_max = 10 # Maximaler Zeitpunkt
t_schritte = t_max * 15 # Anzahl der Zeitschritte
# -- Hauptprogramm --
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
