Skip to content
GitLab
Commit 632e061d authored by Pardini, Lorenzo (lopa)'s avatar Pardini, Lorenzo (lopa)
Browse files

gw xml parser + small fixes

parent 2c7c8b32
Hide whitespace changes
Inline Side-by-side
parser/parser-exciting/exciting_parser_gw.py
View file @ 632e061d
......@@ -5,7 +5,7 @@ from nomadcore.simple_parser import mainFunction, CachingLevel
from nomadcore.simple_parser import SimpleMatcher as SM
from nomadcore.local_meta_info import loadJsonFile, InfoKindEl
from nomadcore.unit_conversion import unit_conversion
import os, sys, json, logging
import os, sys, json, logging, exciting_parser_input
################################################################
# This is the subparser for the exciting GW output
......@@ -48,8 +48,22 @@ class GWParser(object):
vertexLabGWFile = os.path.join(dirPath, "bandstructure.xml")
selfCorGWFile = os.path.join(dirPath, "SELFC.DAT")
inputFile = os.path.join(dirPath, "input.xml")
inputgw1File = os.path.join(dirPath, "input-gw.xml")
inputgw2File = os.path.join(dirPath, "input_gw.xml")
if os.path.exists(inputFile):
if os.path.exists(inputgw1File):
inputgwFile = inputgw1File
elif os.path.exists(inputgw2File):
inputgwFile = inputgw2File
else:
inputgwFile = inputFile
elif os.path.exists(inputgw1File):
inputgwFile = inputgw1File
elif os.path.exists(inputgw2File):
inputgwFile = inputgw2File
if os.path.exists(inputgwFile):
selfGWSetGIndex = backend.openSection("section_method")
backend.addValue('electronic_structure_method', "G0W0")
backend.addValue('gw_starting_point', xcName)
......@@ -58,164 +72,8 @@ class GWParser(object):
backend.addValue("method_to_method_ref", dftMethodSectionGindex)
backend.addValue("method_to_method_kind", "starting_point")
backend.closeNonOverlappingSection("section_method_to_method_refs")
singularity = 'mpd'
actype = 'pade'
npol = 0
scrtype = "rpa"
snempty = 0
pnempty = 0
coreflag = "all"
fgrid = "gaule2"
lmaxmb = 3
epsmb = 0.0001
gmb = 1.0
sciavtype = "isotropic"
cutofftype = "none"
pwm = 2.0
ngridq = [2,2,2]
freqmax = 1.0
nomeg = 16
k1 = 0
k2 = 0
# f1 = 0
# f2 = 0
s1 = 0
s2 = 0
m1 = 0
m2 = 0
bc1 = 0
bc2 = 0
sc1 = 0
sc2 = 0
with open(inputFile) as g:
i = 0
while 1:
s = g.readline()
i += 1
if not s: break
s = s.strip()
s = s.split('=')
if s[0] == "<gw": k1 = i
if s[0] == "</gw>": k2 = i
if s[0] == "<freqgrid": f1 = i
if s[0] == "</freqgrid>": f2 = i
if s[0] == "<selfenergy": s1 = i
if s[0] == "</selfenergy>": s2 = i
if s[0] == "<mixbasis": m1 = i
if s[0] == "</mixbasis>": m2 = i
if s[0] == "<barecoul": bc1 = i
if s[0] == "</barecoul>": bc2 = i
if s[0] == "<scrcoul": sc1 = i
if s[0] == "</scrcoul>": sc2 = i
# print("m1= ",m1)
# print("m2= ",m2)
with open(inputFile) as g:
i = 0
while 1:
s = g.readline()
i += 1
if not s: break
s = s.strip()
s = s.split('=')
if (s[0] == "coreflag") and (i >= k1) and (i < (k2-1)):
coreflag = s[1][1:-1]
elif (s[0] == "coreflag") and (i == (k2-1)):
coreflag = s[1][1:-2]
if (s[0] == "singularity") and (i >= k1) and (i < (k2-1)):
freq_conv = s[1][1:-1]
elif (s[0] == "singularity") and (i == (k2-1)):
freq_conv = s[1][1:-2]
if (s[0] == "actype") and (i >= k1) and (i < (k2-1)):
actype = s[1][1:-1]
elif (s[0] == "actype") and (i == (k2-1)):
actype = s[1][1:-2]
if (s[0] == "ngridq") and (i >= k1) and (i < (k2-1)):
dummy = s[1].split('"')
dummy1 = dummy[1].split()
for j in range(0,3):
ngridq[j] = int(dummy1[j])
elif (s[0] == "ngrid") and (i == (k2-1)):
dummy = s[1].split('"')
dummy1 = dummy[1].split()
for j in range(0,3):
ngridq[j] = int(dummy1[j])
if (s[0] == "npol") and (i >= k1) and (i < (k2-1)):
npol = int(s[1][1:-1])
elif (s[0] == "npol") and (i == (k2-1)):
npol = int(s[1][1:-2])
if (s[0] == "nempty") and (i >= k1) and (i < (k2-1)):
pnempty = int(s[1][1:-1])
elif (s[0] == "nempty") and (i == (k2-1)):
pnempty = int(s[1][1:-2])
if (s[0] == "scrtype") and (i >= k1) and (i < (k2-1)):
scrtype = s[1][1:-1]
elif (s[0] == "scrtype") and (i == (k2-1)):
scrtype = s[1][1:-2]
if (s[0] == "nempty") and (i >= s1) and (i < (s2-1)):
snempty = int(s[1][1:-1])
elif (s[0] == "nempty") and (i == (s2-1)):
snempty = int(s[1][1:-2])
if (s[0] == "freqmax") and (i >= f1) and (i < (f2-1)):
freqmax = float(s[1][1:-1])
elif (s[0] == "freqmax") and (i == (f2-1)):
freqmax = float(s[1][1:-2])
if (s[0] == "nomeg") and (i >= f1) and (i < (f2-1)):
nomeg = int(s[1][1:-1])
elif (s[0] == "nomeg") and (i == (f2-1)):
nomeg = int(s[1][1:-2])
if (s[0] == "lmaxmb") and (i >= m1) and (i < (m2-1)):
lmaxmb = int(s[1][1:-1])
elif (s[0] == "lmaxmb") and (i == (m2-1)):
lmaxmb = int(s[1][1:-2])
if (s[0] == "epsmb") and (i >= m1) and (i < (m2-1)):
epsmb = float(s[1][1:-1])
elif (s[0] == "epsmb") and (i == (m2-1)):
epsmb = float(s[1][1:-2])
if (s[0] == "gmb") and (i >= m1) and (i < (m2-1)):
gmb = float(s[1][1:-1])
elif (s[0] == "gmb") and (i == (m2-1)):
gmb = float(s[1][1:-2])
if (s[0] == "sciavtype") and (i >= sc1) and (i < (sc2-1)):
sciavtype = s[1][1:-1]
elif (s[0] == "sciavtype") and (i == (sc2-1)):
sciavtype = s[1][1:-2]
if (s[0] == "fgrid") and (i >= k1) and (i < (k2-1)):
fgrid = s[1][1:-1]
elif (s[0] == "fgrid") and (i == (k2-1)):
fgrid = s[1][1:-2]
if (s[0] == "pwm") and (i >= bc1) and (i < (bc2-1)):
pwm = float(s[1][1:-1])
elif (s[0] == "pwm") and (i == (bc2-1)):
pwm = float(s[1][1:-2])
if (s[0] == "cutofftype") and (i >= bc1) and (i < (bc2-1)):
cutofftype = s[1][1:-1]
elif (s[0] == "cutofftype") and (i == (bc2-1)):
cutofftype = s[1][1:-2]
# gmb = gmb*self.gmaxvr
# pwm = pwm*gmb*self.gmaxvr
# print("gmb= ",type(gmb))
# print("pwm= ", type(pwm))
# print("self.gmaxvr= ",type(self.gmaxvr))
backend.addValue("gw_frequency_grid_type", fgrid)
backend.addValue("gw_self_energy_c_number_of_empty_states", int(snempty))
backend.addValue("gw_core_treatment", coreflag)
backend.addValue("gw_self_energy_singularity_treatment", singularity)
backend.addValue("gw_self_energy_c_analytical_continuation", actype)
backend.addValue("gw_self_energy_c_number_of_poles", int(npol))
backend.addValue("gw_screened_Coulomb", scrtype)
backend.addValue("gw_polarizability_number_of_empty_states", int(pnempty))
backend.addValue("gw_basis_set", "mixed")
backend.addValue("gw_mixed_basis_lmax", lmaxmb)
backend.addValue("gw_mixed_basis_tolerance", epsmb)
backend.addValue("gw_mixed_basis_gmax", gmb*self.gmaxvr)
backend.addValue("gw_screened_coulomb_volume_average",sciavtype)
backend.addValue("gw_bare_coulomb_gmax", pwm*gmb*self.gmaxvr)
backend.addValue("gw_ngridq", ngridq)
backend.addValue("gw_bare_coulomb_cutofftype", cutofftype)
backend.addValue("gw_max_frequency", freqmax)
backend.addValue("gw_number_of_frequencies", nomeg)
backend.addValue("gw_qp_equation_treatment", "linearization")
# backend.addArrayValues
with open(inputgwFile) as f:
exciting_parser_input.parseInput(f, backend, self.gmaxvr)
backend.closeSection("section_method",selfGWSetGIndex)
if os.path.exists(vertexGWFile):
......
parser/parser-exciting/exciting_parser_input.py
View file @ 632e061d
import xml.sax
import logging
import numpy as np
from nomadcore.unit_conversion.unit_conversion import convert_unit_function
from nomadcore.unit_conversion.unit_conversion import convert_unit
from nomadcore.unit_conversion import unit_conversion
class InputHandler(xml.sax.handler.ContentHandler):
def __init__(self, backend):
def __init__(self, backend, gmaxvr):
self.gmaxvr = gmaxvr
self.backend = backend
self.inputSectionGIndex = -1
self.inInput = False
self.inGWInput = False
self.freqmax = 1.0
self.singularity = 'mpd'
self.actype = 'pade'
self.npol = 0
self.scrtype = "rpa"
self.snempty = 0
self.pnempty = 0
self.coreflag = "all"
self.fgrid = "gaule2"
self.lmaxmb = 3
self.epsmb = 0.0001
self.gmb = 1.0
self.sciavtype = "isotropic"
self.cutofftype = "none"
self.pwm = 2.0
self.ngridqDum = "2 2 2"
self.ngridq = [2,2,2]
self.nomeg = 16
self.freqgrid = "none"
self.selfenergy = "none"
self.mixbasis = "none"
self.barecoul = "none"
self.scrcoul = "none"
def endDocument(self):
pass
if self.freqgrid == "none":
self.backend.addValue("gw_max_frequency", self.freqmax)
self.backend.addValue("gw_frequency_grid_type", self.fgrid)
self.backend.addValue("gw_number_of_frequencies", self.nomeg)
if self.selfenergy == "none":
self.backend.addValue("gw_self_energy_c_number_of_poles", int(self.npol))
self.backend.addValue("gw_self_energy_c_number_of_empty_states", int(self.snempty))
self.backend.addValue("gw_self_energy_singularity_treatment", self.singularity)
self.backend.addValue("gw_self_energy_c_analytical_continuation", self.actype)
if self.mixbasis == "none":
self.backend.addValue("gw_mixed_basis_lmax", self.lmaxmb)
self.backend.addValue("gw_mixed_basis_tolerance", self.epsmb)
self.backend.addValue("gw_mixed_basis_gmax", self.gmb*self.gmaxvr)
if self.barecoul == "none":
self.backend.addValue("gw_bare_coulomb_gmax", self.pwm*self.gmb*self.gmaxvr)
self.backend.addValue("gw_bare_coulomb_cutofftype", self.cutofftype)
if self.scrcoul == "none":
self.backend.addValue("gw_screened_coulomb_volume_average",self.sciavtype)
self.backend.addValue("gw_screened_Coulomb", self.scrtype)
self.backend.addValue("gw_basis_set", "mixed")
self.backend.addValue("gw_qp_equation_treatment", "linearization")
for j in range(0,3):
self.ngridq[j] = int(self.ngridqDum[j])
self.backend.addValue("gw_ngridq", self.ngridq)
def startElement(self, name, attrs):
if name == "structure":
fromH = unit_conversion.convert_unit_function("hartree", "J")
if name == "gw":
self.inputSectionGIndex = self.backend.openSection("section_system")
self.inInput = True
elif name == "atom" and self.inInput:
g = attrs.getValue('coord')
# print ("coord=", g)
# self.backend.addValue("atom_positions",float(attrs.getValue('coord')))
# self.backend.addValue("x_exciting_dos_energy",float(attrs.getValue('e')))
# attrDict={}
# for name in attrs.getNames():
# attrDict[name] = attrs.getValue(name)
# logging.error("start element %s attr %s", name, attrDict)
self.inGWInput = True
try:
self.coreflag = attrs.getValue('coreflag')
self.backend.addValue("gw_core_treatment", self.coreflag)
except:
self.coreflag = "all"
self.backend.addValue("gw_core_treatment", self.coreflag)
try:
self.pnempty = attrs.getValue('nempty')
self.backend.addValue("gw_polarizability_number_of_empty_states", int(self.pnempty))
except:
self.pnempty = 0
self.backend.addValue("gw_polarizability_number_of_empty_states", int(self.pnempty))
try:
dummy = attrs.getValue('ngridq')
self.ngridqDum = dummy.split()
except:
self.ngridqDum = "2 2 2"
elif name == "freqgrid":
self.freqgrid = "freqgrid"
try:
self.freqmax = attrs.getValue('freqmax')
self.backend.addValue("gw_max_frequency", float(self.freqmax))
except:
self.freqmax = 1.0
self.backend.addValue("gw_max_frequency", self.freqmax)
try:
self.fgrid = attrs.getValue('fgrid')
self.backend.addValue("gw_frequency_grid_type", self.fgrid)
except:
self.fgrid = "gaule2"
self.backend.addValue("gw_frequency_grid_type", self.fgrid)
try:
self.nomeg = attrs.getValue('nomeg')
self.backend.addValue("gw_number_of_frequencies", int(self.nomeg))
except:
self.nomeg = 16
self.backend.addValue("gw_number_of_frequencies", self.nomeg)
elif name == "selfenergy":
self.selfenergy = "selfenergy"
try:
self.npol = attrs.getValue('npol')
self.backend.addValue("gw_self_energy_c_number_of_poles", int(self.npol))
except:
self.npol = 0
self.backend.addValue("gw_self_energy_c_number_of_poles", self.npol)
try:
self.snempty = attrs.getValue('nempty')
self.backend.addValue("gw_self_energy_c_number_of_empty_states", int(self.snempty))
except:
self.snempty = 0
self.backend.addValue("gw_self_energy_c_number_of_empty_states", self.snempty)
try:
self.singularity = attrs.getValue('singularity')
self.backend.addValue("gw_self_energy_singularity_treatment", self.singularity)
except:
self.singularity = 'mpd'
self.backend.addValue("gw_self_energy_singularity_treatment", self.singularity)
try:
self.actype = attrs.getValue('actype')
self.backend.addValue("gw_self_energy_c_analytical_continuation", self.actype)
except:
self.actype = 'pade'
self.backend.addValue("gw_self_energy_c_analytical_continuation", self.actype)
elif name == "mixbasis":
self.mixbasis = "mixbasis"
try:
self.lmaxmb = attrs.getValue('lmaxmb')
self.backend.addValue("gw_mixed_basis_lmax", int(self.lmaxmb))
except:
self.lmaxmb = 3
self.backend.addValue("gw_mixed_basis_lmax", self.lmaxmb)
try:
self.epsmb = attrs.getValue('epsmb')
self.backend.addValue("gw_mixed_basis_tolerance", float(self.epsmb))
except:
self.epsmb = 0.0001
self.backend.addValue("gw_mixed_basis_tolerance", self.epsmb)
try:
self.gmb = attrs.getValue('gmb')
self.backend.addValue("gw_mixed_basis_gmax", float(self.gmb)*self.gmaxvr)
except:
self.gmb = 1.0
self.backend.addValue("gw_mixed_basis_gmax", self.gmb*self.gmaxvr)
elif name == "barecoul":
self.barecoul = "barecoul"
try:
self.pwm = attrs.getValue('pwm')
self.backend.addValue("gw_bare_coulomb_gmax", float(self.pwm)*float(self.gmb)*self.gmaxvr)
except:
self.pwm = 2.0
self.backend.addValue("gw_bare_coulomb_gmax", self.pwm*float(self.gmb)*self.gmaxvr)
try:
self.cutofftype = attrs.getValue('cutofftype')
self.backend.addValue("gw_bare_coulomb_cutofftype", self.cutofftype)
except:
self.cutofftype = "none"
self.backend.addValue("gw_bare_coulomb_cutofftype", self.cutofftype)
elif name == "scrcoul":
self.scrcoul = "scrcoul"
try:
self.sciavtype = attrs.getValue('sciavtype')
self.backend.addValue("gw_screened_coulomb_volume_average",self.sciavtype)
except:
self.sciavtype = "isotropic"
self.backend.addValue("gw_screened_coulomb_volume_average",self.sciavtype)
try:
self.scrtype = attrs.getValue('scrtype')
self.backend.addValue("gw_screened_Coulomb", self.scrtype)
except:
self.scrtype = "rpa"
self.backend.addValue("gw_screened_Coulomb", self.scrtype)
def endElement(self, name):
if name == 'structure':
self.inInput = False
self.backend.closeSection("section_system",self.inputSectionGIndex)
self.inputSectionGIndex = -1
# logging.error("end element %s", name)
# def startElementNS(self, name, qname, attrs):
# attrDict={}
# for name in attrs.getNames():
# attrDict[name] = attrs.getValue(name)
# logging.error("start element %s ns %s attr %s", name, qname, attrDict)
# def endElementNS(self, name, qname):
# logging.error("end element %s ns %s", name, qname)
# def characters(self, content):
# pass
def parseInput(inF, backend):
handler = InputHandler(backend)
pass
def parseInput(inF, backend, gmaxvr):
handler = InputHandler(backend, gmaxvr)
logging.error("will parse")
xml.sax.parse(inF, handler)
logging.error("did parse")
parser/parser-exciting/parser_exciting.py
View file @ 632e061d
......@@ -6,7 +6,7 @@ from nomadcore.simple_parser import SimpleMatcher as SM, mainFunction
from nomadcore.local_meta_info import loadJsonFile, InfoKindEl
from nomadcore.caching_backend import CachingLevel
from nomadcore.unit_conversion import unit_conversion
import os, sys, json, exciting_parser_dos,exciting_parser_bandstructure, exciting_parser_gw #, exciting_parser_gw_bor
import os, sys, json, exciting_parser_dos,exciting_parser_bandstructure, exciting_parser_gw #, exciting_parser_input
from ase import Atoms
import logging
......@@ -122,6 +122,7 @@ class ExcitingParserContext(object):
bandFile = os.path.join(dirPath, "bandstructure.xml")
fermiSurfFile = os.path.join(dirPath, "FERMISURF.bxsf")
eigvalFile = os.path.join(dirPath, "EIGVAL.OUT")
# inputFile = os.path.join(dirPath, "input.xml")
# logging.error("done BASE onClose_section_single_configuration_calculation")
if os.path.exists(dosFile):
......@@ -270,8 +271,9 @@ class ExcitingParserContext(object):
smearing_internal_map = {
"Gaussian": ['gaussian'],
"Methfessel-Paxton": ['methfessel-paxton'],
"Fermi-Dirac": ['fermi'],
"Methfessel-Paxton 1": ['methfessel-paxton'],
"Methfessel-Paxton 2": ['methfessel-paxton'],
"Fermi Dirac": ['fermi'],
"Extended": ['tetrahedra']
}
......
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment