New

ResponseFunction.New(Table) creates a new response function object according to the values in Table. Response functions can be of 4 different types (ListOfPoles, Tri, And, or Nat) and single-valued or matrix-valued. Below 8 examples for creating each of these response functions by hand at some arbitrary values.

The input table contains the elements

“type” a string equal to “ListOfPoles”, “Tri”, “And”, or “Nat” defining the type used for the internal storage of a response functoin
“name” an arbitrary string used to recognise the response function
“mu” a double giving the chemical potential. We highly recommend to shift the energy scale such that $\mu=0$. Documentation for the behaviour of several functions at finite chemical potential, $\mu$ is still missing. You can always shift the chemical potential to zero by shifting the onsite energy of all orbitals by $-\mu$.
Depending on the type lists of doubles, matrices, or complex matrices $A$ and $B$. Each section below starts by defining $G(\omega,\Gamma)$ in terms of $A$'s and $B$'s, the input below uses these variables. We use capital font for matrices and small font for numbers. Note that the matrices $A$ and $B$ must fulfil several conditions for the response function to be physical. Only physical response functions can be transformed between all types as unitary transformations.

ListOfPoles representation

Response functions stored as list of poles are defined via $$ G(\omega,\Gamma) = A_0 + \sum_{i=1}^{n} \frac{B_{i-1}}{\omega + \mathrm{i}\Gamma/2 - a_i} $$

Single valued functions

Example.Quanty

a = {10, -1,-0.5, 0,   0.5,  1,  1.5}
b = {  0.1, 0.1, 0.1, 0.1, 0.2, 0.3}
G = ResponseFunction.New( {a,b,mu=0,type="ListOfPoles", name="A"} )
print("The resposne function definition is")
print(G)
omega = 1.1
Gamma = 0.001
print()
print("Evaluated at omega =",omega," and Gamma =",Gamma," yields ",G(omega,Gamma))

Generates the output

The resposne function definition is
{ { 10 , -1 , -0.5 , 0 , 0.5 , 1 , 1.5 } , 
  { 0.1 , 0.1 , 0.1 , 0.1 , 0.2 , 0.3 } ,
  name = A ,
  type = ListOfPoles ,
  mu = 0 }
 
Evaluated at omega =	1.1	 and Gamma =	0.001	 yields 	(11.617645834991 - 0.011148328755289 I)

Matrix valued functions

Example.Quanty

A0 = Matrix.New( {{0,0,0},{0,0,0},{0,0,0}} )
a1 = -1
a2 = 1/2
a3 = 1
B1s = Matrix.New( {{1,1,3},{1,5,6},{3,6,9}} )
B1 = B1s * B1s
B2s = Matrix.New( {{2,0,3},{0,5,6},{3,6,9}} )
B2 = B2s * B2s
B3s = Matrix.New( {{3,0,3},{0,5,6},{3,6,9}} )
B3 = B3s * B3s
G = ResponseFunction.New( { {A0,a1,a2,a3}, {B1,B2,B3}, mu=0, type="ListOfPoles", name="ML"} )
print("The resposne function definition is")
print(G)
omega = 1.1
Gamma = 0.001
print()
print("Evaluated at omega =",omega," and Gamma =",Gamma," yields ")
print(G(omega,Gamma))

Generates the output

{ { { { 0 , 0 , 0 } , 
  { 0 , 0 , 0 } , 
  { 0 , 0 , 0 } } , -1 , 0.5 , 1 } , 
  { { { 11 , 24 , 36 } , 
  { 24 , 62 , 87 } , 
  { 36 , 87 , 126 } } , 
  { { 13 , 18 , 33 } , 
  { 18 , 61 , 84 } , 
  { 33 , 84 , 126 } } , 
  { { 18 , 18 , 36 } , 
  { 18 , 61 , 84 } , 
  { 36 , 84 , 126 } } } ,
  type = ListOfPoles ,
  name = ML ,
  mu = 0 }
 
Evaluated at omega =	1.1	 and Gamma =	0.001	 yields 
{ { (206.90024667403 - 0.91928020904165 I) , (221.42405005987 - 0.9276985714825 I) , (432.13381820162 - 1.8498699350513 I) } , 
  { (221.42405005987 - 0.9276985714825 I) , (741.17515429623 - 3.1416753933531 I) , (1021.4074723828 - 4.3264255332922 I) } , 
  { (432.13381820162 - 1.8498699350513 I) , (1021.4074723828 - 4.3264255332922 I) , (1529.9683515529 - 6.4891280958856 I) } }

