def render_mc_info(self,max_photons=1000,cher_only=True):
#need to render photon tracking info if available
self.gpu_geometries = [self.gpu_geometry]
if self.sum_mode or self.ev is None:
return
if self.photon_display_mode == 'beg':
photons = self.ev.photons_beg
elif self.photon_display_mode == 'end':
photons = self.ev.photons_end
else:
photons = None
if photons is not None:
geometry = Geometry()
self.render_photons(geometry,photons)
geometry = create_geometry_from_obj(geometry)
gpu_geometry = gpu.GPUGeometry(geometry)
self.gpu_geometries.append(gpu_geometry)
if self.track_display_mode in ['geant4', 'both'] and self.ev.vertices is not None:
geometry = Geometry()
any = False
for vertex in self.ev.vertices:
if vertex.steps:
any = True
self.render_vertex(geometry,vertex,children=True)
if any:
geometry = create_geometry_from_obj(geometry)
gpu_geometry = gpu.GPUGeometry(geometry)
self.gpu_geometries.append(gpu_geometry)
if self.track_display_mode in ['chroma', 'both'] and self.ev.photon_tracks is not None:
geometry = Geometry()
print('Total Photons',len(self.ev.photon_tracks))
cherenkov = np.asarray([track.flags[0] & event.CHERENKOV == event.CHERENKOV for track in self.ev.photon_tracks])
ncherenkov = np.count_nonzero(cherenkov)
nphotons = ncherenkov if cher_only else len(self.ev.photon_tracks)
prob = max_photons/nphotons
selector = np.random.random(len(self.ev.photon_tracks)) < prob
nphotons = 0
for track in (t for s,t in zip(selector,self.ev.photon_tracks) if s):
if cher_only and track.flags[0] & event.CHERENKOV == event.CHERENKOV:
self.render_photon_track(geometry,track[:min(len(track),5)],sz=0.05)
nphotons = nphotons + 1
elif not cher_only:
self.render_photon_track(geometry,track[:min(len(track),5)])
nphotons = nphotons + 1
if nphotons > 0:
print('Rendered Photons',nphotons)
geometry = create_geometry_from_obj(geometry)
gpu_geometry = gpu.GPUGeometry(geometry)
self.gpu_geometries.append(gpu_geometry)
def init_gpu(self):
self.context = gpu.create_cuda_context(self.device_id)
self.gpu_geometry = gpu.GPUGeometry(self.geometry)
self.gpu_funcs = gpu.GPUFuncs(gpu.get_cu_module('mesh.h'))
self.hybrid_funcs = gpu.GPUFuncs(gpu.get_cu_module('hybrid_render.cu'))
self.gpu_geometries = [self.gpu_geometry]
self.width, self.height = self.size
self.npixels = self.width * self.height
self.clock = pygame.time.Clock()
self.doom_mode = False
try:
if self.width == 640: # SECRET DOOM MODE!
print 'shotgun activated!'
self.doom_hud = pygame.image.load(
'images/doomhud.png').convert_alpha()
rect = self.doom_hud.get_rect()
self.doom_rect = rect.move(0, self.height - rect.height)
self.doom_mode = True
except:
pass
lower_bound, upper_bound = self.geometry.mesh.get_bounds()
self.mesh_diagonal_norm = np.linalg.norm(upper_bound - lower_bound)
self.scale = self.mesh_diagonal_norm
self.motion = 'coarse'
self.nblocks = 64
self.point = np.array([
0, -self.mesh_diagonal_norm, (lower_bound[2] + upper_bound[2]) / 2
])
self.axis1 = np.array([0, 0, 1], float)
self.axis2 = np.array([1, 0, 0], float)
self.film_width = 35.0 # mm
pos, dir = from_film(self.point,
axis1=self.axis1,
axis2=self.axis2,
size=self.size,
width=self.film_width)
self.rays = gpu.GPURays(pos, dir, max_alpha_depth=self.max_alpha_depth)
self.pixels_gpu = ga.empty(self.npixels, dtype=np.uint32)
self.movie = False
self.movie_index = 0
self.movie_dir = None
self.hybrid_render = False
def render_particle_track(self):
x = 10.0
h = x * np.sqrt(3) / 2
pyramid = make.linear_extrude([-x / 2, 0, x / 2],
[-h / 2, h / 2, -h / 2], h, [0] * 3,
[0] * 3)
marker = Solid(pyramid, vacuum, vacuum)
if self.photon_display_mode == 'beg':
photons = self.ev.photons_beg
else:
photons = self.ev.photons_end
geometry = Geometry()
sample_factor = max(1, len(photons.pos) / 10000)
for pos in photons.pos[::sample_factor]:
geometry.add_solid(marker,
displacement=pos,
rotation=make_rotation_matrix(
np.random.uniform(0, 2 * np.pi),
uniform_sphere()))
geometry = create_geometry_from_obj(geometry)
gpu_geometry = gpu.GPUGeometry(geometry)
self.gpu_geometries = [self.gpu_geometry, gpu_geometry]
def loadlayer(self, layer):
if layer is None:
self.gpu_geometries = [self.gpu_geometry]
else:
try:
gpu_geometry = self.bvh_layers[layer]
except KeyError:
geometry = bvh_mesh(self.geometry, layer)
gpu_geometry = gpu.GPUGeometry(geometry, print_usage=False)
self.bvh_layers[layer] = gpu_geometry
self.gpu_geometries = [self.gpu_geometry, gpu_geometry]
self.update()
def __init__(self,
detector,
seed=None,
cuda_device=None,
particle_tracking=False,
photon_tracking=False,
geant4_processes=4,
nthreads_per_block=64,
max_blocks=1024):
self.detector = detector
self.nthreads_per_block = nthreads_per_block
self.max_blocks = max_blocks
self.photon_tracking = photon_tracking
if seed is None:
self.seed = pick_seed()
else:
self.seed = seed
# We have three generators to seed: numpy.random, GEANT4, and CURAND.
# The latter two are done below.
np.random.seed(self.seed)
if geant4_processes > 0:
self.photon_generator = generator.photon.G4ParallelGenerator(
geant4_processes,
detector.detector_material,
base_seed=self.seed,
tracking=particle_tracking)
else:
self.photon_generator = None
self.context = gpu.create_cuda_context(cuda_device)
if hasattr(detector, 'num_channels'):
self.gpu_geometry = gpu.GPUDetector(detector)
self.gpu_daq = gpu.GPUDaq(self.gpu_geometry)
self.gpu_pdf = gpu.GPUPDF()
self.gpu_pdf_kernel = gpu.GPUKernelPDF()
else:
self.gpu_geometry = gpu.GPUGeometry(detector)
self.rng_states = gpu.get_rng_states(self.nthreads_per_block *
self.max_blocks,
seed=self.seed)
self.pdf_config = None
def propagate_photon(photon_type, numPhotons, nr_steps, geometry,
nthreads_per_block, max_blocks, rng_states):
gpu_photons = gpu.GPUPhotons(photon_type)
gpu_geometry = gpu.GPUGeometry(geometry)
photon_track = np.zeros((nr_steps, numPhotons, 3))
for i in range(nr_steps):
gpu_photons.propagate(gpu_geometry,
rng_states,
nthreads_per_block=nthreads_per_block,
max_blocks=max_blocks,
max_steps=1)
photons = gpu_photons.get()
photon_track[i, :, 0] = photons.pos[:, 0]
photon_track[i, :, 1] = photons.pos[:, 1]
photon_track[i, :, 2] = photons.pos[:, 2]
return photons, photon_track
def render_mc_info(self):
#need to render photon tracking info if available
self.gpu_geometries = [self.gpu_geometry]
if self.sum_mode or self.ev is None:
return
if self.photon_display_mode == 'beg':
photons = self.ev.photons_beg
elif self.photon_display_mode == 'end':
photons = self.ev.photons_end
else:
photons = None
if photons is not None:
geometry = Geometry()
self.render_photons(geometry, photons)
geometry = create_geometry_from_obj(geometry)
gpu_geometry = gpu.GPUGeometry(geometry)
self.gpu_geometries.append(gpu_geometry)
if self.track_display_mode in ['geant4', 'both'
] and self.ev.vertices is not None:
geometry = Geometry()
any = False
for vertex in self.ev.vertices:
if vertex.steps:
any = True
self.render_vertex(geometry, vertex, children=True)
if any:
geometry = create_geometry_from_obj(geometry)
gpu_geometry = gpu.GPUGeometry(geometry)
self.gpu_geometries.append(gpu_geometry)
if self.track_display_mode in ['chroma', 'both'
] and self.ev.photon_tracks is not None:
geometry = Geometry()
print('Total Photons', len(self.ev.photon_tracks))
def has(flags, test):
return flags & test == test
tracks = self.ev.photon_tracks
if self.photons_detected_only:
detected = np.asarray([
has(track.flags[-1], event.SURFACE_DETECT)
for track in tracks
])
tracks = [t for t, m in zip(tracks, detected) if m]
cherenkov = np.asarray([
has(track.flags[0], event.CHERENKOV)
and not has(track.flags[-1], event.BULK_REEMIT)
for track in tracks
])
scintillation = np.asarray([
has(track.flags[0], event.SCINTILLATION)
and not has(track.flags[-1], event.BULK_REEMIT)
for track in tracks
])
reemission = np.asarray(
[has(track.flags[-1], event.BULK_REEMIT) for track in tracks])
if self.photons_only_type is not None:
if self.photons_only_type == 'cher':
selector = cherenkov
elif self.photons_only_type == 'scint':
selector = scintillation
elif self.photons_only_type == 'reemit':
selector = reemission
else:
raise Exception('Unknown only type: %s' % only)
tracks = [t for t, m in zip(tracks, selector) if m]
cherenkov = cherenkov[selector]
scintillation = scintillation[selector]
reemission = reemission[selector]
nphotons = len(tracks)
prob = self.photons_max / nphotons if self.photons_max is not None else 1.0
selector = np.random.random(len(tracks)) < prob
nphotons = np.count_nonzero(selector)
for i, track in ((i, t)
for i, (s, t) in enumerate(zip(selector, tracks))
if s):
if cherenkov[i]:
color = [255, 0, 0]
elif scintillation[i]:
color = [0, 0, 255]
elif reemission[i]:
color = [0, 255, 0]
else:
color = [255, 255, 255]
steps = min(
len(track), self.photons_max_steps
) if self.photons_max_steps is not None else len(track)
self.render_photon_track(geometry,
track[:steps],
sz=self.photons_track_size,
color=color)
if nphotons > 0:
print('Rendered Photons', nphotons)
geometry = create_geometry_from_obj(geometry)
gpu_geometry = gpu.GPUGeometry(geometry)
self.gpu_geometries.append(gpu_geometry)
def render_mc_info_all_events(self):
#function added to visualize all events in a root file at the same time
self.gpu_geometries = [self.gpu_geometry]
for i, ev in enumerate(self.rr):
print('Evaluating event %i' % i)
if self.sum_mode or ev is None:
return
if self.track_display_mode in ['chroma', 'both'
] and ev.photon_tracks is not None:
geometry = Geometry()
print('Total Photons', len(ev.photon_tracks))
def has(flags, test):
return flags & test == test
tracks = ev.photon_tracks
if self.photons_detected_only:
detected = np.asarray([
has(track.flags[-1], event.SURFACE_DETECT)
for track in tracks
])
tracks = [t for t, m in zip(tracks, detected) if m]
cherenkov = np.asarray([
has(track.flags[0], event.CHERENKOV)
and not has(track.flags[-1], event.BULK_REEMIT)
for track in tracks
])
scintillation = np.asarray([
has(track.flags[0], event.SCINTILLATION)
and not has(track.flags[-1], event.BULK_REEMIT)
for track in tracks
])
reemission = np.asarray([
has(track.flags[-1], event.BULK_REEMIT) for track in tracks
])
if self.photons_only_type is not None:
if self.photons_only_type == 'cher':
selector = cherenkov
elif self.photons_only_type == 'scint':
selector = scintillation
elif self.photons_only_type == 'reemit':
selector = reemission
else:
raise Exception('Unknown only type: %s' % only)
tracks = [t for t, m in zip(tracks, selector) if m]
cherenkov = cherenkov[selector]
scintillation = scintillation[selector]
reemission = reemission[selector]
nphotons = len(tracks)
prob = self.photons_max / nphotons if self.photons_max is not None and nphotons is not 0 else 1.0
selector = np.random.random(len(tracks)) < prob
nphotons = np.count_nonzero(selector)
for i, track in ((i, t)
for i, (s,
t) in enumerate(zip(selector, tracks))
if s):
if cherenkov[i]:
color = [255, 0, 0]
elif scintillation[i]:
color = [0, 0, 255]
elif reemission[i]:
color = [0, 255, 0]
else:
color = [255, 255, 255]
steps = min(
len(track), self.photons_max_steps
) if self.photons_max_steps is not None else len(track)
self.render_photon_track(geometry,
track[:steps],
sz=self.photons_track_size,
color=color)
if nphotons > 0:
print('Rendered Photons', nphotons)
geometry = create_geometry_from_obj(geometry)
gpu_geometry = gpu.GPUGeometry(geometry)
self.gpu_geometries.append(gpu_geometry)
