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()
# 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)
# 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__
plt.show()
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
# Auftretende Bewegungen:
# - Bei einem Start im Minimum befinden sich Beitraege zur Wellenfunktion
