def __init__(self, universe_material, nbins, diameter=100., detector_width=100., detector='plane'):

self.universe_material = universe_material

self.geometry = Geometry()

self.source = np.array([-diameter / 2., 0.])

if detector == 'plane':

self.detector = DetectorPlane([diameter / 2., 0.], detector_width, nbins)

elif detector == 'arc':

self.detector = DetectorArc(self.source, diameter, detector_width / 2., -detector_width / 2., nbins)

def get_intersecting_segments(self, start, end, ray=False):

"""

Find intersection points and lixels which intersect ray (start, end).

"""

intercepts, indexes = [], []

intersect_segment = np.array([start, end])

for i, segment in enumerate(self.geometry.mesh.segments):

intercept = math2d.intersect(segment, intersect_segment, ray)

if intercept is not None:

intercepts.append(intercept)

indexes.append(i)

return intercepts, indexes

def attenuation_length(self, start, end):

"""

Calculate attenuation length for geometry.

Can account for starting and ending in any position.

"""

intercepts, indexes = self.get_intersecting_segments(start, end)

if len(intercepts) == 0:

ray_intercepts, ray_indexes = self.get_intersecting_segments(start, end, ray=True)

if len(ray_intercepts) == 0:

return np.linalg.norm(start - end) * self.universe_material.attenuation

distances = np.linalg.norm(np.add(ray_intercepts, -start), axis=1)

distances_argmin = np.argmin(distances)

closest_index = ray_indexes[distances_argmin]

closest_intercept = ray_intercepts[distances_argmin]

closest_normal = math2d.normal(self.geometry.mesh.segments[closest_index])

start_sign = np.sign(np.dot(start - closest_intercept, closest_normal))

if start_sign > 0:

outer_atten = self.geometry.outer_materials[closest_index].attenuation

atten_length = np.linalg.norm(start - end) * outer_atten

else:

inner_atten = self.geometry.inner_materials[closest_index].attenuation

atten_length = np.linalg.norm(start - end) * inner_atten

return atten_length

distances = np.linalg.norm(np.add(intercepts, -start), axis=1)

distances_argmin = np.argmin(distances)

closest_index = indexes[distances_argmin]

closest_intercept = intercepts[distances_argmin]

closest_normal = math2d.normal(self.geometry.mesh.segments[closest_index])

start_sign = np.sign(np.dot(start - closest_intercept, closest_normal))

if start_sign > 0:

outer_atten = self.geometry.outer_materials[closest_index].attenuation

atten_length = np.linalg.norm(start - end) * outer_atten

else:

inner_atten = self.geometry.inner_materials[closest_index].attenuation

atten_length = np.linalg.norm(start - end) * inner_atten

for intercept, index in zip(intercepts, indexes):

normal = math2d.normal(self.geometry.mesh.segments[index])

start_sign = np.sign(np.dot(start - intercept, normal))

end_sign = np.sign(np.dot(end - intercept, normal))

inner_atten = self.geometry.inner_materials[index].attenuation

outer_atten = self.geometry.outer_materials[index].attenuation

atten_length += start_sign * np.linalg.norm(intercept - end) * (inner_atten - outer_atten)

return atten_length

def fission_segments(self, start, end):

"""

Return list of line segments where fissions may occur.

"""

segments, cross_sections = [], []

intercepts, indexes = self.get_intersecting_lixels(start, end)

# otherwise

fission_indexes = []

fission_intercepts = []

for index, intercept in zip(indexes, intercepts):

# test if lixel is border of fissionable material(s)

inner_material = self.geometry.get_inner_material(index)

outer_material = self.geometry.get_outer_material(index)

if inner_material.is_fissionable or outer_material.is_fissionable:

fission_indexes.append(index)

fission_intercepts.append(intercept)

# account for no intersections with fissionable materials

if len(fission_intercepts) == 0:

return segments, cross_sections

# sort fission_indexes and fission_intercepts by distance from start

distances = np.linalg.norm(np.add(fission_intercepts, -start), axis=1)

distance_order = [index_ for (distance_, index_) in sorted(zip(distances, range(len(distances))))]

