def setUp(self):
""" initialize data"""
self.data1=Loader().load("cyl_400_20.txt")
self.data2=Loader().load("cyl_400_40.txt")
# Receives the type of model for the fitting
from sas.models.CylinderModel import CylinderModel
cyl1 = CylinderModel()
cyl1.name = "C1"
self.model1 = Model(cyl1)
self.model1.set(scale= 1.0)
self.model1.set(radius=18)
self.model1.set(length=200)
self.model1.set(sldCyl=3e-006, sldSolv=0.0)
self.model1.set(background=0.0)
cyl2 = CylinderModel()
cyl2.name = "C2"
self.model2 = Model(cyl2)
self.model2.set(scale= 1.0)
self.model2.set(radius=37)
self.model2.set(length=300)
self.model2.set(sldCyl=3e-006, sldSolv=0.0)
self.model2.set(background=0.0)
def setUp(self):
# NIST sample data
self.data = Loader().load("CMSphere5.txt")
# NIST smeared sphere w/ param values below
self.answer = Loader().load("CMSphere5smearsphere.txt")
# call spheremodel
self.model = SphereModel()
# setparams consistent with Igor default
self.model.setParam('scale', 1.0)
self.model.setParam('background', 0.01)
self.model.setParam('radius', 60.0)
self.model.setParam('sldSolv', 6.3e-06)
self.model.setParam('sldSph', 1.0e-06)
def _reset_helper(self, path=None, npts=NPTS):
"""
Set value to fitter and prepare inputs for map function
"""
for i in range(npts):
data = Loader().load(path)
fitter = Fit()
#create model
model = CylinderModel()
model.setParam('scale', 1.0)
model.setParam('radius', 20.0)
model.setParam('length', 400.0)
model.setParam('sldCyl', 4e-006)
model.setParam('sldSolv', 1e-006)
model.setParam('background', 0.0)
for param in model.dispersion.keys():
model.set_dispersion(param, self.polydisp['gaussian']())
model.setParam('cyl_phi.width', 10)
model.setParam('cyl_phi.npts', 3)
model.setParam('cyl_theta.nsigmas', 10)
# for 2 data cyl_theta = 60.0 [deg] cyl_phi= 60.0 [deg]
fitter.set_model(model, i, self.param_to_fit,
self.list_of_constraints)
#smear data
current_smearer = smear_selection(data, model)
import cPickle
p = cPickle.dumps(current_smearer)
sm = cPickle.loads(p)
fitter.set_data(data=data, id=i,
smearer=current_smearer, qmin=self.qmin, qmax=self.qmax)
fitter.select_problem_for_fit(id=i, value=1)
self.list_of_fitter.append(copy.deepcopy(fitter))
self.list_of_function.append('fit')
self.list_of_mapper.append(classMapper)
def fit_single(self, fitter_name, isdream=False):
fitter = Fit(fitter_name)
data = Loader().load("testdata_line.txt")
data.name = data.filename
fitter.set_data(data, 1)
# Receives the type of model for the fitting
model1 = LineModel()
model1.name = "M1"
model = Model(model1, data)
pars1 = ['A', 'B']
fitter.set_model(model, 1, pars1)
fitter.select_problem_for_fit(id=1, value=1)
result1, = fitter.fit(handler=FitHandler())
# The target values were generated from the following statements
p, s, fx = result1.pvec, result1.stderr, result1.fitness
#print "p0,p1,s0,s1,fx = %g, %g, %g, %g, %g"%(p[0],p[1],s[0],s[1],fx)
p0, p1, s0, s1, fx_ = 3.68353, 2.61004, 0.336186, 0.105244, 1.20189
if isdream:
# Dream is not a minimizer: just check that the fit is within
# uncertainty
self.assertTrue(abs(p[0] - p0) <= s0)
self.assertTrue(abs(p[1] - p1) <= s1)
else:
self.assertTrue(abs(p[0] - p0) <= 1e-5)
self.assertTrue(abs(p[1] - p1) <= 1e-5)
self.assertTrue(abs(fx - fx_) <= 1e-5)
def find_extension():
"""
Describe the extensions that can be read by the current application
"""
try:
list = []
EXCEPTION_LIST = ['*', '.', '']
from sas.dataloader.loader import Loader
wild_cards = Loader().get_wildcards()
for item in wild_cards:
#['All (*.*)|*.*']
file_type, ext = string.split(item, "|*.", 1)
if ext.strip() not in EXCEPTION_LIST and ext.strip() not in list:
list.append(ext)
except:
pass
try:
file_type, ext = string.split(local_config.APPLICATION_WLIST, "|*.", 1)
if ext.strip() not in EXCEPTION_LIST and ext.strip() not in list:
list.append(ext)
except:
pass
try:
for item in local_config.PLUGINS_WLIST:
file_type, ext = string.split(item, "|*.", 1)
if ext.strip() not in EXCEPTION_LIST and ext.strip() not in list:
list.append(ext)
except:
pass
return list
def test2(self):
""" fit 2 data and 2 model with no constrainst"""
#load data
l = Loader()
data1 = l.load("testdata_line.txt")
data1.name = data1.filename
data2 = l.load("testdata_line1.txt")
data2.name = data2.filename
#Importing the Fit module
fitter = Fit('bumps')
# Receives the type of model for the fitting
model11 = LineModel()
model11.name = "M1"
model22 = LineModel()
model11.name = "M2"
model1 = Model(model11, data1)
model2 = Model(model22, data2)
pars1 = ['A', 'B']
fitter.set_data(data1, 1)
fitter.set_model(model1, 1, pars1)
fitter.select_problem_for_fit(id=1, value=0)
fitter.set_data(data2, 2)
fitter.set_model(model2, 2, pars1)
fitter.select_problem_for_fit(id=2, value=0)
try:
result1, = fitter.fit(handler=FitHandler())
except RuntimeError, msg:
assert str(msg) == "Nothing to fit"
def test_slits(self):
"""
Check slit data
"""
filename = "cansas1d_slit.xml"
data = Loader().load(filename)
self.data = data[0]
self.assertEqual(self.data.filename, filename)
self.assertEqual(self.data.run[0], "1234")
# Data
self.assertEqual(len(self.data.x), 2)
self.assertEqual(self.data.x_unit, '1/A')
self.assertEqual(self.data.y_unit, '1/cm')
self.assertEqual(self.data.x[0], 0.02)
self.assertEqual(self.data.y[0], 1000)
self.assertEqual(self.data.dxl[0], 0.005)
self.assertEqual(self.data.dxw[0], 0.001)
self.assertEqual(self.data.dy[0], 3)
self.assertEqual(self.data.x[1], 0.03)
self.assertAlmostEquals(self.data.y[1], 1001.0)
self.assertEqual(self.data.dx, None)
self.assertEqual(self.data.dxl[1], 0.005)
self.assertEqual(self.data.dxw[1], 0.001)
self.assertEqual(self.data.dy[1], 4)
self.assertEqual(self.data.run_name['1234'], 'run name')
self.assertEqual(self.data.title, "Test title")
def test_double_trans_spectra(self):
xmlreader = XMLreader(self.isis_1_1_doubletrans, self.schema_1_1)
self.assertTrue(xmlreader.validate_xml())
reader = Loader()
data = reader.load(self.isis_1_1_doubletrans)
for item in data:
self._check_data(item)
def test_sectorphi_full(self):
"""
Test sector averaging I(phi)
When considering the whole azimuthal range (2pi),
the answer should be the same as ring averaging.
The test data was not generated by IGOR.
"""
from sas.dataloader.manipulations import SectorPhi
import math
nbins = 19
phi_min = math.pi / (nbins + 1)
phi_max = math.pi * 2 - phi_min
r = SectorPhi(r_min=.005,
r_max=.01,
phi_min=phi_min,
phi_max=phi_max,
nbins=nbins)
o = r(self.data)
answer = Loader().load('ring_testdata.txt')
for i in range(len(o.x)):
self.assertAlmostEqual(o.x[i], answer.x[i], 4)
self.assertAlmostEqual(o.y[i], answer.y[i], 4)
self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
def get_panels(self, parent):
"""
Create and return the list of wx.Panels for your plug-in.
Define the plug-in perspective.
Panels should inherit from DefaultPanel defined below,
or should present the same interface. They must define
"window_caption" and "window_name".
:param parent: parent window
:return: list of panels
"""
# # Save a reference to the parent
self.parent = parent
self.frame = MDIFrame(self.parent, None, 'None', (100, 200))
self.invariant_panel = InvariantPanel(parent=self.frame)
self.frame.set_panel(self.invariant_panel)
self._frame_set_helper()
self.invariant_panel.set_manager(manager=self)
self.perspective.append(self.invariant_panel.window_name)
# Create reader when fitting panel are created
self.state_reader = reader(self.set_state)
# append that reader to list of available reader
loader = Loader()
loader.associate_file_reader(".inv", self.state_reader)
# loader.associate_file_reader(".svs", self.state_reader)
# Return the list of panels
return [self.invariant_panel]
def setUp(self):
"""
Set up the initial conditions before _each_ test
so that they all start from the same well-defined state.
"""
#Creating a loader
self.L=Loader()
def test_without_resolution(self):
""" Simple cylinder model fit """
out=Loader().load("cyl_400_20.txt")
# This data file has not error, add them
#out.dy = out.y
fitter = Fit()
fitter.set_data(out,1)
# Receives the type of model for the fitting
model1 = CylinderModel()
model1.setParam("scale", 1.0)
model1.setParam("radius",18)
model1.setParam("length", 397)
model1.setParam("sldCyl",3e-006 )
model1.setParam("sldSolv",0.0 )
model1.setParam("background", 0.0)
model = Model(model1)
pars1 =['length','radius','scale']
fitter.set_model(model,1,pars1)
# What the hell is this line for?
fitter.select_problem_for_fit(id=1,value=1)
result1, = fitter.fit()
#print "result1",result1
self.assert_(result1)
self.assertTrue(len(result1.pvec) > 0)
self.assertTrue(len(result1.stderr) > 0)
self.assertTrue( math.fabs(result1.pvec[0]-400.0)/3.0 < result1.stderr[0] )
self.assertTrue( math.fabs(result1.pvec[1]-20.0)/3.0 < result1.stderr[1] )
self.assertTrue( math.fabs(result1.pvec[2]-1)/3.0 < result1.stderr[2] )
self.assertTrue( result1.fitness < 1.0 )
def test4(self):
""" fit 2 data concatenates with limited range of x and one model """
#load data
l = Loader()
data1 = l.load("testdata_line.txt")
data1.name = data1.filename
data2 = l.load("testdata_line1.txt")
data2.name = data2.filename
# Receives the type of model for the fitting
model1 = LineModel()
model1.name = "M1"
model1.setParam("A", 1.0)
model1.setParam("B", 1.0)
model = Model(model1, data1)
pars1 = ['A', 'B']
#Importing the Fit module
fitter = Fit('bumps')
fitter.set_data(data1, 1, qmin=0, qmax=7)
fitter.set_model(model, 1, pars1)
fitter.set_data(data2, 1, qmin=1, qmax=10)
fitter.select_problem_for_fit(id=1, value=1)
result2, = fitter.fit(handler=FitHandler())
self.assert_(result2)
self.assertTrue(
math.fabs(result2.pvec[0] - 4) / 3 <= result2.stderr[0])
self.assertTrue(
math.fabs(result2.pvec[1] - 2.5) / 3 <= result2.stderr[1])
self.assertTrue(result2.fitness / len(data1.x) < 2)
def on_click_save(self, event):
"""
Save change into a file
"""
if not self._data:
return
self.on_change_run(event=None)
self.on_change_title(event=None)
path = None
wildcard = "CanSAS 1D files(*.xml)|*.xml"
dlg = wx.FileDialog(self, "Choose a file",
self._default_save_location, "", wildcard , wx.SAVE)
for data in self._data:
if issubclass(data.__class__, Data2D):
msg = "No conventional writing format for \n\n"
msg += "Data2D at this time.\n"
dlg = wx.MessageDialog(None, msg, 'Error Loading File',
wx.OK | wx.ICON_EXCLAMATION)
dlg.ShowModal()
else:
if dlg.ShowModal() == wx.ID_OK:
path = dlg.GetPath()
mypath = os.path.basename(path)
loader = Loader()
format = ".xml"
if os.path.splitext(mypath)[1].lower() == format:
loader.save(path, data, format)
try:
self._default_save_location = os.path.dirname(path)
except:
pass
dlg.Destroy()
event.Skip()
def test_cylinder_fit(self):
""" Simple cylinder model fit """
out = Loader().load("cyl_400_20.txt")
fitter = Fit('bumps')
# Receives the type of model for the fitting
from sas.models.CylinderModel import CylinderModel
model = CylinderModel()
model.setParam('sldCyl', 1)
model.setParam('sldSolv', 0)
model.setParam('scale', 1e-10)
pars1 = ['length', 'radius', 'scale']
fitter.set_data(out, 1)
fitter.set_model(model, 1, pars1, constraints=())
fitter.select_problem_for_fit(id=1, value=1)
result1, = fitter.fit()
#print result1
#print result1.__dict__
self.assert_(result1)
self.assertTrue(len(result1.pvec) > 0 or len(result1.pvec) == 0)
self.assertTrue(len(result1.stderr) > 0 or len(result1.stderr) == 0)
self.assertTrue(
math.fabs(result1.pvec[0] - 400.0) / 3.0 < result1.stderr[0])
self.assertTrue(
math.fabs(result1.pvec[1] - 20.0) / 3.0 < result1.stderr[1])
self.assertTrue(
math.fabs(result1.pvec[2] - 9.0e-12) / 3.0 < result1.stderr[2])
self.assertTrue(result1.fitness < 1.0)
def test_singleton(self):
"""
Testing whether Loader is truly a singleton
"""
# Create a 'new' Loader
b = Loader()
self.assertEqual(self.loader._get_registry_creation_time(),
b._get_registry_creation_time())
def test_units(self):
"""
Check units.
Note that not all units are available.
"""
filename = "cansas1d_units.xml"
data = Loader().load(filename)
self.data = data[0]
self.assertEqual(self.data.filename, filename)
self._checkdata()
def setUp(self):
data = Loader().load("latex_smeared.xml")
self.data_res = data[0]
self.data_slit = data[1]
self.sphere = SphereModel()
self.sphere.setParam('background', 0)
self.sphere.setParam('radius', 5000.0)
self.sphere.setParam('scale', 0.4)
self.sphere.setParam('sldSolv',0)
self.sphere.setParam('sldSph',1e-6)
def test_old_cansas_files(self):
reader1 = XMLreader(self.cansas1d, self.schema_1_0)
self.assertTrue(reader1.validate_xml())
file_loader = Loader()
file1 = file_loader.load(self.cansas1d)
reader2 = XMLreader(self.cansas1d_units, self.schema_1_0)
self.assertTrue(reader2.validate_xml())
reader3 = XMLreader(self.cansas1d_badunits, self.schema_1_0)
self.assertTrue(reader3.validate_xml())
reader4 = XMLreader(self.cansas1d_slit, self.schema_1_0)
self.assertTrue(reader4.validate_xml())
def __init__(self,
path,
completefn=None,
updatefn=None,
yieldtime=0.01,
worktime=0.01):
CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime)
self.path = path
#Instantiate a loader
self.loader = Loader()
self.starttime = 0
def test_writer(self):
from sas.dataloader.readers.cansas_reader import Reader
r = Reader()
x = numpy.ones(5)
y = numpy.ones(5)
dy = numpy.ones(5)
filename = "write_test.xml"
r.write(filename, self.data)
data = Loader().load(filename)
self.data = data[0]
self.assertEqual(self.data.filename, filename)
self._checkdata()
def setUp(self):
""" initialize data"""
self.data = Loader().load("cyl_400_20.txt")
# Create model that fitting engine understands
from sas.models.CylinderModel import CylinderModel
self.model = CylinderModel()
self.model.setParam("scale", 1.0)
self.model.setParam("radius",18)
self.model.setParam("length", 397)
self.model.setParam("sldCyl",3e-006 )
self.model.setParam("sldSolv",0.0 )
self.model.setParam("background", 0.0)
#select parameters to fit
self.pars1 =['length','radius','scale']
def setUp(self):
loader = Loader()
## IGOR/NIST computation
self.output_gauss = loader.load('Gausssphere.txt')
self.output_shulz = loader.load('Schulzsphere.txt')
from sas.models.SphereModel import SphereModel
self.model = SphereModel()
self.model.setParam('scale', 0.01)
self.model.setParam('radius', 60.0)
self.model.setParam('sldSph', 1.e-6)
self.model.setParam('sldSolv', 3.e-6)
self.model.setParam('background', 0.001)
def setUp(self):
self.loader = Loader()
self.xml_valid = "cansas_test_modified.xml"
self.xml_invalid = "cansas_test.xml"
self.cansas1d_badunits = "cansas1d_badunits.xml"
self.cansas1d = "cansas1d.xml"
self.cansas1d_slit = "cansas1d_slit.xml"
self.cansas1d_units = "cansas1d_units.xml"
self.isis_1_0 = "ISIS_1_0.xml"
self.isis_1_1 = "ISIS_1_1.xml"
self.isis_1_1_notrans = "ISIS_1_1_notrans.xml"
self.isis_1_1_doubletrans = "ISIS_1_1_doubletrans.xml"
self.schema_1_0 = "cansas1d_v1_0.xsd"
self.schema_1_1 = "cansas1d_v1_1.xsd"
def test_cansas_xml(self):
filename = "isis_1_1_write_test.xml"
xmlreader = XMLreader(self.isis_1_1, self.schema_1_1)
valid = xmlreader.validate_xml()
xmlreader.set_processing_instructions()
self.assertTrue(valid)
fo = open(self.isis_1_1)
str = fo.read()
reader_generic = Loader()
dataloader = reader_generic.load(self.isis_1_1)
reader_cansas = Reader()
cansasreader = reader_cansas.read(self.isis_1_1)
for i in range(len(dataloader)):
self._check_data(dataloader[i])
self._check_data_1_1(dataloader[i])
self._check_data(cansasreader[i])
self._check_data_1_1(cansasreader[i])
reader_generic.save(filename, dataloader[i], None)
fo = open(filename)
str = fo.read()
reader2 = Loader()
return_data = reader2.load(filename)
written_data = return_data[0]
self._check_data(written_data)
def setUp(self):
data = Loader().load("cansas1d_slit.xml")
self.data = data[0]
x = 0.001 * numpy.arange(1, 11)
y = 12.0 - numpy.arange(1, 11)
dxl = 0.00 * numpy.ones(10)
dxw = 0.00 * numpy.ones(10)
dx = 0.00 * numpy.ones(10)
self.data.dx = dx
self.data.x = x
self.data.y = y
self.data.dxl = dxl
self.data.dxw = dxw
def test_circularavg(self):
"""
Test circular averaging
The test data was not generated by IGOR.
"""
r = CircularAverage(r_min=.00, r_max=.025, bin_width=0.0003)
r.nbins_phi = 20
o = r(self.data)
answer = Loader().load('avg_testdata.txt')
for i in range(r.nbins_phi):
self.assertAlmostEqual(o.x[i], answer.x[i], 4)
self.assertAlmostEqual(o.y[i], answer.y[i], 4)
self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
def test_bad_pars(self):
fitter = Fit('bumps')
data = Loader().load("testdata_line.txt")
data.name = data.filename
fitter.set_data(data, 1)
model1 = LineModel()
model1.name = "M1"
model = Model(model1, data)
pars1 = ['param1', 'param2']
try:
fitter.set_model(model, 1, pars1)
except ValueError, exc:
#print "ValueError was correctly raised: "+str(msg)
assert str(exc).startswith('parameter param1')
def test_sectorq_full(self):
"""
Test sector averaging I(q)
The test data was not generated by IGOR.
"""
from sas.dataloader.manipulations import SectorQ
import math
r = SectorQ(r_min=.005, r_max=.01, phi_min=0, phi_max=math.pi / 2.0)
r.nbins_phi = 20
o = r(self.data)
answer = Loader().load('sectorq_testdata.txt')
for i in range(len(o.x)):
self.assertAlmostEqual(o.x[i], answer.x[i], 4)
self.assertAlmostEqual(o.y[i], answer.y[i], 4)
self.assertAlmostEqual(o.dy[i], answer.dy[i], 4)
def test_badunits(self):
"""
Check units.
Note that not all units are available.
"""
filename = "cansas1d_badunits.xml"
data = Loader().load(filename)
self.data = data[0]
self.assertEqual(self.data.filename, filename)
# The followed should not have been loaded
self.assertEqual(self.data.sample.thickness, 0.00103)
# This one should
self.assertEqual(self.data.sample.transmission, 0.327)
self.assertEqual(self.data.meta_data['loader'], "CanSAS 1D")
print self.data.errors
self.assertEqual(len(self.data.errors), 1)
