def simulate_laue_pattern(self, crystal_data, minEnergy=5., maxEnergy=35., rmat_s=None, tvec_s=None, grain_params=None, beam_vec=None): """ """ if isinstance(crystal_data, PlaneData): plane_data = crystal_data # grab the expanded list of hkls from plane_data hkls = np.hstack(plane_data.getSymHKLs()) # and the unit plane normals (G-vectors) in CRYSTAL FRAME gvec_c = np.dot(plane_data.latVecOps['B'], hkls) elif len(crystal_data) == 2: # !!! should clean this up hkls = np.array(crystal_data[0]) bmat = crystal_data[1] gvec_c = np.dot(bmat, hkls) else: raise (RuntimeError, 'argument list not understood') nhkls_tot = hkls.shape[1] # parse energy ranges # TODO: allow for spectrum parsing multipleEnergyRanges = False if hasattr(maxEnergy, '__len__'): assert len(maxEnergy) == len(minEnergy), \ 'energy cutoff ranges must have the same length' multipleEnergyRanges = True lmin = [] lmax = [] for i in range(len(maxEnergy)): lmin.append(ct.keVToAngstrom(maxEnergy[i])) lmax.append(ct.keVToAngstrom(minEnergy[i])) else: lmin = ct.keVToAngstrom(maxEnergy) lmax = ct.keVToAngstrom(minEnergy) # parse grain parameters kwarg if grain_params is None: grain_params = np.atleast_2d( np.hstack([np.zeros(6), ct.identity_6x1])) n_grains = len(grain_params) # sample rotation if rmat_s is None: rmat_s = ct.identity_3x3 # dummy translation vector... make input if tvec_s is None: tvec_s = ct.zeros_3 # beam vector if beam_vec is None: beam_vec = ct.beam_vec # ========================================================================= # LOOP OVER GRAINS # ========================================================================= # pre-allocate output arrays xy_det = np.nan * np.ones((n_grains, nhkls_tot, 2)) hkls_in = np.nan * np.ones((n_grains, 3, nhkls_tot)) angles = np.nan * np.ones((n_grains, nhkls_tot, 2)) dspacing = np.nan * np.ones((n_grains, nhkls_tot)) energy = np.nan * np.ones((n_grains, nhkls_tot)) for iG, gp in enumerate(grain_params): rmat_c = makeRotMatOfExpMap(gp[:3]) tvec_c = gp[3:6].reshape(3, 1) vInv_s = mutil.vecMVToSymm(gp[6:].reshape(6, 1)) # stretch them: V^(-1) * R * Gc gvec_s_str = np.dot(vInv_s, np.dot(rmat_c, gvec_c)) ghat_c_str = mutil.unitVector(np.dot(rmat_c.T, gvec_s_str)) # project dpts = gvecToDetectorXY(ghat_c_str.T, self.rmat, rmat_s, rmat_c, self.tvec, tvec_s, tvec_c, beamVec=beam_vec) # check intersections with detector plane canIntersect = ~np.isnan(dpts[:, 0]) npts_in = sum(canIntersect) if np.any(canIntersect): dpts = dpts[canIntersect, :].reshape(npts_in, 2) dhkl = hkls[:, canIntersect].reshape(3, npts_in) # back to angles tth_eta, gvec_l = detectorXYToGvec(dpts, self.rmat, rmat_s, self.tvec, tvec_s, tvec_c, beamVec=beam_vec) tth_eta = np.vstack(tth_eta).T # warp measured points if self.distortion is not None: if len(self.distortion) == 2: dpts = self.distortion[0](dpts, self.distortion[1], invert=True) else: raise (RuntimeError, "something is wrong with the distortion") # plane spacings and energies dsp = 1. / rowNorm(gvec_s_str[:, canIntersect].T) wlen = 2 * dsp * np.sin(0.5 * tth_eta[:, 0]) # clip to detector panel _, on_panel = self.clip_to_panel(dpts, buffer_edges=True) if multipleEnergyRanges: validEnergy = np.zeros(len(wlen), dtype=bool) for i in range(len(lmin)): in_energy_range = np.logical_and( wlen >= lmin[i], wlen <= lmax[i]) validEnergy = validEnergy | in_energy_range pass else: validEnergy = np.logical_and(wlen >= lmin, wlen <= lmax) pass # index for valid reflections keepers = np.where(np.logical_and(on_panel, validEnergy))[0] # assign output arrays xy_det[iG][keepers, :] = dpts[keepers, :] hkls_in[iG][:, keepers] = dhkl[:, keepers] angles[iG][keepers, :] = tth_eta[keepers, :] dspacing[iG, keepers] = dsp[keepers] energy[iG, keepers] = ct.keVToAngstrom(wlen[keepers]) pass # close conditional on valids pass # close loop on grains return xy_det, hkls_in, angles, dspacing, energy
def calibrate_instrument_from_sx(instr, grain_params, bmat, xyo_det, hkls_idx, param_flags=None, dparam_flags=None, ome_period=None, xtol=cnst.sqrt_epsf, ftol=cnst.sqrt_epsf, factor=10., sim_only=False, use_robust_lsq=False): """ arguments xyo_det, hkls_idx are DICTs over panels !!! distortion is still hosed... Currently a dict of detector keys with distortion[key] = [d_func, d_params, d_flags] """ pnames = [ '{:>24s}'.format('wavelength'), '{:>24s}'.format('chi'), '{:>24s}'.format('tvec_s[0]'), '{:>24s}'.format('tvec_s[1]'), '{:>24s}'.format('tvec_s[2]'), '{:>24s}'.format('expmap_c[0]'), '{:>24s}'.format('expmap_c[0]'), '{:>24s}'.format('expmap_c[0]'), '{:>24s}'.format('tvec_c[0]'), '{:>24s}'.format('tvec_c[1]'), '{:>24s}'.format('tvec_c[2]'), ] for det_key, panel in instr.detectors.iteritems(): pnames += [ '{:>24s}'.format('%s tilt[0]' % det_key), '{:>24s}'.format('%s tilt[1]' % det_key), '{:>24s}'.format('%s tilt[2]' % det_key), '{:>24s}'.format('%s tvec[0]' % det_key), '{:>24s}'.format('%s tvec[1]' % det_key), '{:>24s}'.format('%s tvec[2]' % det_key), ] # now add distortion if for det_key, panel in instr.detectors.iteritems(): if panel.distortion is not None: for j in range(len(panel.distortion[1])): pnames.append('{:>24s}'.format('%s dparam[%d]' % (det_key, j))) # reset parameter flags for instrument as specified if param_flags is None: param_flags = instr.param_flags else: # will throw an AssertionError if wrong length instr.param_flags = param_flags det_keys = instr.detectors.keys() # re-map omegas if need be if ome_period is not None: for det_key in det_keys: xyo_det[det_key][:, 2] = xfcapi.mapAngle(xyo_det[det_key][:, 2], ome_period) # grain parameters expmap_c = grain_params[:3] tvec_c = grain_params[3:6] vinv_s = grain_params[6:] plist_full = instr.calibration_params(expmap_c, tvec_c) dfuncs = {} ndparams = {} dparam_flags = [] for det_key, panel in instr.detectors.iteritems(): if panel.distortion is not None: dfuncs[det_key] = panel.distortion[0] # ititialize to all False... ndparams[det_key] = len(panel.distortion[1]) else: dfuncs[det_key] = None ndparams[det_key] = 0 dparam_flags.append(np.zeros(ndparams[det_key], dtype=bool)) dparam_flags = np.hstack(dparam_flags) refine_flags = np.hstack([param_flags, dparam_flags]) plist_fit = plist_full[refine_flags] fit_args = (plist_full, param_flags, dfuncs, dparam_flags, ndparams, instr, xyo_det, hkls_idx, bmat, vinv_s, ome_period, instr.beam_vector, instr.eta_vector) if sim_only: return sxcal_obj_func(plist_fit, plist_full, param_flags, dfuncs, dparam_flags, ndparams, instr, xyo_det, hkls_idx, bmat, vinv_s, ome_period, instr.beam_vector, instr.eta_vector, sim_only=True) else: print("Set up to refine:") for i in np.where(refine_flags)[0]: print("\t%s = %1.7e" % (pnames[i], plist_full[i])) # run optimization if use_robust_lsq: result = least_squares(sxcal_obj_func, plist_fit, args=fit_args, xtol=xtol, ftol=ftol, loss='soft_l1', method='trf') x = result.x resd = result.fun mesg = result.message ierr = result.status else: # do least squares problem x, cov_x, infodict, mesg, ierr = leastsq(sxcal_obj_func, plist_fit, args=fit_args, factor=factor, xtol=xtol, ftol=ftol, full_output=1) resd = infodict['fvec'] if ierr not in [1, 2, 3, 4]: raise RuntimeError("solution not found: ierr = %d" % ierr) else: print("INFO: optimization fininshed successfully with ierr=%d" % ierr) print("INFO: %s" % mesg) # ??? output message handling? fit_params = plist_full fit_params[refine_flags] = x # run simulation with optimized results sim_final = sxcal_obj_func(x, plist_full, param_flags, dfuncs, dparam_flags, ndparams, instr, xyo_det, hkls_idx, bmat, vinv_s, ome_period, instr.beam_vector, instr.eta_vector, sim_only=True) # ??? reset instrument here? instr.beam_energy = cnst.keVToAngstrom(fit_params[0]) instr.chi = fit_params[1] instr.tvec = fit_params[2:5] ii = 11 for det_key, panel in instr.detectors.iteritems(): panel.tilt = fit_params[ii:ii + 3] panel.tvec = fit_params[ii + 3:ii + 6] ii += 6 # !!! use jj to do distortion... if panel.distortion is not None: pass pass return fit_params, resd, sim_final
def simulate_rotation_series(self, plane_data, grain_param_list, eta_ranges=[ (-np.pi, np.pi), ], ome_ranges=[ (-np.pi, np.pi), ], ome_period=(-np.pi, np.pi), chi=0., tVec_s=ct.zeros_3, wavelength=None): """ """ # grab B-matrix from plane data bMat = plane_data.latVecOps['B'] # reconcile wavelength # * added sanity check on exclusions here; possible to # * make some reflections invalid (NaN) if wavelength is None: wavelength = plane_data.wavelength else: if plane_data.wavelength != wavelength: plane_data.wavelength = ct.keVToAngstrom(wavelength) assert not np.any(np.isnan(plane_data.getTTh())),\ "plane data exclusions incompatible with wavelength" # vstacked G-vector id, h, k, l full_hkls = xrdutil._fetch_hkls_from_planedata(plane_data) """ LOOP OVER GRAINS """ valid_ids = [] valid_hkls = [] valid_angs = [] valid_xys = [] ang_pixel_size = [] for gparm in grain_param_list: # make useful parameters rMat_c = makeRotMatOfExpMap(gparm[:3]) tVec_c = gparm[3:6] vInv_s = gparm[6:] # All possible bragg conditions as vstacked [tth, eta, ome] # for each omega solution angList = np.vstack( oscillAnglesOfHKLs( full_hkls[:, 1:], chi, rMat_c, bMat, wavelength, vInv=vInv_s, )) # filter by eta and omega ranges # ??? get eta range from detector? allAngs, allHKLs = xrdutil._filter_hkls_eta_ome( full_hkls, angList, eta_ranges, ome_ranges) allAngs[:, 2] = mapAngle(allAngs[:, 2], ome_period) # find points that fall on the panel det_xy, rMat_s = xrdutil._project_on_detector_plane( allAngs, self.rmat, rMat_c, chi, self.tvec, tVec_c, tVec_s, self.distortion) xys_p, on_panel = self.clip_to_panel(det_xy) valid_xys.append(xys_p) # grab hkls and gvec ids for this panel valid_hkls.append(allHKLs[on_panel, 1:]) valid_ids.append(allHKLs[on_panel, 0]) # reflection angles (voxel centers) and pixel size in (tth, eta) valid_angs.append(allAngs[on_panel, :]) ang_pixel_size.append(self.angularPixelSize(xys_p)) return valid_ids, valid_hkls, valid_angs, valid_xys, ang_pixel_size
def wavelength(self): return constants.keVToAngstrom(self.energy)
def wavelength(self, x): """ in angstrom """ self._energy = constants.keVToAngstrom(x)
def mockup_experiment(): # user options # each grain is provided in the form of a quaternion. # The following array contains the quaternions for the array. Note that the # quaternions are in the columns, with the first row (row 0) being the real # part w. We assume that we are dealing with unit quaternions quats = np.array([[0.91836393, 0.90869942], [0.33952917, 0.18348350], [0.17216207, 0.10095837], [0.10811041, 0.36111851]]) n_grains = quats.shape[-1] # last dimension provides the number of grains phis = 2. * np.arccos( quats[0, :]) # phis are the angles for the quaternion # ns contains the rotation axis as an unit vector ns = hexrd.matrixutil.unitVector(quats[1:, :]) exp_maps = np.array([phis[i] * ns[:, i] for i in range(n_grains)]) rMat_c = rotations.rotMatOfQuat(quats) cvec = np.arange(-25, 26) X, Y, Z = np.meshgrid(cvec, cvec, cvec) crd0 = 1e-3 * np.vstack([X.flatten(), Y.flatten(), Z.flatten()]).T crd1 = crd0 + np.r_[0.100, 0.100, 0] crds = np.array([crd0, crd1]) # make grain parameters grain_params = [] for i in range(n_grains): for j in range(len(crd0)): grain_params.append( np.hstack([exp_maps[i, :], crds[i][j, :], vInv_ref])) # scan range and period ome_period = (0, 2 * np.pi) ome_range = [ ome_period, ] ome_step = np.radians(1.) nframes = 0 for i in range(len(ome_range)): nframes += int((ome_range[i][1] - ome_range[i][0]) / ome_step) ome_edges = np.arange(nframes + 1) * ome_step # instrument with open('./retiga.yml', 'r') as fildes: instr = instrument.HEDMInstrument(yaml.safe_load(fildes)) panel = next(iter(instr.detectors.values())) # !!! there is only 1 # tranform paramters # Sample chi = instr.chi tVec_s = instr.tvec # Detector rMat_d = panel.rmat tilt_angles_xyzp = np.asarray(rotations.angles_from_rmat_xyz(rMat_d)) tVec_d = panel.tvec # pixels row_ps = panel.pixel_size_row col_ps = panel.pixel_size_col pixel_size = (row_ps, col_ps) nrows = panel.rows ncols = panel.cols # panel dimensions panel_dims = [tuple(panel.corner_ll), tuple(panel.corner_ur)] x_col_edges = panel.col_edge_vec y_row_edges = panel.row_edge_vec rx, ry = np.meshgrid(x_col_edges, y_row_edges) max_pixel_tth = instrument.max_tth(instr) detector_params = np.hstack([tilt_angles_xyzp, tVec_d, chi, tVec_s]) distortion = panel.distortion # !!! must be None for now # a different parametrization for the sensor # (makes for faster quantization) base = np.array([x_col_edges[0], y_row_edges[0], ome_edges[0]]) deltas = np.array([ x_col_edges[1] - x_col_edges[0], y_row_edges[1] - y_row_edges[0], ome_edges[1] - ome_edges[0] ]) inv_deltas = 1.0 / deltas clip_vals = np.array([ncols, nrows]) # dilation max_diameter = np.sqrt(3) * 0.005 row_dilation = int(np.ceil(0.5 * max_diameter / row_ps)) col_dilation = int(np.ceil(0.5 * max_diameter / col_ps)) # crystallography data beam_energy = valunits.valWUnit("beam_energy", "energy", instr.beam_energy, "keV") beam_wavelength = constants.keVToAngstrom(beam_energy.getVal('keV')) dmin = valunits.valWUnit( "dmin", "length", 0.5 * beam_wavelength / np.sin(0.5 * max_pixel_tth), "angstrom") gold = material.Material() gold.latticeParameters = [4.0782] gold.dmin = dmin gold.beamEnergy = beam_energy gold.planeData.exclusions = None gold.planeData.tThMax = max_pixel_tth # note this comes detector ns = argparse.Namespace() # grains related information ns.n_grains = n_grains # this can be derived from other values... ns.rMat_c = rMat_c # n_grains rotation matrices (one per grain) ns.exp_maps = exp_maps # n_grains exp_maps (one per grain) ns.plane_data = gold.planeData ns.detector_params = detector_params ns.pixel_size = pixel_size ns.ome_range = ome_range ns.ome_period = ome_period ns.x_col_edges = x_col_edges ns.y_row_edges = y_row_edges ns.ome_edges = ome_edges ns.ncols = ncols ns.nrows = nrows ns.nframes = nframes # used only in simulate... ns.rMat_d = rMat_d ns.tVec_d = tVec_d ns.chi = chi # note this is used to compute S... why is it needed? ns.tVec_s = tVec_s ns.rMat_c = rMat_c ns.row_dilation = row_dilation ns.col_dilation = col_dilation ns.distortion = distortion ns.panel_dims = panel_dims # used only in simulate... ns.base = base ns.inv_deltas = inv_deltas ns.clip_vals = clip_vals return grain_params, ns
from enum import Enum import numpy as np from hexrd import constants # Wavelength to kilo electron volt conversion WAVELENGTH_TO_KEV = constants.keVToAngstrom(1.) KEV_TO_WAVELENGTH = constants.keVToAngstrom(1.) DEFAULT_CMAP = 'plasma' UI_DARK_INDEX_MEDIAN = 0 UI_DARK_INDEX_EMPTY_FRAMES = 1 UI_DARK_INDEX_AVERAGE = 2 UI_DARK_INDEX_MAXIMUM = 3 UI_DARK_INDEX_FILE = 4 UI_DARK_INDEX_NONE = 5 UI_TRANS_INDEX_NONE = 0 UI_TRANS_INDEX_FLIP_VERTICALLY = 1 UI_TRANS_INDEX_FLIP_HORIZONTALLY = 2 UI_TRANS_INDEX_TRANSPOSE = 3 UI_TRANS_INDEX_ROTATE_90 = 4 UI_TRANS_INDEX_ROTATE_180 = 5 UI_TRANS_INDEX_ROTATE_270 = 6 UI_AGG_INDEX_NONE = 0 UI_AGG_INDEX_MAXIMUM = 1 UI_AGG_INDEX_MEDIAN = 2 UI_AGG_INDEX_AVERAGE = 3
def wavelength(self): return constants.keVToAngstrom(self.energy)
def wavelength(self, x): """ in angstrom """ self._energy = constants.keVToAngstrom(x)
instr = instrument.HEDMInstrument(instr_cfg) data_path = './' img_series_root = 'ge_scan_114' img_series = imageseries.open( os.path.join( img_series_root + '-fcache-dir', img_series_root + '-fcache.yml' ) , 'frame-cache') nframes = 240 average_frame = imageseries.stats.average(img_series) #%% wlen = constants.keVToAngstrom(instr_cfg['beam']['energy']) matl = make_matl('LSHR', 225, [3.5905,]) pd = matl.planeData pd.wavelength = instr_cfg['beam']['energy'] # takes keV pd.exclusions = np.zeros_like(pd.exclusions, dtype=bool) set_by_tth_max = False if set_by_tth_max: pd.tThMax = np.radians(6.75) tth_del = np.radians(0.75) tth_avg = np.average(pd.getTTh()) tth_lo = pd.getTTh()[0] - tth_del tth_hi = pd.getTTh()[-1] + tth_del else:
def simulate_laue_pattern(self, crystal_data, minEnergy=5., maxEnergy=35., rmat_s=None, tvec_s=None, grain_params=None, beam_vec=None): """ """ if isinstance(crystal_data, PlaneData): plane_data = crystal_data # grab the expanded list of hkls from plane_data hkls = np.hstack(plane_data.getSymHKLs()) # and the unit plane normals (G-vectors) in CRYSTAL FRAME gvec_c = np.dot(plane_data.latVecOps['B'], hkls) elif len(crystal_data) == 2: # !!! should clean this up hkls = np.array(crystal_data[0]) bmat = crystal_data[1] gvec_c = np.dot(bmat, hkls) else: raise(RuntimeError, 'argument list not understood') nhkls_tot = hkls.shape[1] # parse energy ranges # TODO: allow for spectrum parsing multipleEnergyRanges = False if hasattr(maxEnergy, '__len__'): assert len(maxEnergy) == len(minEnergy), \ 'energy cutoff ranges must have the same length' multipleEnergyRanges = True lmin = [] lmax = [] for i in range(len(maxEnergy)): lmin.append(ct.keVToAngstrom(maxEnergy[i])) lmax.append(ct.keVToAngstrom(minEnergy[i])) else: lmin = ct.keVToAngstrom(maxEnergy) lmax = ct.keVToAngstrom(minEnergy) # parse grain parameters kwarg if grain_params is None: grain_params = np.atleast_2d( np.hstack([np.zeros(6), ct.identity_6x1]) ) n_grains = len(grain_params) # sample rotation if rmat_s is None: rmat_s = ct.identity_3x3 # dummy translation vector... make input if tvec_s is None: tvec_s = ct.zeros_3 # beam vector if beam_vec is None: beam_vec = ct.beam_vec # ========================================================================= # LOOP OVER GRAINS # ========================================================================= # pre-allocate output arrays xy_det = np.nan*np.ones((n_grains, nhkls_tot, 2)) hkls_in = np.nan*np.ones((n_grains, 3, nhkls_tot)) angles = np.nan*np.ones((n_grains, nhkls_tot, 2)) dspacing = np.nan*np.ones((n_grains, nhkls_tot)) energy = np.nan*np.ones((n_grains, nhkls_tot)) for iG, gp in enumerate(grain_params): rmat_c = makeRotMatOfExpMap(gp[:3]) tvec_c = gp[3:6].reshape(3, 1) vInv_s = mutil.vecMVToSymm(gp[6:].reshape(6, 1)) # stretch them: V^(-1) * R * Gc gvec_s_str = np.dot(vInv_s, np.dot(rmat_c, gvec_c)) ghat_c_str = mutil.unitVector(np.dot(rmat_c.T, gvec_s_str)) # project dpts = gvecToDetectorXY(ghat_c_str.T, self.rmat, rmat_s, rmat_c, self.tvec, tvec_s, tvec_c, beamVec=beam_vec) # check intersections with detector plane canIntersect = ~np.isnan(dpts[:, 0]) npts_in = sum(canIntersect) if np.any(canIntersect): dpts = dpts[canIntersect, :].reshape(npts_in, 2) dhkl = hkls[:, canIntersect].reshape(3, npts_in) # back to angles tth_eta, gvec_l = detectorXYToGvec( dpts, self.rmat, rmat_s, self.tvec, tvec_s, tvec_c, beamVec=beam_vec) tth_eta = np.vstack(tth_eta).T # warp measured points if self.distortion is not None: if len(self.distortion) == 2: dpts = self.distortion[0]( dpts, self.distortion[1], invert=True) else: raise(RuntimeError, "something is wrong with the distortion") # plane spacings and energies dsp = 1. / rowNorm(gvec_s_str[:, canIntersect].T) wlen = 2*dsp*np.sin(0.5*tth_eta[:, 0]) # clip to detector panel _, on_panel = self.clip_to_panel(dpts, buffer_edges=True) if multipleEnergyRanges: validEnergy = np.zeros(len(wlen), dtype=bool) for i in range(len(lmin)): in_energy_range = np.logical_and( wlen >= lmin[i], wlen <= lmax[i]) validEnergy = validEnergy | in_energy_range pass else: validEnergy = np.logical_and(wlen >= lmin, wlen <= lmax) pass # index for valid reflections keepers = np.where(np.logical_and(on_panel, validEnergy))[0] # assign output arrays xy_det[iG][keepers, :] = dpts[keepers, :] hkls_in[iG][:, keepers] = dhkl[:, keepers] angles[iG][keepers, :] = tth_eta[keepers, :] dspacing[iG, keepers] = dsp[keepers] energy[iG, keepers] = ct.keVToAngstrom(wlen[keepers]) pass # close conditional on valids pass # close loop on grains return xy_det, hkls_in, angles, dspacing, energy
def simulate_rotation_series(self, plane_data, grain_param_list, eta_ranges=[(-np.pi, np.pi), ], ome_ranges=[(-np.pi, np.pi), ], ome_period=(-np.pi, np.pi), chi=0., tVec_s=ct.zeros_3, wavelength=None): """ """ # grab B-matrix from plane data bMat = plane_data.latVecOps['B'] # reconcile wavelength # * added sanity check on exclusions here; possible to # * make some reflections invalid (NaN) if wavelength is None: wavelength = plane_data.wavelength else: if plane_data.wavelength != wavelength: plane_data.wavelength = ct.keVToAngstrom(wavelength) assert not np.any(np.isnan(plane_data.getTTh())),\ "plane data exclusions incompatible with wavelength" # vstacked G-vector id, h, k, l full_hkls = xrdutil._fetch_hkls_from_planedata(plane_data) """ LOOP OVER GRAINS """ valid_ids = [] valid_hkls = [] valid_angs = [] valid_xys = [] ang_pixel_size = [] for gparm in grain_param_list: # make useful parameters rMat_c = makeRotMatOfExpMap(gparm[:3]) tVec_c = gparm[3:6] vInv_s = gparm[6:] # All possible bragg conditions as vstacked [tth, eta, ome] # for each omega solution angList = np.vstack( oscillAnglesOfHKLs( full_hkls[:, 1:], chi, rMat_c, bMat, wavelength, vInv=vInv_s, ) ) # filter by eta and omega ranges # ??? get eta range from detector? allAngs, allHKLs = xrdutil._filter_hkls_eta_ome( full_hkls, angList, eta_ranges, ome_ranges ) allAngs[:, 2] = mapAngle(allAngs[:, 2], ome_period) # find points that fall on the panel det_xy, rMat_s = xrdutil._project_on_detector_plane( allAngs, self.rmat, rMat_c, chi, self.tvec, tVec_c, tVec_s, self.distortion) xys_p, on_panel = self.clip_to_panel(det_xy) valid_xys.append(xys_p) # grab hkls and gvec ids for this panel valid_hkls.append(allHKLs[on_panel, 1:]) valid_ids.append(allHKLs[on_panel, 0]) # reflection angles (voxel centers) and pixel size in (tth, eta) valid_angs.append(allAngs[on_panel, :]) ang_pixel_size.append(self.angularPixelSize(xys_p)) return valid_ids, valid_hkls, valid_angs, valid_xys, ang_pixel_size
def beam_energy(self): return keVToAngstrom(self.plane_data.wavelength)
instr_cfg_file = open('./ge_detector_new.yml', 'r') instr_cfg = yaml.load(instr_cfg_file) instr = instrument.HEDMInstrument(instr_cfg) data_path = './' img_series_root = 'ge_scan_114' img_series = imageseries.open( os.path.join(img_series_root + '-fcache-dir', img_series_root + '-fcache.yml'), 'frame-cache') nframes = 240 average_frame = imageseries.stats.average(img_series) #%% wlen = constants.keVToAngstrom(instr_cfg['beam']['energy']) matl = make_matl('LSHR', 225, [ 3.5905, ]) pd = matl.planeData pd.wavelength = instr_cfg['beam']['energy'] # takes keV pd.exclusions = np.zeros_like(pd.exclusions, dtype=bool) set_by_tth_max = False if set_by_tth_max: pd.tThMax = np.radians(6.75) tth_del = np.radians(0.75) tth_avg = np.average(pd.getTTh()) tth_lo = pd.getTTh()[0] - tth_del