def gen_schmid_tensors(pd,uvw,hkl):
# slip plane directions
slipdir = mutil.unitVector( np.dot( pd.latVecOps['F'], uvw) ) # 2 -1 -1 0
slipdir_sym = sym.applySym(slipdir, pd.getQSym(), csFlag=False, cullPM=True, tol=1e-08)
# slip plane plane normals
n_plane = mutil.unitVector( np.dot( pd.latVecOps['B'], hkl ) )
n_plane_sym = sym.applySym(n_plane, pd.getQSym(), csFlag=False, cullPM=True, tol=1e-08)
num_slip_plane= n_plane_sym.shape[1]
num_slip_sys=0
for i in range(num_slip_plane):
planeID = np.where(abs(np.dot(n_plane_sym[:, i],slipdir_sym)) < 1.e-8)[0]
num_slip_sys +=planeID.shape[0]
T= np.zeros((num_slip_sys, 3, 3))
counter=0
#
for i in range(num_slip_plane):
planeID = np.where(abs(np.dot(n_plane_sym[:, i],slipdir_sym)) < 1.e-8)[0]
for j in np.arange(planeID.shape[0]):
T[counter, :, :] = np.dot(slipdir_sym[:, planeID[j]].reshape(3, 1), n_plane_sym[:, i].reshape(1, 3))
counter+=1
#Clean some round off errors
round_off_err=np.where(abs(T)<1e-8)
T[round_off_err[0],round_off_err[1],round_off_err[2]]=0.
return T
def makePlaneData(hkls, lparms, qsym, symmGroup, strainMag, wavelength): # spots
"""
hkls : need to work with crystallography.latticePlanes
lparms : need to work with crystallography.latticePlanes
laueGroup : see symmetry module
wavelength : wavelength
strainMag : swag of strian magnitudes
"""
tempSetOutputDegrees(False)
latPlaneData = latticePlanes(hkls, lparms,
ltype=symmGroup,
strainMag=strainMag,
wavelength=wavelength)
latVecOps = latticeVectors(lparms, symmGroup)
hklDataList = []
for iHKL in range(len(hkls.T)): # need transpose because of convention for hkls ordering
# JVB # latVec = latPlaneData['normals'][:,iHKL]
# JVB # # ... if not spots, may be able to work with a subset of these
# JVB # latPlnNrmlList = symmetry.applySym(num.c_[latVec], qsym, csFlag=True, cullPM=False)
# returns UN-NORMALIZED lattice plane normals
latPlnNrmls = symmetry.applySym(
num.dot(latVecOps['B'], hkls[:,iHKL].reshape(3, 1)),
qsym,
csFlag=True,
cullPM=False)
# check for +/- in symmetry group
latPlnNrmlsM = symmetry.applySym(
num.dot(latVecOps['B'], hkls[:,iHKL].reshape(3, 1)),
qsym,
csFlag=False,
cullPM=False)
csRefl = latPlnNrmls.shape[1] == latPlnNrmlsM.shape[1]
# added this so that I retain the actual symmetric integer hkls as well
symHKLs = num.array( num.round( num.dot(latVecOps['F'].T, latPlnNrmls) ), dtype='int' )
hklDataList.append({
'hklID' : iHKL ,
'hkl' : hkls[:,iHKL] ,
'tTheta' : latPlaneData['tThetas'][iHKL] ,
'dSpacings' : latPlaneData['dspacings'][iHKL],
'tThetaLo' : latPlaneData['tThetasLo'][iHKL],
'tThetaHi' : latPlaneData['tThetasHi'][iHKL],
'latPlnNrmls' : unitVector(latPlnNrmls) ,
'symHKLs' : symHKLs,
'centrosym' : csRefl
})
revertOutputDegrees()
return latPlaneData, latVecOps, hklDataList
def gen_schmid_tensors(pd, uvw, hkl):
# slip plane directions
slipdir = mutil.unitVector(np.dot(pd.latVecOps['F'], uvw)) # 2 -1 -1 0
slipdir_sym = sym.applySym(slipdir,
pd.getQSym(),
csFlag=False,
cullPM=True,
tol=1e-08)
# slip plane plane normals
n_plane = mutil.unitVector(np.dot(pd.latVecOps['B'], hkl))
n_plane_sym = sym.applySym(n_plane,
pd.getQSym(),
csFlag=False,
cullPM=True,
tol=1e-08)
num_slip_plane = n_plane_sym.shape[1]
num_slip_sys = 0
for i in range(num_slip_plane):
planeID = np.where(
abs(np.dot(n_plane_sym[:, i], slipdir_sym)) < 1.e-8)[0]
num_slip_sys += planeID.shape[0]
T = np.zeros((num_slip_sys, 3, 3))
counter = 0
#
for i in range(num_slip_plane):
planeID = np.where(
abs(np.dot(n_plane_sym[:, i], slipdir_sym)) < 1.e-8)[0]
for j in np.arange(planeID.shape[0]):
T[counter, :, :] = np.dot(slipdir_sym[:, planeID[j]].reshape(3, 1),
n_plane_sym[:, i].reshape(1, 3))
counter += 1
#Clean some round off errors
round_off_err = np.where(abs(T) < 1e-8)
T[round_off_err[0], round_off_err[1], round_off_err[2]] = 0.
return T
sst_normals = np.array([
np.cross(sst_vertices[:, i[0]], sst_vertices[:, i[1]])
for i in [(0, 1), (1, 2), (2, 0)]
]).T
# DEFINE SAMPLE DIRECTION YOU WANT FOR IPF THEN MOVE THE CRYSTAL FRAME
s = mutil.unitVector(np.c_[0., 1., 0.].T) # sample Y a.k.a. loading
s_c_init = np.zeros((len(rmats_init), 3))
for i, rm in enumerate(rmats_init):
s_c_init[i] = np.dot(rm.T, s).flatten()
# APPLY SYMMETRIES AND PICK REPRESENTATIVE IN SPECIFED SST
sst_list = []
csym_init = []
for c in s_c_init:
csym_init.append(sym.applySym(c.reshape(3, 1), qsym, csFlag=True))
csym_init = np.hstack(csym_init)
sst_idx_init, edges_init = contained_in_sst(csym_init, sst_vertices)
sst_list_init = csym_init[:, np.where(sst_idx_init)[0]].T
# DEFINE SAMPLE DIRECTION YOU WANT FOR IPF THEN MOVE THE CRYSTAL FRAME
s = mutil.unitVector(np.c_[0., 1., 0.].T) # sample Y a.k.a. loading
s_c_final = np.zeros((len(rmats_final), 3))
for i, rm in enumerate(rmats_final):
s_c_final[i] = np.dot(rm.T, s).flatten()
# APPLY SYMMETRIES AND PICK REPRESENTATIVE IN SPECIFED SST
sst_list = []
csym_final = []
for c in s_c_final:
sst_normals = np.array([
np.cross(sst_vertices[:, i[0]], sst_vertices[:, i[1]])
for i in [(0, 1), (1, 2), (2, 0)]
]).T
# DEFINE SAMPLE DIRECTION YOU WANT FOR IPF THEN MOVE THE CRYSTAL FRAME
s = mutil.unitVector(np.c_[0., 1., 0.].T) # sample Y a.k.a. loading
s_c = np.zeros((len(rmats), 3))
for i, rm in enumerate(rmats):
s_c[i] = np.dot(rm.T, s).flatten()
# APPLY SYMMETRIES AND PICK REPRESENTATIVE IN SPECIFED SST
sst_list = []
csym = []
for c in s_c:
csym.append(sym.applySym(c.reshape(3, 1), qsym, csFlag=True))
csym = np.hstack(csym)
sst_idx, edges = contained_in_sst(csym, sst_vertices)
sst_list = csym[:, np.where(sst_idx)[0]].T
# =============================================================================
# %% PLOTTING
# =============================================================================
# the proper COB matrix for the standard SST
# for cubic SST
#cob = np.dot(
# rot.rotMatOfExpMap(-0.5*np.pi*np.c_[0, 0, 1].T),
# rot.rotMatOfExpMap(-0.5*np.pi*np.c_[0, 1, 0].T)
#)
