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.
Files changed (272) hide show
  1. electronicparsers/__init__.py +1162 -0
  2. electronicparsers/abacus/__init__.py +20 -0
  3. electronicparsers/abacus/__main__.py +32 -0
  4. electronicparsers/abacus/metainfo/__init__.py +19 -0
  5. electronicparsers/abacus/metainfo/abacus.py +836 -0
  6. electronicparsers/abacus/nomad_plugin.yaml +44 -0
  7. electronicparsers/abacus/parser.py +1975 -0
  8. electronicparsers/abinit/__init__.py +19 -0
  9. electronicparsers/abinit/__main__.py +31 -0
  10. electronicparsers/abinit/metainfo/__init__.py +20 -0
  11. electronicparsers/abinit/metainfo/abinit.py +871 -0
  12. electronicparsers/abinit/metainfo/abinit_autogenerated.py +6794 -0
  13. electronicparsers/abinit/nomad_plugin.yaml +43 -0
  14. electronicparsers/abinit/parser.py +1922 -0
  15. electronicparsers/ams/__init__.py +19 -0
  16. electronicparsers/ams/__main__.py +31 -0
  17. electronicparsers/ams/metainfo/__init__.py +19 -0
  18. electronicparsers/ams/metainfo/ams.py +769 -0
  19. electronicparsers/ams/nomad_plugin.yaml +19 -0
  20. electronicparsers/ams/parser.py +1849 -0
  21. electronicparsers/ams/rkf.py +620 -0
  22. electronicparsers/atk/__init__.py +19 -0
  23. electronicparsers/atk/__main__.py +31 -0
  24. electronicparsers/atk/metainfo/__init__.py +19 -0
  25. electronicparsers/atk/metainfo/atk.py +71 -0
  26. electronicparsers/atk/nomad_plugin.yaml +34 -0
  27. electronicparsers/atk/parser.py +388 -0
  28. electronicparsers/bigdft/__init__.py +19 -0
  29. electronicparsers/bigdft/__main__.py +31 -0
  30. electronicparsers/bigdft/metainfo/__init__.py +18 -0
  31. electronicparsers/bigdft/nomad_plugin.yaml +19 -0
  32. electronicparsers/bigdft/parser.py +372 -0
  33. electronicparsers/castep/__init__.py +19 -0
  34. electronicparsers/castep/__main__.py +31 -0
  35. electronicparsers/castep/metainfo/__init__.py +19 -0
  36. electronicparsers/castep/metainfo/castep.py +2481 -0
  37. electronicparsers/castep/nomad_plugin.yaml +28 -0
  38. electronicparsers/castep/parser.py +1680 -0
  39. electronicparsers/charmm/__init__.py +19 -0
  40. electronicparsers/charmm/__main__.py +31 -0
  41. electronicparsers/charmm/metainfo/__init__.py +19 -0
  42. electronicparsers/charmm/metainfo/charmm.py +1931 -0
  43. electronicparsers/charmm/nomad_plugin.yaml +18 -0
  44. electronicparsers/charmm/parser.py +61 -0
  45. electronicparsers/cp2k/__init__.py +19 -0
  46. electronicparsers/cp2k/__main__.py +31 -0
  47. electronicparsers/cp2k/metainfo/__init__.py +19 -0
  48. electronicparsers/cp2k/metainfo/cp2k.py +59185 -0
  49. electronicparsers/cp2k/metainfo/cp2k_general.py +1014 -0
  50. electronicparsers/cp2k/nomad_plugin.yaml +49 -0
  51. electronicparsers/cp2k/parser.py +2324 -0
  52. electronicparsers/cpmd/__init__.py +19 -0
  53. electronicparsers/cpmd/__main__.py +31 -0
  54. electronicparsers/cpmd/metainfo/__init__.py +19 -0
  55. electronicparsers/cpmd/metainfo/cpmd.py +10733 -0
  56. electronicparsers/cpmd/metainfo/cpmd_general.py +988 -0
  57. electronicparsers/cpmd/nomad_plugin.yaml +19 -0
  58. electronicparsers/cpmd/parser.py +680 -0
  59. electronicparsers/crystal/__init__.py +19 -0
  60. electronicparsers/crystal/__main__.py +31 -0
  61. electronicparsers/crystal/metainfo/__init__.py +19 -0
  62. electronicparsers/crystal/metainfo/crystal.py +619 -0
  63. electronicparsers/crystal/nomad_plugin.yaml +36 -0
  64. electronicparsers/crystal/parser.py +1745 -0
  65. electronicparsers/dmol3/__init__.py +19 -0
  66. electronicparsers/dmol3/__main__.py +31 -0
  67. electronicparsers/dmol3/metainfo/__init__.py +19 -0
  68. electronicparsers/dmol3/metainfo/dmol3.py +664 -0
  69. electronicparsers/dmol3/nomad_plugin.yaml +19 -0
  70. electronicparsers/dmol3/parser.py +750 -0
  71. electronicparsers/edmft/__init__.py +19 -0
  72. electronicparsers/edmft/__main__.py +31 -0
  73. electronicparsers/edmft/metainfo/__init__.py +19 -0
  74. electronicparsers/edmft/metainfo/edmft.py +96 -0
  75. electronicparsers/edmft/nomad_plugin.yaml +53 -0
  76. electronicparsers/edmft/parser.py +912 -0
  77. electronicparsers/elk/__init__.py +19 -0
  78. electronicparsers/elk/__main__.py +31 -0
  79. electronicparsers/elk/metainfo/__init__.py +19 -0
  80. electronicparsers/elk/metainfo/elk.py +775 -0
  81. electronicparsers/elk/nomad_plugin.yaml +19 -0
  82. electronicparsers/elk/parser.py +493 -0
  83. electronicparsers/exciting/__init__.py +19 -0
  84. electronicparsers/exciting/__main__.py +31 -0
  85. electronicparsers/exciting/metainfo/__init__.py +19 -0
  86. electronicparsers/exciting/metainfo/exciting.py +2942 -0
  87. electronicparsers/exciting/nomad_plugin.yaml +83 -0
  88. electronicparsers/exciting/parser.py +3398 -0
  89. electronicparsers/fhiaims/__init__.py +19 -0
  90. electronicparsers/fhiaims/__main__.py +31 -0
  91. electronicparsers/fhiaims/metainfo/__init__.py +19 -0
  92. electronicparsers/fhiaims/metainfo/fhi_aims.py +1565 -0
  93. electronicparsers/fhiaims/nomad_plugin.yaml +52 -0
  94. electronicparsers/fhiaims/parser.py +2582 -0
  95. electronicparsers/fleur/__init__.py +19 -0
  96. electronicparsers/fleur/__main__.py +31 -0
  97. electronicparsers/fleur/metainfo/__init__.py +19 -0
  98. electronicparsers/fleur/metainfo/fleur.py +623 -0
  99. electronicparsers/fleur/nomad_plugin.yaml +19 -0
  100. electronicparsers/fleur/parser.py +952 -0
  101. electronicparsers/fplo/__init__.py +19 -0
  102. electronicparsers/fplo/__main__.py +31 -0
  103. electronicparsers/fplo/metainfo/__init__.py +19 -0
  104. electronicparsers/fplo/metainfo/fplo.py +188 -0
  105. electronicparsers/fplo/metainfo/fplo_input_autogenerated.py +2744 -0
  106. electronicparsers/fplo/metainfo/fplo_temporaries.py +319 -0
  107. electronicparsers/fplo/nomad_plugin.yaml +19 -0
  108. electronicparsers/fplo/parser.py +42 -0
  109. electronicparsers/gamess/__init__.py +19 -0
  110. electronicparsers/gamess/__main__.py +31 -0
  111. electronicparsers/gamess/metainfo/__init__.py +19 -0
  112. electronicparsers/gamess/metainfo/gamess.py +837 -0
  113. electronicparsers/gamess/nomad_plugin.yaml +19 -0
  114. electronicparsers/gamess/parser.py +941 -0
  115. electronicparsers/gaussian/__init__.py +19 -0
  116. electronicparsers/gaussian/__main__.py +31 -0
  117. electronicparsers/gaussian/metainfo/__init__.py +19 -0
  118. electronicparsers/gaussian/metainfo/gaussian.py +1707 -0
  119. electronicparsers/gaussian/nomad_plugin.yaml +18 -0
  120. electronicparsers/gaussian/parser.py +1556 -0
  121. electronicparsers/gpaw/__init__.py +19 -0
  122. electronicparsers/gpaw/__main__.py +31 -0
  123. electronicparsers/gpaw/metainfo/__init__.py +19 -0
  124. electronicparsers/gpaw/metainfo/gpaw.py +214 -0
  125. electronicparsers/gpaw/nomad_plugin.yaml +19 -0
  126. electronicparsers/gpaw/parser.py +671 -0
  127. electronicparsers/magres/__init__.py +19 -0
  128. electronicparsers/magres/__main__.py +31 -0
  129. electronicparsers/magres/metainfo/__init__.py +19 -0
  130. electronicparsers/magres/metainfo/magres.py +110 -0
  131. electronicparsers/magres/nomad_plugin.yaml +18 -0
  132. electronicparsers/magres/parser.py +505 -0
  133. electronicparsers/molcas/__init__.py +19 -0
  134. electronicparsers/molcas/__main__.py +31 -0
  135. electronicparsers/molcas/metainfo/__init__.py +19 -0
  136. electronicparsers/molcas/metainfo/molcas.py +151 -0
  137. electronicparsers/molcas/nomad_plugin.yaml +19 -0
  138. electronicparsers/molcas/parser.py +59 -0
  139. electronicparsers/mopac/__init__.py +19 -0
  140. electronicparsers/mopac/__main__.py +31 -0
  141. electronicparsers/mopac/metainfo/__init__.py +19 -0
  142. electronicparsers/mopac/metainfo/mopac.py +79 -0
  143. electronicparsers/mopac/nomad_plugin.yaml +19 -0
  144. electronicparsers/mopac/parser.py +304 -0
  145. electronicparsers/nwchem/__init__.py +19 -0
  146. electronicparsers/nwchem/__main__.py +31 -0
  147. electronicparsers/nwchem/metainfo/__init__.py +19 -0
  148. electronicparsers/nwchem/metainfo/nwchem.py +487 -0
  149. electronicparsers/nwchem/nomad_plugin.yaml +19 -0
  150. electronicparsers/nwchem/parser.py +757 -0
  151. electronicparsers/ocean/__init__.py +19 -0
  152. electronicparsers/ocean/__main__.py +31 -0
  153. electronicparsers/ocean/metainfo/__init__.py +19 -0
  154. electronicparsers/ocean/metainfo/ocean.py +410 -0
  155. electronicparsers/ocean/nomad_plugin.yaml +37 -0
  156. electronicparsers/ocean/parser.py +344 -0
  157. electronicparsers/octopus/__init__.py +19 -0
  158. electronicparsers/octopus/__main__.py +31 -0
  159. electronicparsers/octopus/metainfo/__init__.py +19 -0
  160. electronicparsers/octopus/metainfo/octopus.py +71 -0
  161. electronicparsers/octopus/metainfo/octopus_autogenerated.py +11647 -0
  162. electronicparsers/octopus/nomad_plugin.yaml +41 -0
  163. electronicparsers/octopus/parser.py +1214 -0
  164. electronicparsers/onetep/__init__.py +19 -0
  165. electronicparsers/onetep/__main__.py +31 -0
  166. electronicparsers/onetep/metainfo/__init__.py +19 -0
  167. electronicparsers/onetep/metainfo/onetep.py +3443 -0
  168. electronicparsers/onetep/nomad_plugin.yaml +19 -0
  169. electronicparsers/onetep/parser.py +577 -0
  170. electronicparsers/openmx/__init__.py +19 -0
  171. electronicparsers/openmx/__main__.py +31 -0
  172. electronicparsers/openmx/metainfo/__init__.py +19 -0
  173. electronicparsers/openmx/metainfo/openmx.py +24 -0
  174. electronicparsers/openmx/nomad_plugin.yaml +25 -0
  175. electronicparsers/openmx/parser.py +918 -0
  176. electronicparsers/orca/__init__.py +19 -0
  177. electronicparsers/orca/__main__.py +31 -0
  178. electronicparsers/orca/metainfo/__init__.py +19 -0
  179. electronicparsers/orca/metainfo/orca.py +1448 -0
  180. electronicparsers/orca/nomad_plugin.yaml +19 -0
  181. electronicparsers/orca/parser.py +1371 -0
  182. electronicparsers/psi4/__init__.py +19 -0
  183. electronicparsers/psi4/__main__.py +31 -0
  184. electronicparsers/psi4/metainfo/__init__.py +19 -0
  185. electronicparsers/psi4/metainfo/psi4.py +372 -0
  186. electronicparsers/psi4/nomad_plugin.yaml +27 -0
  187. electronicparsers/psi4/parser.py +1362 -0
  188. electronicparsers/qball/__init__.py +19 -0
  189. electronicparsers/qball/__main__.py +31 -0
  190. electronicparsers/qball/metainfo/__init__.py +19 -0
  191. electronicparsers/qball/metainfo/qball.py +27 -0
  192. electronicparsers/qball/nomad_plugin.yaml +25 -0
  193. electronicparsers/qball/parser.py +152 -0
  194. electronicparsers/qbox/__init__.py +19 -0
  195. electronicparsers/qbox/__main__.py +31 -0
  196. electronicparsers/qbox/metainfo/__init__.py +19 -0
  197. electronicparsers/qbox/metainfo/qbox.py +490 -0
  198. electronicparsers/qbox/nomad_plugin.yaml +19 -0
  199. electronicparsers/qbox/parser.py +508 -0
  200. electronicparsers/quantumespresso/__init__.py +19 -0
  201. electronicparsers/quantumespresso/__main__.py +31 -0
  202. electronicparsers/quantumespresso/metainfo/__init__.py +19 -0
  203. electronicparsers/quantumespresso/metainfo/quantum_espresso.py +3296 -0
  204. electronicparsers/quantumespresso/nomad_plugin.yaml +31 -0
  205. electronicparsers/quantumespresso/parser.py +3594 -0
  206. electronicparsers/siesta/__init__.py +19 -0
  207. electronicparsers/siesta/__main__.py +31 -0
  208. electronicparsers/siesta/metainfo/__init__.py +19 -0
  209. electronicparsers/siesta/metainfo/siesta.py +141 -0
  210. electronicparsers/siesta/metainfo/siesta_autogenerated.py +3365 -0
  211. electronicparsers/siesta/nomad_plugin.yaml +19 -0
  212. electronicparsers/siesta/parser.py +607 -0
  213. electronicparsers/soliddmft/__init__.py +19 -0
  214. electronicparsers/soliddmft/__main__.py +31 -0
  215. electronicparsers/soliddmft/metainfo/__init__.py +19 -0
  216. electronicparsers/soliddmft/metainfo/soliddmft.py +274 -0
  217. electronicparsers/soliddmft/nomad_plugin.yaml +26 -0
  218. electronicparsers/soliddmft/parser.py +727 -0
  219. electronicparsers/tbstudio/__init__.py +19 -0
  220. electronicparsers/tbstudio/__main__.py +31 -0
  221. electronicparsers/tbstudio/metainfo/__init__.py +19 -0
  222. electronicparsers/tbstudio/metainfo/tbstudio.py +34 -0
  223. electronicparsers/tbstudio/nomad_plugin.yaml +24 -0
  224. electronicparsers/tbstudio/parser.py +412 -0
  225. electronicparsers/turbomole/__init__.py +19 -0
  226. electronicparsers/turbomole/__main__.py +31 -0
  227. electronicparsers/turbomole/metainfo/__init__.py +19 -0
  228. electronicparsers/turbomole/metainfo/turbomole.py +727 -0
  229. electronicparsers/turbomole/nomad_plugin.yaml +18 -0
  230. electronicparsers/turbomole/parser.py +1585 -0
  231. electronicparsers/utils/__init__.py +20 -0
  232. electronicparsers/utils/magres_workflow.py +61 -0
  233. electronicparsers/utils/utils.py +636 -0
  234. electronicparsers/vasp/__init__.py +19 -0
  235. electronicparsers/vasp/__main__.py +31 -0
  236. electronicparsers/vasp/metainfo/__init__.py +19 -0
  237. electronicparsers/vasp/metainfo/vasp.py +169 -0
  238. electronicparsers/vasp/metainfo/vasp_incars.py +3428 -0
  239. electronicparsers/vasp/metainfo/vasp_incarsOut.py +3428 -0
  240. electronicparsers/vasp/metainfo/vasp_incarsUnknown.py +86 -0
  241. electronicparsers/vasp/nomad_plugin.yaml +28 -0
  242. electronicparsers/vasp/parser.py +2340 -0
  243. electronicparsers/w2dynamics/__init__.py +19 -0
  244. electronicparsers/w2dynamics/__main__.py +31 -0
  245. electronicparsers/w2dynamics/metainfo/__init__.py +19 -0
  246. electronicparsers/w2dynamics/metainfo/w2dynamics.py +1270 -0
  247. electronicparsers/w2dynamics/nomad_plugin.yaml +36 -0
  248. electronicparsers/w2dynamics/parser.py +674 -0
  249. electronicparsers/wannier90/__init__.py +19 -0
  250. electronicparsers/wannier90/__main__.py +31 -0
  251. electronicparsers/wannier90/metainfo/__init__.py +19 -0
  252. electronicparsers/wannier90/metainfo/wannier90.py +56 -0
  253. electronicparsers/wannier90/nomad_plugin.yaml +34 -0
  254. electronicparsers/wannier90/parser.py +671 -0
  255. electronicparsers/wien2k/__init__.py +19 -0
  256. electronicparsers/wien2k/__main__.py +31 -0
  257. electronicparsers/wien2k/metainfo/__init__.py +19 -0
  258. electronicparsers/wien2k/metainfo/wien2k.py +783 -0
  259. electronicparsers/wien2k/nomad_plugin.yaml +18 -0
  260. electronicparsers/wien2k/parser.py +1133 -0
  261. electronicparsers/yambo/__init__.py +19 -0
  262. electronicparsers/yambo/__main__.py +31 -0
  263. electronicparsers/yambo/metainfo/__init__.py +19 -0
  264. electronicparsers/yambo/metainfo/yambo.py +577 -0
  265. electronicparsers/yambo/nomad_plugin.yaml +31 -0
  266. electronicparsers/yambo/parser.py +896 -0
  267. nomad_parser_plugins_electronic-1.0.dist-info/LICENSE +202 -0
  268. nomad_parser_plugins_electronic-1.0.dist-info/METADATA +360 -0
  269. nomad_parser_plugins_electronic-1.0.dist-info/RECORD +272 -0
  270. nomad_parser_plugins_electronic-1.0.dist-info/WHEEL +5 -0
  271. nomad_parser_plugins_electronic-1.0.dist-info/entry_points.txt +43 -0
  272. 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()