def dump_reference_json():
sys.path.insert(0, os.path.join(root, "build/"))
sys.path.insert(0, os.path.join(root, "tests/"))
mp.dps = 200
data = []
for l in range(20):
for n in range(20):
# z > 660 will lead to larger than double::max() values for a > 19
for z in [
1e-2,
1e-1,
1,
10,
20,
30,
40,
60,
80,
100,
150,
200,
500,
660,
]:
a = 0.5 * (n + l + 3)
b = l + 1.5
val = float(hyp1f1(a, b, z))
der = float(a / b * hyp1f1(a + 1, b + 1, z))
data.append(dict(a=a, b=b, z=z, val=val, der=der))
print(len(data))
with open(os.path.join(root, dump_path, "hyp1f1_reference.ubjson"),
"wb") as f:
ubjson.dump(data, f)
def trigger_action(data):
"""packs and writes"""
nant, de = get_delays()
t0, t1, sn, dm, width, pt, s = struct.unpack('ddffff128s', data)
print("Triggered on DM={0:3.2f} S/N={1:2.1f} width={4:2.1f} I0={2}".format(
dm, sn, t0, time.time(), 1e3 * width))
slack_push(
"ML triggered on DM={0:3.2f} S/N={1:2.1f} width={4:2.1f} I0={2}".
format(dm, sn, t0, time.time(), 1e3 * width))
##
ret = dict()
ret['sn'] = sn
ret['dm'] = dm
ret['width'] = width
ret['peak_time'] = pt
ret['t0'] = t0
ret['t1'] = t1
ret['meta'] = s
#ret['nant'] = nant
ret['delays'] = de
ret['antprops'] = ANTPROP
##
i0 = int(t0)
d0 = int(t1 - t0)
fn = "{0}_i{1}_dm{2:05.2f}_sn{3:05.2f}_wd{4:05.2f}.meta".format(
i0, d0, dm, sn, width * 1e3)
with open(os.path.join(METADIR, fn), 'wb') as f:
ubjson.dump(ret, f)
def dump_reference_json():
path = '../'
sys.path.insert(0, os.path.join(path, 'build/'))
sys.path.insert(0, os.path.join(path, 'tests/'))
data = []
a = 0
for order in range(2,20):
for b in np.linspace(2,10,20):
x,w = get_leggauss(order, a, b)
data.append(dict(a=a,b=b,order=order,points=x.tolist(),weights=w.tolist()))
print(len(data))
with open(path+"tests/reference_data/gauss_legendre_reference.ubjson",'wb') as f:
ubjson.dump(data,f)
def dump_reference_json():
sys.path.insert(0, os.path.join(root, "build/"))
sys.path.insert(0, os.path.join(root, "tests/"))
data = dict(i_complete_square=[])
# 1 test the special case in the bessel function and 20 test that we
# can ramp up l_max safely
max_orders = [1, 20]
for max_order in max_orders:
orders = list(range(max_order))
# gaussian sigma in [0.1, 0.9]
alphas = np.linspace(0.6, 50, 10)
# looks at rc up to 10
xns = np.linspace(0.005, 10, 15)
# to test values around the bessel tolerance
xns = np.hstack((1e-6, 1e-5, xns))
# atoms should not be much closer than this
rijs = np.linspace(0.5, 10, 15)
# to test values around the bessel tolerance
rijs = np.hstack((1e-6, 1e-5, rijs))
for alpha in alphas:
for rij in rijs:
vals = []
for xn in xns:
vals.append([])
for order in orders:
val = sbesseli_complete_square(order, alpha, rij, xn)
vals[-1].append(val)
# avoid values that are too small for ubjson to be interpreted
# as doubles
vals = np.array(vals)
vals[vals < 1e-300] = 0.0
data["i_complete_square"].append(
dict(
alpha=alpha,
rij=rij,
xs=xns.tolist(),
max_order=max_order,
vals=vals.tolist(),
))
with open(
os.path.join(root, dump_path,
"modified_bessel_first_kind_reference.ubjson"),
"wb",
) as f:
ubjson.dump(data, f)
def saveb(data, fname, opt={}, **kwargs):
"""@brief Saving a Python data structure to a binary JData (UBJSON) file
@param[in] data: data to be saved
@param[in] fname: a binary (UBJSON based) JData file name
@param[in] opt: options, if opt['encode']=True or 1 (default), call jdata.encode() before saving
"""
opt.setdefault('encode',True)
try:
import ubjson
except ImportError:
raise ImportError('To read/write binary JData files, you must install the py-ubjson module by "pip install py-ubjson"')
else:
if(opt['encode']):
data=jd.encode(data,opt);
with open(fname, "w") as fid:
ubjson.dump(data, fid,**kwargs);
def dump_reference_json():
path = '../'
sys.path.insert(0, os.path.join(path, 'build/'))
sys.path.insert(0, os.path.join(path, 'tests/'))
mp.dps = 200
data = []
for l in range(20):
for n in range(20):
for z in [1e-2, 1e-1, 1, 10, 20, 30, 40, 60, 80, 100, 150, 200]:
a = 0.5 * (n + l + 3)
b = l + 1.5
val = float(hyp1f1(a, b, z))
der = float(a / b * hyp1f1(a + 1, b + 1, z))
data.append(dict(a=a, b=b, z=z, val=val, der=der))
print(len(data))
with open(path + "tests/reference_data/hyp1f1_reference.ubjson",
'wb') as f:
ubjson.dump(data, f)
def dump_reference_json():
sys.path.insert(0, os.path.join(root, "build/"))
sys.path.insert(0, os.path.join(root, "tests/"))
data = []
a = 0
for order in range(2, 20):
for b in np.linspace(2, 10, 20):
x, w = get_leggauss(order, a, b)
data.append(
dict(
a=a,
b=b,
order=order,
points=x.tolist(),
weights=w.tolist(),
))
print(len(data))
with open(os.path.join(root, dump_path, "gauss_legendre_reference.ubjson"),
"wb") as f:
ubjson.dump(data, f)
def tofile(fn, frames):
import numpy as np
keys = ['positions', 'cell', 'numbers', 'pbc']
data = {}
for ii, frame in zip(range(1, len(frames) + 1), frames):
aa = dict(positions=frame.get_positions().tolist(),
cell=frame.get_cell().tolist(),
numbers=frame.get_atomic_numbers().tolist(),
pbc=frame.get_pbc().tolist())
aa['info'] = {}
for k, v in frame.info.items():
if isinstance(v, np.integer):
aa['info'][k] = int(v)
elif isinstance(v, np.bool_):
aa['info'][k] = bool(v)
elif isinstance(v, np.float):
aa['info'][k] = float(v)
elif hasattr(v, 'tolist'):
aa['info'][k] = v.tolist()
else:
aa['info'][k] = v
aa['arrays'] = {}
for k, v in frame.arrays.items():
if k not in keys:
aa['arrays'][k] = v.tolist()
data[str(ii)] = aa
data['ids'] = list(range(1, len(frames) + 1))
data['nextid'] = len(frames) + 1
_, extension = os.path.splitext(fn)
if extension == '.json':
with open(fn, 'w') as f:
# json.dump(data, f)
data_pretty = prettyjson(data, indent=2, maxlinelength=80)
f.write(data_pretty)
elif extension == '.ubjson':
with open(fn, 'wb') as f:
ubjson.dump(data, f, no_float32=False)
def dump_reference_json():
import ubjson
import os
from copy import copy
from itertools import product
path = '../'
sys.path.insert(0, os.path.join(path, 'build/'))
sys.path.insert(0, os.path.join(path, 'tests/'))
cutoffs = [3]
gaussian_sigmas = [0.4]
max_radials = [1, 2, 3]
max_angulars = [1, 2, 4]
soap_types = ["LambdaSpectrum"]
inversion_symmetries = [True, False]
Lambdas = [1]
fns = [
os.path.join(
path, "tests/reference_data/CaCrP2O7_mvc-11955_symmetrized.json"),
os.path.join(path, "tests/reference_data/small_molecule.json")
]
fns_to_write = [
"reference_data/CaCrP2O7_mvc-11955_symmetrized.json",
"reference_data/small_molecule.json",
]
data = dict(filenames=fns_to_write,
cutoffs=cutoffs,
gaussian_sigmas=gaussian_sigmas,
max_radials=max_radials,
soap_types=soap_types,
rep_info=[])
for fn in fns:
frames = read(fn)
for cutoff in cutoffs:
print(fn, cutoff)
data['rep_info'].append([])
for (soap_type, gaussian_sigma, max_radial,
max_angular, inversion_symmetry, Lambda) in product(
soap_types, gaussian_sigmas, max_radials, max_angulars,
inversion_symmetries, Lambdas):
hypers = {"interaction_cutoff": cutoff,
"cutoff_smooth_width": 0.5,
"max_radial": max_radial,
"max_angular": max_angular,
"gaussian_sigma_type": "Constant",
"gaussian_sigma_constant": gaussian_sigma,
"cutoff_function_type": "ShiftedCosine",
"radial_basis": "GTO",
"normalize": True,
"soap_type": soap_type,
"inversion_symmetry": inversion_symmetry,
"lam": Lambda}
soap = SphericalCovariants(**hypers)
soap_vectors = soap.transform(frames)
x = soap_vectors.get_features(soap)
x[np.abs(x) < 1e-300] = 0.
data['rep_info'][-1].append(dict(feature_matrix=x.tolist(),
hypers=copy(soap.hypers)))
with open(path +
"tests/reference_data/spherical_covariants_reference.ubjson",
'wb') as f:
ubjson.dump(data, f)
def dump_reference_json():
import ubjson
from copy import copy
from itertools import product
sys.path.insert(0, os.path.join(root, 'build/'))
sys.path.insert(0, os.path.join(root, 'tests/'))
cutoffs = [2, 3]
gaussian_sigmas = [0.2, 0.5]
max_radials = [4, 10]
max_angulars = [3, 6]
soap_types = ["RadialSpectrum", "PowerSpectrum", "BiSpectrum"]
inversion_symmetry = False
radial_basis = ["GTO"]
fns = [
os.path.join(inputs_path, "CaCrP2O7_mvc-11955_symmetrized.json"),
os.path.join(inputs_path, "small_molecule.json")
]
fns_to_write = [
os.path.join(dump_path, "CaCrP2O7_mvc-11955_symmetrized.json"),
os.path.join(dump_path, "small_molecule.json"),
]
data = dict(filenames=fns_to_write,
cutoffs=cutoffs,
gaussian_sigmas=gaussian_sigmas,
max_radials=max_radials,
soap_types=soap_types,
rep_info=[])
for fn in fns:
frames = read(fn)
for cutoff in cutoffs:
print(fn, cutoff)
data['rep_info'].append([])
for (soap_type, gaussian_sigma, max_radial, max_angular,
rad_basis) in product(soap_types, gaussian_sigmas,
max_radials, max_angulars,
radial_basis):
if 'RadialSpectrum' == soap_type:
max_angular = 0
if "BiSpectrum" == soap_type:
max_radial = 2
max_angular = 1
inversion_symmetry = True
hypers = {
"interaction_cutoff": cutoff,
"cutoff_smooth_width": 0.5,
"max_radial": max_radial,
"max_angular": max_angular,
"gaussian_sigma_type": "Constant",
"normalize": True,
"cutoff_function_type": "ShiftedCosine",
"radial_basis": rad_basis,
"gaussian_sigma_constant": gaussian_sigma,
"soap_type": soap_type,
"inversion_symmetry": inversion_symmetry,
}
soap = SphericalInvariants(**hypers)
soap_vectors = soap.transform(frames)
x = soap_vectors.get_features(soap)
x[np.abs(x) < 1e-300] = 0.
data['rep_info'][-1].append(
dict(feature_matrix=x.tolist(), hypers=copy(soap.hypers)))
with open(
os.path.join(root, dump_path,
"spherical_invariants_reference.ubjson"), 'wb') as f:
ubjson.dump(data, f)
def write_dbson(fname, obj):
"""
Writes dbson.
"""
with open(fname, "wb") as f:
ubjson.dump(from_dbson(obj), f)
"reference_data/CaCrP2O7_mvc-11955_symmetrized.json",
"reference_data/small_molecule.json"
]
data = dict(filenames=fns_to_write, cutoffs=cutoffs, rep_info=[])
hypers = dict(central_decay=-1,
interaction_cutoff=-1,
interaction_decay=-1,
size=10,
sorting_algorithm='')
for fn in fns:
for cutoff in cutoffs:
print(fn, cutoff)
data['rep_info'].append([])
for sort in sorts:
rep = SortedCoulombMatrix(cutoff, sorting_algorithm=sort)
frame = [json2ase(load_json(fn))]
features = rep.transform(frame)
test = features.get_feature_matrix()
hypers['size'] = rep.size
print(rep.size)
hypers['sorting_algorithm'] = sort
data['rep_info'][-1].append(
dict(feature_matrix=test.tolist(), hypers=copy(hypers)))
with open(
os.path.join(path, "tests", "reference_data",
"sorted_coulomb_reference.ubjson"), 'wb') as f:
ubjson.dump(data, f)
def serialize_data(src, data):
with gzip.open(src, "wb") as f:
ubjson.dump(data, f)
def dump_reference_json():
import ubjson
import os
from copy import copy
path = '../'
sys.path.insert(0, os.path.join(path, 'build/'))
sys.path.insert(0, os.path.join(path, 'tests/'))
cutoffs = [2, 3]
gaussian_sigmas = [0.2, 0.5]
max_radials = [4, 10]
max_angulars = [3, 6]
soap_types = ["RadialSpectrum", "PowerSpectrum", "BiSpectrum"]
inversion_symmetry = False
fns = [
os.path.join(
path, "tests/reference_data/CaCrP2O7_mvc-11955_symmetrized.json"),
os.path.join(path, "tests/reference_data/small_molecule.json")
]
fns_to_write = [
"reference_data/CaCrP2O7_mvc-11955_symmetrized.json",
"reference_data/small_molecule.json",
]
data = dict(filenames=fns_to_write,
cutoffs=cutoffs,
gaussian_sigmas=gaussian_sigmas,
max_radials=max_radials,
soap_types=soap_types,
rep_info=[])
for fn in fns:
frames = [json2ase(load_json(fn))]
for cutoff in cutoffs:
print(fn, cutoff)
data['rep_info'].append([])
for soap_type in soap_types:
for gaussian_sigma in gaussian_sigmas:
for max_radial in max_radials:
for max_angular in max_angulars:
if 'RadialSpectrum' == soap_type:
max_angular = 0
if "BiSpectrum" == soap_type:
max_radial = 2
max_angular = 1
inversion_symmetry = True
hypers = {
"interaction_cutoff": cutoff,
"cutoff_smooth_width": 0.5,
"max_radial": max_radial,
"max_angular": max_angular,
"gaussian_sigma_type": "Constant",
"normalize": True,
"cutoff_function_type": "Cosine",
"radial_basis": "GTO",
"gaussian_sigma_constant": gaussian_sigma,
"soap_type": soap_type,
"inversion_symmetry": inversion_symmetry,
}
soap = SphericalInvariants(**hypers)
soap_vectors = soap.transform(frames)
x = soap_vectors.get_feature_matrix()
# x = get_feature_vector(hypers, frames)
data['rep_info'][-1].append(
dict(feature_matrix=x.tolist(),
hypers=copy(soap.hypers)))
with open(
path +
"tests/reference_data/spherical_invariants_reference.ubjson",
'wb') as f:
ubjson.dump(data, f)
def save(graph, output, filename):
nodes = graph.nodes
roots = ((k, v) for (k, v) in graph.nodes.items() if 'parent' not in v)
functions = collections.defaultdict(new_empty_function)
for (fn_name, fn_attrs) in roots:
if 'children' not in fn_attrs:
continue
fn = functions[fn_name]
# Blocks have children; anything else must be an argument.
child_names = set(fn_attrs['children'])
blocks = {
n
for n in child_names if n in nodes #and 'children' in nodes[n]
}
args = child_names.difference(blocks)
for block_name in blocks:
block_attrs = nodes[block_name]
block = fn['blocks'][block_name] = dict([
(k, v) for (k, v) in nodes[block_name].items()
if k not in ('parent', 'children')
])
for child_name in block_attrs['children']:
child_attrs = nodes[child_name] if child_name in nodes else {}
if 'parent' in child_attrs:
child_attrs.pop('parent')
assert 'children' not in child_attrs
block[child_name] = child_attrs
for arg_name in args:
#if arg_name not in nodes:
# continue
arg_attrs = nodes[arg_name]
arg_attrs.pop('parent')
assert 'children' not in arg_attrs
fn['arguments'][arg_name] = dict(arg_attrs)
functions[fn_name] = fn
for (src, dest, data) in graph.edges(data=True):
#if src not in nodes or dest not in nodes:
# continue
(fn_name, src_name) = src.split('::', 1)
kind = data['kind']
data = {
'from': src,
'to': dest,
'kind': EdgeKind.to_str(kind),
}
if kind == EdgeKind.Call:
functions[fn_name]['calls'].append(data)
else:
functions[fn_name]['flows'].append(data)
if filename.endswith('.cdg'):
import ubjson
cg = ubjson.load(stream)
elif filename.endswith('.json'):
import json
cg = json.load(stream)
elif filename.endswith('.yaml'):
import yaml
try:
from yaml import CLoader as Loader
except ImportError:
from yaml import Loader
cg = yaml.load(stream, Loader=Loader)
import ubjson
ubjson.dump({'functions': functions}, output)
def dump_reference_json():
import ubjson
from copy import copy
from itertools import product
sys.path.insert(0, os.path.join(root, 'build/'))
sys.path.insert(0, os.path.join(root, 'tests/'))
cutoffs = [2, 3]
gaussian_sigmas = [0.2, 0.5]
max_radials = [4, 10]
max_angulars = [3, 6]
cutoff_smooth_widths = [0., 1.]
radial_basis = ["GTO", "DVR"]
cutoff_function_types = ['ShiftedCosine', 'RadialScaling']
fns = [
os.path.join(inputs_path, "CaCrP2O7_mvc-11955_symmetrized.json"),
os.path.join(inputs_path, "small_molecule.json")
]
fns_to_write = [
os.path.join(dump_path, "CaCrP2O7_mvc-11955_symmetrized.json"),
os.path.join(dump_path, "small_molecule.json"),
]
data = dict(filenames=fns_to_write,
cutoffs=cutoffs,
gaussian_sigmas=gaussian_sigmas,
max_radials=max_radials,
rep_info=[])
for fn in fns:
for cutoff in cutoffs:
data['rep_info'].append([])
for (gaussian_sigma, max_radial, max_angular, cutoff_smooth_width,
rad_basis, cutoff_function_type) in product(
gaussian_sigmas, max_radials, max_angulars,
cutoff_smooth_widths, radial_basis,
cutoff_function_types):
frames = read(fn)
if cutoff_function_type == 'RadialScaling':
cutoff_function_parameters = dict(rate=1,
scale=cutoff * 0.5,
exponent=3)
else:
cutoff_function_parameters = dict()
hypers = {
"interaction_cutoff": cutoff,
"cutoff_smooth_width": cutoff_smooth_width,
"max_radial": max_radial,
"max_angular": max_angular,
"gaussian_sigma_type": "Constant",
"cutoff_function_type": cutoff_function_type,
'cutoff_function_parameters': cutoff_function_parameters,
"gaussian_sigma_constant": gaussian_sigma,
"radial_basis": rad_basis
}
sph_expn = SphericalExpansion(**hypers)
expansions = sph_expn.transform(frames)
x = expansions.get_features(sph_expn)
x[np.abs(x) < 1e-300] = 0.
data['rep_info'][-1].append(
dict(feature_matrix=x.tolist(),
hypers=copy(sph_expn.hypers)))
with open(
os.path.join(root, dump_path,
"spherical_expansion_reference.ubjson"), 'wb') as f:
ubjson.dump(data, f)
def dump_reference_json():
# to produces more readable tests use l_max 2 or 3
verbose = False
l_max = 30
sys.path.insert(0, os.path.join(root, 'build/'))
sys.path.insert(0, os.path.join(root, 'tests/'))
data = []
mp.dps = 200
# Calculation of spherical harmonics
# with mpmath:
## spherharm(angular_l,angular_m, theta, phi)
# with scipy:
## sph_harm(angular_m, angular_l, phi, theta)
unit_vectors = load_unit_vectors_from_json()
# In arXiv 1410.1748 e.q. (4) the factors in front of the associated
# polynomial
alp_normfacts = np.zeros((l_max + 1, l_max + 1))
for l in range(l_max + 1):
for m in range(l + 1):
alp_normfacts[l, m] = mpmath.sqrt(
(2 * l + 1) / (2 * mpmath.pi) /
reduce(lambda x, y: mpmath.fmul(x, y),
mpmath.arange(l - m + 1, l + m + 1), 1))
if verbose:
print("alp_normfacts")
print(alp_normfacts)
for unit_vector in unit_vectors:
# Calculating the spherical harmonics
harmonics = []
# copy of c++ code:
# double cos_theta = unit_vector[2];
cos_theta = unit_vector[2]
theta = np.arccos(cos_theta)
# copy of c++ code:
# double phi = std::atan2(unit_vector[1], unit_vector[0]);
phi = np.arctan2(unit_vector[1], unit_vector[0])
if verbose:
print(unit_vector)
for l in range(l_max + 1):
# calculation for negative m
for m in range(-l, 0):
result = np.sqrt(2) * np.imag(
sph_harm(np.abs(m), l, phi, theta))
harmonics.append(float(result))
if verbose:
print(l, m, result)
# calculation for m=0
result = np.real(sph_harm(0, l, phi, theta))
harmonics.append(float(result))
if verbose:
print(l, 0, result)
# calculation for positive m
for m in range(1, l + 1):
result = np.sqrt(2) * np.real(sph_harm(m, l, phi, theta))
harmonics.append(float(result))
if verbose:
print(l, m, result)
# Calculating the associated legendre polynomial
# copy of c++ code:
# double cos_theta = unit_vector[2];
cos_theta = unit_vector[2]
alps = lpmn(l_max, l_max, cos_theta)[0].T
if verbose:
print("lpmn")
print(alps)
alps *= alp_normfacts
if verbose:
print("alps")
print(alps)
alps = list(map(float, alps.reshape(-1).tolist()))
data.append(
dict(max_angular_l=int(l_max),
unit_vector=unit_vector,
harmonics=harmonics,
alps=alps))
if verbose:
print(len(data))
with open(
os.path.join(root, dump_path,
"spherical_harmonics_reference.ubjson"), 'wb') as f:
ubjson.dump(data, f)
def dump_reference_json():
import ubjson
import os
from copy import copy
path = '../'
sys.path.insert(0, os.path.join(path, 'build/'))
sys.path.insert(0, os.path.join(path, 'tests/'))
cutoffs = [2, 3]
gaussian_sigmas = [0.2, 0.5]
max_radials = [4, 10]
max_angulars = [3, 6]
cutoff_smooth_widths = [0., 1.]
radial_basis = ["GTO"]
fns = [
os.path.join(
path, "tests/reference_data/CaCrP2O7_mvc-11955_symmetrized.json"),
os.path.join(path, "tests/reference_data/small_molecule.json")
]
fns_to_write = [
"reference_data/CaCrP2O7_mvc-11955_symmetrized.json",
"reference_data/small_molecule.json",
]
data = dict(filenames=fns_to_write,
cutoffs=cutoffs,
gaussian_sigmas=gaussian_sigmas,
max_radials=max_radials,
rep_info=[])
# An example of the gruesomeness of using 4 spaces for one tab
for fn in fns:
for cutoff in cutoffs:
data['rep_info'].append([])
for gaussian_sigma in gaussian_sigmas:
for max_radial in max_radials:
for max_angular in max_angulars:
for cutoff_smooth_width in cutoff_smooth_widths:
for rad_basis in radial_basis:
frames = [json2ase(load_json(fn))]
hypers = {
"interaction_cutoff": cutoff,
"cutoff_smooth_width": cutoff_smooth_width,
"max_radial": max_radial,
"max_angular": max_angular,
"gaussian_sigma_type": "Constant",
"cutoff_function_type": "Cosine",
"gaussian_sigma_constant": gaussian_sigma,
"radial_basis": rad_basis
}
# x = get_soap_vectors(hypers, frames)
sph_expn = SphericalExpansion(**hypers)
expansions = sph_expn.transform(frames)
x = expansions.get_feature_matrix()
data['rep_info'][-1].append(
dict(feature_matrix=x.tolist(),
hypers=copy(sph_expn.hypers)))
with open(
path + "tests/reference_data/spherical_expansion_reference.ubjson",
'wb') as f:
ubjson.dump(data, f)
def dump_reference_json():
import ubjson
from copy import copy
from itertools import product
sys.path.insert(0, os.path.join(root, "build/"))
sys.path.insert(0, os.path.join(root, "tests/"))
cutoffs = [2, 3]
gaussian_sigmas = [0.2, 0.5]
max_radials = [4]
max_angulars = [3]
cutoff_smooth_widths = [1.0]
radial_basis = ["GTO", "DVR"]
cutoff_function_types = ["ShiftedCosine", "RadialScaling"]
fns = [
os.path.join(inputs_path, "CaCrP2O7_mvc-11955_symmetrized.json"),
os.path.join(inputs_path, "small_molecule.json"),
]
fns_to_write = [
os.path.join(read_inputs_path, "CaCrP2O7_mvc-11955_symmetrized.json"),
os.path.join(read_inputs_path, "small_molecule.json"),
]
optimization_args = [
{
"type": "None",
"accuracy": 1e-8
},
{
"type": "Spline",
"accuracy": 1e-8
},
]
data = dict(
filenames=fns_to_write,
cutoffs=cutoffs,
gaussian_sigmas=gaussian_sigmas,
max_radials=max_radials,
rep_info=[],
)
for fn in fns:
for cutoff in cutoffs:
data["rep_info"].append([])
for (
gaussian_sigma,
max_radial,
max_angular,
cutoff_smooth_width,
rad_basis,
cutoff_function_type,
opt_args,
) in product(
gaussian_sigmas,
max_radials,
max_angulars,
cutoff_smooth_widths,
radial_basis,
cutoff_function_types,
optimization_args,
):
frames = read(fn)
if cutoff_function_type == "RadialScaling":
cutoff_function_parameters = dict(rate=1,
scale=cutoff * 0.5,
exponent=3)
else:
cutoff_function_parameters = dict()
hypers = {
"interaction_cutoff": cutoff,
"cutoff_smooth_width": cutoff_smooth_width,
"max_radial": max_radial,
"max_angular": max_angular,
"gaussian_sigma_type": "Constant",
"cutoff_function_type": cutoff_function_type,
"cutoff_function_parameters": cutoff_function_parameters,
"gaussian_sigma_constant": gaussian_sigma,
"radial_basis": rad_basis,
"optimization_args": opt_args,
}
sph_expn = SphericalExpansion(**hypers)
expansions = sph_expn.transform(frames)
x = expansions.get_features(sph_expn)
x[np.abs(x) < 1e-300] = 0.0
data["rep_info"][-1].append(
dict(feature_matrix=x.tolist(),
hypers=copy(sph_expn.hypers)))
with open(
os.path.join(root, dump_path,
"spherical_expansion_reference.ubjson"),
"wb",
) as f:
ubjson.dump(data, f)
def dump_reference_json():
import ubjson
import os
from copy import copy
sys.path.insert(0, os.path.join(root, 'build/'))
sys.path.insert(0, os.path.join(root, 'tests/'))
cutoffs = [3.5]
gaussian_sigmas = [0.5]
max_radials = [6]
max_angulars = [6]
soap_types = ["RadialSpectrum", "PowerSpectrum"]
fn = os.path.join(inputs_path, "small_molecules-20.json")
fn_to_write = os.path.join(
'reference_data', "inputs", "small_molecules-20.json")
start = 0
length = 5
representations = ['spherical_invariants']
kernel_names = ['Cosine']
target_types = ['Structure', 'Atom']
dependant_args = dict(Cosine=[dict(zeta=1), dict(zeta=2), dict(zeta=4)])
data = dict(filename=fn_to_write,
start=start,
length=length,
cutoffs=cutoffs,
gaussian_sigmas=gaussian_sigmas,
max_radials=max_radials,
soap_types=soap_types,
kernel_names=kernel_names,
target_types=target_types,
dependant_args=dependant_args,
rep_info=dict(spherical_invariants=[]))
frames = read(fn, '{}:{}'.format(start, start + length))
for representation_name in representations:
for cutoff in cutoffs:
print(fn, cutoff)
data['rep_info'][representation_name].append([])
for kernel_name in kernel_names:
for target_type in target_types:
for kwargs in dependant_args[kernel_name]:
for soap_type in soap_types:
for gaussian_sigma in gaussian_sigmas:
for max_radial in max_radials:
for max_angular in max_angulars:
if 'RadialSpectrum' == soap_type:
max_angular = 0
hypers = {"interaction_cutoff": cutoff,
"cutoff_smooth_width": 0.5,
"max_radial": max_radial,
"max_angular": max_angular,
"gaussian_sigma_type": "Constant",
"gaussian_sigma_constant": gaussian_sigma,
"soap_type": soap_type,
"cutoff_function_type": "ShiftedCosine",
"normalize": True,
"radial_basis": "GTO"}
soap = SphericalInvariants(**hypers)
soap_vectors = soap.transform(frames)
hypers_kernel = dict(name=kernel_name,
target_type=target_type)
hypers_kernel.update(**kwargs)
kernel = Kernel(soap, **hypers_kernel)
kk = kernel(soap_vectors)
# x = get_spectrum(hypers, frames)
for aa in soap.nl_options:
aa['initialization_arguments'] = aa['args']
data['rep_info'][representation_name][-1].append(dict(kernel_matrix=kk.tolist(),
hypers_rep=copy(
soap.hypers),
hypers_manager=copy(
soap.nl_options),
hypers_kernel=copy(hypers_kernel)))
with open(os.path.join(root, dump_path,
"kernel_reference.ubjson"), 'wb') as f:
ubjson.dump(data, f)
