def test_calc_holo_with_twocolor_index(self):
indices = OrderedDict([('red',1.5),('green',2)])
radius = 0.5
center = (1, 1, 1)
illum_wavelen = OrderedDict([('red', 0.66), ('green', 0.52)])
sphere_red = Sphere(n=indices['red'], r=radius, center=center)
sphere_green = Sphere(n=indices['green'], r=radius, center=center)
sphere_both = Sphere(n=indices, r=radius, center=center)
schema_single_color = update_metadata(
detector_grid(shape=2, spacing=1),
illum_polarization=(0,1),
medium_index=1.3)
schema_two_colors = update_metadata(
detector_grid(
shape=2,spacing=1,extra_dims={'illumination':['red','green']}),
illum_polarization=(0,1),
medium_index=1.3)
red_hologram = calc_holo(
schema_single_color, sphere_red, illum_wavelen=illum_wavelen['red'])
green_hologram = calc_holo(
schema_single_color, sphere_green,
illum_wavelen=illum_wavelen['green'])
both_hologram = calc_holo(
schema_two_colors,sphere_both, illum_wavelen=illum_wavelen)
joined = np.concatenate([
np.array([red_hologram.values]),
np.array([green_hologram.values])])
assert_equal(both_hologram.values, joined)
def test_ComplexPrior():
parm = Sphere(
n=prior.ComplexPrior(real=prior.Uniform(1.58, 1.59), imag=.001))
model = AlphaModel(parm, alpha=prior.Uniform(.6, 1, .7))
assert_equal(model.parameters['n.real'].name, 'n.real')
interpreted_pars = {'alpha': .7, 'n': {'real': 1.585}}
assert_equal(_interpret_parameters(model.parameters), interpreted_pars)
def test_naming():
#parameterizing with fixed params
def makeScatterer(n,m):
n**2+m
return fake_sph
parm = Parametrization(makeScatterer, [par(limit=4),par(2, [1,5])])
assert_equal(parm._fixed_params,{None: 4})
def test_multidim():
s = Sphere(n = {'r':par(0,[-1,1]),'g':par(0,0),'b':prior.Gaussian(0,1),'a':0}, r = xr.DataArray([prior.Gaussian(0,1),par(0,[-1,1]),par(0,0),0], dims='alph',coords={'alph':['a','b','c','d']}), center=[par(0,[-1,1]),par(0,0),0])
par_s = ParameterizedObject(s)
params = {'n_r':3,'n_g':4,'n_b':5,'n_a':6,'r_a':7,'r_b':8,'r_c':9,'r_d':10,'center[0]':7,'center[1]':8,'center[2]':9}
out_s = Sphere(n={'r':3,'g':0,'b':5,'a':0}, r = xr.DataArray([7,8,0,0], dims='alph',coords={'alph':['a','b','c','d']}), center=[7,0,0])
assert_obj_close(par_s.make_from(params), out_s)
m = Model(s, np.sum)
m._use_parameter(OrderedDict([('r',par(0,[-1,1])),('g',par(0,0)),('b',prior.Gaussian(0,1)),('a',0)]),'letters')
m._use_parameter(xr.DataArray([prior.Gaussian(0,1),par(0,[-1,1]),par(0,0),0],dims='numbers',coords={'numbers':['one','two','three','four']}),'count')
expected_params = [par(0,[-1,1],'letters_r'),par(0,0,'letters_g'),prior.Gaussian(0,1,'letters_b'),prior.Gaussian(0,1,'count_one'),par(0,[-1,1],'count_two'), par(0,0,'count_three')]
assert_equal(m.parameters[-6:], expected_params)
def test_ComplexPar():
#complex parameter
def makeScatterer(n):
n**2
return fake_sph
parm = Parametrization(makeScatterer, [ComplexParameter(real = par(1.58),imag = par(.001), name='n')])
model = Model(parm, calc_holo, alpha = par(.7,[.6,1]))
assert_equal(model.parameters[0].name,'n.real')
assert_equal(model.parameters[1].name,'n.imag')
def test_select():
s = Sphere(n=xr.DataArray([1.5, 1.7],
dims='ill',
coords={'ill': ['r', 'g']}),
center=[0, 0, 0],
r=0.5)
assert_equal(s.select({'ill': 'g'}), Sphere(n=1.7, center=[0, 0, 0],
r=0.5))
ss = Spheres([s, s.translated([1, 1, 1])])
assert_equal(
ss.select({'ill': 'g'}),
Spheres([
Sphere(n=1.7, center=[0, 0, 0], r=0.5),
Sphere(n=1.7, center=[1, 1, 1], r=0.5)
]))
def test_find_noise():
noise = 0.5
s = Sphere(n=prior.Uniform(1.5, 1.7), r=2, center=[1, 2, 3])
data_base = detector_grid(10, spacing=0.5)
data_noise = update_metadata(data_base, noise_sd=noise)
model_u = AlphaModel(s, alpha=prior.Uniform(0.7, 0.9))
model_g = AlphaModel(s, alpha=prior.Gaussian(0.8, 0.1))
pars = {'n': 1.6, 'alpha': 0.8}
assert_equal(model_u._find_noise(pars, data_noise), noise)
assert_equal(model_g._find_noise(pars, data_noise), noise)
assert_equal(model_u._find_noise(pars, data_base), 1)
assert_raises(MissingParameter, model_g._find_noise, pars, data_base)
pars.update({'noise_sd': noise})
assert_equal(model_g._find_noise(pars, data_base), noise)
def test_Tying():
#tied parameters
n1 = par(1.59)
sc = Spheres([Sphere(n = n1, r = par(0.5e-6), center = np.array([10., 10., 20.])),
Sphere(n = n1, r = par(0.5e-6), center = np.array([9., 11., 21.]))])
model = Model(sc, calc_holo, alpha = par(.7,[.6,1]))
assert_equal(model.parameters[0].guess, 1.59)
assert_equal(model.parameters[1].guess, 5e-7)
assert_equal(len(model.parameters),4)
def test_Get_Alpha():
#checking get_alpha function
sc = Spheres([Sphere(n = 1.58, r = par(0.5e-6), center = np.array([10., 10., 20.])),
Sphere(n = 1.58, r = par(0.5e-6), center = np.array([9., 11., 21.]))])
model = Model(sc, calc_holo, alpha = par(.7,[.6,1]))
sc = Spheres([Sphere(n = 1.58, r = par(0.5e-6), center = np.array([10., 10., 20.])),
Sphere(n = 1.58, r = par(0.5e-6), center = np.array([9., 11., 21.]))])
model2 = Model(sc, calc_holo)
assert_equal(model.get_alpha(model.parameters).guess, 0.7)
assert_equal(model.get_alpha(model.parameters).name, 'alpha')
assert_equal(model2.get_alpha(model2.parameters), 1.0)
def test_pullingoutguess():
g = Sphere(center=(prior.Uniform(0, 1e-5, guess=.567e-5),
prior.Uniform(0, 1e-5, .567e-5),
prior.Uniform(1e-5, 2e-5, 15e-6)),
r=prior.Uniform(1e-8, 1e-5, 8.5e-7),
n=prior.ComplexPrior(prior.Uniform(1, 2, 1.59), 1e-4))
model = ExactModel(g, calc_holo)
s = Sphere(center=[.567e-5, .567e-5, 15e-6], n=1.59 + 1e-4j, r=8.5e-7)
assert_equal(s.n, model.scatterer.guess.n)
assert_equal(s.r, model.scatterer.guess.r)
assert_equal(s.center, model.scatterer.guess.center)
g = Sphere(center=(prior.Uniform(0, 1e-5, guess=.567e-5),
prior.Uniform(0, 1e-5, .567e-5),
prior.Uniform(1e-5, 2e-5, 15e-6)),
r=prior.Uniform(1e-8, 1e-5, 8.5e-7),
n=1.59 + 1e-4j)
model = ExactModel(g, calc_holo)
s = Sphere(center=[.567e-5, .567e-5, 15e-6], n=1.59 + 1e-4j, r=8.5e-7)
assert_equal(s.n, model.scatterer.guess.n)
assert_equal(s.r, model.scatterer.guess.r)
assert_equal(s.center, model.scatterer.guess.center)
def test_multidim():
par_s = Sphere(n={
'r': prior.Uniform(-1, 1),
'g': 0,
'b': prior.Gaussian(0, 1),
'a': 0
},
r=xr.DataArray(
[prior.Gaussian(0, 1),
prior.Uniform(-1, 1), 0, 0],
dims='alph',
coords={'alph': ['a', 'b', 'c', 'd']}),
center=[prior.Uniform(-1, 1), 0, 0])
params = {
'n:r': 3,
'n:g': 4,
'n:b': 5,
'n:a': 6,
'r:a': 7,
'r:b': 8,
'r:c': 9,
'r:d': 10,
'center.0': 7,
'center.1': 8,
'center.2': 9
}
out_s = Sphere(n={
'r': 3,
'g': 0,
'b': 5,
'a': 0
},
r={
'a': 7,
'b': 8,
'c': 0,
'd': 0
},
center=[7, 0, 0])
assert_obj_close(par_s.from_parameters(params), out_s)
m = ExactModel(out_s, np.sum)
parletters = {
'r': prior.Uniform(-1, 1),
'g': 0,
'b': prior.Gaussian(0, 1),
'a': 0
}
parcount = xr.DataArray(
[prior.Gaussian(0, 1),
prior.Uniform(-1, 1), 0, 0],
dims='numbers',
coords={'numbers': ['one', 'two', 'three', 'four']})
m._use_parameters({'letters': parletters, 'count': parcount})
expected_params = {
'letters:r': prior.Uniform(-1, 1, 0, 'letters:r'),
'letters:b': prior.Gaussian(0, 1, 'letters:b'),
'count:one': prior.Gaussian(0, 1, 'count:one'),
'count:two': prior.Uniform(-1, 1, 0, 'count:two')
}
assert_equal(m.parameters, expected_params)
def test_pullingoutguess():
g = Sphere(center = (par(guess=.567e-5, limit=[0,1e-5]),
par(.567e-5, (0, 1e-5)), par(15e-6, (1e-5, 2e-5))),
r = par(8.5e-7, (1e-8, 1e-5)), n = ComplexParameter(par(1.59, (1,2)),1e-4))
model = Model(g, calc_holo)
s = Sphere(center = [.567e-5, .567e-5, 15e-6], n = 1.59 + 1e-4j, r = 8.5e-7)
assert_equal(s.n, model.scatterer.guess.n)
assert_equal(s.r, model.scatterer.guess.r)
assert_equal(s.center, model.scatterer.guess.center)
g = Sphere(center = (par(guess=.567e-5, limit=[0,1e-5]),
par(.567e-5, (0, 1e-5)), par(15e-6, (1e-5, 2e-5))),
r = par(8.5e-7, (1e-8, 1e-5)), n = 1.59 + 1e-4j)
model = Model(g, calc_holo)
s = Sphere(center = [.567e-5, .567e-5, 15e-6], n = 1.59 + 1e-4j, r = 8.5e-7)
assert_equal(s.n, model.scatterer.guess.n)
assert_equal(s.r, model.scatterer.guess.r)
assert_equal(s.center, model.scatterer.guess.center)