triqs.gfs.gf_factories.gf_factories_dlr_imfreq.make_gf_imfreq

triqs.gfs.gf_factories.gf_factories_dlr_imfreq.make_gf_imfreq()

Dispatched C++ function(s).

[1] (g: Gf[MeshDLR, 0], n_iw: int)
  -> Gf[MeshImFreq, 0]

[2] (g: Gf[MeshDLRImTime, 0], n_iw: int)
  -> Gf[MeshImFreq, 0]

[3] (g: Gf[MeshDLRImFreq, 0], n_iw: int)
  -> Gf[MeshImFreq, 0]

[4] (g: BlockGf[MeshDLR, 0], n_iw: int)
  -> BlockGf[MeshImFreq, 0]

[5] (g: BlockGf[MeshDLRImTime, 0], n_iw: int)
  -> BlockGf[MeshImFreq, 0]

[6] (g: BlockGf[MeshDLRImFreq, 0], n_iw: int)
  -> BlockGf[MeshImFreq, 0]

[7] (g: Block2Gf[MeshDLR, 0], n_iw: int)
  -> Block2Gf[MeshImFreq, 0]

[8] (g: Block2Gf[MeshDLRImTime, 0], n_iw: int)
  -> Block2Gf[MeshImFreq, 0]

[9] (g: Block2Gf[MeshDLRImFreq, 0], n_iw: int)
  -> Block2Gf[MeshImFreq, 0]

[10] (g: Gf[MeshDLR, 1], n_iw: int)
  -> Gf[MeshImFreq, 1]

[11] (g: Gf[MeshDLRImTime, 1], n_iw: int)
  -> Gf[MeshImFreq, 1]

[12] (g: Gf[MeshDLRImFreq, 1], n_iw: int)
  -> Gf[MeshImFreq, 1]

[13] (g: BlockGf[MeshDLR, 1], n_iw: int)
  -> BlockGf[MeshImFreq, 1]

[14] (g: BlockGf[MeshDLRImTime, 1], n_iw: int)
  -> BlockGf[MeshImFreq, 1]

[15] (g: BlockGf[MeshDLRImFreq, 1], n_iw: int)
  -> BlockGf[MeshImFreq, 1]

[16] (g: Block2Gf[MeshDLR, 1], n_iw: int)
  -> Block2Gf[MeshImFreq, 1]

[17] (g: Block2Gf[MeshDLRImTime, 1], n_iw: int)
  -> Block2Gf[MeshImFreq, 1]

[18] (g: Block2Gf[MeshDLRImFreq, 1], n_iw: int)
  -> Block2Gf[MeshImFreq, 1]

[19] (g: Gf[MeshDLR, 2], n_iw: int)
  -> Gf[MeshImFreq, 2]

[20] (g: Gf[MeshDLRImTime, 2], n_iw: int)
  -> Gf[MeshImFreq, 2]

[21] (g: Gf[MeshDLRImFreq, 2], n_iw: int)
  -> Gf[MeshImFreq, 2]

[22] (g: BlockGf[MeshDLR, 2], n_iw: int)
  -> BlockGf[MeshImFreq, 2]

[23] (g: BlockGf[MeshDLRImTime, 2], n_iw: int)
  -> BlockGf[MeshImFreq, 2]

[24] (g: BlockGf[MeshDLRImFreq, 2], n_iw: int)
  -> BlockGf[MeshImFreq, 2]

[25] (g: Block2Gf[MeshDLR, 2], n_iw: int)
  -> Block2Gf[MeshImFreq, 2]

[26] (g: Block2Gf[MeshDLRImTime, 2], n_iw: int)
  -> Block2Gf[MeshImFreq, 2]

[27] (g: Block2Gf[MeshDLRImFreq, 2], n_iw: int)
  -> Block2Gf[MeshImFreq, 2]

[28] (g: Gf[MeshDLR, 3], n_iw: int)
  -> Gf[MeshImFreq, 3]

[29] (g: Gf[MeshDLRImTime, 3], n_iw: int)
  -> Gf[MeshImFreq, 3]

[30] (g: Gf[MeshDLRImFreq, 3], n_iw: int)
  -> Gf[MeshImFreq, 3]

[31] (g: BlockGf[MeshDLR, 3], n_iw: int)
  -> BlockGf[MeshImFreq, 3]

[32] (g: BlockGf[MeshDLRImTime, 3], n_iw: int)
  -> BlockGf[MeshImFreq, 3]

[33] (g: BlockGf[MeshDLRImFreq, 3], n_iw: int)
  -> BlockGf[MeshImFreq, 3]

[34] (g: Block2Gf[MeshDLR, 3], n_iw: int)
  -> Block2Gf[MeshImFreq, 3]

[35] (g: Block2Gf[MeshDLRImTime, 3], n_iw: int)
  -> Block2Gf[MeshImFreq, 3]

[36] (g: Block2Gf[MeshDLRImFreq, 3], n_iw: int)
  -> Block2Gf[MeshImFreq, 3]

[37] (g: Gf[MeshDLR, 4], n_iw: int)
  -> Gf[MeshImFreq, 4]

