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