def pre_shine(self, source: Source):
angles = [
la.cos(
la.plus([self.crystal.D / 2, 0, self.crystal.r],
la.minus(self.crystal.centre, source.loc)),
[self.crystal.D / 2, 0, self.crystal.r]),
la.cos(
la.plus([-self.crystal.D / 2, 0, self.crystal.r],
la.minus(self.crystal.centre, source.loc)),
[-self.crystal.D / 2, 0, self.crystal.r]),
la.cos(
la.plus([0, self.crystal.D / 2, self.crystal.r],
la.minus(self.crystal.centre, source.loc)),
[0, self.crystal.D / 2, self.crystal.r]),
la.cos(
la.plus([0, -self.crystal.D / 2, self.crystal.r],
la.minus(self.crystal.centre, source.loc)),
[0, -self.crystal.D / 2, self.crystal.r])
]
angles = [m.pi / 2 - m.acos(a) for a in angles]
# print([tl.deg_from_rad(a) for a in angles])
if angles[0] < self.curveSi.bragg[
self.crystal.rc] < angles[1] or angles[0] > self.curveSi.bragg[
self.crystal.rc] > angles[1]:
return True
if angles[2] < self.curveSi.bragg[
self.crystal.rc] < angles[3] or angles[2] > self.curveSi.bragg[
self.crystal.rc] > angles[3]:
return True
return False
def reflection_point(self, loc, n, ray: list):
out_intensity = self.curveSi.curve(
self.crystal.rc, m.pi / 2 - m.acos(la.cos(ray, la.i(n))))
if out_intensity != 0:
self.crystal.points.append(loc)
ray = la.x(ray, 1 / la.dot(ray, n))
o = [+ray[i] + 2 * (n[i] - ray[i]) for i in range(3)]
r = np.array(la.minus(self.detector.loc, loc))
# if self.t:
# print(la.norm(n))
# tl.vec_show([ray, n, o])
# print(la.cos(ray,n))
# print(la.cos(o,n))
# self.t = False
coeff = np.linalg.solve(
np.array([la.normalize(o), self.detector.ux,
self.detector.uy]).T, r)
i = int(coeff[1] // self.detector.res + self.detector.nx / 2)
j = int(coeff[2] // self.detector.res + self.detector.ny / 2)
if 0 <= i < self.detector.nx and 0 <= j < self.detector.ny:
self.detector.detected_intensity.append(out_intensity)
self.detector.detected_position.append([i, j])
return True
return False
def __init__(self, d, D, r, loc, rc: int):
self.d = d
self.r = r
self.D = D
self.rc = rc
self.centre = la.minus(loc, [0, 0, (r**2 - (D / 2)**2)**0.5])
self.loc = loc
self.points = list()
self.count_reflected = 0
def reflection_crystal(self, s, source):
cp_loc = la.x(
s,
tl.qroot(
a=1,
b=-2 * la.dot(s, la.minus(self.crystal.centre, source.loc)),
c=la.norm(self.crystal.centre)**2 + la.norm(source.loc)**2 -
2 * la.dot(self.crystal.centre, source.loc) -
self.crystal.r**2))
cp_loc = la.plus(cp_loc, source.loc)
if la.norm(la.minus(cp_loc,
self.crystal.loc)[:2]) < self.crystal.D / 2:
normal = la.normalize(la.minus(self.crystal.centre, cp_loc))
source.photons_total += 1
if not self.reflection_point(cp_loc, normal, s):
return False
return True
return False
def shine_random(self, source: Source):
for i in range(source.number):
done = False
while not done:
s = la.plus(la.minus(self.crystal.loc, source.loc), [
self.crystal.D * (0.5 - random.random()) for j in range(2)
] + [0])
done = self.reflection_crystal(la.normalize(s), source)
source.intensity_per_photon = source.photon_count * (
source.solid_angle / (4 * m.pi)) / source.photons_total
def __init__(self, source, crystal: Crystal, detector: Detector):
for s in source:
s.reset()
self.source = source
self.crystal = crystal
self.detector = detector
self.curveSi = Curves()
self.t = True
for s in self.source:
s.direction = la.normalize(la.minus(crystal.loc, s.loc))
alpha = la.cos([
0, self.crystal.loc[1] - s.loc[1],
self.crystal.loc[2] - s.loc[2]
], [0, 0, 1])
beta = la.cos([
self.crystal.loc[0] - s.loc[0], 0,
self.crystal.loc[2] - s.loc[2]
], [0, 0, 1])
s.solid_angle = (m.pi * self.crystal.D**2 / 4 * alpha *
beta) / (la.norm(la.minus(crystal.loc, s.loc))**2)
def mols(x, y, e: float):
norm = la.norm(la.minus(x, y))
return norm < e