def test_loaders(self):
dat = shgpy.load_data(self.filenames_dict, 'degrees')
self.assertIsInstance(dat, shgpy.DataContainer)
dat = shgpy.load_data_and_dark_subtract(
self.filenames_dict,
'degrees',
self.filenames_dict,
'degrees',
)
self.assertIsInstance(dat, shgpy.DataContainer)
self.assertEqual(dat.get_maxval()[1], 0)
dat, fdat = shgpy.load_data_and_fourier_transform(
self.filenames_dict,
'degrees',
)
self.assertNotEqual(fdat.get_maxval()[1], 0)
dat, fdat = shgpy.load_data_and_fourier_transform(
self.filenames_dict,
'degrees',
self.filenames_dict,
'degrees',
)
self.assertEqual(fdat.get_maxval()[1], 0)
def test_convert(self):
fform_filename = 'tests/fform/T_d-S_2-S_2(110).p'
fform = shgpy.load_fform(fform_filename)
data_filenames_dict = {
'PP': 'tests/Data/dataPP.csv',
'PS': 'tests/Data/dataPS.csv',
'SP': 'tests/Data/dataSP.csv',
'SS': 'tests/Data/dataSS.csv',
}
dat, fdat = shgpy.load_data_and_fourier_transform(
data_filenames_dict,
'degrees',
)
form = shgpy.fform_to_form(fform)
t1 = shgpy.dat_to_fdat(dat)
self.assertIsInstance(t1, type(fdat))
t2 = shgpy.fdat_to_dat(fdat, 1000)
self.assertIsInstance(t2, type(dat))
t3 = shgpy.form_to_dat(
form,
self.random_subs_dict(fform.get_free_symbols()),
1000,
)
self.assertIsInstance(t3, type(dat))
t4 = shgpy.form_to_fform(form)
self.assertIsInstance(t4, type(fform))
t5 = shgpy.form_to_fdat(
form,
self.random_subs_dict(fform.get_free_symbols()),
)
self.assertIsInstance(t5, type(fdat))
t6 = shgpy.fform_to_fdat(
fform,
self.random_subs_dict(fform.get_free_symbols()),
)
self.assertIsInstance(t6, type(fdat))
t7 = shgpy.fform_to_dat(
fform,
self.random_subs_dict(fform.get_free_symbols()),
1000,
)
self.assertIsInstance(t7, type(dat))
t8 = shgpy.fform_to_form(fform)
self.assertIsInstance(t8, type(form))
def test_normal_loading(self):
data_filenames_dict = {
'PP': 'tests/Data/dataPP.csv',
'SP': 'tests/Data/dataPS.csv',
}
dat = shgpy.load_data(data_filenames_dict, 'degrees')
if MANUAL:
easy_plot(
[dat],
[
{
'linestyle': '-',
'marker': 'o',
'markerfacecolor': 'none',
'color': 'blue'
},
],
dat.get_keys(),
)
dat, fdat = shgpy.load_data_and_fourier_transform(
data_filenames_dict,
'degrees',
)
import numpy as np
import logging
import shgpy
import shgpy.shg_symbols as S
from shgpy.plotter import easy_plot
from shgpy.fformfit import least_squares_fit_with_bounds
mylogger = logging.getLogger(__name__)
logging.basicConfig(level=logging.DEBUG)
data_filenames_dict = {
'PP':'Data/dataPP.csv',
'PS':'Data/dataPS.csv',
}
dat, fdat = shgpy.load_data_and_fourier_transform(data_filenames_dict, 'degrees')
fform_filename = 'fform/T_d-S_2-S_2(110)-particularized.p'
fform = shgpy.load_fform(fform_filename)
fform.apply_phase_shift(S.psi)
iterable = {}
for k,v in fform.get_items():
if k in ['PP', 'PS']:
iterable[k] = v
fform = shgpy.fFormContainer(iterable)
guess_dict = {}
for fs in fform.get_free_symbols():
guess_dict[fs] = 1
class TestFit(unittest.TestCase):
fform_filename = 'tests/fform/T_d-S_2-S_2(110)-particularized.p'
fform = shgpy.load_fform(fform_filename)
data_filenames_dict = {
'PP': 'tests/Data/dataPP.csv',
'PS': 'tests/Data/dataPS.csv',
'SP': 'tests/Data/dataSP.csv',
'SS': 'tests/Data/dataSS.csv',
}
dat, fdat = shgpy.load_data_and_fourier_transform(
data_filenames_dict,
'degrees',
)
fform.apply_phase_shift(S.psi)
guess_dict = {k: 1 for k in fform.get_free_symbols()}
bounds_dict = {
k: ((-2, 2) if k != S.psi else (-np.pi, np.pi))
for k in fform.get_free_symbols()
}
free_symbols = fform.get_free_symbols()
def test_minimal(self):
shgpy.fformfit._make_energy_func_wrapper(
self.fform,
self.fdat,
self.free_symbols,
False,
'tests/Data/myfilename.so',
)
shgpy.fformfit._load_func('tests/Data/myfilename.so')
shgpy.fformfit._make_energy_func_wrapper(
self.fform,
self.fdat,
self.free_symbols,
False,
'tests/Data/myfilename.so',
)
shgpy.fformfit._load_func('tests/Data/myfilename.so')
def test_least_squares(self):
ret1 = least_squares_fit(self.fform, self.fdat, self.guess_dict)
ret2 = least_squares_fit_with_bounds(
self.fform,
self.fdat,
self.guess_dict,
self.bounds_dict,
)
for ret in [ret1, ret2]:
self.assertAlmostEqual(abs(ret.xdict[S.psi]), 1.59, delta=0.1)
self.assertAlmostEqual(
abs(ret.xdict[shgpy.map_to_real(S.zyx)]),
1.23,
delta=0.1,
)
fit_dat = shgpy.fform_to_dat(self.fform, ret1.xdict, 1000)
if MANUAL:
easy_plot(
[self.dat, fit_dat],
[
{
'linestyle': ' ',
'markerfacecolor': 'none',
'color': 'blue',
'marker': 'o',
},
{
'linestyle': '-',
'color': 'blue',
},
],
['PP', 'PS', 'SP', 'SS'],
show_plot=True,
filename=None,
show_legend=False,
)
easy_polar_plot(
[self.dat, fit_dat],
[
{
'linestyle': ' ',
'markerfacecolor': 'none',
'color': 'blue',
'marker': 'o'
},
{
'linestyle': '-',
'color': 'blue',
},
],
['PP', 'PS', 'SP', 'SS'],
show_plot=True,
filename=None,
show_legend=False,
)
def test_basinhopping(self):
niter = 100
ret1 = basinhopping_fit(
self.fform,
self.fdat,
self.guess_dict,
niter,
)
ret2 = basinhopping_fit_jac(
self.fform,
self.fdat,
self.guess_dict,
niter,
)
ret3 = basinhopping_fit_with_bounds(
self.fform,
self.fdat,
self.guess_dict,
self.bounds_dict,
niter,
)
ret4 = basinhopping_fit_jac_with_bounds(
self.fform,
self.fdat,
self.guess_dict,
self.bounds_dict,
niter,
)
for ret in [ret1, ret2, ret3, ret4]:
self.assertAlmostEqual(abs(ret.xdict[S.psi]), 1.59, delta=0.1)
self.assertAlmostEqual(
abs(ret.xdict[shgpy.map_to_real(S.zyx)]),
1.23,
delta=0.1,
)
def test_annealing(self):
maxiter = 100
ret1 = dual_annealing_fit_with_bounds(
self.fform,
self.fdat,
self.guess_dict,
self.bounds_dict,
maxiter,
)
for ret in [ret1]:
self.assertAlmostEqual(abs(ret.xdict[S.psi]), 1.59, delta=0.1)
self.assertAlmostEqual(
abs(ret.xdict[shgpy.map_to_real(S.zyx)]),
1.23,
delta=0.1,
)
def test_save(self):
ret1 = dual_annealing_fit_with_bounds(
self.fform,
self.fdat,
self.guess_dict,
self.bounds_dict,
maxiter=100,
save_cost_func_filename='tests/Data/costfunc.so',
)
ret2 = dual_annealing_fit_with_bounds(
self.fform,
self.fdat,
self.guess_dict,
self.bounds_dict,
maxiter=100,
load_cost_func_filename='tests/Data/costfunc.so',
)
ret3 = basinhopping_fit_jac_with_bounds(
self.fform,
self.fdat,
self.guess_dict,
self.bounds_dict,
100,
save_cost_func_filename='tests/Data/costfunc.so',
grad_save_cost_func_filename_prefix='tests/Data/grad_costfunc',
)
ret4 = basinhopping_fit_jac_with_bounds(
self.fform,
self.fdat,
self.guess_dict,
self.bounds_dict,
100,
load_cost_func_filename='tests/Data/costfunc.so',
load_grad_cost_func_filename_prefix='tests/Data/grad_costfunc',
)
ret5 = basinhopping_fit_with_bounds(
self.fform,
self.fdat,
self.guess_dict,
self.bounds_dict,
100,
save_cost_func_filename='tests/Data/costfunc.so',
chunk_cost_func=True,
)
ret6 = basinhopping_fit_with_bounds(
self.fform,
self.fdat,
self.guess_dict,
self.bounds_dict,
100,
load_cost_func_filename='tests/Data/costfunc.so',
chunk_cost_func=True,
)
gen_cost_func(
self.fform,
self.fdat,
save_filename='tests/Data/generated_costfunc.so',
)
ret7 = dual_annealing_fit_with_bounds(
self.fform,
self.fdat,
self.guess_dict,
self.bounds_dict,
maxiter=100,
load_cost_func_filename='tests/Data/generated_costfunc.so',
)
for ret in [ret1, ret2, ret3, ret4, ret5, ret6, ret7]:
self.assertAlmostEqual(abs(ret.xdict[S.psi]), 1.59, delta=0.1)
self.assertAlmostEqual(
abs(ret.xdict[shgpy.map_to_real(S.zyx)]),
1.23,
delta=0.1,
)