nomad-parser-plugins-electronic 1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- electronicparsers/__init__.py +1162 -0
- electronicparsers/abacus/__init__.py +20 -0
- electronicparsers/abacus/__main__.py +32 -0
- electronicparsers/abacus/metainfo/__init__.py +19 -0
- electronicparsers/abacus/metainfo/abacus.py +836 -0
- electronicparsers/abacus/nomad_plugin.yaml +44 -0
- electronicparsers/abacus/parser.py +1975 -0
- electronicparsers/abinit/__init__.py +19 -0
- electronicparsers/abinit/__main__.py +31 -0
- electronicparsers/abinit/metainfo/__init__.py +20 -0
- electronicparsers/abinit/metainfo/abinit.py +871 -0
- electronicparsers/abinit/metainfo/abinit_autogenerated.py +6794 -0
- electronicparsers/abinit/nomad_plugin.yaml +43 -0
- electronicparsers/abinit/parser.py +1922 -0
- electronicparsers/ams/__init__.py +19 -0
- electronicparsers/ams/__main__.py +31 -0
- electronicparsers/ams/metainfo/__init__.py +19 -0
- electronicparsers/ams/metainfo/ams.py +769 -0
- electronicparsers/ams/nomad_plugin.yaml +19 -0
- electronicparsers/ams/parser.py +1849 -0
- electronicparsers/ams/rkf.py +620 -0
- electronicparsers/atk/__init__.py +19 -0
- electronicparsers/atk/__main__.py +31 -0
- electronicparsers/atk/metainfo/__init__.py +19 -0
- electronicparsers/atk/metainfo/atk.py +71 -0
- electronicparsers/atk/nomad_plugin.yaml +34 -0
- electronicparsers/atk/parser.py +388 -0
- electronicparsers/bigdft/__init__.py +19 -0
- electronicparsers/bigdft/__main__.py +31 -0
- electronicparsers/bigdft/metainfo/__init__.py +18 -0
- electronicparsers/bigdft/nomad_plugin.yaml +19 -0
- electronicparsers/bigdft/parser.py +372 -0
- electronicparsers/castep/__init__.py +19 -0
- electronicparsers/castep/__main__.py +31 -0
- electronicparsers/castep/metainfo/__init__.py +19 -0
- electronicparsers/castep/metainfo/castep.py +2481 -0
- electronicparsers/castep/nomad_plugin.yaml +28 -0
- electronicparsers/castep/parser.py +1680 -0
- electronicparsers/charmm/__init__.py +19 -0
- electronicparsers/charmm/__main__.py +31 -0
- electronicparsers/charmm/metainfo/__init__.py +19 -0
- electronicparsers/charmm/metainfo/charmm.py +1931 -0
- electronicparsers/charmm/nomad_plugin.yaml +18 -0
- electronicparsers/charmm/parser.py +61 -0
- electronicparsers/cp2k/__init__.py +19 -0
- electronicparsers/cp2k/__main__.py +31 -0
- electronicparsers/cp2k/metainfo/__init__.py +19 -0
- electronicparsers/cp2k/metainfo/cp2k.py +59185 -0
- electronicparsers/cp2k/metainfo/cp2k_general.py +1014 -0
- electronicparsers/cp2k/nomad_plugin.yaml +49 -0
- electronicparsers/cp2k/parser.py +2324 -0
- electronicparsers/cpmd/__init__.py +19 -0
- electronicparsers/cpmd/__main__.py +31 -0
- electronicparsers/cpmd/metainfo/__init__.py +19 -0
- electronicparsers/cpmd/metainfo/cpmd.py +10733 -0
- electronicparsers/cpmd/metainfo/cpmd_general.py +988 -0
- electronicparsers/cpmd/nomad_plugin.yaml +19 -0
- electronicparsers/cpmd/parser.py +680 -0
- electronicparsers/crystal/__init__.py +19 -0
- electronicparsers/crystal/__main__.py +31 -0
- electronicparsers/crystal/metainfo/__init__.py +19 -0
- electronicparsers/crystal/metainfo/crystal.py +619 -0
- electronicparsers/crystal/nomad_plugin.yaml +36 -0
- electronicparsers/crystal/parser.py +1745 -0
- electronicparsers/dmol3/__init__.py +19 -0
- electronicparsers/dmol3/__main__.py +31 -0
- electronicparsers/dmol3/metainfo/__init__.py +19 -0
- electronicparsers/dmol3/metainfo/dmol3.py +664 -0
- electronicparsers/dmol3/nomad_plugin.yaml +19 -0
- electronicparsers/dmol3/parser.py +750 -0
- electronicparsers/edmft/__init__.py +19 -0
- electronicparsers/edmft/__main__.py +31 -0
- electronicparsers/edmft/metainfo/__init__.py +19 -0
- electronicparsers/edmft/metainfo/edmft.py +96 -0
- electronicparsers/edmft/nomad_plugin.yaml +53 -0
- electronicparsers/edmft/parser.py +912 -0
- electronicparsers/elk/__init__.py +19 -0
- electronicparsers/elk/__main__.py +31 -0
- electronicparsers/elk/metainfo/__init__.py +19 -0
- electronicparsers/elk/metainfo/elk.py +775 -0
- electronicparsers/elk/nomad_plugin.yaml +19 -0
- electronicparsers/elk/parser.py +493 -0
- electronicparsers/exciting/__init__.py +19 -0
- electronicparsers/exciting/__main__.py +31 -0
- electronicparsers/exciting/metainfo/__init__.py +19 -0
- electronicparsers/exciting/metainfo/exciting.py +2942 -0
- electronicparsers/exciting/nomad_plugin.yaml +83 -0
- electronicparsers/exciting/parser.py +3398 -0
- electronicparsers/fhiaims/__init__.py +19 -0
- electronicparsers/fhiaims/__main__.py +31 -0
- electronicparsers/fhiaims/metainfo/__init__.py +19 -0
- electronicparsers/fhiaims/metainfo/fhi_aims.py +1565 -0
- electronicparsers/fhiaims/nomad_plugin.yaml +52 -0
- electronicparsers/fhiaims/parser.py +2582 -0
- electronicparsers/fleur/__init__.py +19 -0
- electronicparsers/fleur/__main__.py +31 -0
- electronicparsers/fleur/metainfo/__init__.py +19 -0
- electronicparsers/fleur/metainfo/fleur.py +623 -0
- electronicparsers/fleur/nomad_plugin.yaml +19 -0
- electronicparsers/fleur/parser.py +952 -0
- electronicparsers/fplo/__init__.py +19 -0
- electronicparsers/fplo/__main__.py +31 -0
- electronicparsers/fplo/metainfo/__init__.py +19 -0
- electronicparsers/fplo/metainfo/fplo.py +188 -0
- electronicparsers/fplo/metainfo/fplo_input_autogenerated.py +2744 -0
- electronicparsers/fplo/metainfo/fplo_temporaries.py +319 -0
- electronicparsers/fplo/nomad_plugin.yaml +19 -0
- electronicparsers/fplo/parser.py +42 -0
- electronicparsers/gamess/__init__.py +19 -0
- electronicparsers/gamess/__main__.py +31 -0
- electronicparsers/gamess/metainfo/__init__.py +19 -0
- electronicparsers/gamess/metainfo/gamess.py +837 -0
- electronicparsers/gamess/nomad_plugin.yaml +19 -0
- electronicparsers/gamess/parser.py +941 -0
- electronicparsers/gaussian/__init__.py +19 -0
- electronicparsers/gaussian/__main__.py +31 -0
- electronicparsers/gaussian/metainfo/__init__.py +19 -0
- electronicparsers/gaussian/metainfo/gaussian.py +1707 -0
- electronicparsers/gaussian/nomad_plugin.yaml +18 -0
- electronicparsers/gaussian/parser.py +1556 -0
- electronicparsers/gpaw/__init__.py +19 -0
- electronicparsers/gpaw/__main__.py +31 -0
- electronicparsers/gpaw/metainfo/__init__.py +19 -0
- electronicparsers/gpaw/metainfo/gpaw.py +214 -0
- electronicparsers/gpaw/nomad_plugin.yaml +19 -0
- electronicparsers/gpaw/parser.py +671 -0
- electronicparsers/magres/__init__.py +19 -0
- electronicparsers/magres/__main__.py +31 -0
- electronicparsers/magres/metainfo/__init__.py +19 -0
- electronicparsers/magres/metainfo/magres.py +110 -0
- electronicparsers/magres/nomad_plugin.yaml +18 -0
- electronicparsers/magres/parser.py +505 -0
- electronicparsers/molcas/__init__.py +19 -0
- electronicparsers/molcas/__main__.py +31 -0
- electronicparsers/molcas/metainfo/__init__.py +19 -0
- electronicparsers/molcas/metainfo/molcas.py +151 -0
- electronicparsers/molcas/nomad_plugin.yaml +19 -0
- electronicparsers/molcas/parser.py +59 -0
- electronicparsers/mopac/__init__.py +19 -0
- electronicparsers/mopac/__main__.py +31 -0
- electronicparsers/mopac/metainfo/__init__.py +19 -0
- electronicparsers/mopac/metainfo/mopac.py +79 -0
- electronicparsers/mopac/nomad_plugin.yaml +19 -0
- electronicparsers/mopac/parser.py +304 -0
- electronicparsers/nwchem/__init__.py +19 -0
- electronicparsers/nwchem/__main__.py +31 -0
- electronicparsers/nwchem/metainfo/__init__.py +19 -0
- electronicparsers/nwchem/metainfo/nwchem.py +487 -0
- electronicparsers/nwchem/nomad_plugin.yaml +19 -0
- electronicparsers/nwchem/parser.py +757 -0
- electronicparsers/ocean/__init__.py +19 -0
- electronicparsers/ocean/__main__.py +31 -0
- electronicparsers/ocean/metainfo/__init__.py +19 -0
- electronicparsers/ocean/metainfo/ocean.py +410 -0
- electronicparsers/ocean/nomad_plugin.yaml +37 -0
- electronicparsers/ocean/parser.py +344 -0
- electronicparsers/octopus/__init__.py +19 -0
- electronicparsers/octopus/__main__.py +31 -0
- electronicparsers/octopus/metainfo/__init__.py +19 -0
- electronicparsers/octopus/metainfo/octopus.py +71 -0
- electronicparsers/octopus/metainfo/octopus_autogenerated.py +11647 -0
- electronicparsers/octopus/nomad_plugin.yaml +41 -0
- electronicparsers/octopus/parser.py +1214 -0
- electronicparsers/onetep/__init__.py +19 -0
- electronicparsers/onetep/__main__.py +31 -0
- electronicparsers/onetep/metainfo/__init__.py +19 -0
- electronicparsers/onetep/metainfo/onetep.py +3443 -0
- electronicparsers/onetep/nomad_plugin.yaml +19 -0
- electronicparsers/onetep/parser.py +577 -0
- electronicparsers/openmx/__init__.py +19 -0
- electronicparsers/openmx/__main__.py +31 -0
- electronicparsers/openmx/metainfo/__init__.py +19 -0
- electronicparsers/openmx/metainfo/openmx.py +24 -0
- electronicparsers/openmx/nomad_plugin.yaml +25 -0
- electronicparsers/openmx/parser.py +918 -0
- electronicparsers/orca/__init__.py +19 -0
- electronicparsers/orca/__main__.py +31 -0
- electronicparsers/orca/metainfo/__init__.py +19 -0
- electronicparsers/orca/metainfo/orca.py +1448 -0
- electronicparsers/orca/nomad_plugin.yaml +19 -0
- electronicparsers/orca/parser.py +1371 -0
- electronicparsers/psi4/__init__.py +19 -0
- electronicparsers/psi4/__main__.py +31 -0
- electronicparsers/psi4/metainfo/__init__.py +19 -0
- electronicparsers/psi4/metainfo/psi4.py +372 -0
- electronicparsers/psi4/nomad_plugin.yaml +27 -0
- electronicparsers/psi4/parser.py +1362 -0
- electronicparsers/qball/__init__.py +19 -0
- electronicparsers/qball/__main__.py +31 -0
- electronicparsers/qball/metainfo/__init__.py +19 -0
- electronicparsers/qball/metainfo/qball.py +27 -0
- electronicparsers/qball/nomad_plugin.yaml +25 -0
- electronicparsers/qball/parser.py +152 -0
- electronicparsers/qbox/__init__.py +19 -0
- electronicparsers/qbox/__main__.py +31 -0
- electronicparsers/qbox/metainfo/__init__.py +19 -0
- electronicparsers/qbox/metainfo/qbox.py +490 -0
- electronicparsers/qbox/nomad_plugin.yaml +19 -0
- electronicparsers/qbox/parser.py +508 -0
- electronicparsers/quantumespresso/__init__.py +19 -0
- electronicparsers/quantumespresso/__main__.py +31 -0
- electronicparsers/quantumespresso/metainfo/__init__.py +19 -0
- electronicparsers/quantumespresso/metainfo/quantum_espresso.py +3296 -0
- electronicparsers/quantumespresso/nomad_plugin.yaml +31 -0
- electronicparsers/quantumespresso/parser.py +3594 -0
- electronicparsers/siesta/__init__.py +19 -0
- electronicparsers/siesta/__main__.py +31 -0
- electronicparsers/siesta/metainfo/__init__.py +19 -0
- electronicparsers/siesta/metainfo/siesta.py +141 -0
- electronicparsers/siesta/metainfo/siesta_autogenerated.py +3365 -0
- electronicparsers/siesta/nomad_plugin.yaml +19 -0
- electronicparsers/siesta/parser.py +607 -0
- electronicparsers/soliddmft/__init__.py +19 -0
- electronicparsers/soliddmft/__main__.py +31 -0
- electronicparsers/soliddmft/metainfo/__init__.py +19 -0
- electronicparsers/soliddmft/metainfo/soliddmft.py +274 -0
- electronicparsers/soliddmft/nomad_plugin.yaml +26 -0
- electronicparsers/soliddmft/parser.py +727 -0
- electronicparsers/tbstudio/__init__.py +19 -0
- electronicparsers/tbstudio/__main__.py +31 -0
- electronicparsers/tbstudio/metainfo/__init__.py +19 -0
- electronicparsers/tbstudio/metainfo/tbstudio.py +34 -0
- electronicparsers/tbstudio/nomad_plugin.yaml +24 -0
- electronicparsers/tbstudio/parser.py +412 -0
- electronicparsers/turbomole/__init__.py +19 -0
- electronicparsers/turbomole/__main__.py +31 -0
- electronicparsers/turbomole/metainfo/__init__.py +19 -0
- electronicparsers/turbomole/metainfo/turbomole.py +727 -0
- electronicparsers/turbomole/nomad_plugin.yaml +18 -0
- electronicparsers/turbomole/parser.py +1585 -0
- electronicparsers/utils/__init__.py +20 -0
- electronicparsers/utils/magres_workflow.py +61 -0
- electronicparsers/utils/utils.py +636 -0
- electronicparsers/vasp/__init__.py +19 -0
- electronicparsers/vasp/__main__.py +31 -0
- electronicparsers/vasp/metainfo/__init__.py +19 -0
- electronicparsers/vasp/metainfo/vasp.py +169 -0
- electronicparsers/vasp/metainfo/vasp_incars.py +3428 -0
- electronicparsers/vasp/metainfo/vasp_incarsOut.py +3428 -0
- electronicparsers/vasp/metainfo/vasp_incarsUnknown.py +86 -0
- electronicparsers/vasp/nomad_plugin.yaml +28 -0
- electronicparsers/vasp/parser.py +2340 -0
- electronicparsers/w2dynamics/__init__.py +19 -0
- electronicparsers/w2dynamics/__main__.py +31 -0
- electronicparsers/w2dynamics/metainfo/__init__.py +19 -0
- electronicparsers/w2dynamics/metainfo/w2dynamics.py +1270 -0
- electronicparsers/w2dynamics/nomad_plugin.yaml +36 -0
- electronicparsers/w2dynamics/parser.py +674 -0
- electronicparsers/wannier90/__init__.py +19 -0
- electronicparsers/wannier90/__main__.py +31 -0
- electronicparsers/wannier90/metainfo/__init__.py +19 -0
- electronicparsers/wannier90/metainfo/wannier90.py +56 -0
- electronicparsers/wannier90/nomad_plugin.yaml +34 -0
- electronicparsers/wannier90/parser.py +671 -0
- electronicparsers/wien2k/__init__.py +19 -0
- electronicparsers/wien2k/__main__.py +31 -0
- electronicparsers/wien2k/metainfo/__init__.py +19 -0
- electronicparsers/wien2k/metainfo/wien2k.py +783 -0
- electronicparsers/wien2k/nomad_plugin.yaml +18 -0
- electronicparsers/wien2k/parser.py +1133 -0
- electronicparsers/yambo/__init__.py +19 -0
- electronicparsers/yambo/__main__.py +31 -0
- electronicparsers/yambo/metainfo/__init__.py +19 -0
- electronicparsers/yambo/metainfo/yambo.py +577 -0
- electronicparsers/yambo/nomad_plugin.yaml +31 -0
- electronicparsers/yambo/parser.py +896 -0
- nomad_parser_plugins_electronic-1.0.dist-info/LICENSE +202 -0
- nomad_parser_plugins_electronic-1.0.dist-info/METADATA +360 -0
- nomad_parser_plugins_electronic-1.0.dist-info/RECORD +272 -0
- nomad_parser_plugins_electronic-1.0.dist-info/WHEEL +5 -0
- nomad_parser_plugins_electronic-1.0.dist-info/entry_points.txt +43 -0
- nomad_parser_plugins_electronic-1.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,2340 @@
|
|
|
1
|
+
#
|
|
2
|
+
# Copyright The NOMAD Authors.
|
|
3
|
+
#
|
|
4
|
+
# This file is part of NOMAD.
|
|
5
|
+
# See https://nomad-lab.eu for further info.
|
|
6
|
+
#
|
|
7
|
+
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
8
|
+
# you may not use this file except in compliance with the License.
|
|
9
|
+
# You may obtain a copy of the License at
|
|
10
|
+
#
|
|
11
|
+
# http://www.apache.org/licenses/LICENSE-2.0
|
|
12
|
+
#
|
|
13
|
+
# Unless required by applicable law or agreed to in writing, software
|
|
14
|
+
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
15
|
+
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
16
|
+
# See the License for the specific language governing permissions and
|
|
17
|
+
# limitations under the License.
|
|
18
|
+
#
|
|
19
|
+
|
|
20
|
+
"""
|
|
21
|
+
To foster reuse of common code between paring run and OURCAR files, this module uses
|
|
22
|
+
several parser classes and hierarchies. The public :class:`VASPParser` provides an
|
|
23
|
+
interface to both parsers. This parser retrieves the content from a run or OURCAR specific
|
|
24
|
+
:class:`ContentParser` and builds the NOMAD archive.
|
|
25
|
+
|
|
26
|
+
The two content parsers :class:`RunContentParser` and
|
|
27
|
+
:class:`OutcarContentParser` provide functionality to retrieve properties from their
|
|
28
|
+
respective file format. They both use separate file (:class:`RunFileParser`) and text
|
|
29
|
+
(:class:`OutcarTextParser`) parsers to read content content from either xml or text files.
|
|
30
|
+
"""
|
|
31
|
+
|
|
32
|
+
from typing import List, Any, Union, Optional
|
|
33
|
+
import os
|
|
34
|
+
import numpy as np
|
|
35
|
+
from datetime import datetime
|
|
36
|
+
import ase
|
|
37
|
+
import re
|
|
38
|
+
from xml.sax import ContentHandler, make_parser # type: ignore
|
|
39
|
+
|
|
40
|
+
from nomad.utils import get_logger
|
|
41
|
+
from nomad.units import ureg
|
|
42
|
+
from nomad.parsing.file_parser import FileParser
|
|
43
|
+
from nomad.parsing.file_parser.text_parser import TextParser, Quantity
|
|
44
|
+
from runschema.system import (
|
|
45
|
+
System,
|
|
46
|
+
Atoms,
|
|
47
|
+
AtomsGroup,
|
|
48
|
+
)
|
|
49
|
+
from runschema.run import Run, Program
|
|
50
|
+
from runschema.method import (
|
|
51
|
+
Method,
|
|
52
|
+
BasisSet,
|
|
53
|
+
BasisSetContainer,
|
|
54
|
+
DFT,
|
|
55
|
+
HubbardKanamoriModel,
|
|
56
|
+
AtomParameters,
|
|
57
|
+
XCFunctional,
|
|
58
|
+
Functional,
|
|
59
|
+
Electronic,
|
|
60
|
+
Scf,
|
|
61
|
+
KMesh,
|
|
62
|
+
GW,
|
|
63
|
+
FrequencyMesh,
|
|
64
|
+
Pseudopotential,
|
|
65
|
+
CoreHole,
|
|
66
|
+
)
|
|
67
|
+
from runschema.calculation import (
|
|
68
|
+
Calculation,
|
|
69
|
+
Energy,
|
|
70
|
+
EnergyEntry,
|
|
71
|
+
Forces,
|
|
72
|
+
ForcesEntry,
|
|
73
|
+
Stress,
|
|
74
|
+
StressEntry,
|
|
75
|
+
BandEnergies,
|
|
76
|
+
DosValues,
|
|
77
|
+
ScfIteration,
|
|
78
|
+
BandStructure,
|
|
79
|
+
BandGapDeprecated,
|
|
80
|
+
Dos,
|
|
81
|
+
Density,
|
|
82
|
+
)
|
|
83
|
+
from simulationworkflowschema import (
|
|
84
|
+
SinglePoint,
|
|
85
|
+
GeometryOptimization,
|
|
86
|
+
GeometryOptimizationMethod,
|
|
87
|
+
MolecularDynamics,
|
|
88
|
+
)
|
|
89
|
+
from .metainfo import vasp # pylint: disable=unused-import
|
|
90
|
+
|
|
91
|
+
|
|
92
|
+
re_n = r'[\n\r]'
|
|
93
|
+
|
|
94
|
+
|
|
95
|
+
def get_key_values(val_in):
|
|
96
|
+
val = [v for v in val_in.split('\n') if '=' in v]
|
|
97
|
+
data = {}
|
|
98
|
+
pattern = re.compile(r'([A-Z_]+)\s*=\s*(\.?[a-zA-Z]*[\d\-\.\+\sE]*\.?)')
|
|
99
|
+
|
|
100
|
+
def convert(v):
|
|
101
|
+
if isinstance(v, list):
|
|
102
|
+
v = [convert(vi) for vi in v]
|
|
103
|
+
elif isinstance(v, str):
|
|
104
|
+
try:
|
|
105
|
+
v = float(v) if '.' in v else int(v)
|
|
106
|
+
except Exception:
|
|
107
|
+
pass
|
|
108
|
+
else:
|
|
109
|
+
pass
|
|
110
|
+
return v
|
|
111
|
+
|
|
112
|
+
for v in val:
|
|
113
|
+
res = pattern.findall(v)
|
|
114
|
+
for resi in res:
|
|
115
|
+
vi = resi[1].split()
|
|
116
|
+
vi = vi[0] if len(vi) == 1 else vi
|
|
117
|
+
if isinstance(vi, str):
|
|
118
|
+
vi = vi.strip()
|
|
119
|
+
vi_upper = vi.upper()
|
|
120
|
+
if vi_upper in ['T', '.TRUE.', 'TRUE']:
|
|
121
|
+
vi = True
|
|
122
|
+
elif vi_upper in ['F', '.FALSE.', 'FALSE']:
|
|
123
|
+
vi = False
|
|
124
|
+
data[resi[0]] = convert(vi)
|
|
125
|
+
return data
|
|
126
|
+
|
|
127
|
+
|
|
128
|
+
def convert(val, dtype):
|
|
129
|
+
if isinstance(val, list):
|
|
130
|
+
return [convert(v, dtype) for v in val]
|
|
131
|
+
else:
|
|
132
|
+
try:
|
|
133
|
+
return dtype(val)
|
|
134
|
+
except Exception:
|
|
135
|
+
return val
|
|
136
|
+
|
|
137
|
+
|
|
138
|
+
class PotParser(TextParser):
|
|
139
|
+
def __init__(self, *args, **kwargs):
|
|
140
|
+
super().__init__(*args, **kwargs)
|
|
141
|
+
|
|
142
|
+
def init_quantities(self):
|
|
143
|
+
"""Extract pseudopotential headers both from POTCAR or OUTCAR."""
|
|
144
|
+
_pseudopotential = [
|
|
145
|
+
Quantity('title', r'TITEL\s+=\s*(.*)'), # extract the VASP native title
|
|
146
|
+
Quantity(
|
|
147
|
+
'flag', r'(L[A-Z]+)\s+=\s+(T|F)', repeats=True
|
|
148
|
+
), # extract booleans keywords
|
|
149
|
+
Quantity(
|
|
150
|
+
'number', r'([A-Z]+)\s+=\s+([-\.0-9]+)', repeats=True
|
|
151
|
+
), # extract floats or integers
|
|
152
|
+
]
|
|
153
|
+
|
|
154
|
+
self._quantities = [
|
|
155
|
+
Quantity(
|
|
156
|
+
'pseudopotential',
|
|
157
|
+
r'(VRHFIN\s+=[\s\S]+?(LMMAX\s=\s+\d|END of))',
|
|
158
|
+
repeats=True, # recognize where a header starts
|
|
159
|
+
sub_parser=TextParser(quantities=_pseudopotential),
|
|
160
|
+
)
|
|
161
|
+
]
|
|
162
|
+
|
|
163
|
+
|
|
164
|
+
class ContentParser:
|
|
165
|
+
def __init__(self):
|
|
166
|
+
self.parser = None
|
|
167
|
+
self._header = None
|
|
168
|
+
self._incar = None
|
|
169
|
+
self._kpoints_info = None
|
|
170
|
+
self._atom_info = None
|
|
171
|
+
self._calculations = None
|
|
172
|
+
self._n_bands = None
|
|
173
|
+
self._n_dos = None
|
|
174
|
+
self.metainfo_mapping = {
|
|
175
|
+
'e_fr_energy': 'energy_free',
|
|
176
|
+
'e_wo_entrp': 'energy_total',
|
|
177
|
+
'e_0_energy': 'energy_total_T0',
|
|
178
|
+
'hartreedc': 'energy_correction_hartree',
|
|
179
|
+
'XCdc': 'energy_XC',
|
|
180
|
+
'forces': 'atom_forces',
|
|
181
|
+
'stress': 'stress_tensor',
|
|
182
|
+
'energy_total': 'energy_free',
|
|
183
|
+
'energy_T0': 'energy_total_T0',
|
|
184
|
+
'energy_entropy0': 'energy_total',
|
|
185
|
+
'DENC': 'energy_correction_hartree',
|
|
186
|
+
'EXHF': 'energy_exchange',
|
|
187
|
+
'EBANDS': 'energy_sum_eigenvalues',
|
|
188
|
+
'efermi': 'fermi',
|
|
189
|
+
}
|
|
190
|
+
|
|
191
|
+
# TODO 2. it appears that there is no
|
|
192
|
+
# single parameter for hybrid functionals so it is difficult to determine, 3. not
|
|
193
|
+
# sure about --, I thought it is lda exchange only.
|
|
194
|
+
self.xc_functional_mapping = {
|
|
195
|
+
'--': ['GGA_X_PBE', 'GGA_C_PBE'],
|
|
196
|
+
'HL': ['LDA_C_HL'],
|
|
197
|
+
'WI': ['LDA_C_WIGNER'],
|
|
198
|
+
'PZ': ['LDA_C_PZ'],
|
|
199
|
+
'91': ['GGA_X_PW91', 'GGA_C_PW91'],
|
|
200
|
+
'PE': ['GGA_X_PBE', 'GGA_C_PBE'],
|
|
201
|
+
'PBE': ['GGA_X_PBE', 'GGA_C_PBE'],
|
|
202
|
+
'RE': ['GGA_X_PBE_R'],
|
|
203
|
+
'VW': ['LDA_C_VWN'],
|
|
204
|
+
'RP': ['GGA_X_RPBE', 'GGA_C_PBE'],
|
|
205
|
+
'PS': ['GGA_C_PBE_SOL', 'GGA_X_PBE_SOL'],
|
|
206
|
+
'AM': ['GGA_X_AM05', 'GGA_C_AM05'],
|
|
207
|
+
'B3': ['HYB_GGA_XC_B3LYP3'],
|
|
208
|
+
'B5': ['HYB_GGA_XC_B3LYP5'],
|
|
209
|
+
'BF': ['GGA_X_BEEFVDW', 'GGA_XC_BEEFVDW'],
|
|
210
|
+
'CO': [], # TODO check if this is ever used
|
|
211
|
+
'OR': ['GGA_X_OPTPBE_VDW'],
|
|
212
|
+
'BO': ['GGA_X_OPTB88_VDW'],
|
|
213
|
+
'MK': ['GGA_X_OPTB86B_VDW'],
|
|
214
|
+
'ML': ['VDW_XC_DF2'],
|
|
215
|
+
'CX': ['VDW_XC_DF_CX'],
|
|
216
|
+
'TPSS': ['MGGA_X_TPSS', 'MGGA_C_TPSS'],
|
|
217
|
+
'RTPSS': ['MGGA_X_RTPSS'],
|
|
218
|
+
'M06L': ['MGGA_C_M06_L'],
|
|
219
|
+
'MS0': ['MGGA_X_MS0'],
|
|
220
|
+
'MS1': ['MGGA_X_MS1'],
|
|
221
|
+
'MS2': ['MGGA_X_MS2'],
|
|
222
|
+
'SCAN': ['MGGA_X_SCAN'],
|
|
223
|
+
'RSCAN': ['MGGA_X_RSCAN', 'MGGA_C_RSCAN'],
|
|
224
|
+
'R2SCAN': ['MGGA_X_R2SCAN', 'MGGA_C_R2SCAN'],
|
|
225
|
+
'SCANL': ['MGGA_X_SCANL', 'MGGA_C_SCANL'],
|
|
226
|
+
'RSCANL': [], # not in LibXC, nor any paper, just deorbitalized SCANL
|
|
227
|
+
'R2SCANL': ['MGGA_X_R2SCANL', 'MGGA_C_R2SCANL'],
|
|
228
|
+
'OFR2': [],
|
|
229
|
+
'MBJ': ['MGGA_X_BJ06'],
|
|
230
|
+
'LBMJ': [], # TODO ask Miguel Marquez
|
|
231
|
+
'HLE17': ['MGGA_XC_HLE17'], # TODO check if this is ever used
|
|
232
|
+
'RA': ['LDA_C_PW_RPA'], # TODO check if this is ever used
|
|
233
|
+
}
|
|
234
|
+
|
|
235
|
+
def init_parser(self, filepath, logger):
|
|
236
|
+
self.parser.mainfile = filepath
|
|
237
|
+
self.parser.logger = logger
|
|
238
|
+
self._incar = None
|
|
239
|
+
self._kpoints_info = None
|
|
240
|
+
self._atom_info = None
|
|
241
|
+
self._header = None
|
|
242
|
+
self._calculations = None
|
|
243
|
+
self._n_bands = None
|
|
244
|
+
self._n_dos = None
|
|
245
|
+
|
|
246
|
+
def reuse_parser(self, parser):
|
|
247
|
+
self.parser.quantities = parser.parser.quantities
|
|
248
|
+
|
|
249
|
+
def _fix_incar(self, incar):
|
|
250
|
+
# fix for LORBIT, list is read
|
|
251
|
+
lorbit = incar.get('LORBIT', None)
|
|
252
|
+
if isinstance(lorbit, list):
|
|
253
|
+
incar['LORBIT'] = lorbit[0]
|
|
254
|
+
# fix for LDAU parameters, int / float is read
|
|
255
|
+
for key in ['LDAUU', 'LDAUJ', 'LDAUL']:
|
|
256
|
+
val = incar.get(key, None)
|
|
257
|
+
if isinstance(val, (int, float)):
|
|
258
|
+
incar[key] = [val]
|
|
259
|
+
|
|
260
|
+
def get_incar(self):
|
|
261
|
+
pass
|
|
262
|
+
|
|
263
|
+
def get_incar_out(self):
|
|
264
|
+
pass
|
|
265
|
+
|
|
266
|
+
# why make a distinction between incar_in and incar_out?
|
|
267
|
+
@property
|
|
268
|
+
def incar(self):
|
|
269
|
+
if self._incar is None:
|
|
270
|
+
self._incar = dict(incar=None, incar_out=None)
|
|
271
|
+
if self._incar['incar'] is None:
|
|
272
|
+
self.get_incar()
|
|
273
|
+
if self._incar['incar_out'] is None:
|
|
274
|
+
self.get_incar_out()
|
|
275
|
+
|
|
276
|
+
incar = dict()
|
|
277
|
+
incar.update(self._incar['incar'])
|
|
278
|
+
incar.update(self._incar['incar_out'])
|
|
279
|
+
|
|
280
|
+
return incar
|
|
281
|
+
|
|
282
|
+
@property
|
|
283
|
+
def ispin(self):
|
|
284
|
+
return self.incar.get('ISPIN', 1)
|
|
285
|
+
|
|
286
|
+
@property
|
|
287
|
+
def ibrion(self):
|
|
288
|
+
val = self.incar.get('IBRION,', None)
|
|
289
|
+
if val is None:
|
|
290
|
+
val = -1 if self.incar.get('NSW', 0) in [0, 1] else 0
|
|
291
|
+
return val
|
|
292
|
+
|
|
293
|
+
def is_converged(self, n_calc):
|
|
294
|
+
return False
|
|
295
|
+
|
|
296
|
+
def get_pseudopotential(
|
|
297
|
+
self, filepath
|
|
298
|
+
): # TODO: combine with its vasprun.xml counterpart
|
|
299
|
+
"""Extract the pseudo-potential headers from an input file,
|
|
300
|
+
and return them as a list of keyword mappings.
|
|
301
|
+
Each element of the list corresponds to a pseudo-potential."""
|
|
302
|
+
|
|
303
|
+
def _to_dict(key_val: list[list[str]], transform=lambda x: x) -> dict[str, Any]:
|
|
304
|
+
"""Convert a list of string pairs to a dictionary.
|
|
305
|
+
Key: first of the pairs
|
|
306
|
+
Value: second of the pairs, with the `transform` function applied
|
|
307
|
+
"""
|
|
308
|
+
return {x[0]: transform(x[1]) for x in key_val}
|
|
309
|
+
|
|
310
|
+
bool_mapping = {'T': True, 'F': False}
|
|
311
|
+
pps = PotParser(filepath).parse().get('pseudopotential', [])
|
|
312
|
+
pps_out = []
|
|
313
|
+
for pp in pps:
|
|
314
|
+
pps_out.append({'title': pp['title']})
|
|
315
|
+
pps_out[-1]['flag'] = _to_dict(
|
|
316
|
+
pp['flag'], transform=lambda x: bool_mapping[x]
|
|
317
|
+
)
|
|
318
|
+
pps_out[-1]['number'] = _to_dict(pp['number'], transform=lambda x: float(x))
|
|
319
|
+
return pps_out
|
|
320
|
+
|
|
321
|
+
def _get_tier(self, raw_data: Union[str, None], type='native') -> Union[str, None]:
|
|
322
|
+
"""Extract the tier from a string, and return it in a standardized format.
|
|
323
|
+
- `raw_data`: the string to extract the tier from
|
|
324
|
+
- `type`: the standardized output format, either `native` to VASP,
|
|
325
|
+
or `standard` NOMAD
|
|
326
|
+
"""
|
|
327
|
+
_map = ['low', 'medium', 'high', 'normal', 'single', 'accurate']
|
|
328
|
+
if tier_name := raw_data:
|
|
329
|
+
if type == 'native':
|
|
330
|
+
for tier in _map:
|
|
331
|
+
if tier.startswith(tier_name.lower()):
|
|
332
|
+
return tier
|
|
333
|
+
return None
|
|
334
|
+
|
|
335
|
+
|
|
336
|
+
class OutcarTextParser(TextParser):
|
|
337
|
+
def __init__(self):
|
|
338
|
+
self._chemical_symbols = None
|
|
339
|
+
|
|
340
|
+
super().__init__(None)
|
|
341
|
+
|
|
342
|
+
def init_quantities(self):
|
|
343
|
+
def str_to_array(val_in):
|
|
344
|
+
val = [
|
|
345
|
+
re.findall(r'(\-?\d+\.[\dEe]+)', v)
|
|
346
|
+
for v in val_in.strip().split('\n')
|
|
347
|
+
if '--' not in v
|
|
348
|
+
]
|
|
349
|
+
return np.array([v[0:3] for v in val], float), np.array(
|
|
350
|
+
[v[3:6] for v in val], float
|
|
351
|
+
)
|
|
352
|
+
|
|
353
|
+
def str_to_stress(val_in):
|
|
354
|
+
val = [float(v) for v in val_in.strip().split()]
|
|
355
|
+
stress = np.zeros((3, 3))
|
|
356
|
+
stress[0][0] = val[0]
|
|
357
|
+
stress[1][1] = val[1]
|
|
358
|
+
stress[2][2] = val[2]
|
|
359
|
+
stress[0][1] = stress[1][0] = val[3]
|
|
360
|
+
stress[1][2] = stress[2][1] = val[4]
|
|
361
|
+
stress[0][2] = stress[2][0] = val[5]
|
|
362
|
+
return stress
|
|
363
|
+
|
|
364
|
+
def str_to_header(val_in):
|
|
365
|
+
(
|
|
366
|
+
version,
|
|
367
|
+
build_date,
|
|
368
|
+
build_type,
|
|
369
|
+
platform,
|
|
370
|
+
date,
|
|
371
|
+
time,
|
|
372
|
+
parallel,
|
|
373
|
+
) = val_in.split()
|
|
374
|
+
parallel = 'parallel' if parallel == 'running' else parallel
|
|
375
|
+
subversion = '%s %s %s' % (build_date, build_type, parallel)
|
|
376
|
+
date = date.replace('.', ' ')
|
|
377
|
+
return dict(
|
|
378
|
+
version=version,
|
|
379
|
+
subversion=subversion,
|
|
380
|
+
platform=platform,
|
|
381
|
+
date=date,
|
|
382
|
+
time=time,
|
|
383
|
+
)
|
|
384
|
+
|
|
385
|
+
def str_to_positions(val_in):
|
|
386
|
+
re_position = re.compile(
|
|
387
|
+
r'\d*\s*(\-*\d+\.\d+)\s*(\-*\d+\.\d+)\s*(\-*\d+\.\d+)'
|
|
388
|
+
)
|
|
389
|
+
positions = []
|
|
390
|
+
for val in val_in.strip().split('\n'):
|
|
391
|
+
position = re_position.search(val)
|
|
392
|
+
if position:
|
|
393
|
+
positions.append(position.groups())
|
|
394
|
+
return np.array(positions, dtype=float)
|
|
395
|
+
|
|
396
|
+
def str_to_eigenvalues(val_in):
|
|
397
|
+
val = []
|
|
398
|
+
for line in val_in.strip().splitlines():
|
|
399
|
+
val.extend(['nan' if '*' in v else v for v in line.split()])
|
|
400
|
+
return np.array(val, np.float64)
|
|
401
|
+
|
|
402
|
+
scf_iteration = [
|
|
403
|
+
Quantity(
|
|
404
|
+
'energy_total',
|
|
405
|
+
r'free energy\s*TOTEN\s*=\s*([\d\.\-]+)\s*eV',
|
|
406
|
+
repeats=False,
|
|
407
|
+
dtype=float,
|
|
408
|
+
),
|
|
409
|
+
Quantity(
|
|
410
|
+
'energy_entropy0',
|
|
411
|
+
r'energy without entropy\s*=\s*([\d\.\-]+)',
|
|
412
|
+
repeats=False,
|
|
413
|
+
dtype=float,
|
|
414
|
+
),
|
|
415
|
+
Quantity(
|
|
416
|
+
'energy_T0',
|
|
417
|
+
r'energy\(sigma\->0\)\s*=\s*([\d\.\-]+)',
|
|
418
|
+
repeats=False,
|
|
419
|
+
dtype=float,
|
|
420
|
+
),
|
|
421
|
+
Quantity(
|
|
422
|
+
'energy_components',
|
|
423
|
+
r'Free energy of the ion-electron system \(eV\)\s*\-+([\s\S]+?)\-{10}',
|
|
424
|
+
str_operation=get_key_values,
|
|
425
|
+
convert=False,
|
|
426
|
+
),
|
|
427
|
+
Quantity(
|
|
428
|
+
'time',
|
|
429
|
+
r'LOOP\: +cpu time +([\d\.]+)\: +real time +([\d\.]+)',
|
|
430
|
+
dtype=np.dtype(np.float64),
|
|
431
|
+
),
|
|
432
|
+
]
|
|
433
|
+
|
|
434
|
+
calculation_quantities = [
|
|
435
|
+
Quantity(
|
|
436
|
+
'scf_iteration',
|
|
437
|
+
r'Iteration\s*\d+\(\s*\d+\s*\)([\s\S]+?energy\(sigma\->0\)\s*=\s*.+)',
|
|
438
|
+
repeats=True,
|
|
439
|
+
sub_parser=TextParser(quantities=scf_iteration),
|
|
440
|
+
),
|
|
441
|
+
Quantity(
|
|
442
|
+
'energies',
|
|
443
|
+
r'FREE ENERGIE OF THE ION-ELECTRON SYSTEM \(eV\)\s*\-+\s*([\s\S]+?)\-{10}',
|
|
444
|
+
sub_parser=TextParser(
|
|
445
|
+
quantities=[
|
|
446
|
+
Quantity(
|
|
447
|
+
'energy_total',
|
|
448
|
+
r'free\s*energy\s*TOTEN\s*=\s*([\-\d\.]+)',
|
|
449
|
+
repeats=False,
|
|
450
|
+
dtype=float,
|
|
451
|
+
),
|
|
452
|
+
Quantity(
|
|
453
|
+
'energy_entropy0',
|
|
454
|
+
r'energy\s*without\s*entropy\s*=\s*([\-\d\.]+)',
|
|
455
|
+
repeats=False,
|
|
456
|
+
dtype=float,
|
|
457
|
+
),
|
|
458
|
+
Quantity(
|
|
459
|
+
'energy_T0',
|
|
460
|
+
r'energy\(sigma\->0\)\s*=\s*([\-\d\.]+)',
|
|
461
|
+
repeats=False,
|
|
462
|
+
dtype=float,
|
|
463
|
+
),
|
|
464
|
+
]
|
|
465
|
+
),
|
|
466
|
+
),
|
|
467
|
+
Quantity(
|
|
468
|
+
'stress',
|
|
469
|
+
r'in kB\s*(\-?\d+\.\d+)\s*(\-?\d+\.\d+)\s*(\-?\d+\.\d+)\s*'
|
|
470
|
+
r'(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)',
|
|
471
|
+
str_operation=str_to_stress,
|
|
472
|
+
convert=False,
|
|
473
|
+
),
|
|
474
|
+
Quantity(
|
|
475
|
+
'positions_forces',
|
|
476
|
+
r'POSITION\s*TOTAL\-FORCE \(eV/Angst\)\s*\-+\s*([\d\.\s\-E]+)',
|
|
477
|
+
str_operation=str_to_array,
|
|
478
|
+
convert=False,
|
|
479
|
+
),
|
|
480
|
+
Quantity(
|
|
481
|
+
'lattice_vectors',
|
|
482
|
+
r'direct lattice vectors\s*reciprocal lattice vectors\s*'
|
|
483
|
+
r'(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)'
|
|
484
|
+
r'(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)'
|
|
485
|
+
r'(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)',
|
|
486
|
+
str_operation=str_to_array,
|
|
487
|
+
convert=False,
|
|
488
|
+
),
|
|
489
|
+
Quantity(
|
|
490
|
+
'converged',
|
|
491
|
+
r'aborting loop because (EDIFF is reached)',
|
|
492
|
+
repeats=False,
|
|
493
|
+
dtype=str,
|
|
494
|
+
convert=False,
|
|
495
|
+
),
|
|
496
|
+
Quantity(
|
|
497
|
+
'fermi_energy', r'E\-fermi :\s*([\d\.]+)', dtype=str, repeats=False
|
|
498
|
+
),
|
|
499
|
+
Quantity(
|
|
500
|
+
'eigenvalues',
|
|
501
|
+
r'band No\.\s*band energies\s*occupation\s*([\d\.\s\-\*]+?)(?:k\-point|spin|\-{10})',
|
|
502
|
+
repeats=True,
|
|
503
|
+
dtype=float,
|
|
504
|
+
str_operation=str_to_eigenvalues,
|
|
505
|
+
),
|
|
506
|
+
Quantity('convergence', r'(aborting loop because EDIFF is reached)'),
|
|
507
|
+
Quantity(
|
|
508
|
+
'time',
|
|
509
|
+
r'LOOP\+\: +cpu time +([\d\.]+)\: +real time +([\d\.]+)',
|
|
510
|
+
dtype=np.dtype(np.float64),
|
|
511
|
+
),
|
|
512
|
+
]
|
|
513
|
+
|
|
514
|
+
self._quantities = [
|
|
515
|
+
Quantity(
|
|
516
|
+
'calculation',
|
|
517
|
+
r'(\-\-\s*Iteration\s*\d+\(\s*1\s*\)\s*[\s\S]+?)'
|
|
518
|
+
r'((?:FREE ENERGIE OF THE ION\-ELECTRON SYSTEM \(eV\)[\s\S]+?LOOP\+.+)|\Z)',
|
|
519
|
+
repeats=True,
|
|
520
|
+
sub_parser=TextParser(quantities=calculation_quantities),
|
|
521
|
+
),
|
|
522
|
+
Quantity(
|
|
523
|
+
'header',
|
|
524
|
+
r'vasp\.([\d\.]+)\s*(\w+)\s*[\s\S]+?\)\s*(\w+)\s*'
|
|
525
|
+
r'executed on\s*(\w+)\s*date\s*([\d\.]+)\s*([\d\:]+)\s*(\w+)',
|
|
526
|
+
repeats=False,
|
|
527
|
+
str_operation=str_to_header,
|
|
528
|
+
convert=False,
|
|
529
|
+
),
|
|
530
|
+
Quantity(
|
|
531
|
+
'parameters',
|
|
532
|
+
r'Startparameter for this run:([\s\S]+?)\-{100}',
|
|
533
|
+
str_operation=get_key_values,
|
|
534
|
+
repeats=False,
|
|
535
|
+
convert=False,
|
|
536
|
+
),
|
|
537
|
+
Quantity(
|
|
538
|
+
'ions_per_type', r'ions per type =\s*([ \d]+)', dtype=int, repeats=False
|
|
539
|
+
),
|
|
540
|
+
Quantity(
|
|
541
|
+
'species',
|
|
542
|
+
r'(\w+) +([A-Z][a-z]*).+?:\s*energy of atom +\d+',
|
|
543
|
+
dtype=str,
|
|
544
|
+
repeats=True,
|
|
545
|
+
), # TODO: deprecate
|
|
546
|
+
Quantity(
|
|
547
|
+
'kpoints',
|
|
548
|
+
r'Following reciprocal coordinates:[\s\S]+?\n([\d\.\s\-]+)',
|
|
549
|
+
repeats=False,
|
|
550
|
+
dtype=float,
|
|
551
|
+
),
|
|
552
|
+
Quantity('nbands', r'NBANDS\s*=\s*(\d+)', dtype=int, repeats=False),
|
|
553
|
+
Quantity(
|
|
554
|
+
'lattice_vectors',
|
|
555
|
+
r'direct lattice vectors\s*reciprocal lattice vectors\s*'
|
|
556
|
+
r'(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)'
|
|
557
|
+
r'(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)'
|
|
558
|
+
r'(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)(\-?\d+\.\d+\s*)',
|
|
559
|
+
str_operation=str_to_array,
|
|
560
|
+
convert=False,
|
|
561
|
+
),
|
|
562
|
+
Quantity(
|
|
563
|
+
'positions',
|
|
564
|
+
r'ion\s*position\s*nearest neighbor table([\s\S]+?)LATTYP',
|
|
565
|
+
str_operation=str_to_positions,
|
|
566
|
+
convert=False,
|
|
567
|
+
),
|
|
568
|
+
# alternative format
|
|
569
|
+
Quantity(
|
|
570
|
+
'positions',
|
|
571
|
+
r'position of ions in cartesian coordinates\s*\(Angst\):([\s\S]+?)\n *\n',
|
|
572
|
+
str_operation=str_to_positions,
|
|
573
|
+
convert=False,
|
|
574
|
+
),
|
|
575
|
+
Quantity(
|
|
576
|
+
'response_functions',
|
|
577
|
+
r'\s*Response functions by sum over occupied states\:([\s\S]+?)(?:\-\-\-\-\-\-)',
|
|
578
|
+
repeats=False,
|
|
579
|
+
sub_parser=TextParser(
|
|
580
|
+
quantities=[
|
|
581
|
+
Quantity(
|
|
582
|
+
'input_parameters',
|
|
583
|
+
rf'{re_n}* *(\w+) *\= *([\w\.\-]+) *.*',
|
|
584
|
+
repeats=True,
|
|
585
|
+
)
|
|
586
|
+
]
|
|
587
|
+
),
|
|
588
|
+
),
|
|
589
|
+
]
|
|
590
|
+
|
|
591
|
+
|
|
592
|
+
class OutcarContentParser(ContentParser):
|
|
593
|
+
def __init__(self):
|
|
594
|
+
super().__init__()
|
|
595
|
+
self.parser = OutcarTextParser()
|
|
596
|
+
|
|
597
|
+
def _get_key_values(self, path):
|
|
598
|
+
if not os.path.isfile(path):
|
|
599
|
+
return dict()
|
|
600
|
+
with self.parser.open(path) as f:
|
|
601
|
+
text = f.read()
|
|
602
|
+
text = text.decode() if isinstance(text, bytes) else text
|
|
603
|
+
data = get_key_values(text)
|
|
604
|
+
return data
|
|
605
|
+
|
|
606
|
+
@property
|
|
607
|
+
def header(self):
|
|
608
|
+
if self._header is None:
|
|
609
|
+
self._header = self.parser.get('header', {})
|
|
610
|
+
self._header['program'] = 'vasp'
|
|
611
|
+
for key, val in self._header.items():
|
|
612
|
+
if not isinstance(val, str):
|
|
613
|
+
self._header[key] = ' '.join(val)
|
|
614
|
+
return self._header
|
|
615
|
+
|
|
616
|
+
def get_incar(self):
|
|
617
|
+
if self._incar is not None and self._incar.get('incar', None) is not None:
|
|
618
|
+
return self._incar.get('incar')
|
|
619
|
+
|
|
620
|
+
incar = dict()
|
|
621
|
+
if self._incar is None:
|
|
622
|
+
self._incar = dict(incar=None, incar_out=None)
|
|
623
|
+
|
|
624
|
+
path = os.path.join(
|
|
625
|
+
self.parser.maindir,
|
|
626
|
+
'INCAR%s' % os.path.basename(self.parser.mainfile).strip('OUTCAR'),
|
|
627
|
+
)
|
|
628
|
+
path = (
|
|
629
|
+
path if os.path.isfile(path) else os.path.join(self.parser.maindir, 'INCAR')
|
|
630
|
+
)
|
|
631
|
+
incar = self._get_key_values(path)
|
|
632
|
+
self._fix_incar(incar)
|
|
633
|
+
self._incar['incar'] = incar
|
|
634
|
+
return incar
|
|
635
|
+
|
|
636
|
+
def get_incar_out(self):
|
|
637
|
+
if self._incar is not None and self._incar.get('incar_out', None) is not None:
|
|
638
|
+
return self._incar.get('incar_out')
|
|
639
|
+
|
|
640
|
+
incar = dict()
|
|
641
|
+
if self._incar is None:
|
|
642
|
+
self._incar = dict(incar=None, incar_out=None)
|
|
643
|
+
|
|
644
|
+
incar = self.parser.get('parameters', {})
|
|
645
|
+
self._incar['incar_out'] = incar
|
|
646
|
+
self._fix_incar(incar)
|
|
647
|
+
return incar
|
|
648
|
+
|
|
649
|
+
@property
|
|
650
|
+
def calculations(self):
|
|
651
|
+
if self._calculations is None:
|
|
652
|
+
self._calculations = self.parser.get('calculation')
|
|
653
|
+
return self._calculations
|
|
654
|
+
|
|
655
|
+
@property
|
|
656
|
+
def n_calculations(self):
|
|
657
|
+
if isinstance(self.calculations, dict):
|
|
658
|
+
return 1
|
|
659
|
+
elif isinstance(self.calculations, list):
|
|
660
|
+
return len(self.calculations)
|
|
661
|
+
else:
|
|
662
|
+
return 0
|
|
663
|
+
|
|
664
|
+
@property
|
|
665
|
+
def kpoints_info(self):
|
|
666
|
+
if self._kpoints_info is None:
|
|
667
|
+
self._kpoints_info = dict()
|
|
668
|
+
kpts_occs = self.parser.get('kpoints')
|
|
669
|
+
if kpts_occs is not None:
|
|
670
|
+
kpts_occs = np.reshape(kpts_occs, (len(kpts_occs) // 4, 4)).T
|
|
671
|
+
self._kpoints_info['points'] = kpts_occs[0:3].T
|
|
672
|
+
k_mults = kpts_occs[3].T
|
|
673
|
+
self._kpoints_info['multiplicities'] = k_mults
|
|
674
|
+
self._kpoints_info['weights'] = k_mults / np.sum(k_mults)
|
|
675
|
+
return self._kpoints_info
|
|
676
|
+
|
|
677
|
+
@property
|
|
678
|
+
def n_bands(self):
|
|
679
|
+
if self._n_bands is None:
|
|
680
|
+
for n in range(self.n_calculations):
|
|
681
|
+
val = self.parser.get('calculation', [{}] * (n + 1))[n].get(
|
|
682
|
+
'eigenvalues', [None]
|
|
683
|
+
)[0]
|
|
684
|
+
if val is not None:
|
|
685
|
+
self._n_bands = len(val) // 3
|
|
686
|
+
break
|
|
687
|
+
if self._n_bands is None:
|
|
688
|
+
# check consistency with eigenvalues
|
|
689
|
+
self._n_bands = self.incar.get('NBANDS', 0)
|
|
690
|
+
return self._n_bands
|
|
691
|
+
|
|
692
|
+
@property
|
|
693
|
+
def n_dos(self):
|
|
694
|
+
if self._n_dos is None:
|
|
695
|
+
path = os.path.join(
|
|
696
|
+
self.parser.maindir,
|
|
697
|
+
'DOSCAR%s' % os.path.basename(self.parser.mainfile).strip('OUTCAR'),
|
|
698
|
+
)
|
|
699
|
+
path = (
|
|
700
|
+
path
|
|
701
|
+
if os.path.isfile(path)
|
|
702
|
+
else os.path.join(self.parser.maindir, 'DOSCAR')
|
|
703
|
+
)
|
|
704
|
+
with open(path) as f:
|
|
705
|
+
for _ in range(6):
|
|
706
|
+
line = f.readline()
|
|
707
|
+
self._n_dos = int(line.split()[2])
|
|
708
|
+
if self._n_dos is None:
|
|
709
|
+
self._n_dos = self._incar.get('NEDOS', 0)
|
|
710
|
+
return self._n_dos
|
|
711
|
+
|
|
712
|
+
@property
|
|
713
|
+
def atom_info(self):
|
|
714
|
+
if self._atom_info is None:
|
|
715
|
+
self._atom_info = {}
|
|
716
|
+
|
|
717
|
+
ions = self.parser.get('ions_per_type', [])
|
|
718
|
+
species = self.parser.get('species', [])
|
|
719
|
+
ions = [ions] if isinstance(ions, int) else ions
|
|
720
|
+
ions = [int(i) for i in ions]
|
|
721
|
+
if len(ions) != len(species):
|
|
722
|
+
# get it from POSCAR
|
|
723
|
+
path = os.path.join(
|
|
724
|
+
self.parser.maindir,
|
|
725
|
+
'POSCAR%s' % os.path.basename(self.parser.mainfile).strip('OUTCAR'),
|
|
726
|
+
)
|
|
727
|
+
path = (
|
|
728
|
+
path
|
|
729
|
+
if os.path.isfile(path)
|
|
730
|
+
else os.path.join(self.parser.maindir, 'POSCAR')
|
|
731
|
+
)
|
|
732
|
+
if os.path.isfile(path):
|
|
733
|
+
with open(path) as f:
|
|
734
|
+
for _ in range(7):
|
|
735
|
+
line = f.readline()
|
|
736
|
+
try:
|
|
737
|
+
ions = [int(n) for n in line.split()]
|
|
738
|
+
except Exception:
|
|
739
|
+
pass
|
|
740
|
+
ions = [i for i in ions if not isinstance(i, str)]
|
|
741
|
+
if len(ions) != len(species):
|
|
742
|
+
self.parser.logger.error('Inconsistent number of ions and species.')
|
|
743
|
+
return self._atom_info
|
|
744
|
+
|
|
745
|
+
self._atom_info['n_atoms'] = sum(ions)
|
|
746
|
+
self._atom_info['n_types'] = len(species)
|
|
747
|
+
|
|
748
|
+
element = []
|
|
749
|
+
atomtype = []
|
|
750
|
+
for n in range(len(ions)):
|
|
751
|
+
element.extend([str(species[n][1])] * ions[n])
|
|
752
|
+
atomtype.extend([(n + 1)] * ions[n])
|
|
753
|
+
self._atom_info['atoms'] = dict(element=element, atomtype=atomtype)
|
|
754
|
+
self._atom_info['atomtypes'] = dict(
|
|
755
|
+
atomspertype=ions, element=[s[1] for s in species]
|
|
756
|
+
)
|
|
757
|
+
|
|
758
|
+
return self._atom_info
|
|
759
|
+
|
|
760
|
+
def get_pseudopotential(self): # TODO: combine with its vasprun.xml counterpart
|
|
761
|
+
"""Extract the pseudo-potential headers from the OUTCAR,
|
|
762
|
+
and return them as a list of keyword mappings.
|
|
763
|
+
Each element of the list corresponds to a pseudo-potential."""
|
|
764
|
+
|
|
765
|
+
return super().get_pseudopotential(self.parser.mainfile)
|
|
766
|
+
|
|
767
|
+
def get_time_calc(self, n_calc):
|
|
768
|
+
return self.parser.get('calculation', [{}] * (n_calc + 1))[n_calc].get(
|
|
769
|
+
'time', [None, None]
|
|
770
|
+
)
|
|
771
|
+
|
|
772
|
+
def get_time_scf(self, n_calc):
|
|
773
|
+
return [
|
|
774
|
+
scf.time
|
|
775
|
+
for scf in self.parser.get('calculation', [{}] * (n_calc + 1))[n_calc].get(
|
|
776
|
+
'scf_iteration', []
|
|
777
|
+
)
|
|
778
|
+
]
|
|
779
|
+
|
|
780
|
+
def get_n_scf(self, n_calc):
|
|
781
|
+
return len(
|
|
782
|
+
self.parser.get('calculation', [{}] * (n_calc + 1))[n_calc].get(
|
|
783
|
+
'scf_iteration', []
|
|
784
|
+
)
|
|
785
|
+
)
|
|
786
|
+
|
|
787
|
+
def get_structure(self, n_calc):
|
|
788
|
+
cell = self.parser.get('calculation', [{}] * (n_calc + 1))[n_calc].get(
|
|
789
|
+
'lattice_vectors', [None]
|
|
790
|
+
)[0]
|
|
791
|
+
positions = self.parser.get('calculation', [{}] * (n_calc + 1))[n_calc].get(
|
|
792
|
+
'positions_forces', [None]
|
|
793
|
+
)[0]
|
|
794
|
+
selective = None
|
|
795
|
+
nose = None
|
|
796
|
+
|
|
797
|
+
if cell is None:
|
|
798
|
+
# get it from initialization
|
|
799
|
+
cell = self.parser.get('lattice_vectors', [None])[0]
|
|
800
|
+
if positions is None:
|
|
801
|
+
positions = self.parser.get('positions', None)
|
|
802
|
+
|
|
803
|
+
if positions is not None:
|
|
804
|
+
positions = positions * ureg.angstrom
|
|
805
|
+
if cell is not None:
|
|
806
|
+
cell = cell * ureg.angstrom
|
|
807
|
+
|
|
808
|
+
return dict(cell=cell, positions=positions, selective=selective, nose=nose)
|
|
809
|
+
|
|
810
|
+
def get_basis_set(self) -> list[BasisSet]:
|
|
811
|
+
sec_bases: list[BasisSet] = []
|
|
812
|
+
for tag in ('ENCUT', 'ENAUG'):
|
|
813
|
+
cutoff_value = self.parser.get('parameters', {}).get(tag)
|
|
814
|
+
sec_basis = BasisSet(
|
|
815
|
+
type='plane waves',
|
|
816
|
+
frozen_core=False
|
|
817
|
+
if self.parser.results.get('parameters', {}).get('ICORELEVEL', 0) == 1
|
|
818
|
+
else True,
|
|
819
|
+
) # TODO: write the core eigenvalues to calculation + display them?
|
|
820
|
+
if cutoff_value:
|
|
821
|
+
sec_basis.cutoff = cutoff_value * ureg.eV # based on examples
|
|
822
|
+
if tag == 'ENCUT':
|
|
823
|
+
sec_basis.scope = ['valence']
|
|
824
|
+
elif tag == 'ENAUG':
|
|
825
|
+
sec_basis.scope = ['augmentation']
|
|
826
|
+
# TODO: add grid spacing (NGX, NGY, NGZ)?
|
|
827
|
+
sec_bases.append(sec_basis)
|
|
828
|
+
return sec_bases
|
|
829
|
+
|
|
830
|
+
def get_tier(self, type='native') -> Union[str, None]:
|
|
831
|
+
return super()._get_tier(
|
|
832
|
+
self.parser.get('parameters', {}).get('PREC'), type=type
|
|
833
|
+
)
|
|
834
|
+
|
|
835
|
+
def get_energies(self, n_calc, n_scf):
|
|
836
|
+
energies = dict()
|
|
837
|
+
multiplier = 1.0
|
|
838
|
+
if n_scf is None:
|
|
839
|
+
section = self.parser.get('calculation', [{}] * (n_calc + 1))[n_calc].get(
|
|
840
|
+
'energies', {}
|
|
841
|
+
)
|
|
842
|
+
# final energies are per-atom (this is not the case)
|
|
843
|
+
# TODO survey all vasp versions to know if energy per atom is printed
|
|
844
|
+
# multiplier = self.atom_info.get(
|
|
845
|
+
# 'n_atoms', len(self.get_structure(n_calc).get('positions')))
|
|
846
|
+
else:
|
|
847
|
+
section = self.parser.get('calculation', [{}] * (n_calc + 1))[n_calc].get(
|
|
848
|
+
'scf_iteration', [{}] * (n_scf + 1)
|
|
849
|
+
)[n_scf]
|
|
850
|
+
for key in ['energy_total', 'energy_T0', 'energy_entropy0']:
|
|
851
|
+
val = section.get(key)
|
|
852
|
+
if val is not None:
|
|
853
|
+
energies[key] = val * multiplier
|
|
854
|
+
|
|
855
|
+
energies.update(section.get('energy_components', {}))
|
|
856
|
+
return energies
|
|
857
|
+
|
|
858
|
+
def get_forces_stress(self, n_calc):
|
|
859
|
+
forces = self.parser.get('calculation', [{}] * (n_calc + 1))[n_calc].get(
|
|
860
|
+
'positions_forces', [None, None]
|
|
861
|
+
)[1]
|
|
862
|
+
stress = self.parser.get('calculation', [{}] * (n_calc + 1))[n_calc].get(
|
|
863
|
+
'stress', None
|
|
864
|
+
)
|
|
865
|
+
|
|
866
|
+
return forces, stress
|
|
867
|
+
|
|
868
|
+
def get_eigenvalues(self, n_calc):
|
|
869
|
+
n_kpts = len(self.kpoints_info.get('points', []))
|
|
870
|
+
eigenvalues = self.parser.get('calculation', [{}] * (n_calc + 1))[n_calc].get(
|
|
871
|
+
'eigenvalues'
|
|
872
|
+
)
|
|
873
|
+
|
|
874
|
+
if eigenvalues is None:
|
|
875
|
+
return
|
|
876
|
+
n_eigs = len(eigenvalues) // (self.ispin * n_kpts)
|
|
877
|
+
try:
|
|
878
|
+
eigenvalues = np.reshape(
|
|
879
|
+
eigenvalues, (n_eigs, self.ispin, n_kpts, self.n_bands, 3)
|
|
880
|
+
)
|
|
881
|
+
except Exception:
|
|
882
|
+
self.parser.logger.error('Error reading eigenvalues')
|
|
883
|
+
return
|
|
884
|
+
# eigenvalues can also be printed every scf iteration but we only save the
|
|
885
|
+
# last one, which corresponds to the calculation
|
|
886
|
+
eigenvalues = np.transpose(eigenvalues)[1:].T[-1]
|
|
887
|
+
return eigenvalues
|
|
888
|
+
|
|
889
|
+
def get_total_dos(self, n_calc):
|
|
890
|
+
dos_energies = dos_values = dos_integrated = e_fermi = None
|
|
891
|
+
|
|
892
|
+
if n_calc != (self.n_calculations - 1):
|
|
893
|
+
return dos_energies, dos_values, dos_integrated, e_fermi
|
|
894
|
+
path = os.path.join(
|
|
895
|
+
self.parser.maindir,
|
|
896
|
+
'DOSCAR%s' % os.path.basename(self.parser.mainfile).strip('OUTCAR'),
|
|
897
|
+
)
|
|
898
|
+
path = (
|
|
899
|
+
path
|
|
900
|
+
if os.path.isfile(path)
|
|
901
|
+
else os.path.join(self.parser.maindir, 'DOSCAR')
|
|
902
|
+
)
|
|
903
|
+
if not os.path.isfile(path):
|
|
904
|
+
return dos_energies, dos_values, dos_integrated, e_fermi
|
|
905
|
+
|
|
906
|
+
dos = []
|
|
907
|
+
n_dos = 0
|
|
908
|
+
with self.parser.open(path) as f:
|
|
909
|
+
try:
|
|
910
|
+
for i, line in enumerate(f):
|
|
911
|
+
if i < 5:
|
|
912
|
+
continue
|
|
913
|
+
if i == 5:
|
|
914
|
+
e_fermi = float(line.split()[1])
|
|
915
|
+
n_dos = int(line.split()[2])
|
|
916
|
+
if i > 5:
|
|
917
|
+
dos.append([float(v) for v in line.split()])
|
|
918
|
+
if i >= n_dos + 5:
|
|
919
|
+
break
|
|
920
|
+
except Exception:
|
|
921
|
+
self.parser.logger.error('Error reading DOSCAR')
|
|
922
|
+
|
|
923
|
+
if not dos:
|
|
924
|
+
return dos_energies, dos_values, dos_integrated, e_fermi
|
|
925
|
+
|
|
926
|
+
# DOSCAR fomat (spin) energy dos_up dos_down integrated_up integrated_down
|
|
927
|
+
dos = np.transpose(dos)
|
|
928
|
+
dos_energies = dos[0]
|
|
929
|
+
dos_values = dos[1 : 1 + self.ispin]
|
|
930
|
+
dos_integrated = dos[1 + self.ispin : 2 * self.ispin + 1]
|
|
931
|
+
|
|
932
|
+
return dos_energies, dos_values, dos_integrated, e_fermi
|
|
933
|
+
|
|
934
|
+
def get_partial_dos(self, n_calc):
|
|
935
|
+
n_atoms = self.atom_info['n_atoms']
|
|
936
|
+
dos = fields = None
|
|
937
|
+
if n_calc != (self.n_calculations - 1):
|
|
938
|
+
return dos, fields
|
|
939
|
+
path = os.path.join(
|
|
940
|
+
self.parser.maindir,
|
|
941
|
+
'DOSCAR%s' % os.path.basename(self.parser.mainfile).strip('OUTCAR'),
|
|
942
|
+
)
|
|
943
|
+
path = (
|
|
944
|
+
path
|
|
945
|
+
if os.path.isfile(path)
|
|
946
|
+
else os.path.join(self.parser.maindir, 'DOSCAR')
|
|
947
|
+
)
|
|
948
|
+
if not os.path.isfile(path):
|
|
949
|
+
return dos, fields
|
|
950
|
+
|
|
951
|
+
dos = []
|
|
952
|
+
n_dos = 0
|
|
953
|
+
atom = 1
|
|
954
|
+
with self.parser.open(path) as f:
|
|
955
|
+
for i, line in enumerate(f):
|
|
956
|
+
if i == 0:
|
|
957
|
+
if int(line.split()[2]) != 1:
|
|
958
|
+
return None, None
|
|
959
|
+
elif i < 5:
|
|
960
|
+
continue
|
|
961
|
+
elif i == 5:
|
|
962
|
+
n_dos = int(line.split()[2])
|
|
963
|
+
if i == ((n_dos + 1) * atom) + 5:
|
|
964
|
+
atom += 1
|
|
965
|
+
continue
|
|
966
|
+
if i > (n_dos + 6):
|
|
967
|
+
dos.append([float(v) for v in line.split()])
|
|
968
|
+
if i >= ((n_dos + 1) * (n_atoms + 1) + 5):
|
|
969
|
+
break
|
|
970
|
+
if len(dos) == 0:
|
|
971
|
+
return None, None
|
|
972
|
+
|
|
973
|
+
dos = np.transpose(dos)[1:]
|
|
974
|
+
n_lm = len(dos) // self.ispin
|
|
975
|
+
try:
|
|
976
|
+
dos = np.reshape(dos, (n_lm, self.ispin, n_atoms, n_dos))
|
|
977
|
+
except Exception:
|
|
978
|
+
self.parser.logger.error('Error reading partial dos.')
|
|
979
|
+
return None, None
|
|
980
|
+
|
|
981
|
+
if n_lm == 3:
|
|
982
|
+
fields = ['s', 'p', 'd']
|
|
983
|
+
elif n_lm == 9:
|
|
984
|
+
fields = ['s', 'py', 'pz', 'px', 'dxy', 'dyz', 'dz2', 'dxz', 'dx2']
|
|
985
|
+
elif n_lm == 16:
|
|
986
|
+
fields = [
|
|
987
|
+
's',
|
|
988
|
+
'py',
|
|
989
|
+
'pz',
|
|
990
|
+
'px',
|
|
991
|
+
'dxy',
|
|
992
|
+
'dyz',
|
|
993
|
+
'dz2',
|
|
994
|
+
'dxz',
|
|
995
|
+
'dx2',
|
|
996
|
+
'f-3',
|
|
997
|
+
'f-2',
|
|
998
|
+
'f-1',
|
|
999
|
+
'f0',
|
|
1000
|
+
'f1',
|
|
1001
|
+
'f2',
|
|
1002
|
+
'f3',
|
|
1003
|
+
]
|
|
1004
|
+
else:
|
|
1005
|
+
fields = [None] * n_lm
|
|
1006
|
+
self.parser.logger.warning(
|
|
1007
|
+
'Cannot determine lm fields for n_lm', data=dict(n_lm=n_lm)
|
|
1008
|
+
)
|
|
1009
|
+
|
|
1010
|
+
return dos, fields
|
|
1011
|
+
|
|
1012
|
+
def get_response_functions(self):
|
|
1013
|
+
parameters_dict = {}
|
|
1014
|
+
try:
|
|
1015
|
+
for param in self.parser.get('response_functions', {}).get(
|
|
1016
|
+
'input_parameters', {}
|
|
1017
|
+
):
|
|
1018
|
+
if param[1] == 'T' or param[1] == 'F':
|
|
1019
|
+
param[1] = param[1] == 'T'
|
|
1020
|
+
if param[0] == 'KPOINT': # problem when serializing array in json
|
|
1021
|
+
continue
|
|
1022
|
+
parameters_dict[param[0]] = param[1]
|
|
1023
|
+
except Exception:
|
|
1024
|
+
self.parser.logger.warning(
|
|
1025
|
+
'Could not resolve response functions input parameters.'
|
|
1026
|
+
)
|
|
1027
|
+
return parameters_dict
|
|
1028
|
+
|
|
1029
|
+
def is_converged(self, n_calc):
|
|
1030
|
+
return (
|
|
1031
|
+
self.parser.get('calculation', [{}] * (n_calc + 1))[n_calc].get(
|
|
1032
|
+
'convergence'
|
|
1033
|
+
)
|
|
1034
|
+
is not None
|
|
1035
|
+
)
|
|
1036
|
+
|
|
1037
|
+
|
|
1038
|
+
class RunXmlContentHandler(ContentHandler):
|
|
1039
|
+
def __init__(self):
|
|
1040
|
+
self._text = ''
|
|
1041
|
+
self._path = []
|
|
1042
|
+
|
|
1043
|
+
self._data = {}
|
|
1044
|
+
self.n_calculations = 0
|
|
1045
|
+
|
|
1046
|
+
# data, attrs, last_sibling, last_sibling_index
|
|
1047
|
+
self._stack = [(self._data, {}, None, -1)]
|
|
1048
|
+
|
|
1049
|
+
def startElement(self, tag, attrs):
|
|
1050
|
+
data, last_attrs, last_sibling, last_sibling_index = self._stack[-1]
|
|
1051
|
+
|
|
1052
|
+
name = attrs.get('name')
|
|
1053
|
+
if not name and tag in ('i', 'v', 'r', 'c'):
|
|
1054
|
+
self._stack.append(
|
|
1055
|
+
(
|
|
1056
|
+
data,
|
|
1057
|
+
attrs,
|
|
1058
|
+
None,
|
|
1059
|
+
-1,
|
|
1060
|
+
)
|
|
1061
|
+
)
|
|
1062
|
+
|
|
1063
|
+
else:
|
|
1064
|
+
if tag == last_sibling:
|
|
1065
|
+
index = last_sibling_index + 1
|
|
1066
|
+
else:
|
|
1067
|
+
index = 0
|
|
1068
|
+
|
|
1069
|
+
self._stack[-1] = (data, last_attrs, tag, index)
|
|
1070
|
+
|
|
1071
|
+
if name:
|
|
1072
|
+
segment = f'{tag}[@name="{name}"]'
|
|
1073
|
+
else:
|
|
1074
|
+
segment = f'{tag}[{index}]'
|
|
1075
|
+
|
|
1076
|
+
self._stack.append(
|
|
1077
|
+
(
|
|
1078
|
+
data.setdefault(segment, {}),
|
|
1079
|
+
attrs,
|
|
1080
|
+
None,
|
|
1081
|
+
-1,
|
|
1082
|
+
)
|
|
1083
|
+
)
|
|
1084
|
+
|
|
1085
|
+
def endElement(self, tag):
|
|
1086
|
+
text = self._text
|
|
1087
|
+
self._text = ''
|
|
1088
|
+
|
|
1089
|
+
data, attrs, _, _ = self._stack.pop()
|
|
1090
|
+
|
|
1091
|
+
if tag == 'calculation':
|
|
1092
|
+
self.n_calculations += 1
|
|
1093
|
+
|
|
1094
|
+
data.setdefault('_data', []).append({tag: text, **attrs})
|
|
1095
|
+
|
|
1096
|
+
def clear_stack(self):
|
|
1097
|
+
while len(self._stack) > 0:
|
|
1098
|
+
self.endElement(self._stack[-1][2])
|
|
1099
|
+
|
|
1100
|
+
def characters(self, content):
|
|
1101
|
+
self._text += content
|
|
1102
|
+
|
|
1103
|
+
def _combine_sub_tree(self, data, results):
|
|
1104
|
+
for key, value in data.items():
|
|
1105
|
+
if key == '_data':
|
|
1106
|
+
results.extend(value)
|
|
1107
|
+
else:
|
|
1108
|
+
self._combine_sub_tree(value, results)
|
|
1109
|
+
|
|
1110
|
+
return results
|
|
1111
|
+
|
|
1112
|
+
def __getitem__(self, key):
|
|
1113
|
+
try:
|
|
1114
|
+
data = self._data
|
|
1115
|
+
segments = key.strip('/').split('/')
|
|
1116
|
+
for segment in segments:
|
|
1117
|
+
data = data[segment]
|
|
1118
|
+
|
|
1119
|
+
return self._combine_sub_tree(data, [])
|
|
1120
|
+
except KeyError:
|
|
1121
|
+
return []
|
|
1122
|
+
|
|
1123
|
+
|
|
1124
|
+
class RunFileParser(FileParser):
|
|
1125
|
+
def parse(self):
|
|
1126
|
+
parser = make_parser()
|
|
1127
|
+
content_handler = RunXmlContentHandler()
|
|
1128
|
+
parser.setContentHandler(content_handler)
|
|
1129
|
+
try:
|
|
1130
|
+
with self.open_mainfile_obj() as f:
|
|
1131
|
+
parser.parse(f)
|
|
1132
|
+
except Exception as e:
|
|
1133
|
+
# support broken XML structure
|
|
1134
|
+
if self.logger:
|
|
1135
|
+
self.logger.warning('could not parse all xml', exc_info=e)
|
|
1136
|
+
content_handler.clear_stack()
|
|
1137
|
+
|
|
1138
|
+
self._results = content_handler
|
|
1139
|
+
|
|
1140
|
+
@property
|
|
1141
|
+
def results(self):
|
|
1142
|
+
return self._results
|
|
1143
|
+
|
|
1144
|
+
@property
|
|
1145
|
+
def n_calculations(self):
|
|
1146
|
+
return self._results.n_calculations
|
|
1147
|
+
|
|
1148
|
+
|
|
1149
|
+
class RunContentParser(ContentParser):
|
|
1150
|
+
def __init__(self):
|
|
1151
|
+
super().__init__()
|
|
1152
|
+
self.parser = None
|
|
1153
|
+
self._re_attrib = re.compile(r'\[@name="(\w+)"\]')
|
|
1154
|
+
self._dtypes = {
|
|
1155
|
+
'string': str,
|
|
1156
|
+
'int': int,
|
|
1157
|
+
'logical': bool,
|
|
1158
|
+
'': float,
|
|
1159
|
+
'float': float,
|
|
1160
|
+
}
|
|
1161
|
+
|
|
1162
|
+
def init_parser(self, filepath, logger):
|
|
1163
|
+
self.parser = RunFileParser(filepath, logger)
|
|
1164
|
+
|
|
1165
|
+
super().init_parser(filepath, logger)
|
|
1166
|
+
|
|
1167
|
+
self._scf_energies = dict()
|
|
1168
|
+
self._n_scf = None
|
|
1169
|
+
|
|
1170
|
+
self.parser.parse()
|
|
1171
|
+
|
|
1172
|
+
def _get_key_values(self, path, repeats=False, array=False):
|
|
1173
|
+
def parse_float_str_vector(str_vector: List[str]):
|
|
1174
|
+
return ['nan' if '*' in x else x for x in str_vector]
|
|
1175
|
+
|
|
1176
|
+
root, base_name = path.strip('/').rsplit('/', 1)
|
|
1177
|
+
|
|
1178
|
+
attrib = re.search(self._re_attrib, base_name)
|
|
1179
|
+
if attrib:
|
|
1180
|
+
attrib = attrib.group(1)
|
|
1181
|
+
base_name = re.sub(self._re_attrib, '', base_name)
|
|
1182
|
+
|
|
1183
|
+
# removes all non indexed segments from the path to collect data from the
|
|
1184
|
+
# whole remaining sub-tree.
|
|
1185
|
+
sections = []
|
|
1186
|
+
for section in root.split('/'):
|
|
1187
|
+
if not section.endswith(']'):
|
|
1188
|
+
break
|
|
1189
|
+
sections.append(section)
|
|
1190
|
+
root = '/'.join(sections) if sections else root
|
|
1191
|
+
|
|
1192
|
+
data = [
|
|
1193
|
+
(
|
|
1194
|
+
d.get(base_name),
|
|
1195
|
+
d.get('name', ''),
|
|
1196
|
+
d.get('type', ''),
|
|
1197
|
+
)
|
|
1198
|
+
for d in self.parser.results[root]
|
|
1199
|
+
]
|
|
1200
|
+
|
|
1201
|
+
if len(data) == 0:
|
|
1202
|
+
return dict()
|
|
1203
|
+
|
|
1204
|
+
result = dict()
|
|
1205
|
+
if array:
|
|
1206
|
+
value = [
|
|
1207
|
+
parse_float_str_vector(item[0].split()) for item in data if item[0]
|
|
1208
|
+
]
|
|
1209
|
+
value = [d[0] if len(d) == 1 and not repeats else d for d in value]
|
|
1210
|
+
dtype = data[0][2]
|
|
1211
|
+
try:
|
|
1212
|
+
result[base_name] = np.array(
|
|
1213
|
+
value, dtype=self._dtypes.get(dtype, float)
|
|
1214
|
+
)
|
|
1215
|
+
except Exception:
|
|
1216
|
+
self.parser.logger.error('Error parsing array.')
|
|
1217
|
+
|
|
1218
|
+
else:
|
|
1219
|
+
for value, name, dtype in data:
|
|
1220
|
+
if not value:
|
|
1221
|
+
continue
|
|
1222
|
+
if attrib and name != attrib:
|
|
1223
|
+
continue
|
|
1224
|
+
name = name if name else base_name
|
|
1225
|
+
dtype = self._dtypes.get(dtype, str)
|
|
1226
|
+
value = value.split()
|
|
1227
|
+
if dtype is bool:
|
|
1228
|
+
value = [v == 'T' for v in value]
|
|
1229
|
+
if dtype is float:
|
|
1230
|
+
# prevent nan printouts
|
|
1231
|
+
value = parse_float_str_vector(value)
|
|
1232
|
+
# using numpy array does not work
|
|
1233
|
+
value = convert(value, dtype)
|
|
1234
|
+
value = value[0] if len(value) == 1 else value
|
|
1235
|
+
result.setdefault(name, [])
|
|
1236
|
+
result[name].append(value)
|
|
1237
|
+
if not repeats:
|
|
1238
|
+
for key, val in result.items():
|
|
1239
|
+
result[key] = val[0] if len(val) == 1 else val
|
|
1240
|
+
|
|
1241
|
+
return result
|
|
1242
|
+
|
|
1243
|
+
@property
|
|
1244
|
+
def header(self):
|
|
1245
|
+
if self._header is None:
|
|
1246
|
+
self._header = self._get_key_values('/modeling[0]/generator[0]/i')
|
|
1247
|
+
for key, val in self._header.items():
|
|
1248
|
+
if not isinstance(val, str):
|
|
1249
|
+
self._header[key] = ' '.join(val)
|
|
1250
|
+
return self._header
|
|
1251
|
+
|
|
1252
|
+
def get_incar(self):
|
|
1253
|
+
if self._incar is not None and self._incar.get('incar', None) is not None:
|
|
1254
|
+
return self._incar.get('incar')
|
|
1255
|
+
|
|
1256
|
+
if self._incar is None:
|
|
1257
|
+
self._incar = dict(incar=None, incar_out=None)
|
|
1258
|
+
incar = self._get_key_values('/modeling[0]/incar[0]/i')
|
|
1259
|
+
incar.update(self._get_key_values('/modeling[0]/incar[0]/v'))
|
|
1260
|
+
self._fix_incar(incar)
|
|
1261
|
+
self._incar['incar'] = incar
|
|
1262
|
+
return incar
|
|
1263
|
+
|
|
1264
|
+
def get_incar_out(self):
|
|
1265
|
+
if self._incar is not None and self._incar.get('incar_out', None) is not None:
|
|
1266
|
+
return self._incar.get('incar_out')
|
|
1267
|
+
|
|
1268
|
+
incar = dict()
|
|
1269
|
+
if self._incar is None:
|
|
1270
|
+
self._incar = dict(incar=None, incar_out=None)
|
|
1271
|
+
incar.update(self._get_key_values('/modeling[0]/parameters[0]/i'))
|
|
1272
|
+
incar.update(self._get_key_values('/modeling[0]/parameters[0]/v'))
|
|
1273
|
+
incar.update(self._get_key_values('/modeling[0]/incar[0]/v'))
|
|
1274
|
+
|
|
1275
|
+
self._incar['incar_out'] = incar
|
|
1276
|
+
self._fix_incar(incar)
|
|
1277
|
+
return incar
|
|
1278
|
+
|
|
1279
|
+
@property
|
|
1280
|
+
def n_calculations(self):
|
|
1281
|
+
return self.parser.n_calculations
|
|
1282
|
+
|
|
1283
|
+
sampling_method_mapping = {
|
|
1284
|
+
'Automatic': 'Gamma-centered',
|
|
1285
|
+
'Gamma': 'Gamma-centered',
|
|
1286
|
+
'Monkhorst-Pack': 'Monkhorst-Pack',
|
|
1287
|
+
'listgenerated': 'Line-path',
|
|
1288
|
+
}
|
|
1289
|
+
|
|
1290
|
+
@property
|
|
1291
|
+
def kpoints_info(self):
|
|
1292
|
+
if self._kpoints_info is None:
|
|
1293
|
+
self._kpoints_info = dict()
|
|
1294
|
+
# initialize parsing of k_points
|
|
1295
|
+
method = self._get_key_values('/modeling[0]/kpoints[0]/generation[0]/param')
|
|
1296
|
+
if method:
|
|
1297
|
+
self._kpoints_info['sampling_method'] = (
|
|
1298
|
+
RunContentParser.sampling_method_mapping[method['param']]
|
|
1299
|
+
)
|
|
1300
|
+
divisions = self._get_key_values(
|
|
1301
|
+
'/modeling[0]/kpoints[0]/generation[0]/v[@name="divisions"]'
|
|
1302
|
+
)
|
|
1303
|
+
if not divisions:
|
|
1304
|
+
divisions = self._get_key_values(
|
|
1305
|
+
'/modeling[0]/kpoints[0]/generation[0]/i[@name="divisions"]'
|
|
1306
|
+
)
|
|
1307
|
+
if divisions:
|
|
1308
|
+
grid = divisions['divisions']
|
|
1309
|
+
self._kpoints_info['grid'] = (
|
|
1310
|
+
grid if isinstance(grid, list) else [int(grid)]
|
|
1311
|
+
)
|
|
1312
|
+
volumeweight = self._get_key_values(
|
|
1313
|
+
'/modeling[0]/kpoints[0]/generation[0]/i[@name="volumeweight"]'
|
|
1314
|
+
)
|
|
1315
|
+
if volumeweight:
|
|
1316
|
+
volumeweight = (volumeweight['volumeweight'] * ureg.angstrom**3).to(
|
|
1317
|
+
'm**3'
|
|
1318
|
+
)
|
|
1319
|
+
# TODO set propert unit in metainfo
|
|
1320
|
+
self._kpoints_info['x_vasp_tetrahedron_volume'] = volumeweight.magnitude
|
|
1321
|
+
points = self._get_key_values(
|
|
1322
|
+
'/modeling[0]/kpoints[0]/varray[@name="kpointlist"]/v', array=True
|
|
1323
|
+
)
|
|
1324
|
+
if points:
|
|
1325
|
+
self._kpoints_info['points'] = points['v']
|
|
1326
|
+
weights = self._get_key_values(
|
|
1327
|
+
'/modeling[0]/kpoints[0]/varray[@name="weights"]/v', array=True
|
|
1328
|
+
)
|
|
1329
|
+
if weights:
|
|
1330
|
+
self._kpoints_info['weights'] = weights['v']
|
|
1331
|
+
tetrahedrons = self._get_key_values(
|
|
1332
|
+
'/modeling[0]/kpoints[0]/varray[@name="tetrahedronlist"]/v', array=True
|
|
1333
|
+
)
|
|
1334
|
+
if tetrahedrons:
|
|
1335
|
+
self._kpoints_info['x_vasp_tetrahedrons_list'] = tetrahedrons['v']
|
|
1336
|
+
return self._kpoints_info
|
|
1337
|
+
|
|
1338
|
+
@property
|
|
1339
|
+
def n_bands(self):
|
|
1340
|
+
if self._n_bands is None:
|
|
1341
|
+
for n in range(self.n_calculations - 1, -1, -1):
|
|
1342
|
+
val = self._get_key_values(
|
|
1343
|
+
'/modeling[0]/calculation[%d]/eigenvalues[0]/array[0]/set[0]/set[0]/set[0]/r'
|
|
1344
|
+
% n
|
|
1345
|
+
)
|
|
1346
|
+
if val:
|
|
1347
|
+
self._n_bands = len(val['r'])
|
|
1348
|
+
break
|
|
1349
|
+
if self._n_bands is None:
|
|
1350
|
+
self._n_bands = self.incar.get('NBANDS', 0)
|
|
1351
|
+
return self._n_bands
|
|
1352
|
+
|
|
1353
|
+
@property
|
|
1354
|
+
def n_dos(self):
|
|
1355
|
+
if self._n_dos is None:
|
|
1356
|
+
for n in range(self.n_calculations - 1, -1, -1):
|
|
1357
|
+
val = self._get_key_values(
|
|
1358
|
+
'/modeling[0]/calculation[%d]/dos[0]/total[0]/array[0]/set[0]/set[0]/r'
|
|
1359
|
+
% n
|
|
1360
|
+
)
|
|
1361
|
+
if val:
|
|
1362
|
+
self._n_dos = len(val['r'])
|
|
1363
|
+
break
|
|
1364
|
+
if self._n_dos is None:
|
|
1365
|
+
self._n_dos = self._incar.get('NEDOS', 0)
|
|
1366
|
+
return self._n_dos
|
|
1367
|
+
|
|
1368
|
+
@property
|
|
1369
|
+
def atom_info(self):
|
|
1370
|
+
if self._atom_info is None:
|
|
1371
|
+
self._atom_info = {}
|
|
1372
|
+
root = '/modeling[0]/atominfo[0]'
|
|
1373
|
+
self._atom_info['n_atoms'] = int(
|
|
1374
|
+
self._get_key_values(f'{root}/atoms[0]/atoms').get('atoms', 0)
|
|
1375
|
+
)
|
|
1376
|
+
self._atom_info['n_types'] = int(
|
|
1377
|
+
self._get_key_values(f'{root}/types[0]/types').get('types', 0)
|
|
1378
|
+
)
|
|
1379
|
+
|
|
1380
|
+
number = dict(
|
|
1381
|
+
atoms=self._atom_info['n_atoms'], atomtypes=self._atom_info['n_types']
|
|
1382
|
+
)
|
|
1383
|
+
for key in ['atoms', 'atomtypes']:
|
|
1384
|
+
rcs = self._get_key_values(
|
|
1385
|
+
f'{root}/array[@name="%s"]/set[0]/c' % key, repeats=True
|
|
1386
|
+
).get('c', [])
|
|
1387
|
+
fields = self._get_key_values(
|
|
1388
|
+
f'{root}/array[@name="%s"]/field' % key, repeats=True
|
|
1389
|
+
).get('field', [])
|
|
1390
|
+
array_info = {}
|
|
1391
|
+
if len(rcs) != len(fields) * number[key]:
|
|
1392
|
+
self._atom_info = array_info
|
|
1393
|
+
continue
|
|
1394
|
+
for n in range(number[key]):
|
|
1395
|
+
for i in range(len(fields)):
|
|
1396
|
+
array_info.setdefault(fields[i], [])
|
|
1397
|
+
array_info[fields[i]].append(rcs[n * len(fields) + i])
|
|
1398
|
+
self._atom_info[key] = array_info
|
|
1399
|
+
return self._atom_info
|
|
1400
|
+
|
|
1401
|
+
def get_pseudopotential(self): # TODO: combine with its OUTCAR counterpart
|
|
1402
|
+
"""Extract the pseudo-potential headers from the POTCAR,
|
|
1403
|
+
and return them as a list of keyword mappings.
|
|
1404
|
+
Each element of the list corresponds to a pseudo-potential."""
|
|
1405
|
+
potcar_file = os.path.join(self.parser.maindir, 'POTCAR.stripped')
|
|
1406
|
+
return super().get_pseudopotential(potcar_file)
|
|
1407
|
+
|
|
1408
|
+
def get_basis_set(self) -> list[BasisSet]:
|
|
1409
|
+
path = '/modeling[0]/parameters/separator[@name="electronic"]'
|
|
1410
|
+
sec_bases: list[BasisSet] = []
|
|
1411
|
+
for tag in ('ENMAX', 'ENAUG'):
|
|
1412
|
+
cutoff_path = f'{path}/i[@name="{tag}"]'
|
|
1413
|
+
cutoff_value = self._get_key_values(cutoff_path).get(tag)
|
|
1414
|
+
if cutoff_value is not None:
|
|
1415
|
+
sec_basis = BasisSet(
|
|
1416
|
+
type='plane waves',
|
|
1417
|
+
cutoff=(
|
|
1418
|
+
cutoff_value[-1]
|
|
1419
|
+
if isinstance(cutoff_value, (np.ndarray, list))
|
|
1420
|
+
else cutoff_value
|
|
1421
|
+
)
|
|
1422
|
+
* ureg.eV, # based on examples
|
|
1423
|
+
frozen_core=False
|
|
1424
|
+
if self.get_incar_out().get('ICORELEVEL', 0) == 1
|
|
1425
|
+
else True,
|
|
1426
|
+
) # TODO: write the core eigenvalues to calculation + display them?
|
|
1427
|
+
if tag == 'ENMAX':
|
|
1428
|
+
sec_basis.scope = ['valence']
|
|
1429
|
+
elif tag == 'ENAUG':
|
|
1430
|
+
sec_basis.scope = ['augmentation']
|
|
1431
|
+
# TODO: add grid spacing (NGX, NGY, NGZ)?
|
|
1432
|
+
sec_bases.append(sec_basis)
|
|
1433
|
+
return sec_bases
|
|
1434
|
+
|
|
1435
|
+
def get_tier(self, type='native') -> Union[str, None]:
|
|
1436
|
+
return super()._get_tier(
|
|
1437
|
+
self._get_key_values(
|
|
1438
|
+
'/modeling[0]/parameters/separator[@name="electronic"]/i[@name="PREC"]'
|
|
1439
|
+
)['PREC'][0],
|
|
1440
|
+
type=type,
|
|
1441
|
+
)
|
|
1442
|
+
|
|
1443
|
+
def get_time_calc(self, n_calc):
|
|
1444
|
+
return self._get_key_values(
|
|
1445
|
+
f'/modeling[0]/calculation[{n_calc}]/time[@name="totalsc"]'
|
|
1446
|
+
).get('totalsc', [None, None])
|
|
1447
|
+
|
|
1448
|
+
def get_time_scf(self, n_calc):
|
|
1449
|
+
time = self._get_key_values(
|
|
1450
|
+
f'/modeling[0]/calculation[{n_calc}]/scstep/time[@name="total"]'
|
|
1451
|
+
).get('total', [])
|
|
1452
|
+
if time and len(np.shape(time)) != 2:
|
|
1453
|
+
time = np.reshape(time, (np.size(time) // 2, 2))
|
|
1454
|
+
return time
|
|
1455
|
+
|
|
1456
|
+
def get_n_scf(self, n_calc):
|
|
1457
|
+
if self._n_scf is None:
|
|
1458
|
+
self._n_scf = [None] * self.n_calculations
|
|
1459
|
+
if self._n_scf[n_calc] is None:
|
|
1460
|
+
self._n_scf[n_calc] = len(self.get_time_scf(n_calc))
|
|
1461
|
+
return self._n_scf[n_calc]
|
|
1462
|
+
|
|
1463
|
+
def get_structure(self, n_calc):
|
|
1464
|
+
structure = '/modeling[0]/calculation[%d]/structure[0]' % n_calc
|
|
1465
|
+
cell = self._get_key_values(
|
|
1466
|
+
f'{structure}/crystal[0]/varray[@name="basis"]/v', array=True
|
|
1467
|
+
).get('v', None)
|
|
1468
|
+
if cell is None:
|
|
1469
|
+
structure = '/modeling[0]/structure[@name="finalpos"]'
|
|
1470
|
+
cell = self._get_key_values(
|
|
1471
|
+
f'{structure}/crystal[0]/varray[@name="basis"]/v', array=True
|
|
1472
|
+
).get('v', None)
|
|
1473
|
+
|
|
1474
|
+
positions = self._get_key_values(
|
|
1475
|
+
f'{structure}/varray[@name="positions"]/v', array=True
|
|
1476
|
+
).get('v', None)
|
|
1477
|
+
selective = self._get_key_values(
|
|
1478
|
+
f'{structure}/varray[@name="selective"]/v', array=True
|
|
1479
|
+
).get('v', None)
|
|
1480
|
+
# COMMENTED OUT: there is a problem with the versioning: sometimes is nose
|
|
1481
|
+
# others nose[0]; when trying ifs, _get_key_values gives error trying to set
|
|
1482
|
+
# the array.
|
|
1483
|
+
# if self._get_key_values(f'{structure}/nose/v', array=True):
|
|
1484
|
+
# nose = self._get_key_values(
|
|
1485
|
+
# f'{structure}/nose/v', array=True).get('v', None)
|
|
1486
|
+
# else:
|
|
1487
|
+
# nose = self._get_key_values(
|
|
1488
|
+
# f'{structure}/nose[0]/v', array=True).get('v', None)
|
|
1489
|
+
nose = None
|
|
1490
|
+
|
|
1491
|
+
if positions is not None:
|
|
1492
|
+
positions = np.dot(positions, cell) * ureg.angstrom
|
|
1493
|
+
if cell is not None:
|
|
1494
|
+
cell = cell * ureg.angstrom
|
|
1495
|
+
|
|
1496
|
+
return dict(cell=cell, positions=positions, selective=selective, nose=nose)
|
|
1497
|
+
|
|
1498
|
+
def get_energies(self, n_calc, n_scf):
|
|
1499
|
+
calculation = '/modeling[0]/calculation[%d]' % n_calc
|
|
1500
|
+
if n_scf is None:
|
|
1501
|
+
# we need to cache this separately for faster access
|
|
1502
|
+
self._scf_energies = self._get_key_values(
|
|
1503
|
+
f'{calculation}/scstep/i', repeats=True
|
|
1504
|
+
)
|
|
1505
|
+
return self._get_key_values(f'{calculation}/energy[0]/i')
|
|
1506
|
+
else:
|
|
1507
|
+
scf_energies = dict()
|
|
1508
|
+
for key, val in self._scf_energies.items():
|
|
1509
|
+
try:
|
|
1510
|
+
scf_energies[key] = val[n_scf]
|
|
1511
|
+
except Exception:
|
|
1512
|
+
scf_energies[key] = (
|
|
1513
|
+
val[-1] if n_scf == self.get_n_scf(n_calc) - 1 else None
|
|
1514
|
+
)
|
|
1515
|
+
return scf_energies
|
|
1516
|
+
|
|
1517
|
+
def get_forces_stress(self, n_calc):
|
|
1518
|
+
forces = self._get_key_values(
|
|
1519
|
+
'/modeling[0]/calculation[%d]/varray[@name="forces"]/v' % n_calc, array=True
|
|
1520
|
+
).get('v', None)
|
|
1521
|
+
stress = self._get_key_values(
|
|
1522
|
+
'/modeling[0]/calculation[%d]/varray[@name="stress"]/v' % n_calc, array=True
|
|
1523
|
+
).get('v', None)
|
|
1524
|
+
return forces, stress
|
|
1525
|
+
|
|
1526
|
+
def get_eigenvalues(self, n_calc):
|
|
1527
|
+
n_kpts = len(self.kpoints_info.get('points', []))
|
|
1528
|
+
root = '/modeling[0]/calculation[%s]/eigenvalues[0]/array[0]/set[0]' % n_calc
|
|
1529
|
+
eigenvalues = self._get_key_values(f'{root}/r', array=True).get('r', None)
|
|
1530
|
+
if eigenvalues is None:
|
|
1531
|
+
return
|
|
1532
|
+
|
|
1533
|
+
try:
|
|
1534
|
+
eigenvalues = np.reshape(eigenvalues, (self.ispin, n_kpts, self.n_bands, 2))
|
|
1535
|
+
except Exception:
|
|
1536
|
+
self.parser.logger.error('Error reading eigenvalues')
|
|
1537
|
+
return
|
|
1538
|
+
|
|
1539
|
+
return eigenvalues
|
|
1540
|
+
|
|
1541
|
+
def get_total_dos(self, n_calc):
|
|
1542
|
+
dos_energies = dos_values = dos_integrated = e_fermi = None
|
|
1543
|
+
|
|
1544
|
+
root = '/modeling[0]/calculation[%d]/dos[0]' % n_calc
|
|
1545
|
+
dos = self._get_key_values(
|
|
1546
|
+
rf'{root}/total[0]/array[0]/set[0]/set/r', array=True
|
|
1547
|
+
).get('r', None)
|
|
1548
|
+
|
|
1549
|
+
if dos is None:
|
|
1550
|
+
return dos_energies, dos_values, dos_integrated, e_fermi
|
|
1551
|
+
|
|
1552
|
+
e_fermi = self._get_key_values(f'{root}/i[@name="efermi"]').get('efermi', 0.0)
|
|
1553
|
+
n_dos = 1 if isinstance(e_fermi, float) else len(e_fermi)
|
|
1554
|
+
if n_dos > 1:
|
|
1555
|
+
e_fermi = e_fermi[-1]
|
|
1556
|
+
self.parser.logger.warning('Multiple dos found, will read only last.')
|
|
1557
|
+
|
|
1558
|
+
try:
|
|
1559
|
+
dos = np.reshape(
|
|
1560
|
+
dos, (n_dos, self.ispin, len(dos) // self.ispin // n_dos, 3)
|
|
1561
|
+
)[-1]
|
|
1562
|
+
except Exception:
|
|
1563
|
+
self.parser.logger.error('Error reading total dos.')
|
|
1564
|
+
return dos_energies, dos_values, dos_integrated, e_fermi
|
|
1565
|
+
|
|
1566
|
+
dos = np.transpose(dos)
|
|
1567
|
+
dos_energies = dos[0].T[0]
|
|
1568
|
+
dos_values = dos[1].T
|
|
1569
|
+
dos_integrated = dos[2].T
|
|
1570
|
+
|
|
1571
|
+
return dos_energies, dos_values, dos_integrated, e_fermi
|
|
1572
|
+
|
|
1573
|
+
def get_partial_dos(self, n_calc):
|
|
1574
|
+
n_atoms = self.atom_info['n_atoms']
|
|
1575
|
+
root = '/modeling[0]/calculation[%d]/dos[0]/partial[0]/array[0]' % n_calc
|
|
1576
|
+
|
|
1577
|
+
dos = self._get_key_values(f'{root}/r').get('r', None)
|
|
1578
|
+
|
|
1579
|
+
if dos is None:
|
|
1580
|
+
return None, None
|
|
1581
|
+
|
|
1582
|
+
# TODO use atomprojecteddos section
|
|
1583
|
+
fields = self._get_key_values(f'{root}/field').get('field', [])
|
|
1584
|
+
try:
|
|
1585
|
+
dos = np.reshape(
|
|
1586
|
+
dos,
|
|
1587
|
+
(n_atoms, self.ispin, len(dos) // (n_atoms * self.ispin), len(fields)),
|
|
1588
|
+
)
|
|
1589
|
+
except Exception:
|
|
1590
|
+
self.parser.logger.error('Error reading partial dos.')
|
|
1591
|
+
return None, None
|
|
1592
|
+
|
|
1593
|
+
fields = [field for field in fields if field != 'energy']
|
|
1594
|
+
dos = np.transpose(dos)[1:]
|
|
1595
|
+
dos = np.transpose(dos, axes=(0, 2, 3, 1))
|
|
1596
|
+
|
|
1597
|
+
return dos, fields
|
|
1598
|
+
|
|
1599
|
+
def get_response_functions(self):
|
|
1600
|
+
root = '/modeling[0]/parameters[0]/separator[@name="response functions"]/i'
|
|
1601
|
+
return self._get_key_values(root)
|
|
1602
|
+
|
|
1603
|
+
|
|
1604
|
+
class VASPParser:
|
|
1605
|
+
def __init__(self):
|
|
1606
|
+
self._vasprun_parser = RunContentParser()
|
|
1607
|
+
self._outcar_parser = OutcarContentParser()
|
|
1608
|
+
self._calculation_type = 'dft'
|
|
1609
|
+
self.hubbard_dc_corrections = {
|
|
1610
|
+
1: 'Liechtenstein',
|
|
1611
|
+
2: 'Dudarev',
|
|
1612
|
+
4: 'Liechtenstein without exchange splitting',
|
|
1613
|
+
}
|
|
1614
|
+
self.hubbard_orbital_types = {-1: None, 0: 's', 1: 'p', 2: 'd', 3: 'f'}
|
|
1615
|
+
self.gw_algo = ''
|
|
1616
|
+
self._gw_algo_map = {
|
|
1617
|
+
'EVGW0': 'ev-scGW0',
|
|
1618
|
+
'EVGW0R': 'ev-scGW0',
|
|
1619
|
+
'EVGW': 'ev-scGW',
|
|
1620
|
+
'QPGW0': 'qp-scGW0',
|
|
1621
|
+
'QPGW': 'qp-scGW',
|
|
1622
|
+
'GW0R': 'scGW0',
|
|
1623
|
+
'GWR': 'scGW',
|
|
1624
|
+
}
|
|
1625
|
+
|
|
1626
|
+
def init_parser(self, filepath, logger):
|
|
1627
|
+
self.parser = (
|
|
1628
|
+
self._vasprun_parser if '.xml' in filepath else self._outcar_parser
|
|
1629
|
+
)
|
|
1630
|
+
self.parser.init_parser(filepath, logger)
|
|
1631
|
+
self.maindir = os.path.dirname(os.path.abspath(filepath))
|
|
1632
|
+
|
|
1633
|
+
def parse_incarsinout(self):
|
|
1634
|
+
sec_method = self.archive.run[-1].method[-1]
|
|
1635
|
+
|
|
1636
|
+
def parse_incar(parameters, target):
|
|
1637
|
+
for key, val in parameters.items():
|
|
1638
|
+
if isinstance(val, np.ndarray):
|
|
1639
|
+
val = list(val)
|
|
1640
|
+
parameters[key] = val
|
|
1641
|
+
try:
|
|
1642
|
+
setattr(sec_method, target, parameters)
|
|
1643
|
+
except Exception:
|
|
1644
|
+
self.logger.warning(
|
|
1645
|
+
'Error setting metainfo defintion x_vasp_incar_in',
|
|
1646
|
+
data=dict(incar=parameters),
|
|
1647
|
+
)
|
|
1648
|
+
|
|
1649
|
+
parse_incar(self.parser.get_incar(), 'x_vasp_incar_in')
|
|
1650
|
+
parse_incar(self.parser.get_incar_out(), 'x_vasp_incar_out')
|
|
1651
|
+
|
|
1652
|
+
def parse_kpoints(self, section):
|
|
1653
|
+
sec_k_mesh = KMesh()
|
|
1654
|
+
section.k_mesh = sec_k_mesh
|
|
1655
|
+
for key, val in self.parser.kpoints_info.items():
|
|
1656
|
+
quantity_def = sec_k_mesh.m_def.all_quantities.get(key)
|
|
1657
|
+
if val is not None and quantity_def is not None:
|
|
1658
|
+
sec_k_mesh.m_set(quantity_def, val)
|
|
1659
|
+
if sec_k_mesh.points is None:
|
|
1660
|
+
sec_k_mesh.points = [[0.0] * 3]
|
|
1661
|
+
|
|
1662
|
+
def parse_core_hole(self) -> tuple[Optional[CoreHole], Optional[AtomsGroup], int]:
|
|
1663
|
+
"""
|
|
1664
|
+
Map the core-hole information to a `CoreHole` section.
|
|
1665
|
+
Returns the core-hole, the `AtomsGroup` to which it refers, along with the matching element index.
|
|
1666
|
+
"""
|
|
1667
|
+
|
|
1668
|
+
source = self.parser.incar
|
|
1669
|
+
# setup `AtomsGroup` parameters
|
|
1670
|
+
elem_id = source.get('CLNT', 1) - 1
|
|
1671
|
+
elem_ids = [
|
|
1672
|
+
int(x) for x in self.parser.atom_info['atomtypes'].get('atomspertype', [])
|
|
1673
|
+
]
|
|
1674
|
+
lower_range = elem_ids[elem_id - 1] if elem_id > 1 else 0
|
|
1675
|
+
atom_ids = list(range(lower_range, elem_ids[elem_id]))
|
|
1676
|
+
return (
|
|
1677
|
+
CoreHole(
|
|
1678
|
+
n_quantum_number=source.get('CLN', 1),
|
|
1679
|
+
l_quantum_number=source.get('CLL', 0),
|
|
1680
|
+
n_electrons_excited=source.get('CLZ', 0.0), # tested with VASP 6.4.1
|
|
1681
|
+
dscf_state='final',
|
|
1682
|
+
),
|
|
1683
|
+
AtomsGroup(
|
|
1684
|
+
label='core-hole',
|
|
1685
|
+
type='active_orbitals',
|
|
1686
|
+
atom_indices=atom_ids,
|
|
1687
|
+
n_atoms=len(atom_ids),
|
|
1688
|
+
),
|
|
1689
|
+
elem_id,
|
|
1690
|
+
)
|
|
1691
|
+
|
|
1692
|
+
def parse_method(self):
|
|
1693
|
+
sec_method = Method()
|
|
1694
|
+
self.archive.run[-1].method.append(sec_method)
|
|
1695
|
+
sec_dft = DFT()
|
|
1696
|
+
sec_method.dft = sec_dft
|
|
1697
|
+
sec_method.electronic = Electronic(
|
|
1698
|
+
method='DFT+U' if self.parser.incar.get('LDAU', False) else 'DFT'
|
|
1699
|
+
)
|
|
1700
|
+
|
|
1701
|
+
# input/output incar
|
|
1702
|
+
self.parse_incarsinout()
|
|
1703
|
+
# kpoints
|
|
1704
|
+
self.parse_kpoints(sec_method)
|
|
1705
|
+
|
|
1706
|
+
# atom properties & hubbard correction
|
|
1707
|
+
# based on https://www.vasp.at/wiki/index.php/LDAUTYPE (08/07/2022)
|
|
1708
|
+
hubbard_present = False
|
|
1709
|
+
# try parsing vasprun.xml, incar, outcar (abbreviated settings)
|
|
1710
|
+
for file_type, parser_type in zip(
|
|
1711
|
+
['incar_out', 'incar', 'incar', 'incar_out'],
|
|
1712
|
+
[
|
|
1713
|
+
RunContentParser,
|
|
1714
|
+
RunContentParser,
|
|
1715
|
+
OutcarContentParser,
|
|
1716
|
+
OutcarContentParser,
|
|
1717
|
+
],
|
|
1718
|
+
):
|
|
1719
|
+
# self.parser.incar ## in case the keys are not being found: put this line back in
|
|
1720
|
+
parsed_file = self.parser._incar[file_type]
|
|
1721
|
+
if not (type(self.parser) is parser_type and parsed_file):
|
|
1722
|
+
continue
|
|
1723
|
+
# check minimum requirements to define hubbard_model
|
|
1724
|
+
if (file_type == 'incar' and parsed_file.get('LDAU')) or (
|
|
1725
|
+
parsed_file.get('LDAUL')
|
|
1726
|
+
):
|
|
1727
|
+
hubbard_present = True
|
|
1728
|
+
break
|
|
1729
|
+
|
|
1730
|
+
# Atom Parameters
|
|
1731
|
+
atomtypes = self.parser.atom_info.get('atomtypes', {})
|
|
1732
|
+
element = atomtypes.get('element', [])
|
|
1733
|
+
atom_counts = {e: 0 for e in element}
|
|
1734
|
+
pseudopotentials = self.parser.get_pseudopotential()
|
|
1735
|
+
for i in range(len(element)):
|
|
1736
|
+
sec_method_atom_kind = AtomParameters()
|
|
1737
|
+
sec_method.atom_parameters.append(sec_method_atom_kind)
|
|
1738
|
+
atom_number = ase.data.atomic_numbers.get(element[i], 0)
|
|
1739
|
+
sec_method_atom_kind.atom_number = atom_number
|
|
1740
|
+
atom_label = (
|
|
1741
|
+
'%s%d' % (element[i], atom_counts[element[i]])
|
|
1742
|
+
if atom_counts[element[i]] > 0
|
|
1743
|
+
else element[i]
|
|
1744
|
+
)
|
|
1745
|
+
sec_method_atom_kind.label = str(atom_label)
|
|
1746
|
+
if pseudopotentials:
|
|
1747
|
+
try:
|
|
1748
|
+
pseudopotential = pseudopotentials[i]
|
|
1749
|
+
except IndexError:
|
|
1750
|
+
self.logger.error(
|
|
1751
|
+
f'Pseudopotential not found for atom {element[i]}'
|
|
1752
|
+
)
|
|
1753
|
+
sec_method_atom_kind.mass = (
|
|
1754
|
+
pseudopotential['number']['POMASS'] * ureg.amu
|
|
1755
|
+
)
|
|
1756
|
+
sec_method_atom_kind.n_valence_electrons = pseudopotential['number'][
|
|
1757
|
+
'ZVAL'
|
|
1758
|
+
]
|
|
1759
|
+
pp = Pseudopotential()
|
|
1760
|
+
pp.type = 'PAW'
|
|
1761
|
+
if pseudopotential['flag']['LULTRA']:
|
|
1762
|
+
pp.type = 'US V' # TODO check if this is correct
|
|
1763
|
+
pp.cutoff = pseudopotential['number']['ENMAX'] * ureg.eV
|
|
1764
|
+
try:
|
|
1765
|
+
pp.xc_functional_name = self.parser.xc_functional_mapping.get(
|
|
1766
|
+
pseudopotential['title'][0].split('_')[1],
|
|
1767
|
+
['GGA_X_PBE', 'GGA_C_PBE'],
|
|
1768
|
+
)
|
|
1769
|
+
except IndexError:
|
|
1770
|
+
self.logger.warning(
|
|
1771
|
+
f'Could not extract xc functional from pseudopotential for {element[i]}'
|
|
1772
|
+
)
|
|
1773
|
+
pp.name = ' '.join(pseudopotential['title'])
|
|
1774
|
+
sec_method_atom_kind.pseudopotential = pp
|
|
1775
|
+
|
|
1776
|
+
if hubbard_present:
|
|
1777
|
+
orbital = self.hubbard_orbital_types[int(parsed_file.get('LDAUL')[i])]
|
|
1778
|
+
if orbital:
|
|
1779
|
+
sec_hubb = HubbardKanamoriModel()
|
|
1780
|
+
sec_method_atom_kind.hubbard_kanamori_model = sec_hubb
|
|
1781
|
+
sec_hubb.orbital = orbital
|
|
1782
|
+
sec_hubb.u = float(parsed_file.get('LDAUU')[i]) * ureg.eV
|
|
1783
|
+
sec_hubb.j = float(parsed_file.get('LDAUJ')[i]) * ureg.eV
|
|
1784
|
+
sec_hubb.double_counting_correction = (
|
|
1785
|
+
self.hubbard_dc_corrections.get(parsed_file.get('LDAUTYPE'))
|
|
1786
|
+
)
|
|
1787
|
+
sec_hubb.x_vasp_projection_type = 'on-site'
|
|
1788
|
+
atom_counts[element[i]] += 1
|
|
1789
|
+
|
|
1790
|
+
sec_method.electrons_representation = [
|
|
1791
|
+
BasisSetContainer(
|
|
1792
|
+
type='plane waves',
|
|
1793
|
+
scope=['wavefunction'],
|
|
1794
|
+
native_tier=self.parser.get_tier(type='native'),
|
|
1795
|
+
basis_set=self.parser.get_basis_set(),
|
|
1796
|
+
)
|
|
1797
|
+
]
|
|
1798
|
+
|
|
1799
|
+
sec_xc_functional = XCFunctional()
|
|
1800
|
+
sec_dft.xc_functional = sec_xc_functional
|
|
1801
|
+
if self.parser.incar.get('LHFCALC', False):
|
|
1802
|
+
gga = self.parser.incar.get('GGA', 'PE')
|
|
1803
|
+
aexx = self.parser.incar.get('AEXX', 0.0)
|
|
1804
|
+
aggax = self.parser.incar.get('AGGAX', 1.0)
|
|
1805
|
+
aggac = self.parser.incar.get('AGGAC', 1.0)
|
|
1806
|
+
aldac = self.parser.incar.get('ALDAC', 1.0)
|
|
1807
|
+
hfscreen = self.parser.incar.get('HFSCREEN', 0.0)
|
|
1808
|
+
|
|
1809
|
+
if hfscreen == 0.2:
|
|
1810
|
+
sec_xc_functional.hybrid.append(Functional(name='HYB_GGA_XC_HSE06'))
|
|
1811
|
+
elif hfscreen == 0.3:
|
|
1812
|
+
sec_xc_functional.hybrid.append(Functional(name='HYB_GGA_XC_HSE03'))
|
|
1813
|
+
elif (
|
|
1814
|
+
gga == 'B3'
|
|
1815
|
+
and aexx == 0.2
|
|
1816
|
+
and aggax == 0.72
|
|
1817
|
+
and aggac == 0.81
|
|
1818
|
+
and aldac == 0.19
|
|
1819
|
+
):
|
|
1820
|
+
sec_xc_functional.hybrid.append(Functional(name='HYB_GGA_XC_B3LYP3'))
|
|
1821
|
+
elif aexx == 1.0 and aldac == 0.0 and aggac == 0.0:
|
|
1822
|
+
sec_xc_functional.contributions.append(Functional(name='HF_X'))
|
|
1823
|
+
elif gga == 'PE':
|
|
1824
|
+
sec_xc_functional.hybrid.append(Functional(name='HYB_GGA_XC_PBEH'))
|
|
1825
|
+
else:
|
|
1826
|
+
sec_xc_functional.hybrid.append(
|
|
1827
|
+
Functional(
|
|
1828
|
+
name='HYB_GGA_XC_%s' % gga,
|
|
1829
|
+
parameters=dict(aggax=aggax, aggac=aggac, aldac=aldac),
|
|
1830
|
+
)
|
|
1831
|
+
)
|
|
1832
|
+
|
|
1833
|
+
else:
|
|
1834
|
+
metagga = self.parser.incar.get('METAGGA')
|
|
1835
|
+
if metagga:
|
|
1836
|
+
xc_functionals = self.parser.xc_functional_mapping.get(
|
|
1837
|
+
metagga, [metagga]
|
|
1838
|
+
)
|
|
1839
|
+
else:
|
|
1840
|
+
xc_functionals = self.parser.xc_functional_mapping.get(
|
|
1841
|
+
self.parser.incar.get('GGA'), []
|
|
1842
|
+
)
|
|
1843
|
+
for xc_functional in xc_functionals:
|
|
1844
|
+
if '_X_' in xc_functional or xc_functional.endswith('_X'):
|
|
1845
|
+
sec_xc_functional.exchange.append(Functional(name=xc_functional))
|
|
1846
|
+
elif '_C_' in xc_functional or xc_functional.endswith('_C'):
|
|
1847
|
+
sec_xc_functional.correlation.append(Functional(name=xc_functional))
|
|
1848
|
+
elif 'HYB' in xc_functional:
|
|
1849
|
+
sec_xc_functional.hybrid.append(Functional(name=xc_functional))
|
|
1850
|
+
else:
|
|
1851
|
+
sec_xc_functional.contributions.append(
|
|
1852
|
+
Functional(name=xc_functional)
|
|
1853
|
+
)
|
|
1854
|
+
|
|
1855
|
+
# save hybrid parameters
|
|
1856
|
+
if len(sec_xc_functional.hybrid):
|
|
1857
|
+
if not sec_xc_functional.hybrid[-1].parameters:
|
|
1858
|
+
sec_xc_functional.hybrid[-1].parameters = dict()
|
|
1859
|
+
sec_xc_functional.hybrid[-1].parameters['exact_exchange_mixing_factor'] = (
|
|
1860
|
+
aexx
|
|
1861
|
+
)
|
|
1862
|
+
sec_xc_functional.normalize_hybrid()
|
|
1863
|
+
|
|
1864
|
+
# convergence thresholds
|
|
1865
|
+
tolerance = self.parser.incar.get('EDIFF')
|
|
1866
|
+
if tolerance is not None:
|
|
1867
|
+
sec_method.scf = Scf(threshold_energy_change=tolerance * ureg.eV)
|
|
1868
|
+
|
|
1869
|
+
# perform electron counting
|
|
1870
|
+
# first establish a reference for the number of valence electrons in a neutral system
|
|
1871
|
+
neutral_count = 0.0
|
|
1872
|
+
for param, n_atoms in dict(
|
|
1873
|
+
zip(
|
|
1874
|
+
sec_method.atom_parameters,
|
|
1875
|
+
self.parser.atom_info['atomtypes'].get('atomspertype', []),
|
|
1876
|
+
)
|
|
1877
|
+
).items():
|
|
1878
|
+
# correct based on core-holes
|
|
1879
|
+
# since ZVAL information is centrally reported, it's all or nothing
|
|
1880
|
+
try:
|
|
1881
|
+
species_electrons = param.n_electrons
|
|
1882
|
+
except AttributeError:
|
|
1883
|
+
break
|
|
1884
|
+
try:
|
|
1885
|
+
species_electrons -= param.core_hole.n_electrons_excited
|
|
1886
|
+
except AttributeError:
|
|
1887
|
+
pass
|
|
1888
|
+
neutral_count += species_electrons * n_atoms
|
|
1889
|
+
# extract the number of valence electrons
|
|
1890
|
+
sec_method.electronic.n_electrons = self.parser.incar.get(
|
|
1891
|
+
'NELECT', neutral_count
|
|
1892
|
+
)
|
|
1893
|
+
if neutral_count:
|
|
1894
|
+
sec_method.electronic.charge = (
|
|
1895
|
+
neutral_count - sec_method.electronic.n_electrons
|
|
1896
|
+
) * ureg.e
|
|
1897
|
+
|
|
1898
|
+
def parse_gw(self):
|
|
1899
|
+
sec_run = self.archive.run[-1]
|
|
1900
|
+
sec_method = Method()
|
|
1901
|
+
sec_run.method.append(sec_method)
|
|
1902
|
+
sec_gw = GW()
|
|
1903
|
+
sec_method.gw = sec_gw
|
|
1904
|
+
|
|
1905
|
+
# input/output incar
|
|
1906
|
+
self.parse_incarsinout()
|
|
1907
|
+
|
|
1908
|
+
# Code-specific parameters
|
|
1909
|
+
response_functions = self.parser.get_response_functions()
|
|
1910
|
+
sec_gw.x_vasp_response_functions_incar = response_functions
|
|
1911
|
+
|
|
1912
|
+
# Type
|
|
1913
|
+
nelmgw = response_functions.get('NELMGW', 1)
|
|
1914
|
+
sec_gw.type = 'G0W0' if nelmgw == 1 else self._gw_algo_map.get(self.gw_algo)
|
|
1915
|
+
if sec_gw.type is None:
|
|
1916
|
+
self.logger.warning('Error setting the GW type.')
|
|
1917
|
+
sec_gw.n_states = self.parser.get_incar().get('NBANDS')
|
|
1918
|
+
# KMesh
|
|
1919
|
+
self.parse_kpoints(sec_method)
|
|
1920
|
+
# QMesh
|
|
1921
|
+
sec_gw.m_add_sub_section(GW.q_mesh, sec_method.k_mesh)
|
|
1922
|
+
# Analytical continuation
|
|
1923
|
+
sec_gw.analytical_continuation = 'pade'
|
|
1924
|
+
# FrequencyMesh
|
|
1925
|
+
sec_freq_mesh = FrequencyMesh(
|
|
1926
|
+
dimensionality=1, n_points=response_functions.get('NOMEGA', 100)
|
|
1927
|
+
)
|
|
1928
|
+
sec_method.m_add_sub_section(Method.frequency_mesh, sec_freq_mesh)
|
|
1929
|
+
|
|
1930
|
+
def parse_workflow(self):
|
|
1931
|
+
ibrion = -1
|
|
1932
|
+
incar = self.archive.run[-1].method[-1].x_vasp_incar_out
|
|
1933
|
+
if incar is not None:
|
|
1934
|
+
nsw = incar.get('NSW')
|
|
1935
|
+
ibrion = -1 if nsw == 0 else incar.get('IBRION', 0)
|
|
1936
|
+
|
|
1937
|
+
workflow = None
|
|
1938
|
+
if ibrion == -1:
|
|
1939
|
+
workflow = SinglePoint()
|
|
1940
|
+
elif ibrion == 0:
|
|
1941
|
+
workflow = MolecularDynamics()
|
|
1942
|
+
else:
|
|
1943
|
+
workflow = GeometryOptimization(method=GeometryOptimizationMethod())
|
|
1944
|
+
tolerance = self.parser.incar.get('EDIFFG')
|
|
1945
|
+
if tolerance is not None:
|
|
1946
|
+
if tolerance > 0:
|
|
1947
|
+
workflow.method.convergence_tolerance_energy_difference = (
|
|
1948
|
+
tolerance * ureg.eV
|
|
1949
|
+
)
|
|
1950
|
+
else:
|
|
1951
|
+
workflow.method.convergence_tolerance_force_maximum = (
|
|
1952
|
+
abs(tolerance) * ureg.eV / ureg.angstrom
|
|
1953
|
+
)
|
|
1954
|
+
self.archive.workflow2 = workflow
|
|
1955
|
+
|
|
1956
|
+
def parse_configurations(self):
|
|
1957
|
+
sec_run = self.archive.run[-1]
|
|
1958
|
+
|
|
1959
|
+
def parse_system(n_calc):
|
|
1960
|
+
sec_system = System()
|
|
1961
|
+
sec_run.system.append(sec_system)
|
|
1962
|
+
sec_atoms = Atoms()
|
|
1963
|
+
sec_system.atoms = sec_atoms
|
|
1964
|
+
|
|
1965
|
+
structure = self.parser.get_structure(n_calc)
|
|
1966
|
+
cell = structure.get('cell', None)
|
|
1967
|
+
if cell is not None:
|
|
1968
|
+
sec_atoms.lattice_vectors = cell
|
|
1969
|
+
|
|
1970
|
+
sec_atoms.periodic = [True] * 3
|
|
1971
|
+
sec_atoms.labels = self.parser.atom_info.get('atoms', {}).get('element', [])
|
|
1972
|
+
|
|
1973
|
+
positions = structure.get('positions', None)
|
|
1974
|
+
if positions is not None:
|
|
1975
|
+
sec_atoms.positions = positions
|
|
1976
|
+
|
|
1977
|
+
selective = structure.get('selective', None)
|
|
1978
|
+
if selective is not None:
|
|
1979
|
+
selective = [[s[i] == 'T' for i in range(len(s))] for s in selective]
|
|
1980
|
+
sec_system.x_vasp_selective_dynamics = selective
|
|
1981
|
+
|
|
1982
|
+
nose = structure.get('nose')
|
|
1983
|
+
if nose is not None:
|
|
1984
|
+
sec_system.x_vasp_nose_thermostat = nose
|
|
1985
|
+
|
|
1986
|
+
# Check for core-holes
|
|
1987
|
+
## note that this check should be added to `parse_core_hole` if other kinds of atom_parameters are set
|
|
1988
|
+
if self.parser.incar.get('ICORELEVEL', 0) == 2:
|
|
1989
|
+
core_hole, core_hole_group, corehole_id = self.parse_core_hole()
|
|
1990
|
+
if sec_method := sec_run.method:
|
|
1991
|
+
try:
|
|
1992
|
+
sec_method[-1].atom_parameters[
|
|
1993
|
+
corehole_id
|
|
1994
|
+
].core_hole = core_hole
|
|
1995
|
+
except (IndexError, AttributeError, TypeError):
|
|
1996
|
+
self.logger.error(
|
|
1997
|
+
f'Error setting core-hole: no atom_parameters with index {corehole_id}'
|
|
1998
|
+
)
|
|
1999
|
+
|
|
2000
|
+
if sec_system.atoms_group is None:
|
|
2001
|
+
sec_system.atoms_group = []
|
|
2002
|
+
sec_system.atoms_group.append(core_hole_group)
|
|
2003
|
+
# add the reference from any core-hole to its matching atoms_group
|
|
2004
|
+
for atom_parameter in sec_run.method[0].atom_parameters:
|
|
2005
|
+
if atom_parameter.core_hole is not None:
|
|
2006
|
+
atom_parameter.core_hole.atomsgroup_ref = (
|
|
2007
|
+
sec_system.atoms_group[-1]
|
|
2008
|
+
)
|
|
2009
|
+
|
|
2010
|
+
return sec_system
|
|
2011
|
+
|
|
2012
|
+
def parse_energy(n_calc, n_scf=None):
|
|
2013
|
+
if n_scf is None:
|
|
2014
|
+
section = Calculation()
|
|
2015
|
+
sec_run.calculation.append(section)
|
|
2016
|
+
else:
|
|
2017
|
+
section = ScfIteration()
|
|
2018
|
+
sec_run.calculation[-1].scf_iteration.append(section)
|
|
2019
|
+
|
|
2020
|
+
energies = self.parser.get_energies(n_calc, n_scf)
|
|
2021
|
+
sec_energy = Energy()
|
|
2022
|
+
section.energy = sec_energy
|
|
2023
|
+
for key, val in energies.items():
|
|
2024
|
+
metainfo_key = self.parser.metainfo_mapping.get(key, None)
|
|
2025
|
+
if val is None or metainfo_key is None:
|
|
2026
|
+
continue
|
|
2027
|
+
|
|
2028
|
+
try:
|
|
2029
|
+
val = val * ureg.eV
|
|
2030
|
+
if metainfo_key.startswith('energy_'):
|
|
2031
|
+
sec_energy.m_add_sub_section(
|
|
2032
|
+
getattr(
|
|
2033
|
+
Energy, metainfo_key.replace('energy_', '').lower()
|
|
2034
|
+
),
|
|
2035
|
+
EnergyEntry(value=val),
|
|
2036
|
+
)
|
|
2037
|
+
else:
|
|
2038
|
+
setattr(section, metainfo_key, val)
|
|
2039
|
+
except Exception:
|
|
2040
|
+
self.logger.warning('Error setting metainfo', data=dict(key=key))
|
|
2041
|
+
|
|
2042
|
+
return section
|
|
2043
|
+
|
|
2044
|
+
def parse_eigenvalues(n_calc):
|
|
2045
|
+
eigenvalues = self.parser.get_eigenvalues(n_calc)
|
|
2046
|
+
if eigenvalues is None:
|
|
2047
|
+
return
|
|
2048
|
+
|
|
2049
|
+
sec_scc = sec_run.calculation[-1]
|
|
2050
|
+
eigenvalues = np.transpose(eigenvalues)
|
|
2051
|
+
eigs = eigenvalues[0].T
|
|
2052
|
+
occs = eigenvalues[1].T
|
|
2053
|
+
kpoints = self.parser.kpoints_info.get('points', [])
|
|
2054
|
+
|
|
2055
|
+
# get valence(conduction) and maximum(minimum)
|
|
2056
|
+
# we have a case where no band is occupied, i.e. valence_max should be below
|
|
2057
|
+
# min(eigs)
|
|
2058
|
+
valence_max, conduction_min = [], []
|
|
2059
|
+
for i in range(len(eigs)):
|
|
2060
|
+
occupied = [eigs[i, o[0], o[1]] for o in np.argwhere(occs[i] >= 0.5)]
|
|
2061
|
+
valence_max.append(
|
|
2062
|
+
np.amin(eigs[i]) - 1.0 if not occupied else max(occupied)
|
|
2063
|
+
)
|
|
2064
|
+
unoccupied = [eigs[i, o[0], o[1]] for o in np.argwhere(occs[i] < 0.5)]
|
|
2065
|
+
conduction_min.append(
|
|
2066
|
+
np.amin(eigs[i]) - 1.0 if not unoccupied else min(unoccupied)
|
|
2067
|
+
)
|
|
2068
|
+
sec_scc.energy.highest_occupied = max(valence_max) * ureg.eV
|
|
2069
|
+
sec_scc.energy.lowest_unoccupied = min(conduction_min) * ureg.eV
|
|
2070
|
+
|
|
2071
|
+
if self.parser.kpoints_info.get('sampling_method', None) == 'Line-path':
|
|
2072
|
+
sec_k_band = BandStructure()
|
|
2073
|
+
sec_scc.band_structure_electronic.append(sec_k_band)
|
|
2074
|
+
for n in range(len(eigs)):
|
|
2075
|
+
sec_band_gap = BandGapDeprecated()
|
|
2076
|
+
sec_k_band.band_gap.append(sec_band_gap)
|
|
2077
|
+
sec_band_gap.energy_highest_occupied = valence_max[n] * ureg.eV
|
|
2078
|
+
sec_band_gap.energy_lowest_unoccupied = conduction_min[n] * ureg.eV
|
|
2079
|
+
divisions = self.parser.kpoints_info.get('grid', None)
|
|
2080
|
+
if divisions is None:
|
|
2081
|
+
return
|
|
2082
|
+
divisions = max(divisions)
|
|
2083
|
+
n_segments = len(kpoints) // divisions
|
|
2084
|
+
kpoints = np.reshape(kpoints, (n_segments, divisions, 3))
|
|
2085
|
+
eigs = np.reshape(
|
|
2086
|
+
eigs,
|
|
2087
|
+
(self.parser.ispin, n_segments, divisions, self.parser.n_bands),
|
|
2088
|
+
)
|
|
2089
|
+
occs = np.reshape(
|
|
2090
|
+
occs,
|
|
2091
|
+
(self.parser.ispin, n_segments, divisions, self.parser.n_bands),
|
|
2092
|
+
)
|
|
2093
|
+
eigs = np.transpose(eigs, axes=(1, 0, 2, 3)) * ureg.eV
|
|
2094
|
+
occs = np.transpose(occs, axes=(1, 0, 2, 3))
|
|
2095
|
+
for n in range(n_segments):
|
|
2096
|
+
sec_k_band_segment = BandEnergies()
|
|
2097
|
+
sec_k_band.segment.append(sec_k_band_segment)
|
|
2098
|
+
sec_k_band_segment.kpoints = kpoints[n]
|
|
2099
|
+
sec_k_band_segment.energies = eigs[n]
|
|
2100
|
+
sec_k_band_segment.occupations = occs[n]
|
|
2101
|
+
else:
|
|
2102
|
+
eigs = eigs * ureg.eV
|
|
2103
|
+
sec_eigenvalues = BandEnergies()
|
|
2104
|
+
sec_scc.eigenvalues.append(sec_eigenvalues)
|
|
2105
|
+
sec_eigenvalues.kpoints = kpoints
|
|
2106
|
+
sec_eigenvalues.kpoints_weights = self.parser.kpoints_info.get(
|
|
2107
|
+
'weights', []
|
|
2108
|
+
)
|
|
2109
|
+
sec_eigenvalues.kpoints_multiplicities = self.parser.kpoints_info.get(
|
|
2110
|
+
'multiplicities', []
|
|
2111
|
+
)
|
|
2112
|
+
sec_eigenvalues.energies = eigs
|
|
2113
|
+
sec_eigenvalues.occupations = occs
|
|
2114
|
+
|
|
2115
|
+
def parse_dos(n_calc):
|
|
2116
|
+
energies, values, integrated, efermi = self.parser.get_total_dos(n_calc)
|
|
2117
|
+
|
|
2118
|
+
# TODO: I do not know how the f-orbitals are arranged
|
|
2119
|
+
lm_converter = {
|
|
2120
|
+
's': [0, 0],
|
|
2121
|
+
'p': [1, -1],
|
|
2122
|
+
'px': [1, 0],
|
|
2123
|
+
'py': [1, 1],
|
|
2124
|
+
'pz': [1, 2],
|
|
2125
|
+
'd': [2, -1],
|
|
2126
|
+
'dx2': [2, 0],
|
|
2127
|
+
'dxy': [2, 1],
|
|
2128
|
+
'dxz': [2, 2],
|
|
2129
|
+
'dy2': [2, 3],
|
|
2130
|
+
'dyz': [2, 4],
|
|
2131
|
+
'dz2': [2, 5],
|
|
2132
|
+
'f': [3, -1],
|
|
2133
|
+
'f-3': [3, 0],
|
|
2134
|
+
'f-2': [3, 1],
|
|
2135
|
+
'f-1': [3, 2],
|
|
2136
|
+
'f0': [3, 3],
|
|
2137
|
+
'f1': [3, 4],
|
|
2138
|
+
'f2': [3, 5],
|
|
2139
|
+
'f3': [3, 6],
|
|
2140
|
+
}
|
|
2141
|
+
|
|
2142
|
+
# total dos
|
|
2143
|
+
if values is not None:
|
|
2144
|
+
sec_scc = sec_run.calculation[-1]
|
|
2145
|
+
|
|
2146
|
+
n_spin_channels = len(values)
|
|
2147
|
+
for spin in range(n_spin_channels):
|
|
2148
|
+
sec_dos = Dos()
|
|
2149
|
+
sec_scc.dos_electronic.append(sec_dos)
|
|
2150
|
+
sec_dos.spin_channel = spin if n_spin_channels == 2 else None
|
|
2151
|
+
sec_dos.energies = energies * ureg.eV
|
|
2152
|
+
sec_dos.energy_fermi = efermi * ureg.eV
|
|
2153
|
+
sec_dos_total = DosValues()
|
|
2154
|
+
sec_dos.total.append(sec_dos_total)
|
|
2155
|
+
sec_dos_total.value = values[spin] / ureg.eV
|
|
2156
|
+
sec_dos_total.value_integrated = integrated[spin]
|
|
2157
|
+
|
|
2158
|
+
# TODO rework on the atom_projected and orbital_projected DOS and add examples to testing
|
|
2159
|
+
dos, fields = self.parser.get_partial_dos(n_calc)
|
|
2160
|
+
if dos is not None:
|
|
2161
|
+
n_lm, n_atoms, n_energies = dos.shape[0], dos.shape[2], dos.shape[3]
|
|
2162
|
+
dos = np.reshape(dos, (n_spin_channels, n_atoms, n_lm, n_energies))
|
|
2163
|
+
for spin in range(n_spin_channels):
|
|
2164
|
+
if (
|
|
2165
|
+
sec_scc.dos_electronic is not None
|
|
2166
|
+
and sec_scc.dos_electronic[spin]
|
|
2167
|
+
):
|
|
2168
|
+
sec_dos = sec_scc.dos_electronic[spin]
|
|
2169
|
+
else:
|
|
2170
|
+
sec_dos = Dos()
|
|
2171
|
+
sec_scc.dos_electronic.append(sec_dos)
|
|
2172
|
+
sec_dos.spin_channel = (
|
|
2173
|
+
spin if n_spin_channels == 2 else None
|
|
2174
|
+
)
|
|
2175
|
+
for atom in range(n_atoms):
|
|
2176
|
+
for lm in range(n_lm):
|
|
2177
|
+
sec_dos_orbital = DosValues()
|
|
2178
|
+
sec_dos.orbital_projected.append(sec_dos_orbital)
|
|
2179
|
+
sec_dos_orbital.m_kind = 'polynomial'
|
|
2180
|
+
sec_dos_orbital.lm = lm_converter.get(
|
|
2181
|
+
fields[lm], [-1, -1]
|
|
2182
|
+
)
|
|
2183
|
+
sec_dos_orbital.atom_index = atom
|
|
2184
|
+
sec_dos_orbital.value = dos[spin][atom][lm] / ureg.eV
|
|
2185
|
+
|
|
2186
|
+
if efermi is not None:
|
|
2187
|
+
sec_run.calculation[-1].energy.fermi = efermi * ureg.eV
|
|
2188
|
+
|
|
2189
|
+
sec_scc = None
|
|
2190
|
+
for n in range(self.parser.n_calculations):
|
|
2191
|
+
# energies
|
|
2192
|
+
time_initial = (
|
|
2193
|
+
sec_run.calculation[-1].time_physical
|
|
2194
|
+
if sec_run.calculation
|
|
2195
|
+
else 0 * ureg.s
|
|
2196
|
+
)
|
|
2197
|
+
sec_scc = parse_energy(n, None)
|
|
2198
|
+
time = self.parser.get_time_calc(n)[-1]
|
|
2199
|
+
if time:
|
|
2200
|
+
sec_scc.time_calculation = float(time)
|
|
2201
|
+
sec_scc.time_physical = time_initial + sec_scc.time_calculation
|
|
2202
|
+
|
|
2203
|
+
time_scf = self.parser.get_time_scf(n)
|
|
2204
|
+
for n_scf in range(self.parser.get_n_scf(n)):
|
|
2205
|
+
time_initial = (
|
|
2206
|
+
sec_scc.scf_iteration[-1].time_physical
|
|
2207
|
+
if n_scf > 0
|
|
2208
|
+
else time_initial
|
|
2209
|
+
)
|
|
2210
|
+
sec_scf = parse_energy(n, n_scf)
|
|
2211
|
+
if time_scf[n_scf] is not None:
|
|
2212
|
+
sec_scf.time_calculation = time_scf[n_scf][-1]
|
|
2213
|
+
if sec_scf.time_calculation:
|
|
2214
|
+
sec_scf.time_physical = time_initial + sec_scf.time_calculation
|
|
2215
|
+
if not sec_scc.time_calculation:
|
|
2216
|
+
times = [scf.time_calculation for scf in sec_scc.scf_iteration]
|
|
2217
|
+
if None not in times:
|
|
2218
|
+
sec_scc.time_calculation = sum(times)
|
|
2219
|
+
if sec_scc.time_calculation:
|
|
2220
|
+
sec_scc.time_physical = sec_scc.scf_iteration[-1].time_physical
|
|
2221
|
+
|
|
2222
|
+
# forces and stress
|
|
2223
|
+
forces, stress = self.parser.get_forces_stress(n)
|
|
2224
|
+
if forces is not None:
|
|
2225
|
+
try:
|
|
2226
|
+
sec_scc.forces = Forces(
|
|
2227
|
+
total=ForcesEntry(value=forces * ureg.eV / ureg.angstrom)
|
|
2228
|
+
)
|
|
2229
|
+
except Exception:
|
|
2230
|
+
self.logger.error('Error parsing forces.')
|
|
2231
|
+
if stress is not None:
|
|
2232
|
+
try:
|
|
2233
|
+
# TODO verify if stress unit in xml is also kbar
|
|
2234
|
+
sec_scc.stress = Stress(total=StressEntry(value=stress * ureg.kbar))
|
|
2235
|
+
except Exception:
|
|
2236
|
+
self.logger.error('Error parsing stress.')
|
|
2237
|
+
|
|
2238
|
+
# structure
|
|
2239
|
+
sec_system = parse_system(n)
|
|
2240
|
+
sec_scc.system_ref = sec_system
|
|
2241
|
+
sec_scc.method_ref = sec_run.method[-1]
|
|
2242
|
+
|
|
2243
|
+
# eigenvalues
|
|
2244
|
+
parse_eigenvalues(n)
|
|
2245
|
+
|
|
2246
|
+
# dos
|
|
2247
|
+
parse_dos(n)
|
|
2248
|
+
|
|
2249
|
+
# convergence
|
|
2250
|
+
converged = self.parser.is_converged(n)
|
|
2251
|
+
if converged is not None:
|
|
2252
|
+
sec_scc.single_configuration_calculation_converged = converged
|
|
2253
|
+
|
|
2254
|
+
# parse charge density
|
|
2255
|
+
# TODO add test data
|
|
2256
|
+
chgcar_file = os.path.join(self.maindir, 'CHGCAR')
|
|
2257
|
+
if sec_scc and os.path.isfile(chgcar_file):
|
|
2258
|
+
grid = None
|
|
2259
|
+
n_points = 0
|
|
2260
|
+
charge_density = []
|
|
2261
|
+
re_grid = re.compile(r' *\d+ +\d+ +\d+\s+')
|
|
2262
|
+
for line in open(chgcar_file):
|
|
2263
|
+
if not line.strip():
|
|
2264
|
+
grid = []
|
|
2265
|
+
if grid is None:
|
|
2266
|
+
continue
|
|
2267
|
+
|
|
2268
|
+
match = re_grid.match(line)
|
|
2269
|
+
if match and n_points == 0:
|
|
2270
|
+
grid = [int(i) for i in line.strip().split()]
|
|
2271
|
+
n_points = grid[0] * grid[1] * grid[2]
|
|
2272
|
+
elif len(charge_density) < n_points:
|
|
2273
|
+
charge_density.extend([float(v) for v in line.strip().split()])
|
|
2274
|
+
if charge_density and len(charge_density) == n_points:
|
|
2275
|
+
sec_density = Density()
|
|
2276
|
+
sec_scc.density_charge.append(sec_density)
|
|
2277
|
+
sec_density.value_hdf5 = np.reshape(
|
|
2278
|
+
np.array(charge_density, np.float64), grid
|
|
2279
|
+
)
|
|
2280
|
+
grid = []
|
|
2281
|
+
n_points = 0
|
|
2282
|
+
charge_density = []
|
|
2283
|
+
|
|
2284
|
+
if self.parser.n_calculations == 0:
|
|
2285
|
+
self.logger.warning('No calculation was parsed.')
|
|
2286
|
+
|
|
2287
|
+
def parse(self, filepath, archive, logger):
|
|
2288
|
+
self.filepath = filepath
|
|
2289
|
+
self.archive = archive
|
|
2290
|
+
self.logger = get_logger(__name__) if logger is None else logger
|
|
2291
|
+
self.init_parser(filepath, logger)
|
|
2292
|
+
|
|
2293
|
+
sec_run = Run()
|
|
2294
|
+
self.archive.run.append(sec_run)
|
|
2295
|
+
program_name = self.parser.header.get('program', '')
|
|
2296
|
+
if program_name.strip().upper() != 'VASP':
|
|
2297
|
+
sec_run.program = Program()
|
|
2298
|
+
self.logger.error(
|
|
2299
|
+
'invalid program name', data=dict(program_name=program_name)
|
|
2300
|
+
)
|
|
2301
|
+
return
|
|
2302
|
+
sec_run.program = Program(name='VASP')
|
|
2303
|
+
|
|
2304
|
+
version = ' '.join(
|
|
2305
|
+
[
|
|
2306
|
+
self.parser.header.get(key, '')
|
|
2307
|
+
for key in ['version', 'subversion', 'platform']
|
|
2308
|
+
]
|
|
2309
|
+
).strip()
|
|
2310
|
+
if version:
|
|
2311
|
+
sec_run.program.version = version
|
|
2312
|
+
|
|
2313
|
+
date = self.parser.header.get('date')
|
|
2314
|
+
if date is not None:
|
|
2315
|
+
date = datetime.strptime(date.strip(), '%Y %m %d').date()
|
|
2316
|
+
time = self.parser.header.get('time', '0:0:0')
|
|
2317
|
+
time = datetime.strptime(time.strip(), '%H:%M:%S').timetz()
|
|
2318
|
+
dtime = datetime.combine(date, time) - datetime.utcfromtimestamp(0)
|
|
2319
|
+
sec_run.program.compilation_datetime = dtime.total_seconds()
|
|
2320
|
+
|
|
2321
|
+
# TODO VASP>=6.3.0 can do DFT+GW calculations in one single step: with data we can extend
|
|
2322
|
+
# the parser to inherit from BeyondDFTWorkflowsParser to address automatic GW workflow.
|
|
2323
|
+
if self.parser.get_incar().get('ALGO', ''):
|
|
2324
|
+
# TODO check why ALGO is a list
|
|
2325
|
+
if isinstance(self.parser.get_incar().get('ALGO', ''), list):
|
|
2326
|
+
self.gw_algo = self.parser.get_incar().get('ALGO', '')[0]
|
|
2327
|
+
else:
|
|
2328
|
+
self.gw_algo = self.parser.get_incar().get('ALGO', '')
|
|
2329
|
+
if self.gw_algo in self._gw_algo_map.keys():
|
|
2330
|
+
self._calculation_type = 'gw'
|
|
2331
|
+
|
|
2332
|
+
if self._calculation_type == 'gw':
|
|
2333
|
+
self.parse_gw()
|
|
2334
|
+
else:
|
|
2335
|
+
self.parse_method()
|
|
2336
|
+
|
|
2337
|
+
# Note: the logic for a proper topology might have to become more complex
|
|
2338
|
+
self.parse_configurations()
|
|
2339
|
+
|
|
2340
|
+
self.parse_workflow()
|