sorted_fission_indexes = [fission_indexes[i] for i in distance_order]

sorted_fission_intercepts = [fission_intercepts[i] for i in distance_order]

for i in xrange(len(sorted_fission_indexes)):

f_ind = sorted_fission_indexes[i]

f_int = sorted_fission_intercepts[i]

if i == 0:

# test if start to first fission lixel is fissionable

normal = self.geometry.mesh.lixel_normal(f_ind)

sign = np.sign(np.dot(start - f_int, normal))

inner_material = self.geometry.get_inner_material(f_ind)

outer_material = self.geometry.get_outer_material(f_ind)

if sign > 0 and outer_material.is_fissionable:

segments.append([start, f_int])

cross_sections.append(outer_material.macro_fission)

elif sign < 0 and inner_material.is_fissionable:

segments.append([start, f_int])

cross_sections.append(inner_material.macro_fission)

elif i == len(sorted_fission_indexes)-1:

# test if end to last fission lixel is fissionable

normal = self.geometry.mesh.lixel_normal(f_ind)

sign = np.sign(np.dot(end - f_int, normal))

inner_material = self.geometry.get_inner_material(f_ind)

outer_material = self.geometry.get_outer_material(f_ind)

if sign > 0 and outer_material.is_fissionable:

segments.append([f_int, end])

cross_sections.append(outer_material.macro_fission)

elif sign < 0 and inner_material.is_fissionable:

segments.append([f_int, end])

cross_sections.append(inner_material.macro_fission)

continue

# test all intervening segments

normal_1 = self.geometry.mesh.lixel_normal(f_ind)

sign_1 = np.sign(np.dot(start - f_int, normal_1))

f_ind2 = sorted_fission_indexes[i+1]

f_int2 = sorted_fission_intercepts[i+1]

normal_2 = self.geometry.mesh.lixel_normal(f_ind2)

sign_2 = np.sign(np.dot(start - f_int2, normal_2))

if sign_1 > 0:

mat_1 = self.geometry.get_inner_material(f_ind)

else:

mat_1 = self.geometry.get_outer_material(f_ind)

if sign_2 < 0:

mat_2 = self.geometry.get_inner_material(f_ind)

else:

mat_2 = self.geometry.get_outer_material(f_ind)

if mat_1.is_fissionable and mat_2.is_fissionable:

if mat_1.macro_fission != mat_2.macro_fission:

raise NotImplementedError

segments.append([f_int, f_int2])

cross_sections.append(mat_1.macro_fission)

return segments, cross_sections

def scan(self, angles=[0], nbins=100):

atten_length = np.zeros((nbins, len(angles)))

detector_bins = self.detector.create_bins(nbins)

source = self.source

for i, angle in enumerate(angles):

rot = angle_matrix(angle)

rot_source = np.inner(source, rot)

rot_detector_bins = np.inner(detector_bins, rot)

for j, detector_bin in enumerate(rot_detector_bins):

atten_length[j, i] = self.attenuation_length(rot_source, detector_bin)

return atten_length

def radon_transform(self, angles=[0]):

if type(self.detector) is not DetectorPlane:

raise TypeError('self.detector is not DetectorPlane')

detector_centers = (self.detector.segments[:, 0, :] + self.detector.segments[:, 1, :]) / 2.

radon = np.zeros((np.size(detector_centers, 0), len(angles)))

source_bins = np.inner(detector_centers, math2d.angle_matrix(180.))[::-1]

for i, angle in enumerate(angles):

print i, len(angles)

rot = math2d.angle_matrix(angle)

rot_source = np.inner(source_bins, rot)

rot_detector = np.inner(detector_centers, rot)

for j in xrange(len(rot_detector)):

radon[j, i] = self.attenuation_length(rot_source[j], rot_detector[j])

return radon

def draw(self, draw_normals=False):

self.geometry.draw(draw_normals)

if self.source is not None:

plt.scatter(self.source[0], self.source[1], color='red', marker='x')

self.detector.draw(draw_normals)

plt.axis('equal')

plt.xlabel('X (cm)')

plt.ylabel('Y (cm)')