Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
documentation:language_reference:objects:responsefunction:start [2024/12/17 16:32] – Maurits W. Haverkortdocumentation:language_reference:objects:responsefunction:start [2024/12/20 17:07] (current) – Maurits W. Haverkort
Line 2: Line 2:
 ====== Response function ====== ====== Response function ======
  
-The ResponseFunction object in Quanty defines (linear) response functions. For Hamiltonian $H$, ground-state $| \psi_0 \rangle$ and transition operator $T$ we define the response function $G(\omega,\Gamma)$ as+### 
 + 
 +The ResponseFunction object in Quanty defines (linear) response functions. For Hamiltonian $H$, ground-state $| \psi_0 \rangle$ and a list of transition operators $T_i$ with $i \in [1,n]$ we define the response function $G(\omega,\Gamma)$ as giving an $n$ by $n$ matrix for each value of $\omega$ and $\Gamma$. The elements of this matrix are given as
 $$ $$
-G(\omega,\Gamma) = \left\langle \psi_0 \middle| T^{\dagger} \frac{1}{\omega - H + \mathrm{i} \Gamma/2 + E_0} T^{\phantom{\dagger}} \middle| \psi_0 \right\rangle.+G_{i,j}(\omega,\Gamma) = \left\langle \psi_0 \middle| T^{\dagger}_i \frac{1}{\omega - H + \mathrm{i} \Gamma/2 + E_0} T^{\phantom{\dagger}}_j \middle| \psi_0 \right\rangle,
 $$ $$
 +with $E_0 = \left\langle \psi_0 \middle| H \middle| \psi_0 \right\rangle$. One can calculate response functions using the Quanty function [[documentation:language_reference:functions:createspectra|CreateSpectra]]. This function returns two objects. At the first position a spectra object that contains the intensity for given values of $\omega$ and one specific value of $\Gamma$ on a grid. At the second position [[documentation:language_reference:functions:createspectra|CreateSpectra]] returns a ResponseFunction object.
  
-==== Definitions ==== +###
-<code Quanty Example.Quanty> +
--- Defining single-valued response functions+
  
-a = {0, -1,-0.5, 0,   0.5,  1,  1.5} 
-b = {  0.2, 0.1, 0.1, 0.1, 0.2, 0.3} 
-GA_L = {a,b,mu=0,type="ListOfPoles", name="A"} 
-setmetatable(GA_L, ResponseFunctionMeta) 
  
-a = {0, 1,   1,   1,   1,   1,  1} +###
-b = {   1, 0.5, 0.5, 0.5, 0.5, 0.5} +
-GB_T = {a,b,mu=0,type="Tri", name="B"} +
-setmetatable(GB_T, ResponseFunctionMeta)+
  
-a = {0, 1, 1.5,   2, 2.5,   3, 3.5} +ResponseFunctions are objects that can be evaluated at any frequency or imaginary offset. For example: 
-b = {   1, 0.5, 0.5, 0.5, 0.5, 0.5} +<code Quanty Example.Quanty> 
-GC_A = {a,b,mu=0,type="And", name="C"} +H   = Matrix.ToOperator( Matrix.Diagonal({1,2,3,4,5}) ) 
-setmetatable(GC_A, ResponseFunctionMeta)+psi = NewWavefunction(5,0,{{"00000",1}}) 
 +T = {} 
 +for i=0,4 do 
 +  T[i+1] = NewOperator(5,0,{{i,1}}) 
 +end 
 +S, G = CreateSpectra(H,T,psi) 
 +omega = 1.1 
 +gamma = 0.01 
 +print(G[1](omega,gamma)) 
 +</code> 
 +returns 
 +<file Quanty_Output> 
 +(9.9750623441396 - 0.49875311720698 I) 
 +</file> 
 +i.e. the value of the response function for the first transition operator defined at $\omega=1.1$ and $\Gamma=0.01$. 
  
