class TestGuinierHayterM(unittest.TestCase):
"""
Unit tests for GuinierModel(Q) * HayterMSAStructure(Q)
"""
def setUp(self):
from sas.models.GuinierModel import GuinierModel
from sas.models.HayterMSAStructure import HayterMSAStructure
from sas.models.MultiplicationModel import MultiplicationModel
self.model = GuinierModel()
self.model2 = HayterMSAStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
#Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
def test_multplication_radius(self):
"""
test multiplication model (check the effective radius & the output
of the multiplication)
"""
self.model.setParam("rg", 60)
self.model.setParam("scale", 1)
#Compare new method with old method
self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
#effective radius calculation is not implemented for this model.
self.assertEqual(self.model3.calculate_ER(), NotImplemented)
class TestGuinierHayterM(unittest.TestCase):
"""
Unit tests for GuinierModel(Q) * HayterMSAStructure(Q)
"""
def setUp(self):
from sas.models.GuinierModel import GuinierModel
from sas.models.HayterMSAStructure import HayterMSAStructure
from sas.models.MultiplicationModel import MultiplicationModel
self.model = GuinierModel()
self.model2 = HayterMSAStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
#Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
def test_multplication_radius(self):
"""
test multiplication model (check the effective radius & the output
of the multiplication)
"""
self.model.setParam("rg", 60)
self.model.setParam("scale", 1)
#Compare new method with old method
self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
#effective radius calculation is not implemented for this model.
self.assertEqual(self.model3.calculate_ER(), NotImplemented)
def setUp(self):
from sas.models.LamellarModel import LamellarModel
from sas.models.HayterMSAStructure import HayterMSAStructure
from sas.models.MultiplicationModel import MultiplicationModel
self.model = LamellarModel()
self.model2 = HayterMSAStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
def setUp(self):
from sas.models.SphereModel import SphereModel
from sas.models.HardsphereStructure import HardsphereStructure
from sas.models.DiamCylFunc import DiamCylFunc
from sas.models.MultiplicationModel import MultiplicationModel
self.model = SphereModel()
self.model2 = HardsphereStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
self.modelD = DiamCylFunc()
def setUp(self):
from sas.models.CylinderModel import CylinderModel
from sas.models.HayterMSAStructure import HayterMSAStructure
from sas.models.DiamCylFunc import DiamCylFunc
from sas.models.MultiplicationModel import MultiplicationModel
self.model = CylinderModel()
self.model2 = HayterMSAStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
self.modelD = DiamCylFunc()
def setUp(self):
from sas.models.LamellarModel import LamellarModel
from sas.models.HayterMSAStructure import HayterMSAStructure
from sas.models.MultiplicationModel import MultiplicationModel
self.model = LamellarModel()
self.model2 = HayterMSAStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
def setUp(self):
from sas.models.SphereModel import SphereModel
from sas.models.HardsphereStructure import HardsphereStructure
from sas.models.DiamCylFunc import DiamCylFunc
from sas.models.MultiplicationModel import MultiplicationModel
self.model = SphereModel()
self.model2 = HardsphereStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
self.modelD = DiamCylFunc()
def setUp(self):
from sas.models.CylinderModel import CylinderModel
from sas.models.HayterMSAStructure import HayterMSAStructure
from sas.models.DiamCylFunc import DiamCylFunc
from sas.models.MultiplicationModel import MultiplicationModel
self.model = CylinderModel()
self.model2 = HayterMSAStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
self.modelD = DiamCylFunc()
def _on_model(self, evt):
"""
React to a model menu event
:param event: wx menu event
"""
if int(evt.GetId()) in self.form_factor_dict.keys():
from sas.models.MultiplicationModel import MultiplicationModel
self.model_dictionary[MultiplicationModel.__name__] = MultiplicationModel
model1, model2 = self.form_factor_dict[int(evt.GetId())]
model = MultiplicationModel(model1, model2)
else:
model = self.struct_factor_dict[str(evt.GetId())]()
class TestLamellarHayterM(unittest.TestCase):
"""
Unit tests for LamellarModel(Q) * HayterMSAStructure(Q)
"""
def setUp(self):
from sas.models.LamellarModel import LamellarModel
from sas.models.HayterMSAStructure import HayterMSAStructure
from sas.models.MultiplicationModel import MultiplicationModel
self.model = LamellarModel()
self.model2 = HayterMSAStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
#Radius of model1.calculate_ER should Not be finite.
def test_multplication_radius(self):
"""
test multiplication model (check the effective radius & the output
of the multiplication)
"""
#Check run
self.assertFalse(numpy.isfinite(self.model3.run(0.1)))
#check effective radius .
self.assertTrue(numpy.isfinite(self.model.calculate_ER()))
class TestLamellarHayterM(unittest.TestCase):
"""
Unit tests for LamellarModel(Q) * HayterMSAStructure(Q)
"""
def setUp(self):
from sas.models.LamellarModel import LamellarModel
from sas.models.HayterMSAStructure import HayterMSAStructure
from sas.models.MultiplicationModel import MultiplicationModel
self.model = LamellarModel()
self.model2 = HayterMSAStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
#Radius of model1.calculate_ER should Not be finite.
def test_multplication_radius(self):
"""
test multiplication model (check the effective radius & the output
of the multiplication)
"""
#Check run
self.assertFalse(numpy.isfinite(self.model3.run(0.1)))
#check effective radius .
self.assertTrue(numpy.isfinite(self.model.calculate_ER()))
def eval_sasview(model_info, data):
# type: (Modelinfo, Data) -> Calculator
"""
Return a model calculator using the pre-4.0 SasView models.
"""
# importing sas here so that the error message will be that sas failed to
# import rather than the more obscure smear_selection not imported error
import sas
import sas.models
from sas.models.qsmearing import smear_selection
from sas.models.MultiplicationModel import MultiplicationModel
from sas.models.dispersion_models import models as dispersers
def get_model_class(name):
# type: (str) -> "sas.models.BaseComponent"
#print("new",sorted(_pars.items()))
__import__('sas.models.' + name)
ModelClass = getattr(getattr(sas.models, name, None), name, None)
if ModelClass is None:
raise ValueError("could not find model %r in sas.models" % name)
return ModelClass
# WARNING: ugly hack when handling model!
# Sasview models with multiplicity need to be created with the target
# multiplicity, so we cannot create the target model ahead of time for
# for multiplicity models. Instead we store the model in a list and
# update the first element of that list with the new multiplicity model
# every time we evaluate.
# grab the sasview model, or create it if it is a product model
if model_info.composition:
composition_type, parts = model_info.composition
if composition_type == 'product':
P, S = [get_model_class(revert_name(p))() for p in parts]
model = [MultiplicationModel(P, S)]
else:
raise ValueError("sasview mixture models not supported by compare")
else:
old_name = revert_name(model_info)
if old_name is None:
raise ValueError("model %r does not exist in old sasview" %
model_info.id)
ModelClass = get_model_class(old_name)
model = [ModelClass()]
model[0].disperser_handles = {}
# build a smearer with which to call the model, if necessary
smearer = smear_selection(data, model=model)
if hasattr(data, 'qx_data'):
q = np.sqrt(data.qx_data**2 + data.qy_data**2)
index = ((~data.mask) & (~np.isnan(data.data))
& (q >= data.qmin) & (q <= data.qmax))
if smearer is not None:
smearer.model = model # because smear_selection has a bug
smearer.accuracy = data.accuracy
smearer.set_index(index)
def _call_smearer():
smearer.model = model[0]
return smearer.get_value()
theory = _call_smearer
else:
theory = lambda: model[0].evalDistribution(
[data.qx_data[index], data.qy_data[index]])
elif smearer is not None:
theory = lambda: smearer(model[0].evalDistribution(data.x))
else:
theory = lambda: model[0].evalDistribution(data.x)
def calculator(**pars):
# type: (float, ...) -> np.ndarray
"""
Sasview calculator for model.
"""
oldpars = revert_pars(model_info, pars)
# For multiplicity models, create a model with the correct multiplicity
control = oldpars.pop("CONTROL", None)
if control is not None:
# sphericalSLD has one fewer multiplicity. This update should
# happen in revert_pars, but it hasn't been called yet.
model[0] = ModelClass(control)
# paying for parameter conversion each time to keep life simple, if not fast
for k, v in oldpars.items():
if k.endswith('.type'):
par = k[:-5]
if v == 'gaussian': continue
cls = dispersers[v if v != 'rectangle' else 'rectangula']
handle = cls()
model[0].disperser_handles[par] = handle
try:
model[0].set_dispersion(par, handle)
except Exception:
exception.annotate_exception("while setting %s to %r" %
(par, v))
raise
#print("sasview pars",oldpars)
for k, v in oldpars.items():
name_attr = k.split('.') # polydispersity components
if len(name_attr) == 2:
par, disp_par = name_attr
model[0].dispersion[par][disp_par] = v
else:
model[0].setParam(k, v)
return theory()
calculator.engine = "sasview"
return calculator
def test_cyl_times_square(self):
""" Simple cylinder model fit """
out=Loader().load("cyl_400_20.txt")
data = Data1D(x=out.x, y=out.y, dx=out.dx, dy=out.dy)
# Receives the type of model for the fitting
model1 = MultiplicationModel(CylinderModel(),SquareWellStructure())
model1.setParam('background', 0.0)
model1.setParam('sldCyl', 3e-006)
model1.setParam('sldSolv', 0.0)
model1.setParam('length', 420)
model1.setParam('radius', 40)
model1.setParam('scale_factor', 2)
model1.setParam('volfraction', 0.04)
model1.setParam('welldepth', 1.5)
model1.setParam('wellwidth', 1.2)
model = Model(model1)
pars1 =['length','radius','scale_factor']
fitter = Fit()
fitter.set_data(data,1)
fitter.set_model(model,1,pars1)
fitter.select_problem_for_fit(id=1,value=1)
result1, = fitter.fit()
self.assert_(result1)
self.assertTrue(len(result1.pvec)>=0 )
self.assertTrue(len(result1.stderr)>= 0)
#print "results",list(zip(result1.pvec, result1.stderr))
self.assertTrue( math.fabs(result1.pvec[0]-612)/3.0 <= result1.stderr[0] )
self.assertTrue( math.fabs(result1.pvec[1]-20.3)/3.0 <= result1.stderr[1] )
self.assertTrue( math.fabs(result1.pvec[2]-25)/3.0 <= result1.stderr[2] )
self.assertTrue( result1.fitness/len(data.x) < 1.0 )
def eval_sasview(model_info, data):
"""
Return a model calculator using the pre-4.0 SasView models.
"""
# importing sas here so that the error message will be that sas failed to
# import rather than the more obscure smear_selection not imported error
import sas
from sas.models.qsmearing import smear_selection
def get_model(name):
#print("new",sorted(_pars.items()))
sas = __import__('sas.models.' + name)
ModelClass = getattr(getattr(sas.models, name, None), name, None)
if ModelClass is None:
raise ValueError("could not find model %r in sas.models" % name)
return ModelClass()
# grab the sasview model, or create it if it is a product model
if model_info['composition']:
composition_type, parts = model_info['composition']
if composition_type == 'product':
from sas.models.MultiplicationModel import MultiplicationModel
P, S = [get_model(revert_name(p)) for p in parts]
model = MultiplicationModel(P, S)
else:
raise ValueError("sasview mixture models not supported by compare")
else:
model = get_model(revert_name(model_info))
# build a smearer with which to call the model, if necessary
smearer = smear_selection(data, model=model)
if hasattr(data, 'qx_data'):
q = np.sqrt(data.qx_data**2 + data.qy_data**2)
index = ((~data.mask) & (~np.isnan(data.data))
& (q >= data.qmin) & (q <= data.qmax))
if smearer is not None:
smearer.model = model # because smear_selection has a bug
smearer.accuracy = data.accuracy
smearer.set_index(index)
theory = lambda: smearer.get_value()
else:
theory = lambda: model.evalDistribution(
[data.qx_data[index], data.qy_data[index]])
elif smearer is not None:
theory = lambda: smearer(model.evalDistribution(data.x))
else:
theory = lambda: model.evalDistribution(data.x)
def calculator(**pars):
"""
Sasview calculator for model.
"""
# paying for parameter conversion each time to keep life simple, if not fast
pars = revert_pars(model_info, pars)
for k, v in pars.items():
parts = k.split('.') # polydispersity components
if len(parts) == 2:
model.dispersion[parts[0]][parts[1]] = v
else:
model.setParam(k, v)
return theory()
calculator.engine = "sasview"
return calculator
class TestsphereHardS(unittest.TestCase):
"""
Unit tests for SphereModel(Q) * HardsphereStructure(Q)
"""
def setUp(self):
from sas.models.SphereModel import SphereModel
from sas.models.HardsphereStructure import HardsphereStructure
from sas.models.DiamCylFunc import DiamCylFunc
from sas.models.MultiplicationModel import MultiplicationModel
self.model = SphereModel()
self.model2 = HardsphereStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
self.modelD = DiamCylFunc()
#Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
def test_multplication_radius(self):
"""
test multiplication model (check the effective radius & the output
of the multiplication)
"""
self.model.setParam("radius", 60)
modelDrun = 60
self.model2.setParam("volfraction", 0.2)
self.model2.setParam("effect_radius", modelDrun )
#Compare new method with old method
self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
#Compare radius from two different calculations. Note: modelD.run(0.0) is DIAMETER
self.assertEqual(self.model.calculate_ER(), modelDrun)
def testMultiplicationParam(self):
""" Test Multiplication (check the parameters)"""
## test details dictionary
## test parameters list
list3= self.model3.getParamList()
for item in self.model.getParamList():
if not 'scale' in item:
self.assert_(item in list3)
for item in self.model2.getParamList():
#model3 parameters should not include effect_radius*
if not 'effect_radius' in item:
self.assert_(item in list3)
## test set value for parameters and get paramaters
self.model3.setParam("scale_factor", 15)
self.assertEqual(self.model3.getParam("scale_factor"), 15)
self.model3.setParam("radius", 20)
self.assertEqual(self.model3.getParam("radius"), 20)
self.model3.setParam("radius.width", 15)
self.assertEqual(self.model3.getParam("radius.width"), 15)
self.model3.setParam("scale_factor", 15)
self.assertEqual(self.model3.getParam("scale_factor"), 15)
self.assertEqual(self.model3.getParam("volfraction"), self.model.getParam("scale"))
## Dispersity
list3= self.model3.getDispParamList()
self.assertEqual(list3, ['radius.npts', 'radius.nsigmas', 'radius.width'])
from sas.models.dispersion_models import ArrayDispersion
disp_th = ArrayDispersion()
values_th = numpy.zeros(100)
weights = numpy.zeros(100)
for i in range(100):
values_th[i]=(math.pi/99.0*i)
weights[i]=(1.0)
disp_th.set_weights(values_th, weights)
self.model3.set_dispersion('radius', disp_th)
val_1d = self.model3.run(math.sqrt(0.0002))
val_2d = self.model3.runXY([0.01,0.01])
self.assertTrue(math.fabs(val_1d-val_2d)/val_1d < 0.02)
model4= self.model3.clone()
self.assertEqual(model4.getParam("radius"), 20)
class TestsphereHardS(unittest.TestCase):
"""
Unit tests for SphereModel(Q) * HardsphereStructure(Q)
"""
def setUp(self):
from sas.models.SphereModel import SphereModel
from sas.models.HardsphereStructure import HardsphereStructure
from sas.models.DiamCylFunc import DiamCylFunc
from sas.models.MultiplicationModel import MultiplicationModel
self.model = SphereModel()
self.model2 = HardsphereStructure()
self.model3 = MultiplicationModel(self.model, self.model2)
self.modelD = DiamCylFunc()
#Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
def test_multplication_radius(self):
"""
test multiplication model (check the effective radius & the output
of the multiplication)
"""
self.model.setParam("radius", 60)
modelDrun = 60
self.model2.setParam("volfraction", 0.2)
self.model2.setParam("effect_radius", modelDrun )
#Compare new method with old method
self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
#Compare radius from two different calculations. Note: modelD.run(0.0) is DIAMETER
self.assertEqual(self.model.calculate_ER(), modelDrun)
def testMultiplicationParam(self):
""" Test Multiplication (check the parameters)"""
## test details dictionary
## test parameters list
list3= self.model3.getParamList()
for item in self.model.getParamList():
if not 'scale' in item:
self.assert_(item in list3)
for item in self.model2.getParamList():
#model3 parameters should not include effect_radius*
if not 'effect_radius' in item:
self.assert_(item in list3)
## test set value for parameters and get paramaters
self.model3.setParam("scale_factor", 15)
self.assertEqual(self.model3.getParam("scale_factor"), 15)
self.model3.setParam("radius", 20)
self.assertEqual(self.model3.getParam("radius"), 20)
self.model3.setParam("radius.width", 15)
self.assertEqual(self.model3.getParam("radius.width"), 15)
self.model3.setParam("scale_factor", 15)
self.assertEqual(self.model3.getParam("scale_factor"), 15)
self.assertEqual(self.model3.getParam("volfraction"), self.model.getParam("scale"))
## Dispersity
list3= self.model3.getDispParamList()
self.assertEqual(list3, ['radius.npts', 'radius.nsigmas', 'radius.width'])
from sas.models.dispersion_models import ArrayDispersion
disp_th = ArrayDispersion()
values_th = numpy.zeros(100)
weights = numpy.zeros(100)
for i in range(100):
values_th[i]=(math.pi/99.0*i)
weights[i]=(1.0)
disp_th.set_weights(values_th, weights)
self.model3.set_dispersion('radius', disp_th)
val_1d = self.model3.run(math.sqrt(0.0002))
val_2d = self.model3.runXY([0.01,0.01])
self.assertTrue(math.fabs(val_1d-val_2d)/val_1d < 0.02)
model4= self.model3.clone()
self.assertEqual(model4.getParam("radius"), 20)