def test_valid_qcschema_slow(basis_name):
basis_dict = api.get_basis(basis_name)
qcs_str = api.get_basis(basis_name, fmt='qcschema')
qcs_json = json.loads(qcs_str)
el_list = [
lut.element_sym_from_Z(x, True) for x in basis_dict['elements'].keys()
]
coords = []
for idx, el in enumerate(el_list):
coords.extend((0.0, 0.0, float(idx)))
qcs_json['atom_map'] = list(qcs_json['center_data'].keys())
assert len(qcs_json['atom_map']) == len(el_list)
dummy_inp = {
"schema_name": "qc_schema_input",
"schema_version": 1,
"keywords": {},
"molecule": {
"schema_name": "qcschema_molecule",
"schema_version": 2,
"geometry": coords,
"symbols": el_list
},
'driver': 'energy',
'model': {
'method': 'B3LYP',
'basis': qcs_json
}
}
qcschema.validate(dummy_inp, 'input')
def test_element_data(Z):
# Cycle through the elements and check that
# the info returned from the functions is consistent
data = lut.element_data_from_Z(Z)
assert data[1] == Z
assert data == lut.element_data_from_sym(data[0])
assert data == lut.element_data_from_name(data[2])
assert data[0] == lut.element_sym_from_Z(Z)
assert data[2] == lut.element_name_from_Z(Z)
nsym = lut.element_sym_from_Z(Z, True)
nname = lut.element_name_from_Z(Z, True)
assert nsym[0] == data[0][0].upper()
assert nname[0] == data[2][0].upper()
def test_get_basis_2(basis_name):
"""For all versions of basis sets, test a simple get_basis
with different element selections
"""
this_metadata = bs_metadata[basis_name]
latest = this_metadata['latest_version']
avail_elements = this_metadata['versions'][latest]['elements']
nelements = random.randint(1, len(avail_elements))
selected_elements = random.sample(avail_elements, nelements)
# Change some selected elements to strings
for idx in range(len(selected_elements)):
if idx % 3 == 1:
selected_elements[idx] = lut.element_sym_from_Z(
selected_elements[idx])
elif idx % 3 == 2:
selected_elements[idx] = str(selected_elements[idx])
bs = bse.get_basis(basis_name, elements=selected_elements)
assert len(bs['basis_set_elements']) == len(selected_elements)
raise RuntimeError('Incorrect terminator: {}'.format(el[-1].strip()))
# Remove last line
el.pop()
# Check that there is no extra terminator
nterm = sum([1 if terminator_re.match(line) else 0 for line in el])
if nterm != 0:
for iline, line in enumerate(el):
if terminator_re.match(line):
raise RuntimeError('Problem in entry: {}'.format(el[iline+1]))
# Extract the name of the basis set
elname, Z = parse_line_regex(element_re, el[0], 'elementbasisname, Z')
# Clean out the basis set name from the string
sym = element_sym_from_Z(Z).upper()
assert elname[:len(sym)] == sym
basname = elname[len(sym):].strip()
print('basis = {} sym = {}'.format(basname, sym))
# Parse the shells
shell_sections = partition_lines(el[1:], shell_re.match)
# Basis set in Gaussian'94 format
elstr = '{} 0\n'.format(element_sym_from_Z(Z, normalize=True))
for shell in shell_sections:
# First line is just shell definition
elstr += ' '.join(shell[0].split()[1:]) + ' 1.00\n'
for line in shell[1:]:
elstr += ' ' + ' '.join(line.split()[1:]) + '\n'
assert el1 == el2
assert name2 == 'ANO-RCC'
assert name1 in all_names
el = lut.element_Z_from_sym(el1, as_str=True)
assert el not in split_data[name1]
cont = re.findall(r'\d+[a-z]+', cont)
split_data[name1][el] = cont
print(split_data)
for name, el_cont_data in split_data.items():
print(name)
new_basis = api.get_basis(name)
for el, eldata in new_basis['elements'].items():
el_split = el_cont_data[el]
am = [sh['angular_momentum'] for sh in eldata['electron_shells']]
new_pattern = []
for sh in eldata['electron_shells']:
new_pattern.append('{}{}'.format(
len(sh['coefficients']),
lut.amint_to_char(sh['angular_momentum'])))
print(lut.element_sym_from_Z(el, True), ''.join(new_pattern))
assert new_pattern == el_split
print()
