Esempio n. 1
0
def R4g():
    """
    
    """
    A = Ugde(b, t1 + t2 + t3) * Uedg(b, t1 + t2) * Ugde(a, t1)

    return evaluate_cumulant(A)
Esempio n. 2
0
def R2fs():
    """
    
    """
    A = (Ugde(b, t1) * Uedg(b, t1 + t2 + t3) * Ugde(f, t1 + t2 + t3) *
         Uedg(f, t1 + t2) * Ugde(a, t1 + t2))

    return evaluate_cumulant(A)
Esempio n. 3
0
def print_R2fst():
    """
    
    """
    A = Uedg(b, t3) * Ugde(f, t3)
    print(evaluate_cumulant(A))

    B = Ugde(a, t1)
    print(evaluate_cumulant(B))
Esempio n. 4
0
def print_trans_R2g():
    """

    """
    A = (Uedg(a, t1 + tau) * Ugde(b, t1 + tau) * Uedg(b, t1 + t2) *
         Ugde(b, t1 + t2 + t3) * Uedg(b, t1 + tau) * Ugde(a, t1 + tau) *
         Uedg(a, t1))

    print(evaluate_cumulant(A))
Esempio n. 5
0
def print_R1gt():
    """
    
    """
    A = Ugde(b, t3)
    print(evaluate_cumulant(A))

    B = Ugde(a, t1)
    print(evaluate_cumulant(B))
Esempio n. 6
0
def R4g():
    """
    
    """
    A = Ugde(b, t1 + t2 + t3) * Uedg(b, t1 + t2) * Ugde(a, t1)

    return evaluate_cumulant(A,
                             positive_times=(t1, t2, t3),
                             leading_index=a,
                             arrays=["gg"])
Esempio n. 7
0
def print_trans_R2g():
    """

    """
    A = (Uedg(a, t1 + tau) * Ugde(b, t1 + tau) * Uedg(b, t1 + t2) *
         Ugde(b, t1 + t2 + t3) * Uedg(b, t1 + tau) * Ugde(a, t1 + tau) *
         Uedg(a, t1))

    print(
        evaluate_cumulant(A,
                          positive_times=(t1, t2, t3),
                          leading_index=a,
                          arrays=["gg"]))
Esempio n. 8
0
def print_R2fst():
    """
    
    """
    A = Uedg(b, t3) * Ugde(f, t3)
    print(
        evaluate_cumulant(A,
                          positive_times=(t1, t2, t3),
                          leading_index=a,
                          arrays=["gg"]))

    B = Ugde(a, t1)
    print(
        evaluate_cumulant(B,
                          positive_times=(t1, t2, t3),
                          leading_index=a,
                          arrays=["gg"]))
Esempio n. 9
0
def oneex_twoex():

    A = Uedg(f, t1) * Ugde(a, t1)

    print(
        evaluate_cumulant(A,
                          positive_times=(t1, ),
                          leading_index=a,
                          arrays="gg"))
Esempio n. 10
0
def test():

    A = Uged(a, t1 + t2) * Ugde(d, t3) * Uegd(a, t2)

    print(
        evaluate_cumulant(A,
                          positive_times=(t1, t2, t3),
                          leading_index=a,
                          arrays=["gg"]))
Esempio n. 11
0
def generate_nth_order_R2g(states_tuple, times_tuple):

    order = len(states_tuple)
    if order != len(times_tuple):
        raise Exception("Wrong tuple/list length")

    # starting state
    a = states_tuple[0]
    # final state (can be the same as starting)
    b = states_tuple[len(states_tuple) - 1]

    # final time (must be t2)
    tt = times_tuple[len(times_tuple) - 1]

    AL = Uged(a, t1)
    Amid = Uedg(b, tt) * Ugde(b, t3 + tt)

    filL = 1
    filR = 1

    for k in range(len(times_tuple) - 1):
        tau = times_tuple[k]
        s1 = states_tuple[k]
        s2 = states_tuple[k + 1]
        filL = filL * Uedg(s1, tau) * Ugde(s2, tau)
        filR = Uedg(s2, tau) * Ugde(s1, tau) * filR

    A = AL * filL * Amid * filR

    print(A)

    print(
        evaluate_cumulant(A,
                          positive_times=(t1, tt, t3),
                          leading_index=a,
                          arrays=["gg"]))