-acon = {0,         1,   1,   1,   1,   1,  1} +###
-bcon = {   sqrt(1/2), 0.5, 0.5, 0.5, 0.5, 0.5} +
-Gcon = {acon,bcon,mu=0,type="Tri"} +
-setmetatable(Gcon, ResponseFunctionMeta) +
-aval = {0,        -1,  -1,  -1,  -1,  -1, -1} +
-bval = {   sqrt(1/2), 0.5, 0.5, 0.5, 0.5, 0.5} +
-Gval = {aval,bval,mu=0,type="Tri"} +
-setmetatable(Gval, ResponseFunctionMeta) +
-a0=0 +
-b0=1 +
-GD_N = {{a0,b0},val=Gval,con=Gcon,mu=0,type="Nat", name="D"} +
-setmetatable(GD_N, ResponseFunctionMeta)+
  
--- For a more efficient storage, one can convert from Table to Userdata +###
-GA_l = ResponseFunction.ToUserdata(GA_L) +
-GB_t = ResponseFunction.ToUserdata(GB_T) +
-GC_a = ResponseFunction.ToUserdata(GC_A) +
-GD_n = ResponseFunction.ToUserdata(GD_N)+
  
-print("GA_L:") +Besides single complex valued functions we can generate a response function that returns a matrix for each value of $\omega$. For example 
-print(GA_L) +<code Quanty Example.Quanty> 
-print("GA_l:") +H   = Matrix.ToOperator( Matrix.Diagonal({1,2,3,4,5}) ) 
-print(GA_l)+psi = NewWavefunction(5,0,{{"00000",1}}) 
 +T = {} 
 +for i=0,4 do 
 +  T[i+1] = NewOperator(5,0,{{i,1}}) 
 +end 
 +S, G = CreateSpectra(H,T,psi,{{"Tensor",true}}) 
 +omega = 1.1 
 +gamma = 0.01 
 +print(G(omega,gamma)) 
 +</code> 
 +returns 
 +<file Quanty_Output> 
 +{ { (9.9750623441396 - 0.49875311720698 I) , 0 , 0 , 0 , 0 } ,  
 +  { 0 , (-1.1110768186167 - 0.0061726489923151 I) , 0 , 0 , 0 } ,  
 +  { 0 , 0 , (-0.52631214465274 - 0.0013850319596125 I) , 0 , 0 } ,  
 +  { 0 , 0 , 0 , (-0.34482656115767 - 0.00059452855372011 I) , 0 } ,  
 +  { 0 , 0 , 0 , 0 , (-0.25640983496082 - 0.00032873055764208 I) } } 
 +</file> 
 +i.e. a 5 by 5 matrix with matrix elements $G_{i,j}(\omega,\gamma)$. (In this case the response function is diagonal as the Hamiltonian is diagonal. In general all elements can be non-zero.)
  
-print("GB_T:") +###
-print(GB_T) +
-print("GB_t:") +
-print(GB_t)+
  
-print("GC_A:") +###
-print(GC_A) +
-print("GC_a:") +
-print(GC_a)+
  
-print("GD_N:") +Response functions can be added, subtracted, scaled and many other functions are available to modify them. Response functions can be used to calculate self energies of systems and used for diagrammatic expansions of problems otherwise to involved to solve.
-print(GD_N) +
-print("GD_n:") +
-print(GD_n)+
  
--- response functions in Quanty are functions that, given  +###
--- a complex number as input w + I gamma/2 return a complex +
--- number (single valued functions) or a matrix (matrix functions) +
-omega = 0.764 +
-gamma = 0.1 +
-print("omega = ", omega) +
-print("gamma = ", gamma)+
  
-print("") +###
-print("GA_L(omega, gamma) = ", GA_L(omega, gamma)) +
-print("GA_l(omega, gamma) = ", GA_l(omega, gamma))+
  
