#!/usr/bin/python  
import sys  
from math import *
import numpy  
from numpy import *
from numpy import dot  
import csv  
import re  
from matplotlib import *
from pylab import plot, show, ylim, xlim, yticks, xlabel, ylabel  
import matplotlib.path as mpath  
import matplotlib.patches as mpatches  
import matplotlib.pyplot as plt  
from matplotlib.font_manager import FontProperties  
import matplotlib  
import eigenval_reader as er  
if (__name__ == '__main__'):  
     filename = 'EIGENVAL'
     if len(sys.argv) == 2:  
        filename = sys.argv[1]  
     else:  
         print("Defaulting filename to 'EIGENVAL', if you wish to specify another filename on the command prompt do it like this: plot_eigenval.py myfilename")  
   
    parser = er.EigenvalParser()  
    kpoints = parser.parse(filename)  
    rcParams['lines.linewidth'] = 4.0
    rcParams['font.weight'] = "heavy"
    rcParams['axes.linewidth'] = 4.0

    rcParams['xtick.major.size'] = 0.0
     rcParams['xtick.minor.size'] = 0.0

     rcParams['ytick.major.size'] = 0.0

     rcParams['ytick.minor.size'] = 0.0   

    for band in er.get_bands(kpoints):  
         plot(range(0,len(band)), band, 'k')  
     xlim(0,60)  
    ylim(-8,4)  
     plt.title("Band Structure")  
     xlabel("K-Points")  
     ylabel("Energy(eV)")  
     plt.show()

import re  

02   

03 class EigenvalReader:  

04     def __init__(self):  

05         self.listeners = {}  

06   

07     def add_listener(self, event_name, callback):  

08         if (not self.listeners.has_key(event_name)):  

09             self.listeners[event_name] = []  

10         self.listeners[event_name].append(callback)  

11   

12     def __raise__(self, event_name, args):  

13         if not self.listeners.has_key(event_name):  

14             return

15   

16         callbacks = self.listeners[event_name]  

17         if callbacks != None:  

18             for c in callbacks:  

19                 c(self, args)  

20   

21     def read_file(self, eigen_file):  

22         f = open(eigen_file)  

23         for i in range(0,5):  

24             f.readline()  

25   

26         throwaway, kpoint_count, band_count = f.readline().split()  

27         self.__raise__('ON_KPOINT_COUNT', kpoint_count)  

28         self.__raise__('ON_BAND_COUNT', band_count)  

29   

30         # Blank Line  

31         f.readline()  

32   

33         # End of File (EOF)  

34         eof = False

35         while (not eof):  

36             line = f.readline()  

37             if line == None:  

38                 eof = True

39                 continue

40             try:  

41                 x,y,z,weight = line.split()  

42                 self.__raise__('ON_KPOINT', { "x": x, "y": y, "z": z, "weight": weight })  

43             except:  

44                 print('failed to split line: ' + line)  

45   

46             for i in range(0, int(band_count)):  

47                 line = f.readline()  

48                 try:  

49                     id, energy = line.split()  

50                     self.__raise__('ON_BAND', { 'id': id, 'energy': float(energy) })  

51                 except:  

52                     print('failed to get band info from: ' + line)  

53   

54             line = f.readline()  

55             if line == '':  

56                 eof = True

57   

58 class EigenvalParser:  

59     def parse(self, filename):  

60         self.kpoints = []  

61         reader = EigenvalReader()  

62         reader.add_listener('ON_KPOINT', self.__on_kpoint__)  

63         reader.add_listener('ON_BAND', lambda reader, band: self.kpoints[-1]['bands'].append(band))  

64   

65         reader.read_file(filename)  

66   

67         return self.kpoints  

68   

69     def __on_kpoint__(self, reader, kpoint):  

70         kpoint['bands'] = []  

71         self.kpoints.append(kpoint)  

72   

73 def get_bands(kpoints):  

74     bands = [[] for b in range(0,len(kpoints[0]['bands']))]  

75   

76     for kp in kpoints:  

77         kp_bands = kp['bands']  

78         for kp_band in kp_bands:  

79             bands[int(kp_band['id']) - 1].append(kp_band['energy'])  

80   

81     return bands

#!/usr/bin/python  

002 import sys  

003 from math import *

004 import numpy  

005 from numpy import *

006 from numpy import dot  

007 import csv  

008 import re  

009 from matplotlib import *

010 from pylab import plot, show, ylim, xlim, yticks, xlabel, ylabel  

011 import matplotlib.path as mpath  

012 import matplotlib.patches as mpatches  

013 import matplotlib.pyplot as plt  

014 from matplotlib.font_manager import FontProperties  

015 import matplotlib  

016   

017 def getMeta(line):  

