1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
|
import re
import numpy as np
from xml.dom import minidom
def get_ion(fname):
"""
Read the ion.xml file of a specie
Input parameters:
-----------------
fname (str): name of the ion file
Output Parameters:
------------------
ion (dict): The ion dictionary contains all the data
from the ion file. Each field of the xml file give
one key.
The different keys are:
'lmax_basis': int
'self_energy': float
'z': int
'symbol': str
'label': str
'mass': flaot
'lmax_projs': int
'basis_specs': str
'norbs_nl': int
'valence': float
'nprojs_nl: int
The following keys give the pao field,
'npts': list of int
'delta':list of float
'cutoff': list of float
'data':list of np.arrayof shape (npts[i], 2)
'orbital': list of dictionary
'projector': list of dictionary
"""
doc = minidom.parse(fname)
# the elements from the header
elements_headers = [['symbol', str], ['label', str], ['z', int],
['valence', float], ['mass', float],
['self_energy', float], ['lmax_basis', int],
['norbs_nl', int], ['lmax_projs', int],
['nprojs_nl', int]]
ion = {}
for i, elname in enumerate(elements_headers):
name = doc.getElementsByTagName(elname[0])
ion[elname[0]] = get_data_elements(name[0], elname[1])
# extract the basis_specs
name = doc.getElementsByTagName("basis_specs")
ion["basis_specs"] = getNodeText(name[0])
extract_pao_elements(ion, doc)
return ion
def getNodeText(node):
nodelist = node.childNodes
result = []
for node in nodelist:
if node.nodeType == node.TEXT_NODE:
result.append(node.data)
return ''.join(result)
def get_data_elements(name, dtype):
"""
return the right type of the element value
"""
if dtype is int:
data = str2int(getNodeText(name))
if len(data) > 1:
return np.array(data)
elif len(data) == 1:
return data[0]
else:
raise ValueError("len(data)<1 ??")
elif dtype is float:
data = str2float(getNodeText(name))
if len(data) > 1:
return np.array(data)
elif len(data) == 1:
return data[0]
else:
raise ValueError("len(data)<1 ??")
elif dtype is str:
return getNodeText(name)
else:
raise ValueError('not implemented')
def extract_pao_elements(ion, doc):
"""
extract the different pao element of the xml file
Input Parameters:
-----------------
ion (dict)
doc (minidom.parse)
Output Parameters:
------------------
ion (dict): the following keys are added to the ion dict:
npts
delta
cutoff
data
orbital
projector
"""
name_npts = doc.getElementsByTagName("npts")
name_delta = doc.getElementsByTagName("delta")
name_cutoff = doc.getElementsByTagName("cutoff")
name_data = doc.getElementsByTagName("data")
name_orbital = doc.getElementsByTagName("orbital")
name_projector = doc.getElementsByTagName("projector")
ion["orbital"] = []
ion["projector"] = []
for i in range(len(name_orbital)):
ion["orbital"].append(extract_orbital(name_orbital[i]))
for i in range(len(name_projector)):
ion["projector"].append(extract_projector(name_projector[i]))
if len(name_data) != len(name_npts):
raise ValueError("len(name_data) != len(name_npts): {0} != {1}".
format(len(name_data), len(name_npts)))
if len(name_data) != len(name_cutoff):
raise ValueError("len(name_data) != len(name_cutoff): {0} != {1}".
format(len(name_data), len(name_cutoff)))
if len(name_data) != len(name_delta):
raise ValueError("len(name_data) != len(name_delta): {0} != {1}".
format(len(name_data), len(name_delta)))
ion["npts"] = np.zeros((len(name_npts)), dtype=int)
ion["delta"] = np.zeros((len(name_delta)), dtype=float)
ion["cutoff"] = np.zeros((len(name_cutoff)), dtype=float)
ion["data"] = []
for i in range(len(name_data)):
ion["npts"][i] = get_data_elements(name_npts[i], int)
ion["cutoff"][i] = get_data_elements(name_cutoff[i], float)
ion["delta"][i] = get_data_elements(name_delta[i], float)
ion["data"].append(get_data_elements(name_data[i], float).
reshape(ion["npts"][i], 2))
def extract_orbital(orb_xml):
"""
extract the orbital
"""
orb = {}
orb['l'] = str2int(orb_xml.attributes['l'].value)[0]
orb['n'] = str2int(orb_xml.attributes['n'].value)[0]
orb['z'] = str2int(orb_xml.attributes['z'].value)[0]
orb['ispol'] = str2int(orb_xml.attributes['ispol'].value)[0]
orb['population'] = str2float(orb_xml.attributes['population'].value)[0]
return orb
def extract_projector(pro_xml):
"""
extract the projector
"""
pro = {}
pro['l'] = str2int(pro_xml.attributes['l'].value)[0]
pro['n'] = str2int(pro_xml.attributes['n'].value)[0]
pro['ref_energy'] = str2float(pro_xml.attributes['ref_energy'].value)[0]
return pro
def str2float(string):
numeric_const_pattern = r"""
[-+]? # optional sign
(?:
(?: \d* \. \d+ ) # .1 .12 .123 etc 9.1 etc 98.1 etc
|
(?: \d+ \.? ) # 1. 12. 123. etc 1 12 123 etc
)
# followed by optional exponent part if desired
(?: [Ee] [+-]? \d+ ) ?
"""
rx = re.compile(numeric_const_pattern, re.VERBOSE)
nb = rx.findall(string)
for i in enumerate(nb):
nb[i[0]] = float(i[1])
return np.array(nb)
def str2int(string):
numeric_const_pattern = r"""
[-+]? # optional sign
(?:
(?: \d* \. \d+ ) # .1 .12 .123 etc 9.1 etc 98.1 etc
|
(?: \d+ \.? ) # 1. 12. 123. etc 1 12 123 etc
)
# followed by optional exponent part if desired
(?: [Ee] [+-]? \d+ ) ?
"""
rx = re.compile(numeric_const_pattern, re.VERBOSE)
nb = rx.findall(string)
for i in enumerate(nb):
nb[i[0]] = int(i[1])
return np.array(nb)
|