-print("GB_T(omega, gamma) = ", GB_T(omega, gamma)) +Internally response functions can be stored in different formats. We need several formats as (1) transformations between the different formats take time (2) transformations between different formats can involve a loss of numerical accuracy and (3) different algorithms require the response function in different formats. The formats used in Quanty to store response functions are 
-print("GB_t(omega, gamma) = ", GB_t(omega, gamma))+  - List of poles $$ G(\omega,\Gamma) = A_0 + \sum_{i=1}^{n} B_{i-1} \frac{1}{\omega + \mathrm{i}\Gamma/2 - a_i} $$ 
 +  - Tri-diagonal $$ G(\omega,\Gamma) = A_0 + B_0^* \frac{1}{\omega + \mathrm{i}\Gamma/2 - A_1 - B_{1}^{\phantom{\dagger}} \frac{1}{\omega + \mathrm{i}\Gamma/2 - A_2 - B_{2}^{\phantom{\dagger}} \frac{1}{\omega + \mathrm{i}\Gamma/2 - A_2 - B_{3}^{\phantom{\dagger}} \frac{...}{\omega + \mathrm{i}\Gamma/2 - A_{n-1} - B_{n-1}^{\phantom{\dagger}} \frac{1}{\omega + \mathrm{i}\Gamma/2 - A_n } B_{n-1}^{\dagger}} B_{3}^{\dagger} } B_{2}^{\dagger} } B_{1}^{\dagger} } B_0^T $$ 
 +  - Anderson $$ G(\omega,\Gamma) = A_0 + B_0^* \frac{1}{\omega + \mathrm{i}\Gamma/2 - A_1 - \sum_{i=2}^{n} B_{i-1}^{\phantom{\dagger}} \frac{1}{\omega + \mathrm{i}\Gamma/2 - A_{i} } B_{i-1}^{\dagger} } B_0^T $$ 
 +  - Natural Impurity. We define $G_{val}(\omega,\Gamma)$ and $G_{con}(\omega,\Gamma)$ as response functions with poles either at positive energy ($G_{con}(\omega,\Gamma)$) or poles at negative energy ($G_{val}(\omega,\Gamma)$). The full response function is defined as $$ G(\omega,\Gamma) = A_0 + B_0^* \left( G_{val}(\omega,\Gamma) + G_{con}(\omega,\Gamma) \right) B_0^T$$ 
  
-print("GC_A(omega, gamma) = ", GC_A(omega, gamma)) +###
-print("GC_a(omega, gamma) = ", GC_a(omega, gamma))+
  
-print("GD_N(omega, gamma) = ", GD_N(omega, gamma)) +###
-print("GD_n(omega, gamma) = ", GD_n(omega, gamma))+
  
  
--- Defining matrix response functions+Whereby capital letters $A_i$ and $B_i$ refer to matrices equal to the dimension of $G(\omega,\Gamma)$ and small letters $a_i$ refer to numbers.
  
-A0 = {{0,0,0},{0,0,0},{0,0,0}} +###
-setmetatable(A0, MatrixMeta) +
-A1 = {{1,2,3},{2,5,6},{3,6,9}} +
-setmetatable(A1, MatrixMeta) +
-A2 = {{2,2,3},{2,5,6},{3,6,9}} +
-setmetatable(A2, MatrixMeta) +
-A3 = {{3,2,3},{2,5,6},{3,6,9}} +
-setmetatable(A3, MatrixMeta) +
-a1 = -1 +
-a2 = 0 +
-a3 = 1 +
-av1 = -0.5 +
-av2 = -1.0 +
-av3 = -1.5 +
-ac1 = 0.5 +
-ac2 = 1.0 +
-ac3 = 1.5 +
-B0s = {{1,0,0},{0,1,0},{0,0,1}} +
-setmetatable(B0s, MatrixMeta) +
-t=sqrt(0.5) +
-B0vs = {{t,0,0},{0,t,0},{0,0,t}} +
-setmetatable(B0vs, MatrixMeta) +
-B0cs = {{t,0,0},{0,t,0},{0,0,t}} +
-setmetatable(B0cs, MatrixMeta) +
-B0 = B0s * B0s +
-B0v = B0vs * B0vs +
-B0c = B0cs * B0cs +
-B1s = {{1,I,3},{-I,5,6},{3,6,9}} +
-setmetatable(B1s, MatrixMeta) +
-B1 = B1s * B1s +
-B2s = {{2,0,3},{0,5,6},{3,6,9}} +
-setmetatable(B2s, MatrixMeta) +
-B2 = B2s * B2s +
-B3s = {{3,0,3},{0,5,6},{3,6,9}} +
-setmetatable(B3s, MatrixMeta) +
-B3 = B3s * B3s+
  