018  metaMatcher = re.compile("#[^:]+:([^#]+)#[^:]+:([^#]+)#[^:]+:(.+)$")  

019  m = metaMatcher.match(line)  

020  kpointsCount = int(m.group(1))  

021  bandsCount = int(m.group(2))  

022  ionsCount = int(m.group(3))  

023  return (kpointsCount, bandsCount, ionsCount)  

024   

025 def readKPoint(stream, bandsCount, ionsCount):  

026  kpointHeaderMatcher = re.compile("\s*k-point[^:]+:\s*([^\s]+)\s*([^\s]+)\s*([^\s]+)")  

027  line = stream.readline()  

028  while (not kpointHeaderMatcher.match(line)):  

029  line = stream.readline()  

030  kpointHeaderLine = line  

031  m = kpointHeaderMatcher.match(kpointHeaderLine)  

032  kpoint_x = float(m.group(1))  

033  kpoint_y = float(m.group(2))  

034  kpoint_z = float(m.group(3))  

035   

036  bandHeaderMatcher = re.compile(".+energy\s+([^#]+)# occ\.\s(.+)$")  

037   

038  bands = []  

039  for i in range(0,bandsCount):  

040  line = stream.readline()  

041  while (not bandHeaderMatcher.match(line)):  

042  line = stream.readline()  

043  bandHeaderLine = line  

044  energy = float(bandHeaderMatcher.match(line).group(1))  

045   

046  orbitalHeaderMatcher = re.compile("ion\s+s.+tot$")  

047  line = stream.readline()  

048  while (not orbitalHeaderMatcher.match(line)):  

049  line = stream.readline()  

050  orbitalHeaderLine = line  

051   

052  orbitals = []  

053  for j in range(0,ionsCount):  

054  line = stream.readline()  

055  orbitalAssignmentText = line.split()  

056  orbitals.append(orbitalAssignmentText)  

057   

058  bands.append({ "energy": energy,"orbitals": orbitals })  

059  return { "kpoint_x": kpoint_x, "kpoint_y": kpoint_y, "kpoint_z": kpoint_z, "bands": bands }  

060   

061 def readFile(procar):  

062  f = open(procar, "r")  

063  f.readline() # throwaway  

064  metaLine = f.readline() # metadata  

065  kpointsCount, bandsCount, ionsCount = getMeta(metaLine)  

066  kpoints = []  

067  for i in range(0,kpointsCount):  

068  kpoint = readKPoint(f, bandsCount, ionsCount)  

069  kpoints.append(kpoint)  

070  return (kpoints, bandsCount, ionsCount)  

071   

072 kpoints, bandsCount, ionsCount = readFile("/Working/Eclipse/plotting/Molecule2/PROCAR")  

073 kpointsCount = len(kpoints)  

074   

075 orbitalNames = ["s","py","pz","px","dxy","dyz","dz2","dxz","dx2-y2"]  

076   

077 #print "band,ion,s,py,pz,px,dxy,dyz,dz2,dxz,dx2,tot,energy,kpoint_x,kpoint_y,kpoint_z"  

078 print "kpoint,band,ion,energy,character"

079   

080 energies = []  

081 kpointNums = []  

082 Ef = -4.41823711

083   

084 for i in range(0,bandsCount):  

085  energies.append([])  

086   

087 kpointNum = 1

088 for kpoint in kpoints:  

089  bandNum = 0

090  for band in kpoint["bands"]:  

091  for ion in band["orbitals"]:  

092  character = ""  

093  for i in range(1,9):  

094  if float(ion[i]) > 0:  

095  character += orbitalNames[i-1] + " "

096  kpointNums.append(kpointNum)  

097  energies[bandNum].append(band["energy"]-Ef)  

098  bandNum += 1

099  kpointNum += 1

100   

101 rcParams['lines.linewidth'] = 4.0

102 rcParams['font.weight'] = "heavy"

103 rcParams['axes.linewidth'] = 4.0

104 rcParams['xtick.major.size'] = 0.0

105 rcParams['xtick.minor.size'] = 0.0

106 rcParams['ytick.major.size'] = 0.0

107 rcParams['ytick.minor.size'] = 0.0

108   

109 for i in range(0,bandsCount):  

110  plot(range(0,len(energies[i])),energies[i], 'k')  

111 xlim(0,60)  

112 ylim(-8,4)  

113 plt.title("Band Structure")  

114 xlabel("K-Points")  

115 ylabel("Energy(eV)")  

116 plt.show()

Originally posted by hakuna at 2010-10-22 10:20:37:
To obtain band structure plots from the GW method, first you have to perform a DFT calculation. The INCAR file I used for DFT on Si looks like this:

ISTART = 0
ISYM = 0
ICHARG = 2
ISMEAR = 0
...