Tridiagonal representation

Response functions stored in tridiagonal format are defined via $$ 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 $$

Single valued functions

Example.Quanty

a = {0, 1,   1,   1,   1,   1,  1}
b = {   1, 0.5, 0.5, 0.5, 0.5, 0.5}
G = ResponseFunction.New( {a,b,mu=0,type="Tri", name="GT"} )
print("The resposne function definition is")
print(G)
omega = 1.1
Gamma = 0.001
print()
print("Evaluated at omega =",omega," and Gamma =",Gamma," yields ")
print(G(omega,Gamma))

Generates the output

{ { 0 , 1 , 1 , 1 , 1 , 1 , 1 } , 
  { 1 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 } ,
  name = GT ,
  type = Tri ,
  mu = 0 }
 
Evaluated at omega =	1.1	 and Gamma =	0.001	 yields 
(-1.4800882525182 - 0.010904814637879 I)

Matrix valued functions

Example.Quanty

A0 = Matrix.New( {{0,0,0},{0,0,0},{0,0,0}} )
A1 = Matrix.New( {{1,2,3},{2,5,6},{3,6,9}} )
A2 = Matrix.New( {{2,2,3},{2,5,6},{3,6,9}} )
A3 = Matrix.New( {{3,2,3},{2,5,6},{3,6,9}} )
B0s = Matrix.New( {{1,0,0},{0,1,0},{0,0,1}} )
B0 = B0s * B0s
B1s = Matrix.New( {{1,1,3},{1,5,6},{3,6,9}} )
B1 = B1s * B1s
B2s = Matrix.New( {{2,0,3},{0,5,6},{3,6,9}} )
B2 = B2s * B2s
B3s = Matrix.New( {{3,0,3},{0,5,6},{3,6,9}} )
B3 = B3s * B3s
G = ResponseFunction.New( { {A0,A1,A2,A3}, {B0,B1,B2}, mu=0, type="Tri", name="MT"} )
print("The resposne function definition is")
print(G)
omega = 1.1
Gamma = 0.001
print()
print("Evaluated at omega =",omega," and Gamma =",Gamma," yields ")
print(G(omega,Gamma))

Generates the output

{ { { { 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 , 24 , 36 } , 
  { 24 , 62 , 87 } , 
  { 36 , 87 , 126 } } , 
  { { 13 , 18 , 33 } , 
  { 18 , 61 , 84 } , 
  { 33 , 84 , 126 } } } ,
  type = Tri ,
  mu = 0 ,
  BlockSize = { 3 , 3 , 3 , 3 } ,
  name = MT }
 
Evaluated at omega =	1.1	 and Gamma =	0.001	 yields 
{ { (0.82041346528466 - 0.0005287731551253 I) , (-0.10773626514221 + 0.00047135055668369 I) , (-0.18782055050369 - 0.00021908813997981 I) } , 
  { (-0.10773626514222 + 0.00047135055668371 I) , (0.9906660606812 - 0.0018715007457328 I) , (-0.67958409204703 + 0.0013049040629232 I) } , 
  { (-0.18782055050369 - 0.00021908813997982 I) , (-0.67958409204703 + 0.0013049040629232 I) , (0.51775011277794 - 0.00095267059250443 I) } }

Anderson representation

Response functions stored in Anderson format are defined via $$ 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 $$

Single valued functions

Example.Quanty

a = {0, 1, 1.5,   2, 2.5,   3, 3.5}
b = {   1, 0.5, 0.5, 0.5, 0.5, 0.5}
G = ResponseFunction.New( {a,b,mu=0,type="And", name="GA"} )
print("The resposne function definition is")
print(G)
omega = 1.1
Gamma = 0.001
print()
print("Evaluated at omega =",omega," and Gamma =",Gamma," yields ")
print(G(omega,Gamma))

Generates the output

The resposne function definition is
{ { 0 , 1 , 1.5 , 2 , 2.5 , 3 , 3.5 } , 
  { 1 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 } ,
  type = And ,
  name = GA ,
  mu = 0 }
 
Evaluated at omega =	1.1	 and Gamma =	0.001	 yields 
(0.70566877797716 - 0.00077467678957667 I)

Matrix valued functions

Example.Quanty