-MA_L = { {A0,a1,a2,a3}, {B1,B2,B3}, mu=0, type="ListOfPoles", name="A"} +###
-setmetatable(MA_L, ResponseFunctionMeta)+
  
-MB_T = { {A0,A1,A2,A3}, {B0,B1,B2}, mu=0, type="Tri", name="B"} 
-setmetatable(MB_T, ResponseFunctionMeta) 
  
-MC_A = { {A0,A1,A2,A3}, {B0,B1,B2}, mu=0, type="And", name="C"} +Below you find several functions, methods, properties and operations related to response functions.
-setmetatable(MC_A, ResponseFunctionMeta)+
  
-MD_Nv = { {A0,av1,av2,av3}, {B1,B2,B3}, mu=0, type="ListOfPoles", name="Dv"} +Response functions can be stored internally as Lua tables with a metatable set to ResponseFunctionMeta, or as a user data. Both objects behave similarly. One should be careful as a comparison between a response function stored as a table to a response function stored as a user data is always falls. That said, comparing functions of doubles will always be problematic due to numerical inaccuracies.
-setmetatable(MD_Nv, ResponseFunctionMeta)+
  
-MD_Nc = { {A0,ac1,ac2,ac3}, {B1,B2,B3}, mu=0, type="ListOfPoles", name="Dc"} +###
-setmetatable(MD_Nc, ResponseFunctionMeta) +
- +
-MD_N = {{A0,B0},val=MD_Nv,con=MD_Nc,mu=0,type="Nat", name="D"} +
-setmetatable(MD_N, ResponseFunctionMeta) +
- +
--- For a more efficient storage, one can convert from Table to Userdata +
-MA_l = ResponseFunction.ToUserdata(MA_L) +
-MB_t = ResponseFunction.ToUserdata(MB_T) +
-MC_a = ResponseFunction.ToUserdata(MC_A) +
-MD_n = ResponseFunction.ToUserdata(MD_N) +
- +
- +
-print("MA_L:") +
-print(MA_L) +
-print("MA_l:") +
-print(MA_l) +
- +
-print("MB_T:") +
-print(MB_T) +
-print("MB_t:") +
-print(MB_t) +
- +
-print("MC_A:") +
-print(MC_A) +
-print("MC_a:") +
-print(MC_a) +
- +
-print("MD_N:") +
-print(MD_N) +
-print("MD_n:") +
-print(MD_n) +
- +
- +
--- response functions in Quanty are functions that, given  +
--- a complex number as input w + I gamma/2 return a complex +
--- number (single valued functions) or a matrix (matrix functions) +
-omega = 0.764 +
-gamma = 0.1 +
-print("omega = ", omega) +
-print("gamma = ", gamma) +
- +
-print("") +
-print("MA_L(omega, gamma) = ") +
-print(MA_L(omega, gamma)) +
-print("MA_l(omega, gamma) = ") +
-print(MA_l(omega, gamma)) +
- +
-print("") +
-print("MB_T(omega, gamma) = ") +
-print(MB_T(omega, gamma)) +
-print("MB_t(omega, gamma) = ") +
-print(MB_t(omega, gamma)) +
- +
-print("") +
-print("MC_A(omega, gamma) = ") +
-print(MC_A(omega, gamma)) +
-print("MC_a(omega, gamma) = ") +
-print(MC_a(omega, gamma)) +
- +
-print("") +
-print("MD_N(omega, gamma) = ") +
-print(MD_N(omega, gamma)) +
-print("MD_n(omega, gamma) = ") +
-print(MD_n(omega, gamma)) +
-</code> +
- +
-<file Quanty_Output> +
-GA_L: +
-{ { 0 , -1 , -0.5 , 0 , 0.5 , 1 , 1.5 } ,  +
-  { 0.2 , 0.1 , 0.1 , 0.1 , 0.2 , 0.3 } , +
-  type = ListOfPoles , +
-  mu = 0 , +
-  name = A } +
-GA_l: +
-ResponseFunction in userdata format use ToTable() in order to get a table form +
-GB_T: +
-{ { 0 , 1 , 1 , 1 , 1 , 1 , 1 } ,  +
-  { 1 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 } , +
-  type = Tri , +
-  mu = 0 , +
-  name = B } +
-GB_t: +
-ResponseFunction in userdata format use ToTable() in order to get a table form +
-GC_A: +
-{ { 0 , 1 , 1.5 , 2 , 2.5 , 3 , 3.5 } ,  +
-  { 1 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 } , +
-  type = And , +
-  mu = 0 , +
-  name = C } +
-GC_a: +
-ResponseFunction in userdata format use ToTable() in order to get a table form +
-GD_N: +
-{ { 0 , 1 } , +
-  type = Nat , +
-  val = { { 0 , -1 , -1 , -1 , -1 , -1 , -1 } ,  +
-  { 0.70710678118655 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 } , +
-  mu = 0 , +
-  type = Tri } , +
-  con = { { 0 , 1 , 1 , 1 , 1 , 1 , 1 } ,  +
-  { 0.70710678118655 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 } , +
-  mu = 0 , +
-  type = Tri } , +
-  name = D , +
-  mu = 0 } +
-GD_n: +
-ResponseFunction in userdata format use ToTable() in order to get a table form +
-omega = 0.764 +
-gamma = 0.1 +
- +
-GA_L(omega, gamma) = (-0.52850742098896 - 0.28351791776891 I) +
-GA_l(omega, gamma) = (-0.52850742098896 - 0.28351791776891 I) +
-GB_T(omega, gamma) = (-1.6762624946074 - 5.2043002596032 I) +
-GB_t(omega, gamma) = (-1.6762624946074 - 5.2043002596032 I) +
-GC_A(omega, gamma) = (1.5075603166492 - 0.20713674761056 I) +
-GC_a(omega, gamma) = (1.5075603166492 - 0.20713674761056 I) +
-GD_N(omega, gamma) = (-0.52770560643508 - 2.61282805234 I) +
-GD_n(omega, gamma) = (-0.52770560643508 - 2.61282805234 I) +
-MA_L: +
-{ { { { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } } , -1 , 0 , 1 } ,  +
-  { { { 11 , (18 + 6 I) , (30 + 6 I) } ,  +
-  { (18 - 6 I) , 62 , (84 - 3 I) } ,  +
-  { (30 - 6 I) , (84 + 3 I) , 126 } } ,  +
-  { { 13 , 18 , 33 } ,  +
-  { 18 , 61 , 84 } ,  +
-  { 33 , 84 , 126 } } ,  +
-  { { 18 , 18 , 36 } ,  +
-  { 18 , 61 , 84 } ,  +
-  { 36 , 84 , 126 } } } , +
-  type = ListOfPoles , +
-  mu = 0 , +
-  name = A } +
-MA_l: +
-ResponseFunction in userdata format use ToTable() in order to get a table form +
-MB_T: +
-{ { { { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } } ,  +
-  { { 1 , 2 , 3 } ,  +
-  { 2 , 5 , 6 } ,  +
-  { 3 , 6 , 9 } } ,  +
-  { { 2 , 2 , 3 } ,  +
-  { 2 , 5 , 6 } ,  +
-  { 3 , 6 , 9 } } ,  +
-  { { 3 , 2 , 3 } ,  +
-  { 2 , 5 , 6 } ,  +
-  { 3 , 6 , 9 } } } ,  +
-  { { { 1 , 0 , 0 } ,  +
-  { 0 , 1 , 0 } ,  +
-  { 0 , 0 , 1 } } ,  +
-  { { 11 , (18 + 6 I) , (30 + 6 I) } ,  +
-  { (18 - 6 I) , 62 , (84 - 3 I) } ,  +
-  { (30 - 6 I) , (84 + 3 I) , 126 } } ,  +
-  { { 13 , 18 , 33 } ,  +
-  { 18 , 61 , 84 } ,  +
-  { 33 , 84 , 126 } } } , +
-  type = Tri , +
-  mu = 0 , +
-  name = B } +
-MB_t: +
-ResponseFunction in userdata format use ToTable() in order to get a table form +
-MC_A: +
-{ { { { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } } ,  +
-  { { 1 , 2 , 3 } ,  +
-  { 2 , 5 , 6 } ,  +
-  { 3 , 6 , 9 } } ,  +
-  { { 2 , 2 , 3 } ,  +
-  { 2 , 5 , 6 } ,  +
-  { 3 , 6 , 9 } } ,  +
-  { { 3 , 2 , 3 } ,  +
-  { 2 , 5 , 6 } ,  +
-  { 3 , 6 , 9 } } } ,  +
-  { { { 1 , 0 , 0 } ,  +
-  { 0 , 1 , 0 } ,  +
-  { 0 , 0 , 1 } } ,  +
-  { { 11 , (18 + 6 I) , (30 + 6 I) } ,  +
-  { (18 - 6 I) , 62 , (84 - 3 I) } ,  +
-  { (30 - 6 I) , (84 + 3 I) , 126 } } ,  +
-  { { 13 , 18 , 33 } ,  +
-  { 18 , 61 , 84 } ,  +
-  { 33 , 84 , 126 } } } , +
-  type = And , +
-  mu = 0 , +
-  name = C } +
-MC_a: +
-ResponseFunction in userdata format use ToTable() in order to get a table form +
-MD_N: +
-{ { { { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } } ,  +
-  { { 1 , 0 , 0 } ,  +
-  { 0 , 1 , 0 } ,  +
-  { 0 , 0 , 1 } } } , +
-  type = Nat , +
-  val = { { { { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } } , -0.5 , -1 , -1.5 } ,  +
-  { { { 11 , (18 + 6 I) , (30 + 6 I) } ,  +
-  { (18 - 6 I) , 62 , (84 - 3 I) } ,  +
-  { (30 - 6 I) , (84 + 3 I) , 126 } } ,  +
-  { { 13 , 18 , 33 } ,  +
-  { 18 , 61 , 84 } ,  +
-  { 33 , 84 , 126 } } ,  +
-  { { 18 , 18 , 36 } ,  +
-  { 18 , 61 , 84 } ,  +
-  { 36 , 84 , 126 } } } , +
-  type = ListOfPoles , +
-  mu = 0 , +
-  name = Dv } , +
-  con = { { { { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } ,  +
-  { 0 , 0 , 0 } } , 0.5 , 1 , 1.5 } ,  +
-  { { { 11 , (18 + 6 I) , (30 + 6 I) } ,  +
-  { (18 - 6 I) , 62 , (84 - 3 I) } ,  +
-  { (30 - 6 I) , (84 + 3 I) , 126 } } ,  +
-  { { 13 , 18 , 33 } ,  +
-  { 18 , 61 , 84 } ,  +
-  { 33 , 84 , 126 } } ,  +
-  { { 18 , 18 , 36 } ,  +
-  { 18 , 61 , 84 } ,  +
-  { 36 , 84 , 126 } } } , +
-  type = ListOfPoles , +
-  mu = 0 , +
-  name = Dc } , +
-  name = D , +
-  mu = 0 } +
-MD_n: +
-ResponseFunction in userdata format use ToTable() in order to get a table form +
-omega = 0.764 +
-gamma = 0.1 +
- +
-MA_L(omega, gamma) =  +
-{ { (-49.82074737235 - 16.750435144161 I) , (-39.242754250336 - 13.890672203015 I) , (-85.890426598686 - 30.827754261851 I) } ,  +
-  { (-39.435420350993 - 20.687932234176 I) , (-132.74935751632 - 58.607579693628 I) , (-183.63057392827 - 82.382725361235 I) } ,  +
-  { (-86.083092699343 - 37.625014293012 I) , (-183.53424087794 - 78.984095345655 I) , (-275.37361110465 - 121.02511553017 I) } } +
-MA_l(omega, gamma) =  +
-{ { (-49.82074737235 - 16.750435144161 I) , (-39.242754250336 - 13.890672203015 I) , (-85.890426598686 - 30.827754261851 I) } ,  +
-  { (-39.435420350993 - 20.687932234176 I) , (-132.74935751632 - 58.607579693628 I) , (-183.63057392827 - 82.382725361235 I) } ,  +
-  { (-86.083092699343 - 37.625014293012 I) , (-183.53424087794 - 78.984095345655 I) , (-275.37361110465 - 121.02511553017 I) } } +
- +
-MB_T(omega, gamma) =  +
-{ { (0.99841211757801 - 0.4318886700871 I) , (-0.92217346376056 - 0.59364349550167 I) , (0.33618642304746 + 0.56252370645231 I) } ,  +
-  { (-0.51999398150154 + 0.87279523667066 I) , (0.69431808205569 - 0.1748977600005 I) , (-0.34355189835894 - 0.03809026037919 I) } ,  +
-  { (0.13982839704936 - 0.53101630282404 I) , (-0.25718128095213 + 0.17938506335344 I) , (0.080137084707226 - 0.049212538037938 I) } } +
-MB_t(omega, gamma) =  +
-{ { (0.99841211757801 - 0.4318886700871 I) , (-0.92217346376056 - 0.59364349550167 I) , (0.33618642304746 + 0.56252370645231 I) } ,  +
-  { (-0.51999398150154 + 0.87279523667066 I) , (0.69431808205569 - 0.1748977600005 I) , (-0.34355189835894 - 0.03809026037919 I) } ,  +
-  { (0.13982839704936 - 0.53101630282404 I) , (-0.25718128095213 + 0.17938506335344 I) , (0.080137084707226 - 0.049212538037938 I) } } +
- +
-MC_A(omega, gamma) =  +
-{ { (0.0033404740201663 - 0.049014208032374 I) , (-0.0092579857609902 - 0.018133779674219 I) , (0.0041464743284782 + 0.021581712320061 I) } ,  +
-  { (0.001131475130102 - 0.019625764066449 I) , (-0.006620607647268 - 0.0094591143626733 I) , (0.0044705980344151 + 0.010254424901895 I) } ,  +
-  { (0.0018776712535675 + 0.024036826455971 I) , (0.0083397043445284 + 0.01003150710377 I) , (-0.0056913744700838 - 0.011590149052798 I) } } +
-MC_a(omega, gamma) =  +
-{ { (0.0033404740201663 - 0.049014208032374 I) , (-0.0092579857609902 - 0.018133779674219 I) , (0.0041464743284782 + 0.021581712320061 I) } ,  +
-  { (0.001131475130102 - 0.019625764066449 I) , (-0.006620607647268 - 0.0094591143626733 I) , (0.0044705980344151 + 0.010254424901895 I) } ,  +
-  { (0.0018776712535675 + 0.024036826455971 I) , (0.0083397043445284 + 0.01003150710377 I) , (-0.0056913744700838 - 0.011590149052798 I) } } +
- +
-MD_N(omega, gamma) =  +
-{ { (-12.839446772164 - 21.169048830916 I) , (5.1855777994224 - 3.9320983625761 I) , (-10.184899840804 - 27.575394683943 I) } ,  +
-  { (-3.5000860033155 - 57.291484603566 I) , (7.3025877301526 - 104.46376534286 I) , (1.7613982402315 - 156.19487348125 I) } ,  +
-  { (-18.870563643542 - 80.934780924933 I) , (6.1042301416005 - 129.51518036075 I) , (5.8992212863723 - 214.2825403815 I) } } +
-MD_n(omega, gamma) =  +
-{ { (-12.839446772164 - 21.169048830916 I) , (5.1855777994224 - 3.9320983625761 I) , (-10.184899840804 - 27.575394683943 I) } ,  +
-  { (-3.5000860033155 - 57.291484603566 I) , (7.3025877301526 - 104.46376534286 I) , (1.7613982402315 - 156.19487348125 I) } ,  +
-  { (-18.870563643542 - 80.934780924933 I) , (6.1042301416005 - 129.51518036075 I) , (5.8992212863723 - 214.2825403815 I) } } +
-</file>+
  
 ===== Table of contents ===== ===== Table of contents =====
 {{indexmenu>.#2|tsort}} {{indexmenu>.#2|tsort}}
  

You are here: Quanty - a quantum many body script language » Documentation » Language Reference » Objects » Response function

Print/export