Esempio n. 12
0
def print_trans_R2g_alt2():
    """

    """
    #A = (Uedg(a,t1+tau)*Ugde(b,t1+tau)*Uedg(b,t1+t2)*Ugde(b,t1+t2+t3)
    #    *Uedg(b,t1+tau)*Ugde(a,t1+tau)*Uedg(a,t1))

    #A = (Uged(a,t1)*Uedg(a,tau1)*Ugde(b,tau1)*Uedg(b,t2)*Ugde(b,t2+t3)*Uedg(b,tau1)*Ugde(a,tau1))

    A = (Uged(a, t1 + tau1) * Uedg(b, t2 - tau1) * Ugde(b, t2 + t3 - tau1) *
         Uegd(a, tau1))

    print(
        evaluate_cumulant(A,
                          positive_times=(t1, t2, t3),
                          leading_index=a,
                          arrays=["gg"]))
Esempio n. 13
0
    
    = Uged(e,T)*Uedg(a,t)*Ugde(b,t)*Uedg(c,t-tau)*Ugde(d,t-tau)*Uegd(d,T)

"""

m = Symbol('m')
n = Symbol('n')
t1 = Symbol('t1')
k = Symbol('k')
k1 = Symbol('k1')

#A = Uged(n,T)*Uedg(n,tau)*ExpdV(a,tau,x)*Ugde(m,tau)*ExpdV(b,0,y)*Uegd(n,T)
#A = Uged(b,T)*ExpdV(n,0,x)*Uegd(a,tau)*ExpdV(m,-tau,y)*Uged(b,tau)*Uegd(b,T)

#A = Uedg(b,t)*ExpdV(m,0,x)*Ugde(a,t)*Uedg(a,tau)*ExpdV(n,0,y)*Ugde(b,tau)
A = Uedg(b,t)*ExpdV(m,t,x)*Ugde(a,t)*Uedg(a,tau)*ExpdV(n,tau,y)*Ugde(b,tau)
#A = Uedg(b,t)*             Ugde(a,t-tau)*             Ugde(b,tau)

#A = Uedg(b,tau)*ExpdV(m,tau,x)*Ugde(a,tau)*Uedg(a,0)*ExpdV(n,0,y)*Ugde(a,0)
#A = Uedg(b,t)*ExpdV(m,t,x)*Ugde(a,t)*Uedg(a,tau)*ExpdV(n,tau,y)*Ugde(a,tau)

Anorm = Uged(n,T)*Uegd(n,T)  

verbatim = True

if verbatim:
    print(" ")
    print("Expression to evaluate: ")
    print(" ")
    print("    Tr_bath{",A,"W_eq}")
    print(" ")
Esempio n. 14
0
#A = Uedg(b,t)*ExpdV(m,0,x)*Ugde(a,t)*Uedg(a,tau)*ExpdV(n,0,y)*Ugde(b,tau)
#A = Uedg(b,t)*ExpdV(m,t,x)*Ugde(a,t)*Uedg(a,tau)*ExpdV(n,tau,y)*Ugde(b,tau)
#A = Uedg(b,t)*             Ugde(a,t-tau)*             Ugde(b,tau)

#A = Uedg(b,tau)*ExpdV(m,tau,x)*Ugde(a,tau)*Uedg(a,0)*ExpdV(n,0,y)*Ugde(a,0)
#A = Uedg(b,t)*ExpdV(m,t,x)*Ugde(a,t)*Uedg(a,tau)*ExpdV(n,tau,y)*Ugde(a,tau)

#A = Uged(e,T)*Uedg(a,t)*Ugde(b,t)*Uedg(c,t-tau)*Ugde(d,t-tau)*Uegd(d,T)


""" Parts of the relaxation tensor """
part = "test3"

""" M1 K """
if part == "M1_K":
    A = Uged(b,T)*Uedg(b,t)*ExpdV(m,t,x)*Ugde(a,t)*Uedg(a,t-tau)\
    *ExpdV(n,t-tau,y)*Ugde(b,t-tau)*Uegd(b,T)

    use_norm = False
    Anorm = Uged(n,T)*Uegd(n,T)  
    nderiv = 2

    filename = "m1_K.txt"

elif part == "M1_H":
    
    pass


elif part == "K_bk":
    
Esempio n. 15
0
    = <\Psi_g|Dagger(U_e(T))Dagger(U_a(t))<a|dV|b>U_b(t)Dagger(U_c(t-tau))
      <c|dV|d>U_d(t-tau)U_d(T)|\Psi_g>
      
    = <\Psi_g|[U_g(T)Dagger(U_e(T))][Dagger(U_a(t))U_g(t)][Dagger(U_g(t)U_b(t)]
    x [Dagger(U_c(t-tau))U_g(t-tau)][Dagger(U_g(t-tau)U_d(t-tau)]
    x [U_d(T)Dagger(U_g(T))]|\Psi_g>
    
    = Uged(e,T)*Uedg(a,t)*Ugde(b,t)*Uedg(c,t-tau)*Ugde(d,t-tau)*Uegd(d,T)

"""

