def test_Spheres_rotation():
s1 = Sphere(n = 1.59, r = 1, center = [1, 0, 0])
s2 = Sphere(n = 1.59, r = 1, center = [-1, 0, 1])
sc = Spheres(scatterers = [s1, s2])
sc2 = sc.rotated(-np.pi/2, 0, 0)
assert_equal(sc.scatterers[0].r, sc2.scatterers[0].r)
assert_equal(sc.scatterers[1].r, sc2.scatterers[1].r)
assert_equal(sc.scatterers[0].n, sc2.scatterers[0].n)
assert_equal(sc.scatterers[1].n, sc2.scatterers[1].n)
assert_almost_equal([0, -1, 0], sc2.scatterers[0].center)
assert_almost_equal([0, 1, 1], sc2.scatterers[1].center)
def test_Spheres_translation():
s1 = Sphere(n = 1.59, r = 5, center=[1, -1, 10])
s2 = Sphere(n = 1.59, r = 1, center=[0,0,0])
sc = Spheres(scatterers = [s1, s2])
sc2 = sc.translated(1, 1, 1)
assert_equal(sc.scatterers[0].r, sc2.scatterers[0].r)
assert_equal(sc.scatterers[1].r, sc2.scatterers[1].r)
assert_equal(sc.scatterers[0].n, sc2.scatterers[0].n)
assert_equal(sc.scatterers[1].n, sc2.scatterers[1].n)
assert_equal([2, 0, 11], sc2.scatterers[0].center)
assert_equal([1, 1, 1], sc2.scatterers[1].center)
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_nonlinearity():
# look at superposition of scattering from two large particles;
# make sure that this is *not equal* to sum of holograms from
# individual scatterers (scattered intensity should be
# non-negligible for this case)
x2 = x*2
y2 = y*2
z2 = z*2
scaling_alpha = 1.0
r = wavelen # order of wavelength
sphere1 = Sphere(n=n, r=r, center = (x, y, z))
sphere2 = Sphere(n=n, r=r, center = (x2, y2, z2))
sc = Spheres(scatterers = [sphere1, sphere2])
holo_1 = calc_holo(xschema, sphere1, index, wavelen, illum_polarization=xpolarization, scaling=scaling_alpha)
holo_2 = calc_holo(xschema, sphere2, index, wavelen, illum_polarization=xpolarization, scaling=scaling_alpha)
holo_super = calc_holo(xschema, sc, index, wavelen, xpolarization, scaling=scaling_alpha, theory=Mie)
# test nonlinearity by subtracting off individual holograms
try:
assert_array_almost_equal(holo_super - holo_1 + 1, holo_2)
except AssertionError:
pass # no way to do "assert array not equal" in numpy.testing
else:
raise AssertionError("Holograms computed for "
"wavelength-scale scatterers should "
"not superpose linearly")
def test_Mie_multiple():
s1 = Sphere(n = 1.59, r = 5e-7, center = (1e-6, -1e-6, 10e-6))
s2 = Sphere(n = 1.59, r = 1e-6, center=[8e-6,5e-6,5e-6])
s3 = Sphere(n = 1.59+0.0001j, r = 5e-7, center=[5e-6,10e-6,3e-6])
sc = Spheres(scatterers=[s1, s2, s3])
thry = Mie(False)
schema = yschema
fields = calc_field(schema, sc, index, wavelen, ypolarization, thry)
verify(fields, 'mie_multiple_fields')
calc_intensity(schema, sc, index, wavelen, ypolarization, thry)
holo = calc_holo(schema, sc, index, wavelen, theory=thry)
verify(holo, 'mie_multiple_holo')
# should throw exception when fed a ellipsoid
el = Ellipsoid(n = 1.59, r = (1e-6, 2e-6, 3e-6), center=[8e-6,5e-6,5e-6])
with assert_raises(TheoryNotCompatibleError) as cm:
calc_field(schema, el, index, wavelen, theory=Mie)
assert_equal(str(cm.exception), "Mie scattering theory can't handle "
"scatterers of type Ellipsoid")
assert_raises(TheoryNotCompatibleError, calc_field, schema, el, index, wavelen, xpolarization, Mie)
assert_raises(TheoryNotCompatibleError, calc_intensity,
schema, el, index, wavelen, xpolarization, Mie)
assert_raises(TheoryNotCompatibleError, calc_holo, schema, el, index, wavelen, xpolarization, Mie)
def test_Spheres_construction_typechecking():
# heterogeneous composite should raise exception, since a
# sphere cluster must contain only Spheres
s1 = Sphere(n = 1.59, r = 5e-7, center = (1e-6, -1e-6, 10e-6))
s2 = Sphere(n = 1.59, r = 1e-6, center=[0,0,0])
s3 = Sphere(n = 1.59+0.0001j, r = 5e-7, center=[5e-6,0,0])
cs = Ellipsoid(n=1.59+0.0001j, r=(5e-7, 5e-7, 8e-7),
center=[-5e-6, 0,0])
sc = Spheres(scatterers=[s1, s2, s3, cs])
def test_Spheres_parameters():
s1 = Sphere(n = 1.59, r = 5e-7, center=[1e-6, -1e-6, 10e-6])
s2 = Sphere(n = 1.59, r = 1e-6, center=[0,0,0])
sc = Spheres(scatterers = [s1, s2])
assert_equal(sc.parameters, dict([('0:center', [1e-6, -1e-6, 1.0e-05]),
('0:n', 1.59), ('0:r', 5e-07),
('1:center', [0, 0, 0]),
('1:n', 1.59), ('1:r', 1e-06)]))
sc2 = sc.from_parameters(sc.parameters)
assert_equal(sc.scatterers[0].r, sc2.scatterers[0].r)
assert_equal(sc.scatterers[1].r, sc2.scatterers[1].r)
assert_equal(sc.scatterers[0].n, sc2.scatterers[0].n)
assert_equal(sc.scatterers[1].n, sc2.scatterers[1].n)
assert_equal(sc.scatterers[0].center, sc2.scatterers[0].center)
assert_equal(sc.scatterers[1].center, sc2.scatterers[1].center)
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_fit_superposition():
"""
Fit Mie superposition to a calculated hologram from two spheres
"""
# Make a test hologram
optics = Optics(wavelen=6.58e-07,
index=1.33,
polarization=[0.0, 1.0],
divergence=0,
spacing=None,
train=None,
mag=None,
pixel_scale=[2 * 2.302e-07, 2 * 2.302e-07])
s1 = Sphere(n=1.5891 + 1e-4j, r=.65e-6, center=(1.56e-05, 1.44e-05, 15e-6))
s2 = Sphere(n=1.5891 + 1e-4j, r=.65e-6, center=(3.42e-05, 3.17e-05, 10e-6))
sc = Spheres([s1, s2])
alpha = .629
theory = Mie(optics, 100)
holo = theory.calc_holo(sc, alpha)
# Now construct the model, and fit
parameters = [
Parameter(name='x0', guess=1.6e-5, limit=[0, 1e-4]),
Parameter('y0', 1.4e-5, [0, 1e-4]),
Parameter('z0', 15.5e-6, [0, 1e-4]),
Parameter('r0', .65e-6, [0.6e-6, 0.7e-6]),
Parameter('nr', 1.5891, [1, 2]),
Parameter('x1', 3.5e-5, [0, 1e-4]),
Parameter('y1', 3.2e-5, [0, 1e-4]),
Parameter('z1', 10.5e-6, [0, 1e-4]),
Parameter('r1', .65e-6, [0.6e-6, 0.7e-6])
]
def make_scatterer(x0, x1, y0, y1, z0, z1, r0, r1, nr):
s = Spheres([
Sphere(center=(x0, y0, z0), r=r0, n=nr + 1e-4j),
Sphere(center=(x1, y1, z1), r=r1, n=nr + 1e-4j)
])
return s
model = Model(parameters,
Mie,
make_scatterer=make_scatterer,
alpha=Parameter('alpha', .63, [.5, 0.8]))
result = fit(model, holo)
assert_obj_close(result.scatterer, sc)
assert_approx_equal(result.alpha, alpha, significant=4)
assert_equal(result.model, model)
assert_read_matches_write(result)
def test_RigidCluster():
# test construction
s1 = Sphere(n = 1, center = (1, 0, 0))
s2 = Sphere(n = 2, center = (-1, 0, 0))
s3 = Sphere(n = 3, center = (0, 1,0))
s4 = Sphere(n = 4, center = (0, -1, 0))
base = Spheres([s1, s2, s3, s4])
rc = RigidCluster(base)
assert_obj_close(rc.scatterers, base.scatterers)
assert_raises(InvalidScatterer, RigidCluster,s1)
# test transformation
ts1 = Sphere(n = 1, center = [-1/np.sqrt(2)+1, 2., -1/np.sqrt(2)+3])
ts2 = Sphere(n = 2, center = [1/np.sqrt(2)+1, 2., 1/np.sqrt(2)+3])
ts3 = Sphere(n = 3, center = [-1/np.sqrt(2)+1,2., +1/np.sqrt(2)+3])
ts4 = Sphere(n = 4, center = [1/np.sqrt(2)+1, 2., -1/np.sqrt(2)+3])
trans = Spheres([ts1,ts2,ts3,ts4])
trc = RigidCluster(base, rotation=(np.pi/4,np.pi/2,np.pi/2),translation=(1,2,3))
assert_obj_close(trc.scatterers,trans.scatterers)
# test parameters, from_parameters
assert_obj_close(trc.from_parameters(trc.parameters), trans)
def test_mielens_multiple_returns_nonzero(self):
scatterers = [
Sphere(n=1.59, r=5e-7, center=(1e-6, -1e-6, 10e-6)),
Sphere(n=1.59, r=1e-6, center=[8e-6, 5e-6, 5e-6]),
Sphere(n=1.59 + 0.0001j, r=5e-7, center=[5e-6, 10e-6, 3e-6]),
]
sphere_collection = Spheres(scatterers=scatterers)
theory = MieLens()
schema = yschema
holo = calc_holo(schema, sphere_collection, index, wavelen,
theory=theory)
self.assertTrue(holo is not None)
self.assertTrue(holo.values.std() > 0)
def test_constraint():
sch = ImageSchema(100)
with warnings.catch_warnings():
# TODO: we should really only supress overlap warnings here,
# but I am too lazy to figure it out right now, and I don't
# think we are likely to hit warnings here that won't get
# caught elsewhere -tgd 2013-12-01
warnings.simplefilter("ignore")
spheres = Spheres([Sphere(r=.5, center=(0,0,0)),
Sphere(r=.5, center=(0,0,par(.2)))])
model = Model(spheres, Multisphere.calc_holo, constraints=limit_overlaps())
coster = CostComputer(sch, model)
cost = coster._calc({'1:Sphere.center[2]' : .2})
assert_equal(cost, np.ones_like(sch)*np.inf)
def test_Spheres_construction():
# cluster of multiple spheres
s1 = Sphere(n = 1.59, r = 5e-7, center = (1e-6, -1e-6, 10e-6))
s2 = Sphere(n = 1.59, r = 1e-6, center=[0,0,0])
s3 = Sphere(n = 1.59+0.0001j, r = 5e-7, center=[5e-6,0,0])
sc = Spheres(scatterers=[s1, s2, s3])
# test attribute access
sc.n
sc.n_real
sc.n_imag
sc.r
sc.x
sc.y
sc.z
sc.centers
sc.center
def test_linearity():
# look at superposition of scattering from two point particles;
# make sure that this is sum of holograms from individual point
# particles (scattered intensity should be negligible for this
# case)
x2 = x*2
y2 = y*2
z2 = z*2
scaling_alpha = 1.0
r = 1e-2*wavelen # something much smaller than wavelength
sphere1 = Sphere(n=n, r=r, center = (x, y, z))
sphere2 = Sphere(n=n, r=r, center = (x2, y2, z2))
sc = Spheres(scatterers = [sphere1, sphere2])
holo_1 = calc_holo(xschema, sphere1, index, wavelen, xpolarization, scaling=scaling_alpha)
holo_2 = calc_holo(xschema, sphere2, index, wavelen, xpolarization, scaling=scaling_alpha)
holo_super = calc_holo(xschema, sc, index, wavelen, xpolarization, theory=Mie, scaling=scaling_alpha)
# make sure we're not just looking at uniform arrays (could
# happen if the size is set too small)
try:
assert_array_almost_equal(holo_1, holo_2, decimal=12)
except AssertionError:
pass # no way to do "assert array not equal" in numpy.testing
else:
raise AssertionError("Hologram computed for point particle" +
" looks suspiciously close to having" +
" no fringes")
# Test linearity by subtracting off individual holograms.
# This should recover the other hologram
assert_array_almost_equal(holo_super - holo_1 + 1, holo_2)
assert_array_almost_equal(holo_super - holo_2 + 1, holo_1)
def _scsmfo_setup(self, scatterer, medium_wavevec, medium_index):
"""
Given multiple spheres, calculate amn coefficients for scattered
field expansion in VSH using SCSMFO.
Parameters
----------
scatterer : :mod:`.scatterer` object
scatterer or list of scatterers to compute field for
Returns
-------
amn : arrays of field expansion coefficients
"""
if isinstance(scatterer,Sphere):
scatterer=Spheres([scatterer])
elif not isinstance(scatterer, Spheres):
raise TheoryNotCompatibleError(self, scatterer)
# check for spheres being uniform
for sph in scatterer.scatterers:
if not np.isscalar(sph.n):
raise TheoryNotCompatibleError(self, scatterer, "Multisphere" +
" cannot compute scattering" +
" from layered particles.")
# check that the parameters are in a range where the multisphere
# expansion will work
for s in scatterer.scatterers:
if s.r * medium_wavevec > 1e3:
raise InvalidScatterer(s, "radius too large, field "+
"calculation would take forever")
# switch to centroid weighted coordinate system tmatrix code expects
# and nondimensionalize
centers = (scatterer.centers - scatterer.centers.mean(0)) * medium_wavevec
m = scatterer.n / medium_index
if (centers > 1e4).any():
raise InvalidScatterer(scatterer, "Particle separation "
"too large, calculation would take forever")
with SuppressOutput(suppress_output=self.suppress_fortran_output):
# The fortran code uses oppositely directed z axis (they
# have laser propagation as positive, we have it negative),
# so we multiply the z coordinate by -1 to correct for that.
_, lmax, amn0, converged = scsmfo_min.amncalc(
1, centers[:,0], centers[:,1],
-1.0 * centers[:,2], m.real, m.imag,
scatterer.r * medium_wavevec, self.niter, self.eps,
self.qeps1, self.qeps2, self.meth, (0,0))
# converged == 1 if the SCSMFO iterative solver converged
# f2py converts F77 LOGICAL to int
if not converged:
raise MultisphereFailure()
# chop off unused parts of amn0, the fortran code currently has a hard
# coded number of parameters so it will return too many coefficients.
# We truncate here to reduce the length of stuff we have to compute with
# later.
limit = lmax**2 + 2*lmax
amn = amn0[:, 0:limit, :]
if np.isnan(amn).any():
raise MultisphereFailure()
return amn, lmax
def make_scatterer(x0, x1, y0, y1, z0, z1, r0, r1, nr0, nr1):
s = Spheres([
Sphere(center = (x0, y0, z0), r=r0, n = nr0+1e-5j),
Sphere(center = (x1, y1, z1), r=r1, n = nr1+1e-5j)])
return s
def test_Spheres_ovelap_checking():
s1 = Sphere(n = 1.59, r = 5e-7, center=(1e-6, -1e-6, 10e-6))
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always', OverlapWarning)
sc = Spheres([s1, s1, s1])
assert len(w) > 0
import holopy as hp
from holopy.scattering.theory import Mie
from holopy.scattering.scatterer import Sphere, Spheres
from holopy.core import ImageSchema, Optics
schema = ImageSchema(shape=100,
spacing=.1,
optics=Optics(wavelen=.660,
index=1.33,
polarization=[1, 0]))
s1 = Sphere(center=(5, 5, 5), n=1.59, r=.5)
s2 = Sphere(center=(4, 4, 5), n=1.59, r=.5)
collection = Spheres([s1, s2])
holo = Mie.calc_holo(collection, schema)
hp.show(holo)
import xarray as xr
from numpy.testing import assert_allclose, assert_equal
from nose.plugins.attrib import attr
from holopy.core import detector_grid, detector_points
from holopy.core.metadata import update_metadata, flat
from holopy.scattering.theory.scatteringtheory import ScatteringTheory
from holopy.scattering.theory import Mie
from holopy.scattering.scatterer import Sphere, Spheres, Ellipsoid
from holopy.scattering.errors import TheoryNotCompatibleError
from holopy.scattering.interface import prep_schema
from holopy.scattering.tests.common import xschema as XSCHEMA
SPHERE = Sphere(n=1.5, r=1.0, center=(0, 0, 2))
SPHERES = Spheres([
Sphere(n=1.5, r=1.0, center=(-1, -1, 2)),
Sphere(n=1.5, r=1.0, center=(+1, +1, 2)),
])
ELLIPSOID = Ellipsoid(n=1.5, r=(0.5, 0.5, 1.2), center=(0, 0, 2))
TOLS = {'atol': 1e-14, 'rtol': 1e-14}
MEDTOLS = {'atol': 1e-7, 'rtol': 1e-7}
SCAT_SCHEMA = prep_schema(detector_grid(shape=(5, 5), spacing=.1),
medium_index=1.33,
illum_wavelen=0.66,
illum_polarization=False)
class MockTheory(ScatteringTheory):
"""Minimally-functional daughter of ScatteringTheory for fast tests."""
def __init__(*args, **kwargs):
pass # an init is necessary for the repr
