hiro/master-thesis
1
0
Fork 0
mirror of https://github.com/vale981/master-thesis synced 2025-03-06 18:41:38 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
master-thesis/python/richard_hops/energy_flow_thermal.org

580 lines
17 KiB
Org Mode
Raw Normal View History

begin implementation general
2021-10-27 09:18:04 +02:00
#+PROPERTY: header-args :session therm_test :kernel python :pandoc t :async yes
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
* Setup
** Jupyter
#+begin_src jupyter-python
%load_ext autoreload
%autoreload 2
%load_ext jupyter_spaces
#+end_src
#+RESULTS:
** Matplotlib
#+begin_src jupyter-python
import matplotlib
import matplotlib.pyplot as plt
#matplotlib.use("TkCairo", force=True)
%gui tk
%matplotlib inline
plt.style.use('ggplot')
#+end_src
#+RESULTS:
** Richard (old) HOPS
#+begin_src jupyter-python
import hierarchyLib
import hierarchyData
import numpy as np
from stocproc.stocproc import StocProc_FFT
import bcf
from dataclasses import dataclass, field
import scipy
import scipy.misc
import scipy.signal
import pickle
from scipy.special import gamma as gamma_func
from scipy.optimize import curve_fit
#+end_src
#+RESULTS:
** Auxiliary Definitions
#+begin_src jupyter-python
σ1 = np.matrix([[0,1],[1,0]])
σ2 = np.matrix([[0,-1j],[1j,0]])
σ3 = np.matrix([[1,0],[0,-1]])
#+end_src
#+RESULTS:
* Model Setup
Basic parameters.
#+begin_src jupyter-python
class params:
T = 2.09
run on remote kernel
2021-10-26 13:44:18 +02:00
t_max = 15
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
t_steps = int(t_max * 1/.01)
k_max = 3
begin implementation general
2021-10-27 09:18:04 +02:00
N = 1
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
seed = 100
dim = 2
H_s = σ3 + np.eye(dim)
L = 1 / 2 * (σ1 - 1j * σ2)
ψ_0 = np.array([1, 0])
s = 1
num_exp_t = 5
wc = 1
with open("good_fit_data_abs_brute_force", "rb") as f:
good_fit_data_abs = pickle.load(f)
alpha = 0.8
# _, g_tilde, w_tilde = good_fit_data_abs[(numExpFit, s)]
# g_tilde = np.array(g_tilde)
# w_tilde = np.array(w_tilde)
# g = 1 / np.pi * gamma_func(s + 1) * wc ** (s + 1) * np.asarray(g_tilde)
# w = wc * np.asarray(w_tilde)
bcf_scale = np.pi / 2 * alpha * wc ** (1 - s)
#+end_src
#+RESULTS:
** BCF and Thermal BCF
#+begin_src jupyter-python
@dataclass
class CauchyBCF:
δ: float
wc: float
def I(self, ω):
return np.sqrt(self.δ) / (self.δ + (ω - self.wc) ** 2 / self.δ)
def __call__(self, τ):
return np.sqrt(self.δ) * np.exp(-1j * self.wc * τ - np.abs(τ) * self.δ)
def __bfkey__(self):
return self.δ, self.wc
α = bcf.OBCF(s=params.s, eta=1, gamma=params.wc)
I = bcf.OSD(s=params.s, eta=1, gamma=params.wc)
#+end_src
#+RESULTS:
*** Fit
We now fit a sum of exponentials against the BCF.
#+begin_src jupyter-python
from lmfit import minimize, Parameters
def α_apprx(τ, g, w):
return np.sum(
g[np.newaxis, :] * np.exp(-w[np.newaxis, :] * (τ[:, np.newaxis])), axis=1
)
def _fit():
def residual(fit_params, x, data):
resid = 0
w = np.array([fit_params[f"w{i}"] for i in range(params.num_exp_t)]) + 1j * np.array(
[fit_params[f"wi{i}"] for i in range(params.num_exp_t)]
)
g = np.array([fit_params[f"g{i}"] for i in range(params.num_exp_t)]) + 1j * np.array(
[fit_params[f"gi{i}"] for i in range(params.num_exp_t)]
)
resid = data - α_apprx(x, g, w)
return resid.view(float)
fit_params = Parameters()
for i in range(params.num_exp_t):
fit_params.add(f"g{i}", value=.1)
fit_params.add(f"gi{i}", value=.1)
fit_params.add(f"w{i}", value=.1)
fit_params.add(f"wi{i}", value=.1)
ts = np.linspace(0, params.t_max, 1000)
out = minimize(residual, fit_params, args=(ts, α(ts)))
w = np.array([out.params[f"w{i}"] for i in range(params.num_exp_t)]) + 1j * np.array(
[out.params[f"wi{i}"] for i in range(params.num_exp_t)]
)
g = np.array([out.params[f"g{i}"] for i in range(params.num_exp_t)]) + 1j * np.array(
[out.params[f"gi{i}"] for i in range(params.num_exp_t)]
)
return w, g
w, g = _fit()
#+end_src
#+RESULTS:
*** Plot
Let's look a the result.
#+begin_src jupyter-python
class bcfplt:
t = np.linspace(0, params.t_max, 1000)
ω = np.linspace(params.wc - 10, params.wc + 10, 1000)
fig, axs = plt.subplots(2)
axs[0].plot(t, np.real(α(t)))
axs[0].plot(t, np.imag(α(t)))
axs[0].plot(t, np.real(α_apprx(t, g, w)))
axs[0].plot(t, np.imag(α_apprx(t, g, w)))
axs[1].plot(ω, I(ω).real)
axs[1].plot(ω, I(ω).imag)
#+end_src
#+RESULTS:
run on remote kernel
2021-10-26 13:44:18 +02:00
[[file:./.ob-jupyter/40ecf4ea5d24df75d9b11c003d6735ca0955683f.png]]
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
Seems ok for now.
** Hops setup
#+begin_src jupyter-python
HierachyParam = hierarchyData.HiP(
k_max=params.k_max,
# g_scale=None,
# sample_method='random',
seed=params.seed,
nonlinear=True,
normalized=False,
# terminator=False,
result_type=hierarchyData.RESULT_TYPE_ALL,
# accum_only=None,
# rand_skip=None
)
#+end_src
#+RESULTS:
Integration.
#+begin_src jupyter-python
IntegrationParam = hierarchyData.IntP(
t_max=params.t_max,
t_steps=params.t_steps,
# integrator_name='zvode',
# atol=1e-8,
# rtol=1e-8,
# order=5,
# nsteps=5000,
# method='bdf',
# t_steps_skip=1
)
#+end_src
#+RESULTS:
And now the system.
#+begin_src jupyter-python
SystemParam = hierarchyData.SysP(
H_sys=params.H_s,
L=params.L,
psi0=params.ψ_0, # excited qubit
g=np.array(g),
w=np.array(w),
H_dynamic=[],
bcf_scale=params.bcf_scale, # some coupling strength (scaling of the fit parameters 'g_i')
gw_hash=None, # this is used to load g,w from some database
len_gw=len(g),
)
#+end_src
#+RESULTS:
The quantum noise.
#+begin_src jupyter-python
Eta = StocProc_FFT(
I,
params.t_max,
α,
negative_frequencies=False,
seed=params.seed,
intgr_tol=1e-2,
intpl_tol=1e-2,
scale=params.bcf_scale,
)
#+end_src
#+RESULTS:
#+begin_example
stocproc.stocproc - INFO - non neg freq only
stocproc.method_ft - INFO - get_dt_for_accurate_interpolation, please wait ...
stocproc.method_ft - INFO - acc interp N 33 dt 6.22e-01 -> diff 1.50e-01
stocproc.method_ft - INFO - acc interp N 65 dt 3.11e-01 -> diff 3.37e-02
stocproc.method_ft - INFO - acc interp N 129 dt 1.55e-01 -> diff 7.11e-03
stocproc.method_ft - INFO - requires dt < 1.555e-01
stocproc.method_ft - INFO - get_N_a_b_for_accurate_fourier_integral, please wait ...
stocproc.method_ft - INFO - J_w_min:1.00e-02 N 32 yields: interval [0.00e+00,6.47e+00] diff 9.83e-03
stocproc.method_ft - INFO - return, cause tol of 0.01 was reached
stocproc.method_ft - INFO - requires dx < 2.023e-01
stocproc.stocproc - INFO - Fourier Integral Boundaries: [0.000e+00, 4.575e+01]
stocproc.stocproc - INFO - Number of Nodes : 256
stocproc.stocproc - INFO - yields dx : 1.787e-01
stocproc.stocproc - INFO - yields dt : 1.373e-01
stocproc.stocproc - INFO - yields t_max : 3.502e+01
#+end_example
The sample trajectories are smooth.
#+begin_src jupyter-python
%%space plot
ts = np.linspace(0, params.t_max, 1000)
Eta.new_process()
plt.plot(ts, Eta(ts).real)
#+end_src
#+RESULTS:
:RESULTS:
begin implementation general
2021-10-27 09:18:04 +02:00
| <matplotlib.lines.Line2D | at | 0x7f163532b610> |
run on remote kernel
2021-10-26 13:44:18 +02:00
[[file:./.ob-jupyter/46ad00a9cdeed60b738ebddfcd4235d85a2fc83a.png]]
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
:END:
And now the thermal noise.
#+begin_src jupyter-python
EtaTherm = StocProc_FFT(
spectral_density=bcf.OFTDens(s=params.s, eta=1, gamma=params.wc, beta=1 / params.T),
t_max=params.t_max,
alpha=bcf.OFTCorr(s=params.s, eta=1, gamma=params.wc, beta=1 / params.T),
intgr_tol=1e-3,
intpl_tol=1e-3,
seed=params.seed,
negative_frequencies=False,
scale=params.bcf_scale,
)
#+end_src
#+RESULTS:
#+begin_example
stocproc.stocproc - INFO - non neg freq only
stocproc.method_ft - INFO - get_dt_for_accurate_interpolation, please wait ...
run on remote kernel
2021-10-26 13:44:18 +02:00
stocproc.method_ft - INFO - acc interp N 33 dt 9.38e-01 -> diff 6.66e-02
stocproc.method_ft - INFO - acc interp N 65 dt 4.69e-01 -> diff 1.51e-02
stocproc.method_ft - INFO - acc interp N 129 dt 2.34e-01 -> diff 3.27e-03
stocproc.method_ft - INFO - acc interp N 257 dt 1.17e-01 -> diff 7.84e-04
stocproc.method_ft - INFO - requires dt < 1.172e-01
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
stocproc.method_ft - INFO - get_N_a_b_for_accurate_fourier_integral, please wait ...
run on remote kernel
2021-10-26 13:44:18 +02:00
stocproc.method_ft - INFO - J_w_min:1.00e-02 N 32 yields: interval [0.00e+00,4.18e+00] diff 2.13e-02
stocproc.method_ft - INFO - J_w_min:1.00e-03 N 32 yields: interval [0.00e+00,5.92e+00] diff 5.64e-02
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
stocproc.method_ft - INFO - J_w_min:1.00e-02 N 64 yields: interval [0.00e+00,4.18e+00] diff 8.00e-03
run on remote kernel
2021-10-26 13:44:18 +02:00
stocproc.method_ft - INFO - J_w_min:1.00e-04 N 32 yields: interval [0.00e+00,7.62e+00] diff 9.04e-02
stocproc.method_ft - INFO - J_w_min:1.00e-03 N 64 yields: interval [0.00e+00,5.92e+00] diff 1.17e-02
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
stocproc.method_ft - INFO - J_w_min:1.00e-02 N 128 yields: interval [0.00e+00,4.18e+00] diff 7.66e-03
run on remote kernel
2021-10-26 13:44:18 +02:00
stocproc.method_ft - INFO - J_w_min:1.00e-05 N 32 yields: interval [0.00e+00,9.30e+00] diff 1.10e-01
stocproc.method_ft - INFO - J_w_min:1.00e-04 N 64 yields: interval [0.00e+00,7.62e+00] diff 2.02e-02
stocproc.method_ft - INFO - J_w_min:1.00e-03 N 128 yields: interval [0.00e+00,5.92e+00] diff 2.75e-03
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
stocproc.method_ft - INFO - J_w_min:1.00e-02 N 256 yields: interval [0.00e+00,4.18e+00] diff 7.57e-03
stocproc.method_ft - INFO - increasing N while shrinking the interval does lower the error -> try next level
stocproc.method_ft - INFO - J_w_min:1.00e-06 N 32 yields: interval [0.00e+00,1.10e+01] diff 1.30e-01
run on remote kernel
2021-10-26 13:44:18 +02:00
stocproc.method_ft - INFO - J_w_min:1.00e-05 N 64 yields: interval [0.00e+00,9.30e+00] diff 3.16e-02
stocproc.method_ft - INFO - J_w_min:1.00e-04 N 128 yields: interval [0.00e+00,7.62e+00] diff 4.70e-03
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
stocproc.method_ft - INFO - J_w_min:1.00e-03 N 256 yields: interval [0.00e+00,5.92e+00] diff 7.99e-04
stocproc.method_ft - INFO - return, cause tol of 0.001 was reached
stocproc.method_ft - INFO - requires dx < 2.311e-02
run on remote kernel
2021-10-26 13:44:18 +02:00
stocproc.stocproc - INFO - Fourier Integral Boundaries: [0.000e+00, 7.124e+01]
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
stocproc.stocproc - INFO - Number of Nodes : 4096
run on remote kernel
2021-10-26 13:44:18 +02:00
stocproc.stocproc - INFO - yields dx : 1.739e-02
stocproc.stocproc - INFO - yields dt : 8.820e-02
stocproc.stocproc - INFO - yields t_max : 3.612e+02
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
#+end_example
The sample trajectories are smooth too.
#+begin_src jupyter-python
%%space plot
ts = np.linspace(0, params.t_max, 1000)
EtaTherm.new_process()
plt.plot(ts, EtaTherm(ts).real)
#+end_src
#+RESULTS:
:RESULTS:
begin implementation general
2021-10-27 09:18:04 +02:00
| <matplotlib.lines.Line2D | at | 0x7f164b0c3f10> |
run on remote kernel
2021-10-26 13:44:18 +02:00
[[file:./.ob-jupyter/f245ae911955352536a0cc5c7719cca75d6c8fc8.png]]
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
:END:
* Actual Hops
Generate the key for binary caching.
#+begin_src jupyter-python
hi_key = hierarchyData.HIMetaKey_type(
HiP=HierachyParam,
IntP=IntegrationParam,
SysP=SystemParam,
Eta=Eta,
begin implementation general
2021-10-27 09:18:04 +02:00
EtaTherm=EtaTherm,
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
)
#+end_src
#+RESULTS:
Initialize Hierarchy.
#+begin_src jupyter-python
myHierarchy = hierarchyLib.HI(hi_key, number_of_samples=params.N, desc="calculate the heat flow")
#+end_src
#+RESULTS:
run on remote kernel
2021-10-26 13:44:18 +02:00
: init Hi class, use 112 equation
begin implementation general
2021-10-27 09:18:04 +02:00
: /home/hiro/Documents/Projects/UNI/master/masterarb/python/richard_hops/hierarchyLib.py:1057: UserWarning: sum_k_max is not implemented! DO SO BEFORE NEXT USAGE (use simplex).HierarchyParametersType does not yet know about sum_k_max
: warnings.warn(
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
Run the integration.
#+begin_src jupyter-python
begin implementation general
2021-10-27 09:18:04 +02:00
myHierarchy.integrate_simple(data_name="energy_flow_therm_new_again.data")
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
#+end_src
#+RESULTS:
begin implementation general
2021-10-27 09:18:04 +02:00
: samples :0.0%
: integration :0.0%
: samples : 100%
: integration :0.0%
yay, eta_dot works
2021-10-26 15:56:23 +02:00
: 
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
Get the samples.
#+BEGIN_SRC jupyter-python
# to access the data the 'hi_key' is used to find the data in the hdf5 file
class int_result:
with hierarchyData.HIMetaData(
begin implementation general
2021-10-27 09:18:04 +02:00
hid_name="energy_flow_therm_new_again.data", hid_path="."
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
) as metaData:
with metaData.get_HIData(hi_key, read_only=True) as data:
smp = data.get_samples()
print("{} samples found in database".format(smp))
τ = data.get_time()
rho_τ = data.get_rho_t()
s_proc = np.array(data.stoc_proc)
states = np.array(data.aux_states).copy()
ψ_1 = np.array(data.aux_states)[:, :, 0 : params.num_exp_t * params.dim]
ψ_0 = np.array(data.stoc_traj)
y = np.array(data.y)
η = np.array(data.stoc_proc)
begin implementation general
2021-10-27 09:18:04 +02:00
temp_y = np.array(data.temp_y)
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
#+end_src
#+RESULTS:
begin implementation general
2021-10-27 09:18:04 +02:00
: 1 samples found in database
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
Calculate energy.
#+begin_src jupyter-python
%matplotlib inline
energy = np.array([np.trace(ρ @ params.H_s).real for ρ in int_result.rho_τ])
plt.plot(int_result.τ, energy)
#+end_src
#+RESULTS:
:RESULTS:
begin implementation general
2021-10-27 09:18:04 +02:00
| <matplotlib.lines.Line2D | at | 0x7f164aead1c0> |
[[file:./.ob-jupyter/a2561c9e3e0b28bd94d0c69b7a897d35381b7d90.png]]
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
:END:
* Energy Flow
:PROPERTIES:
yay, eta_dot works
2021-10-26 15:56:23 +02:00
:ID: 9ce93da8-d323-40ec-96a2-42ba184dc963
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
:END:
#+begin_src jupyter-python
int_result.ψ_1.shape
#+end_src
#+RESULTS:
begin implementation general
2021-10-27 09:18:04 +02:00
| 10 | 1500 | 10 |
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
Let's look at the norm.
#+begin_src jupyter-python
plt.plot(int_result.τ, (int_result.ψ_0[0].conj() * int_result.ψ_0[0]).sum(axis=1).real)
#+end_src
#+RESULTS:
:RESULTS:
begin implementation general
2021-10-27 09:18:04 +02:00
| <matplotlib.lines.Line2D | at | 0x7f164aea1730> |
[[file:./.ob-jupyter/0846a4769d06b7edae316fc359128aded9c43a73.png]]
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
:END:
And try to calculate the energy flow.
#+begin_src jupyter-python
begin implementation general
2021-10-27 09:18:04 +02:00
def flow_for_traj(ψ_0, ψ_1, temp_y):
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
a = np.array((params.L @ ψ_0.T).T)
begin implementation general
2021-10-27 09:18:04 +02:00
EtaTherm.new_process(temp_y)
η_dot = scipy.misc.derivative(EtaTherm, int_result.τ, dx=1e-5, order=5)
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
ψ_1 = (-w * g * params.bcf_scale)[None, :, None] * ψ_1.reshape(
params.t_steps, params.num_exp_t, params.dim
)
# return np.array(np.sum(ψ_0.conj() * ψ_0, axis=1)).flatten().real
return np.array(
2
,* (
1j
begin implementation general
2021-10-27 09:18:04 +02:00
,* (
np.sum(a.conj()[:, None, :] * ψ_1, axis=(1, 2))
+ np.sum(a.conj() * ψ_0, axis=1) * η_dot
)
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
/ np.sum(ψ_0.conj() * ψ_0, axis=1)
).real
).flatten()
#+end_src
#+RESULTS:
Now we calculate the average over all trajectories.
#+begin_src jupyter-python
class Flow:
j = np.zeros_like(int_result.τ)
for i in range(0, params.N):
begin implementation general
2021-10-27 09:18:04 +02:00
j += flow_for_traj(int_result.ψ_0[i], int_result.ψ_1[i], int_result.temp_y[i])
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
j /= params.N
#+end_src
#+RESULTS:
yay, eta_dot works
2021-10-26 15:56:23 +02:00
And plot it :).
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
#+begin_src jupyter-python
%matplotlib inline
plt.plot(int_result.τ, Flow.j)
plt.show()
#+end_src
#+RESULTS:
begin implementation general
2021-10-27 09:18:04 +02:00
[[file:./.ob-jupyter/14e62ac9961e98b075c7ded1a397b65a9fc9ad20.png]]
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
Let's calculate the integrated energy.
#+begin_src jupyter-python
E_t = np.array(
[0]
+ [
scipy.integrate.simpson(Flow.j[0:n], int_result.τ[0:n])
for n in range(1, len(int_result.τ))
]
)
print(E_t[-1])
E_t = E_t / E_t[-1] * 2
#+end_src
#+RESULTS:
run on remote kernel
2021-10-26 13:44:18 +02:00
: 1.9601462799140077
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
With this we can retrieve the energy of the interaction Hamiltonian.
#+begin_src jupyter-python
E_I = 2 - energy - E_t
#+end_src
#+RESULTS:
#+begin_src jupyter-python
%%space plot
plt.rcParams['figure.figsize'] = [15, 10]
#plt.plot(τ, j, label="$J$", linestyle='--')
plt.plot(int_result.τ, E_t, label=r"$\langle H_{\mathrm{B}}\rangle$")
plt.plot(int_result.τ, E_I, label=r"$\langle H_{\mathrm{I}}\rangle$")
plt.plot(int_result.τ, energy, label=r"$\langle H_{\mathrm{S}}\rangle$")
plt.xlabel("τ")
plt.legend()
plt.show()
#+end_src
#+RESULTS:
:RESULTS:
yay, eta_dot works
2021-10-26 15:56:23 +02:00
| <matplotlib.lines.Line2D | at | 0x7f7645cf2250> |
| <matplotlib.lines.Line2D | at | 0x7f7645cf2640> |
| <matplotlib.lines.Line2D | at | 0x7f7645cf2a00> |
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
: Text(0.5, 0, 'τ')
yay, eta_dot works
2021-10-26 15:56:23 +02:00
: <matplotlib.legend.Legend at 0x7f7645cf2d30>
run on remote kernel
2021-10-26 13:44:18 +02:00
[[file:./.ob-jupyter/b7b76964cd8898f39b360a5b07df2c04cbcc5712.png]]
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
:END:
* System + Interaction Energy
#+begin_src jupyter-python
def h_si_for_traj(ψ_0, ψ_1):
a = np.array((params.L @ ψ_0.T).T)
b = np.array((params.H_s @ ψ_0.T).T)
ψ_1 = (g*params.bcf_scale)[None, :, None] * ψ_1.reshape(
params.t_steps, params.num_exp_t, params.dim
)
E_i = np.array(
2
,* (
-1j
,* np.sum(
a.conj()[:, None, :]
,* ψ_1,
axis=(1, 2),
)
).real
).flatten()
E_s = np.array(np.sum(b.conj() * ψ_0, axis=1)).flatten().real
return (E_i + E_s) / np.sum(ψ_0.conj() * ψ_0, axis=1).real
#+end_src
#+RESULTS:
#+begin_src jupyter-python
e_si = np.zeros_like(int_result.τ)
for i in range(0, params.N):
e_si += h_si_for_traj(int_result.ψ_0[i], int_result.ψ_1[i])
e_si /= params.N
#+end_src
#+RESULTS:
Not too bad...
#+begin_src jupyter-python
yay, eta_dot works
2021-10-26 15:56:23 +02:00
plt.plot(int_result.τ, e_si, label=r"with $\psi^{1}$")
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
plt.plot(int_result.τ, E_I + energy)
plt.legend()
#+end_src
#+RESULTS:
:RESULTS:
yay, eta_dot works
2021-10-26 15:56:23 +02:00
: <matplotlib.legend.Legend at 0x7f7645b895e0>
[[file:./.ob-jupyter/1af5beb3e18a401e7585654f6937523b307c2d0a.png]]
generalize to multiple exponentials
2021-10-26 11:42:16 +02:00
:END:
Reference in a new issue Copy permalink