m = Symbol('m')
n = Symbol('n')
t1 = Symbol('t1')

A = Uged(n, T) * Uedg(n, tau) * ExpdV(a, tau, x) * Ugde(m, tau) * ExpdV(
    b, 0, y) * Uegd(n, T)
A = Uged(b, T) * ExpdV(n, 0, x) * Uegd(a, tau) * ExpdV(m, -tau, y) * Uged(
    b, tau) * Uegd(b, T)

Anorm = Uged(n, T) * Uegd(n, T)

verbatim = True

if verbatim:
    print(" ")
    print("Expression to evaluate: ")
    print(" ")
    print("    Tr_bath{", A, "W_eq}")
    print(" ")
    print("The expression is normalized by:")
Esempio n. 16
0
    <a|H(t)|b><c|W|d>
    
    = J_ac*<\Psi_d|Dagger(U_a(t))*U_b(t)|\Psi_c>/Norm
    = J_ac*<\Psi_g|U_g(T)Dagger(U_d(T))Dagger(U_a(t))U_g(t)
     x Dagger(U_g(t))U_b(t)U_c(T)Dagger(U_g(T))|\Psi_g>/Norm
    = J_ac*<\Psi_g|[U_g(T)Dagger(U_d(T))][Dagger(U_a(t))U_g(t)]
     x [Dagger(U_g(t))U_b(t)][U_c(T)Dagger(U_g(T))]|\Psi_g>
     x Norm^-1

    => Uged(d,T)*Uedg(a,t)*Ugde(b,t)*Uegd(c,T)*(1/Norm)
    
    Norm = Uged(d,T)*Uegd(c,T)
        
    
"""
A     = Uged(d,T) *Uedg(a,t)*Ugde(b,t)* Uegd(c,T)

Anorm = Uged(d,T)*Uegd(c,T)


verbatim = False
if verbatim:
    print(" ")
    print("Expression to evaluate: ")
    print(" ")
    print("Tr_bath{",A,"W_eq}")
    print(" ")
    print(" ")


A = A.rewrite(gg)
Esempio n. 17
0
    <a|H(t)|b><c|H(t-tau)|d><d|W|e>
    
    = <\Psi_e|<a|H(t)|b><c|H(t-tau)|d>|\Psi_d>
    = <\Psi_g|Dagger(U_e(T))Dagger(U_a(t))U_b(t)Dagger(U_c(t-tau))U_d(t-tau)
      x U_d(T)|\Psi_g>
      
    = <\Psi_g|[U_g(T)Dagger(U_e(T))][Dagger(U_a(t))U_g(t)][Dagger(U_g(t)U_b(t)]
    x [Dagger(U_c(t-tau))U_g(t-tau)][Dagger(U_g(t-tau)U_d(t-tau)]
    x [U_d(T)Dagger(U_g(T))]|\Psi_g>
    
    = Uged(e,T)*Uedg(a,t)*Ugde(b,t)*Uedg(c,t-tau)*Ugde(d,t-tau)*Uegd(d,T)

"""

A = Uged(e, T) * Uedg(a, t) * Ugde(b, t) * Uedg(c, t - tau) * Ugde(
    d, t - tau) * Uegd(d, T)
Anorm = Uged(e, T) * Uegd(d, T)

verbatim = True

if verbatim:
    print(" ")
    print("Expression to evaluate: ")
    print(" ")
    print("    Tr_bath{", A, "W_eq}")
    print(" ")
    print("The expression is normalized by:")
    print(" ")
    print("    Tr_bath{", Anorm, "W_eq}")
    print(" ")