A0 = Matrix.New( {{0,0,0},{0,0,0},{0,0,0}} )
A1 = Matrix.New( {{1,2,3},{2,5,6},{3,6,9}} )
A2 = Matrix.New( {{2,2,3},{2,5,6},{3,6,9}} )
A3 = Matrix.New( {{3,2,3},{2,5,6},{3,6,9}} )
B0s = Matrix.New( {{1,0,0},{0,1,0},{0,0,1}} )
B0 = B0s * B0s
B1s = Matrix.New( {{1,1,3},{1,5,6},{3,6,9}} )
B1 = B1s * B1s
B2s = Matrix.New( {{2,0,3},{0,5,6},{3,6,9}} )
B2 = B2s * B2s
B3s = Matrix.New( {{3,0,3},{0,5,6},{3,6,9}} )
B3 = B3s * B3s
G = ResponseFunction.New( { {A0,A1,A2,A3}, {B0,B1,B2}, mu=0, type="And", name="MA"} )
print("The resposne function definition is")
print(G)
omega = 1.1
Gamma = 0.001
print()
print("Evaluated at omega =",omega," and Gamma =",Gamma," yields ")
print(G(omega,Gamma))

Generates the output

{ { { { 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 , 24 , 36 } , 
  { 24 , 62 , 87 } , 
  { 36 , 87 , 126 } } , 
  { { 13 , 18 , 33 } , 
  { 18 , 61 , 84 } , 
  { 33 , 84 , 126 } } } ,
  mu = 0 ,
  name = MA ,
  type = And }
 
Evaluated at omega =	1.1	 and Gamma =	0.001	 yields 
{ { (0.079202023515427 - 0.00018271816123949 I) , (0.019672301598063 - 0.00021050428128743 I) , (-0.033329362936266 + 0.00019529208541705 I) } , 
  { (0.019672301598062 - 0.00021050428128743 I) , (-0.028178571653589 - 0.00029307470840254 I) , (0.014801870346139 + 0.00026254621032145 I) } , 
  { (-0.033329362936266 + 0.00019529208541705 I) , (0.014801870346139 + 0.00026254621032145 I) , (-0.0017775335507766 - 0.00023672956892774 I) } }

Natural impurity orbital representation

Response functions stored in Natural impurity format are defined via $$ G(\omega,\Gamma) = A_0 + B_0^* \left( G_{val}(\omega,\Gamma) + G_{con}(\omega,\Gamma) \right) B_0^T$$, with $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)$).

Single valued functions

Example.Quanty

acon = {0,         1,   1,   1,   1,   1,  1}
bcon = {   sqrt(1/2), 0.5, 0.5, 0.5, 0.5, 0.5}
Gcon = ResponseFunction.New(  {acon,bcon,mu=0,type="Tri"} )
aval = {0,        -1,  -1,  -2,  -1,  -1, -1}
bval = {   sqrt(1/2), 0.5, 0.5, 0.5, 0.5, 0.5}
Gval = ResponseFunction.New( {aval,bval,mu=0,type="Tri"} )
a0=0
b0=1
G = ResponseFunction.New( {{a0,b0},val=Gval,con=Gcon,mu=0,type="Nat", name="GD"} )
print("The resposne function definition is")
print(G)
omega = 1.1
Gamma = 0.001
print()
print("Evaluated at omega =",omega," and Gamma =",Gamma," yields ")
print(G(omega,Gamma))

Generates the output

The resposne function definition is
{ { 0 , 1 } ,
  type = NaturalImpurityOrbital ,
  name = GD ,
  mu = 0 ,
  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 = Matrix } ,
  epsilon = 0 ,
  val = { { 0 , -1 , -1 , -2 , -1 , -1 , -1 } , 
  { 0.70710678118655 , 0.5 , 0.5 , 0.5 , 0.5 , 0.5 } ,
  mu = 0 ,
  type = Tri ,
  name = Matrix } }
 
Evaluated at omega =	1.1	 and Gamma =	0.001	 yields 
(-0.48700605787262 - 0.0055204934115643 I)

Matrix valued functions

Example.Quanty

-- some example code

Generates the output

text produced as output

Table of Contents

New

ListOfPoles representation

Single valued functions

Matrix valued functions

Tridiagonal representation

Single valued functions

Matrix valued functions

Anderson representation

Single valued functions

Matrix valued functions

Natural impurity orbital representation

Single valued functions

Matrix valued functions

Table of contents