def test_aperturized():
r = 100
a = np.ones((2 * r + 5, 2 * r + 5))
maskop = sf.aperturized(a.shape, (r + 2, r + 2), r)
b = a * maskop
assert np.abs(1 - np.sum(b) / (np.pi * r**2)) < 1e-3
maskop2 = sf.aperturized(a.shape, (r + 2, r + 2), r, sharpedge=True)
c = a * maskop2
assert np.abs(1 - np.sum(c) / np.sum(b)) < 1e-3
assert maskop.shape == maskop2.shape == a.shape
def power_within_area(self, radius, position=None):
data = self.data.data()
if position is None:
position = self.find_laser()
distance = self._smallest_distance_to_edge(position)
if radius + 0.5 >= np.min(distance):
print("Part of the aperture lies outside of the dataset")
power = []
for i in range(len(data)):
p = np.sum(data[i] *
sf.aperturized(data[i].shape, position[i], radius))
power.append(p)
return power
def cum_power_fraction_within_area(self):
data = self.data.data()
best_pos = self.find_laser()
distance = self._smallest_distance_to_edge(best_pos)
power = []
for i in range(len(data)):
power2 = []
for j in range(distance[i]):
p = np.sum(data[i] *
sf.aperturized(data[i].shape, best_pos[i], j))
power2.append(p / np.sum(data[i]))
power.append(np.array(power2))
return power
def findT(self, x, y, r, plot=True):
"""Calculates the Transmissivity by integrating over a circular
aperture centered on x, y with radius r. T is de fraction of lens to
nolens. If plot is True also calls show to visualise where was
integrated.
"""
assert len(x) == len(y) == len(r) == len(
self.lens), "all lengths must match!"
x, y, r = np.array(x), np.array(y), np.array(r)
T = []
for i in range(len(self.lens)):
A = np.sum(
self.lens.data()[i] *
sf.aperturized(self.lens.data()[i].shape, [y[i], x[i]], r))
B = np.sum(
self.nolens.data()[i] *
sf.aperturized(self.nolens.data()[i].shape, [y[i], x[i]], r))
T.append(A / B)
if plot is True:
self.show(x, y, r)
return T
def _focalpower(self, data, waist, subtract_median=True):
if subtract_median is True:
_data = data - np.median(data) # subtract remaining background from pc screens and light switches.
else:
_data = data
r = waist / self.pixel_size
if r < self.delta:
maskop = sf.aperturized(_data.shape, [self.delta, self.delta], r)
power = np.sum(_data * maskop)
area = self.pixel_size**2 * np.sum(maskop)
else:
power = -1
area = -1
return [power, area]
def test_aperture():
r = 50
a = np.ones((2 * r + 5, 2 * r + 5))
maskop = sf.aperturized(a.shape, (r + 2, r + 2), r, sharpedge=True)
mask = sf.aperture(a.shape, (r + 2, r + 2), r)
assert np.sum(np.abs(maskop - mask)) == 0