def test_disorientation_blending(self, lattice, a, b):
o = Orientation.from_random(lattice=lattice, shape=a)
p = Orientation.from_random(lattice=lattice, shape=b)
blend = util.shapeblender(o.shape, p.shape)
for loc in np.random.randint(0, blend, (10, len(blend))):
assert o[tuple(loc[:len(o.shape)])].disorientation(p[tuple(loc[-len(p.shape):])]) \
.isclose(o.disorientation(p)[tuple(loc)])
def test_relationship_vectorize(self, set_of_quaternions, lattice, model):
r = Orientation(rotation=set_of_quaternions[:200].reshape((50, 4, 4)),
lattice=lattice).related(model)
for i in range(200):
assert (r.reshape(
(-1, 200))[:, i] == Orientation(set_of_quaternions[i],
lattice).related(model)).all()
def test_in_FZ_vectorization(self, set_of_rodrigues, lattice):
result = Orientation.from_Rodrigues_vector(
rho=set_of_rodrigues.reshape(
(-1, 4, 4)), lattice=lattice).in_FZ.reshape(-1)
for r, rho in zip(result, set_of_rodrigues[:len(result)]):
assert r == Orientation.from_Rodrigues_vector(
rho=rho, lattice=lattice).in_FZ
def test_relationship_vectorize(self, set_of_quaternions, lattice, model):
result = Orientation(set_of_quaternions[:200].reshape(50, 4, 4),
lattice).related(model)
ref_qu = result.rotation.quaternion.reshape(-1, 200, 4)
for i in range(200):
single = Orientation(set_of_quaternions[i],
lattice).related(model).rotation.quaternion
assert np.allclose(ref_qu[:, i, :], single)
def test_add_IPF_color(self, default, d):
default.add_IPF_color(d, 'O')
qu = default.place('O')
crystal_structure = qu.dtype.metadata['lattice']
c = Orientation(rotation=qu, lattice=crystal_structure)
in_memory = np.uint8(c.IPF_color(np.array(d)) * 255)
in_file = default.place('IPFcolor_({} {} {})'.format(*d))
assert np.allclose(in_memory, in_file)
def test_average(self, angle, lattice):
R_1 = Orientation(
Rotation.from_axis_angle([0, 0, 1, 10], degrees=True), lattice)
R_2 = Orientation(
Rotation.from_axis_angle([0, 0, 1, angle], degrees=True), lattice)
avg_angle = R_1.average(R_2).rotation.as_axis_angle(degrees=True,
pair=True)[1]
assert np.isclose(avg_angle, 10 + (angle - 10) / 2.)
def test_reduced_equivalent(self, lattice):
i = Orientation(lattice=lattice)
o = Orientation.from_random(lattice=lattice)
eq = o.equivalent
FZ = np.argmin(
abs(
eq.misorientation(i.broadcast_to(
len(eq))).as_axis_angle(pair=True)[1]))
assert o.reduced == eq[FZ]
def test_relationship_reference(self, update, ref_path, model, lattice):
reference = ref_path / f'{lattice}_{model}.txt'
o = Orientation(lattice=lattice)
eu = o.related(model).as_Euler_angles(degrees=True)
if update:
coords = np.array([(1, i + 1) for i, x in enumerate(eu)])
Table(eu,{'Eulers':(3,)})\
.add('pos',coords)\
.save(reference)
assert np.allclose(eu, Table.load(reference).get('Eulers'))
def test_disorientation_blending(self, family, left, right):
o = Orientation.from_random(family=family, shape=left)
p = Orientation.from_random(family=family, shape=right)
blend = util.shapeblender(o.shape, p.shape)
for loc in np.random.randint(0, blend, (10, len(blend))):
# print(f'{a}/{b} @ {loc}')
# print(o[tuple(loc[:len(o.shape)])].disorientation(p[tuple(loc[-len(p.shape):])]))
# print(o.disorientation(p)[tuple(loc)])
assert o[tuple(loc[:len(o.shape)])].disorientation(p[tuple(loc[-len(p.shape):])]) \
.isclose(o.disorientation(p)[tuple(loc)])
def test_Schmid(self, update, ref_path, lattice, mode):
L = Orientation(lattice=lattice)
reference = ref_path / f'{lattice}_{mode}.txt'
P = L.Schmid(mode)
if update:
table = Table(P.reshape(-1, 9), {'Schmid': (
3,
3,
)})
table.save(reference)
assert np.allclose(P, Table.load(reference).get('Schmid'))
def test_relationship_reference(self, update, reference_dir, model,
lattice):
reference = os.path.join(reference_dir, f'{lattice}_{model}.txt')
ori = Orientation(Rotation(), lattice)
eu = np.array(
[o.rotation.as_Eulers(degrees=True) for o in ori.related(model)])
if update:
coords = np.array([(1, i + 1) for i, x in enumerate(eu)])
table = Table(eu, {'Eulers': (3, )})
table = table.add('pos', coords)
table.save(reference)
assert np.allclose(eu, Table.load(reference).get('Eulers'))
def test_to_frame_to_lattice(self, lattice, a, b, c, alpha, beta, gamma,
vector, keyFrame, keyLattice):
L = Orientation(lattice=lattice,
a=a,
b=b,
c=c,
alpha=alpha,
beta=beta,
gamma=gamma)
assert np.allclose(
vector,
L.to_frame(**{keyFrame: L.to_lattice(**{keyLattice: vector})}))
def test_Schmid(self, update, ref_path, lattice):
O = Orientation(lattice=lattice) # noqa
for mode in ['slip', 'twin']:
reference = ref_path / f'{lattice}_{mode}.txt'
P = O.Schmid(N_slip='*') if mode == 'slip' else O.Schmid(
N_twin='*')
if update:
table = Table(P.reshape(-1, 9), {'Schmid': (
3,
3,
)})
table.save(reference)
assert np.allclose(P, Table.load(reference).get('Schmid'))
def test_disorientation(self, lattice, N):
o = Orientation.from_random(lattice=lattice, shape=N)
p = Orientation.from_random(lattice=lattice, shape=N)
d, ops = o.disorientation(p, return_operators=True)
for n in range(N):
assert np.allclose(d[n].as_quaternion(),
o[n].equivalent[ops[n][0]]
.misorientation(p[n].equivalent[ops[n][1]])
.as_quaternion()) \
or np.allclose((~d)[n].as_quaternion(),
o[n].equivalent[ops[n][0]]
.misorientation(p[n].equivalent[ops[n][1]])
.as_quaternion())
def test_relationship_reference(self, update, reference_dir, model,
lattice):
reference = os.path.join(reference_dir,
'{}_{}.txt'.format(lattice, model))
ori = Orientation(Rotation(), lattice)
eu = np.array([
o.rotation.as_Eulers(degrees=True)
for o in ori.relatedOrientations(model)
])
if update:
coords = np.array([(1, i + 1) for i, x in enumerate(eu)])
table = damask.Table(eu, {'Eulers': (3, )})
table.add('pos', coords)
table.to_ASCII(reference)
assert np.allclose(eu,
damask.Table.from_ASCII(reference).get('Eulers'))
def test_average(self, angle, lattice):
o = Orientation.from_axis_angle(lattice=lattice,
axis_angle=[[0, 0, 1, 10],
[0, 0, 1, angle]],
degrees=True)
avg_angle = o.average().as_axis_angle(degrees=True, pair=True)[1]
assert np.isclose(avg_angle, 10 + (angle - 10) / 2.)
def test_add_IPF_color(self, default, d):
default.add_IPF_color('O', d)
loc = {
'orientation': default.get_dataset_location('O'),
'color':
default.get_dataset_location('IPFcolor_[{} {} {}]'.format(*d))
}
qu = default.read_dataset(loc['orientation']).view(np.double).reshape(
-1, 4)
crystal_structure = default.get_crystal_structure()
in_memory = np.empty((qu.shape[0], 3), np.uint8)
for i, q in enumerate(qu):
o = Orientation(q, crystal_structure).reduced
in_memory[i] = np.uint8(o.IPF_color(np.array(d)) * 255)
in_file = default.read_dataset(loc['color'])
assert np.allclose(in_memory, in_file)
def test_IPF_color_vectorization(self, lattice, shape, vector, proper,
in_SST):
o = Orientation.from_random(lattice=lattice, shape=shape)
for r, theO in zip(
o.IPF_color(vector, in_SST=in_SST, proper=proper).reshape(
(-1, 3)), o.flatten()):
assert np.allclose(
r, theO.IPF_color(vector, in_SST=in_SST, proper=proper))
def test_Schmid_vectorization(self, lattice):
O = Orientation.from_random(shape=4, lattice=lattice) # noqa
for mode in ['slip', 'twin']:
Ps = O.Schmid(N_slip='*') if mode == 'slip' else O.Schmid(
N_twin='*')
for i in range(4):
P = O[i].Schmid(N_slip='*') if mode == 'slip' else O[i].Schmid(
N_twin='*')
assert np.allclose(P, Ps[:, i])
def test_to_SST_blending(self, family, left, right):
o = Orientation.from_random(family=family, shape=left)
v = np.random.random(right + (3, ))
blend = util.shapeblender(o.shape, v.shape[:-1])
for loc in np.random.randint(0, blend, (10, len(blend))):
assert np.allclose(
o[tuple(loc[:len(o.shape)])].to_SST(v[tuple(
loc[-len(v.shape[:-1]):])]),
o.to_SST(v)[tuple(loc)])
def test_from_directions(self, kwargs):
for a, b in np.random.random((10, 2, 3)):
c = np.cross(b, a)
if np.all(np.isclose(c, 0)): continue
o = Orientation.from_directions(uvw=a, hkl=c, **kwargs)
x = o.to_pole(uvw=a)
z = o.to_pole(hkl=c)
assert np.isclose(np.dot(x/np.linalg.norm(x),np.array([1,0,0])),1) \
and np.isclose(np.dot(z/np.linalg.norm(z),np.array([0,0,1])),1)
def test_reduced_corner_cases(self, lattice):
# test whether there is always a sym-eq rotation that falls into the FZ
N = np.random.randint(10, 40)
size = np.ones(3) * np.pi**(2. / 3.)
grid = grid_filters.coordinates0_node([N + 1, N + 1, N + 1], size,
-size * .5)
evenly_distributed = Orientation.from_cubochoric(x=grid[:-2, :-2, :-2],
lattice=lattice)
assert evenly_distributed.shape == evenly_distributed.reduced.shape
def test_bases_contraction(self, lattice, a, b, c, alpha, beta, gamma):
L = Orientation(lattice=lattice,
a=a,
b=b,
c=c,
alpha=alpha,
beta=beta,
gamma=gamma)
assert np.allclose(
np.eye(3), np.einsum('ik,jk', L.basis_real, L.basis_reciprocal))
def test_unknown_relation_lattice(self, relation, lattice, a, b, c, alpha,
beta, gamma):
with pytest.raises(KeyError):
Orientation(lattice=lattice,
a=a,
b=b,
c=c,
alpha=alpha,
beta=beta,
gamma=gamma).related(relation) # noqa
def test_negative_angle(self):
with pytest.raises(ValueError):
Orientation(lattice='aP',
a=1,
b=2,
c=3,
alpha=45,
beta=45,
gamma=-45,
degrees=True) # noqa
def test_excess_angle(self):
with pytest.raises(ValueError):
Orientation(lattice='aP',
a=1,
b=2,
c=3,
alpha=45,
beta=45,
gamma=90.0001,
degrees=True) # noqa
def test_to_SST_blending(self, lattice, a, b):
o = Orientation.from_random(lattice=lattice, shape=a)
v = np.random.random(b + (3, ))
blend = util.shapeblender(o.shape, b)
for loc in np.random.randint(0, blend, (10, len(blend))):
print(f'{a}/{b} @ {loc}')
print(o[tuple(loc[:len(o.shape)])].to_SST(v[tuple(loc[-len(b):])]))
print(o.to_SST(v)[tuple(loc)])
assert np.allclose(
o[tuple(loc[:len(o.shape)])].to_SST(v[tuple(loc[-len(b):])]),
o.to_SST(v)[tuple(loc)])
def test_to_pole(self, shape, lattice, a, b, c, alpha, beta, gamma, vector,
kw, with_symmetry):
o = Orientation.from_random(shape=shape,
lattice=lattice,
a=a,
b=b,
c=c,
alpha=alpha,
beta=beta,
gamma=gamma)
assert o.to_pole(**{kw:vector,'with_symmetry':with_symmetry}).shape \
== o.shape + (o.symmetry_operations.shape if with_symmetry else ()) + vector.shape
def test_from_fiber_component(self):
r = Rotation.from_fiber_component(alpha=np.zeros(2),
beta=np.zeros(2),
sigma=0.0,
N=1,
rng_seed=0)
assert np.all(
Orientation.from_fiber_component(alpha=np.zeros(2),
beta=np.zeros(2),
sigma=0.0,
N=1,
rng_seed=0,
lattice='triclinic').quaternion ==
r.quaternion)
def test_add_pole(self, default, options):
default.add_pole(**options)
rot = default.place('O')
in_memory = Orientation(
rot, lattice=rot.dtype.metadata['lattice']).to_pole(**options)
brackets = ['[[]', '[]]'] if 'uvw' in options.keys() else [
'(', ')'
] # escape fnmatch
label = '{}{} {} {}{}'.format(brackets[0],
*(list(options.values())[0]),
brackets[1])
in_file = default.place(f'p^{label}')
print(in_file - in_memory)
assert np.allclose(in_memory, in_file)
