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()