[38] (g: Gf[MeshDLRImTime, 4], n_iw: int)
  -> Gf[MeshImFreq, 4]

[39] (g: Gf[MeshDLRImFreq, 4], n_iw: int)
  -> Gf[MeshImFreq, 4]

[40] (g: BlockGf[MeshDLR, 4], n_iw: int)
  -> BlockGf[MeshImFreq, 4]

[41] (g: BlockGf[MeshDLRImTime, 4], n_iw: int)
  -> BlockGf[MeshImFreq, 4]

[42] (g: BlockGf[MeshDLRImFreq, 4], n_iw: int)
  -> BlockGf[MeshImFreq, 4]

[43] (g: Block2Gf[MeshDLR, 4], n_iw: int)
  -> Block2Gf[MeshImFreq, 4]

[44] (g: Block2Gf[MeshDLRImTime, 4], n_iw: int)
  -> Block2Gf[MeshImFreq, 4]

[45] (g: Block2Gf[MeshDLRImFreq, 4], n_iw: int)
  -> Block2Gf[MeshImFreq, 4]

[46] (g: Gf[MeshProduct[MeshDLR, MeshBrZone], 0],
     n_iw: int)
  -> Gf[MeshProduct[MeshImFreq, MeshBrZone], 0]

[47] (g: Gf[MeshProduct[MeshBrZone, MeshDLR], 0],
     n_iw: int)
  -> Gf[MeshProduct[MeshBrZone, MeshImFreq], 0]

[48] (g: Gf[MeshProduct[MeshDLR, MeshCycLat], 0],
     n_iw: int)
  -> Gf[MeshProduct[MeshImFreq, MeshCycLat], 0]

[49] (g: Gf[MeshProduct[MeshCycLat, MeshDLR], 0],
     n_iw: int)
  -> Gf[MeshProduct[MeshCycLat, MeshImFreq], 0]

[50] (g: BlockGf[MeshProduct[MeshDLR, MeshBrZone], 0],
     n_iw: int)
  -> BlockGf[MeshProduct[MeshImFreq, MeshBrZone], 0]

[51] (g: BlockGf[MeshProduct[MeshBrZone, MeshDLR], 0],
     n_iw: int)
  -> BlockGf[MeshProduct[MeshBrZone, MeshImFreq], 0]

[52] (g: BlockGf[MeshProduct[MeshDLR, MeshCycLat], 0],
     n_iw: int)
  -> BlockGf[MeshProduct[MeshImFreq, MeshCycLat], 0]

[53] (g: BlockGf[MeshProduct[MeshCycLat, MeshDLR], 0],
     n_iw: int)
  -> BlockGf[MeshProduct[MeshCycLat, MeshImFreq], 0]

[54] (g: Gf[MeshProduct[MeshDLR, MeshBrZone], 2],
     n_iw: int)
  -> Gf[MeshProduct[MeshImFreq, MeshBrZone], 2]

[55] (g: Gf[MeshProduct[MeshBrZone, MeshDLR], 2],
     n_iw: int)
  -> Gf[MeshProduct[MeshBrZone, MeshImFreq], 2]

[56] (g: Gf[MeshProduct[MeshDLR, MeshCycLat], 2],
     n_iw: int)
  -> Gf[MeshProduct[MeshImFreq, MeshCycLat], 2]

[57] (g: Gf[MeshProduct[MeshCycLat, MeshDLR], 2],
     n_iw: int)
  -> Gf[MeshProduct[MeshCycLat, MeshImFreq], 2]

[58] (g: BlockGf[MeshProduct[MeshDLR, MeshBrZone], 2],
     n_iw: int)
  -> BlockGf[MeshProduct[MeshImFreq, MeshBrZone], 2]

[59] (g: BlockGf[MeshProduct[MeshBrZone, MeshDLR], 2],
     n_iw: int)
  -> BlockGf[MeshProduct[MeshBrZone, MeshImFreq], 2]

[60] (g: BlockGf[MeshProduct[MeshDLR, MeshCycLat], 2],
     n_iw: int)
  -> BlockGf[MeshProduct[MeshImFreq, MeshCycLat], 2]

[61] (g: BlockGf[MeshProduct[MeshCycLat, MeshDLR], 2],
     n_iw: int)
  -> BlockGf[MeshProduct[MeshCycLat, MeshImFreq], 2]

Build a uniform Matsubara Green’s function from any DLR representation.

Applies to every overload. The input lives on a single DLR coefficient, DLR imaginary-time, or DLR Matsubara frequency mesh, or on a product mesh pairing a DLR axis with a lattice axis. Block and block-of-block Green’s function containers are handled component-wise, and product meshes are handled axis-wise. All target ranks (scalar, vector, matrix, rank-3, rank-4) are supported. Inputs on a DLR imaginary-time or DLR Matsubara frequency mesh are first converted to DLR coefficients internally.

Parameters:

gGf[MeshDLR, 0]

A Green’s function on a DLR coefficient, DLR imaginary-time, or DLR Matsubara frequency mesh.

n_iwint

Number of positive Matsubara frequencies in the output mesh.

Returns:

Gf[MeshImFreq, 0]

The Green’s function on a uniform Matsubara frequency mesh.