class SCR(object):
def __init__(self, param_file):
self.params = parameters.read_par_file(param_file)
self.grain_fitter = GrainFitter()
self.field_converter = FieldConverter()
def reconstruct(self, flt, grains, number_y_scans, ymin, ystep,
grain_topology_masks):
rows, cols = grain_topology_masks[0].shape
field_recons = self.field_converter.initiate_field_dict(rows, cols)
for i, g in enumerate(grains):
active = grain_topology_masks[i]
ii, jj = np.mgrid[0:rows, 0:rows] - rows // 2
ii = -1 * ii
for j, (ix, iy) in enumerate(zip(ii[active], jj[active])):
voxel = self.fit_one_point(g, flt, self.params, ix, iy, ystep)
row = ix + rows // 2
col = iy + rows // 2
self.field_converter.add_voxel_to_field(
voxel, field_recons, row, col, self.params)
return field_recons
def fit_one_point(self, gr, flt, pars, ix, iy, ystep):
"""
Take each time the nearest point in dty (not the mask!)
"""
om = np.radians(flt.omega[gr.mask])
co = np.cos(om)
so = np.sin(om)
#idtycalc = np.round(-ix * so + iy * co) # this seeems wrong?! why mirror across y!?
idtycalc = np.round(ix * so + iy * co)
idty = np.round(flt.dty[gr.mask] / ystep)
# m = abs(dty - dtycalc) < ystep*0.75
m = idtycalc == idty
voxel = grain.grain(gr.ubi)
voxel.hkl = gr.hkl[:, m]
voxel.etasigns = gr.etasigns[m]
inds = np.arange(flt.nrows, dtype=int)
voxel.mask = np.zeros(flt.nrows, np.bool)
voxel.mask[inds[gr.mask][m]] = True
self.grain_fitter.fit_one_grain(voxel, flt, pars)
return voxel
def __init__(self,
param_file,
omegastep,
gradient_constraint,
maxiter=100,
number_cpus=None):
self.params = parameters.read_par_file(param_file)
self.omegastep = omegastep
self.field_converter = FieldConverter()
self.gradient_constraint = gradient_constraint
self.maxiter = maxiter
self.number_cpus = number_cpus
class ASR(object):
def __init__(self,
param_file,
omegastep,
gradient_constraint,
maxiter=100,
number_cpus=None):
self.params = parameters.read_par_file(param_file)
self.omegastep = omegastep
self.field_converter = FieldConverter()
self.gradient_constraint = gradient_constraint
self.maxiter = maxiter
self.number_cpus = number_cpus
def reconstruct(self, flt, grains, number_y_scans, ymin, ystep,
grain_topology_masks):
rows, cols = grain_topology_masks[0].shape
field_recons = self.field_converter.initiate_field_dict(rows, cols)
# Handle user input CPU settings
if self.number_cpus is None:
nproc = 1
elif self.number_cpus == 'all':
nproc = mp.cpu_count() - 1
else:
nproc = self.number_cpus
print('Attempting to run with: ' + str(nproc) + ' active CPUs')
# Launch ASR reconstructions in parallel
def multi_asr(active, ystep, number_y_scans, ymin, g, flt,
result_queue):
result_queue.put(
self.run_asr(active, ystep, number_y_scans, ymin, g, flt))
running_procs = []
result_queue = mp.Queue()
count = 0
for i in range(nproc):
if count < len(grains):
args = grain_topology_masks[
count], ystep, number_y_scans, ymin, grains[
count], flt, result_queue
running_procs.append(mp.Process(target=multi_asr, args=args))
running_procs[-1].start()
print('Launched ASR for grain ' + str(count))
count += 1
# Collect results from individual processes and refill the queue with new jobs
results = []
while True:
try:
result = result_queue.get(False, 0.01)
results.append(result)
except:
pass
allExited = True
for proc in running_procs:
if proc.exitcode is None:
allExited = False
break
for proc in running_procs:
if proc.exitcode is not None and count < len(grains):
args = grain_topology_masks[
count], ystep, number_y_scans, ymin, grains[
count], flt, result_queue
running_procs.append(
mp.Process(target=multi_asr, args=args))
running_procs[-1].start()
print('Launched parallel process for grain ' + str(count))
count += 1
if allExited & result_queue.empty():
break
# Merge results from all the processes
for res in results:
voxels, coordinates = res
for voxel, c in zip(voxels, coordinates):
row = int((c[0] / ystep) + rows // 2)
col = int((c[1] / ystep) + rows // 2)
self.field_converter.add_voxel_to_field(
voxel, field_recons, row, col, self.params)
return field_recons
def run_asr(self, topology, ystep, number_y_scans, ymin, g, flt):
origin = np.array([topology.shape[0] // 2, topology.shape[0] // 2])
mesh = mesher.create_pixel_mesh(topology, ystep, origin)
distance = self.params.get('distance')
pixelsize = (self.params.get('y_size') +
self.params.get('z_size')) / 2.0
wavelength = self.params.get('wavelength')
cell_original = [
self.params.get('cell__a'),
self.params.get('cell__b'),
self.params.get('cell__c'),
self.params.get('cell_alpha'),
self.params.get('cell_beta'),
self.params.get('cell_gamma')
]
strains, directions, omegas, dtys, weights, tths, etas, intensity, sc, G_omegas, hkl = mc.extract_strain_and_directions(
cell_original, wavelength, distance, pixelsize, g, flt, ymin,
ystep, self.omegastep, number_y_scans)
# #With orient
# UBs = asr.solve_with_orient( g, hkl, G_omegas, omegas, weights, mesh, dtys, ystep, cell_original )
# voxels = []
# coordinates = mesher.get_elm_centres( mesh )
# #print("UBs.shape",UBs.shape)
# for i in range(UBs.shape[0]):
# #print(UBs[i,:,:])
# UBI = np.linalg.inv(UBs[i,:,:])
# voxels.append( grain.grain( UBI ) )
# return voxels, coordinates
# only strain
# tikhonov_solve
#eps_xx, eps_yy, eps_zz, eps_yz, eps_xz, eps_xy = asr.tikhonov_solve( mesh, directions, strains , omegas, dtys, weights, ystep, self.gradient_constraint )
#trust region
eps_xx, eps_yy, eps_zz, eps_yz, eps_xz, eps_xy = asr.trust_constr_solve(
mesh, etas, hkl, tths, intensity, directions, strains, omegas,
dtys, weights, ystep, self.gradient_constraint, self.maxiter)
voxels = []
coordinates = mesher.get_elm_centres(mesh)
for i, elm in enumerate(mesh):
# [e11, e12, e13, e22, e23, e33]
epsilon_sample = np.array([[eps_xx[i], eps_xy[i], eps_xz[i]],
[eps_xy[i], eps_yy[i], eps_yz[i]],
[eps_xz[i], eps_yz[i], eps_zz[i]]])
eps_cry = np.dot(np.dot(np.transpose(g.u), epsilon_sample), g.u)
eps_cry_flat = [
eps_cry[0, 0], eps_cry[0, 1], eps_cry[0, 2], eps_cry[1, 1],
eps_cry[1, 2], eps_cry[2, 2]
]
B = tools.epsilon_to_b(eps_cry_flat, cell_original)
UBI = np.linalg.inv(np.dot(g.u, B)) * (2 * np.pi)
voxels.append(grain.grain(UBI))
return voxels, coordinates
def __init__(self, param_file, cif_file, omegastep):
self.params = parameters.read_par_file(param_file)
self.cif_file = cif_file
self.omegastep = omegastep
self.field_converter = FieldConverter()
class PCR(object):
def __init__(self, param_file, cif_file, omegastep):
self.params = parameters.read_par_file(param_file)
self.cif_file = cif_file
self.omegastep = omegastep
self.field_converter = FieldConverter()
def reconstruct(self, flt, grains, number_y_scans, ymin, ystep,
grain_topology_masks):
rows, cols = grain_topology_masks[0].shape
field_recons = self.field_converter.initiate_field_dict(rows, cols)
for i, g in enumerate(grains):
active = grain_topology_masks[i]
#plt.imshow(active)
#plt.show()
voxels_as_grain_objects = self.run_pcr(self.cif_file, \
active, flt, g, number_y_scans, ymin, ystep)
ii, jj = np.mgrid[0:rows, 0:rows] - rows // 2
ii = -1 * ii
for j, (ix, iy) in enumerate(zip(ii[active], jj[active])):
index1 = -(ix - ii[0, 0])
index2 = iy - jj[0, 0]
voxel = voxels_as_grain_objects[index1, index2]
row = ix + rows // 2
col = iy + rows // 2
self.field_converter.add_voxel_to_field(
voxel, field_recons, row, col, self.params)
return field_recons
def run_pcr(self, cif_file, grain_mask, flt, gr, number_y_scans, ymin,
ystep):
no_voxels = sum(grain_mask[grain_mask == 1])
unit_cell = self.field_converter.extract_cell(self.params)
UBI = gr.ubi.copy()
cell = tools.ubi_to_cell(UBI)
U, strain = tools.ubi_to_u_and_eps(UBI, unit_cell)
euler = tools.u_to_euler(U)
average = np.concatenate((strain, euler), axis=None)
initial_guess = np.concatenate((average, average), axis=None)
for i in range(no_voxels - 2):
initial_guess = np.concatenate((initial_guess, average), axis=None)
th_min, th_max = setup_grain.get_theta_bounds(flt, gr)
param = setup_grain.setup_experiment(self.params, cif_file, no_voxels,
ystep, th_min, th_max)
measured_data = setup_grain.get_measured_data(gr, flt, number_y_scans,
ymin, ystep, param)
hkl = setup_grain.get_hkls(param, flt, gr)
voxel_positions, C, constraint = setup_grain.get_positions(
grain_mask, ystep)
voxel_data = find_refl_func.find_refl_func(param, hkl, voxel_positions,
measured_data, unit_cell,
initial_guess, ymin,
number_y_scans, C,
constraint)
bounds_low, bounds_high = setup_grain.get_bounds_strain(initial_guess)
solution = voxel_data.steepest_descent(bounds_low, bounds_high,
initial_guess)
voxels_as_grain_objects = setup_grain.map_solution_to_voxels(
solution, grain_mask, no_voxels, voxel_data, var_choice='strain')
return voxels_as_grain_objects
def __init__(self, param_file, omegastep, gradient_constraint):
self.params = parameters.read_par_file(param_file)
self.omegastep = omegastep
self.field_converter = FieldConverter()
self.gradient_constraint = gradient_constraint
class ASR(object):
def __init__(self, param_file, omegastep, gradient_constraint):
self.params = parameters.read_par_file(param_file)
self.omegastep = omegastep
self.field_converter = FieldConverter()
self.gradient_constraint = gradient_constraint
def reconstruct(self, flt, grains, number_y_scans, ymin, ystep,
grain_topology_masks):
rows, cols = grain_topology_masks[0].shape
field_recons = self.field_converter.initiate_field_dict(rows, cols)
for i, g in enumerate(grains):
active = grain_topology_masks[i]
voxels, coordinates = self.run_asr(active, ystep, number_y_scans,
ymin, g, flt)
for voxel, c in zip(voxels, coordinates):
row = int((c[0] / ystep) + rows // 2)
col = int((c[1] / ystep) + rows // 2)
self.field_converter.add_voxel_to_field(
voxel, field_recons, row, col, self.params)
return field_recons
def run_asr(self, topology, ystep, number_y_scans, ymin, g, flt):
origin = np.array([topology.shape[0] // 2, topology.shape[0] // 2])
mesh = mesher.create_pixel_mesh(topology, ystep, origin)
distance = self.params.get('distance')
pixelsize = (self.params.get('y_size') +
self.params.get('z_size')) / 2.0
wavelength = self.params.get('wavelength')
cell_original = [
self.params.get('cell__a'),
self.params.get('cell__b'),
self.params.get('cell__c'),
self.params.get('cell_alpha'),
self.params.get('cell_beta'),
self.params.get('cell_gamma')
]
strains, directions, omegas, dtys, weights, tths, etas, intensity, sc, G_omegas, hkl = mc.extract_strain_and_directions(
cell_original, wavelength, distance, pixelsize, g, flt, ymin,
ystep, self.omegastep, number_y_scans)
# #With orient
# UBs = asr.solve_with_orient( g, hkl, G_omegas, omegas, weights, mesh, dtys, ystep, cell_original )
# voxels = []
# coordinates = mesher.get_elm_centres( mesh )
# #print("UBs.shape",UBs.shape)
# for i in range(UBs.shape[0]):
# #print(UBs[i,:,:])
# UBI = np.linalg.inv(UBs[i,:,:])
# voxels.append( grain.grain( UBI ) )
# return voxels, coordinates
# only strain
# tikhonov_solve
#eps_xx, eps_yy, eps_zz, eps_yz, eps_xz, eps_xy = asr.tikhonov_solve( mesh, directions, strains , omegas, dtys, weights, ystep, self.gradient_constraint )
#trust region
eps_xx, eps_yy, eps_zz, eps_yz, eps_xz, eps_xy = asr.trust_constr_solve(
mesh, etas, hkl, tths, intensity, directions, strains, omegas,
dtys, weights, ystep, self.gradient_constraint)
voxels = []
coordinates = mesher.get_elm_centres(mesh)
for i, elm in enumerate(mesh):
# [e11, e12, e13, e22, e23, e33]
epsilon_sample = np.array([[eps_xx[i], eps_xy[i], eps_xz[i]],
[eps_xy[i], eps_yy[i], eps_yz[i]],
[eps_xz[i], eps_yz[i], eps_zz[i]]])
eps_cry = np.dot(np.dot(np.transpose(g.u), epsilon_sample), g.u)
eps_cry_flat = [
eps_cry[0, 0], eps_cry[0, 1], eps_cry[0, 2], eps_cry[1, 1],
eps_cry[1, 2], eps_cry[2, 2]
]
B = tools.epsilon_to_b(eps_cry_flat, cell_original)
UBI = np.linalg.inv(np.dot(g.u, B)) * (2 * np.pi)
voxels.append(grain.grain(UBI))
return voxels, coordinates
def __init__(self, param_file):
self.params = parameters.read_par_file(param_file)
self.grain_fitter = GrainFitter()
self.field_converter = FieldConverter()