EBSD digitization and FE basic equations for
A novel EBSD-based finite-element wave propagation model for investigating seismic
anisotropy: Application to Finero Peridotite, Ivrea-Verbano Zone, Northern Italy
Xin Zhong, Marcel Frehner, Karsten Kunze and Alba Zappone
(ETH Zurich, Switzerland)
Original EBSD-data is written in ASCII readable .dat file and contains the mineral phase,
coordinates, confidential index of each pixel, and three Euler angles describing the
crystallographic orientation (in Bunge convention). The goal of this script is to give a simple
but useful tutorial to digitize the obtained EBSD-data. Other types of data files are also
encouraged as long as the above information can be extracted. The original digitization code
is written in Matlab R2011b with the MTex toolbox implemented. Parts of the descriptions
below are written using MTex functions to allow users to directly understand and apply for
their purpose.
1. Read the EBSD data
This seems trivial but it needs to be noted that the data head should be removed beforehand
(usually contain hkl information and phase symmetry but we will define them by hand). Save
the phase index, three Bunge angles with respect to the pixel coordinates in 2D.
2. Define crystallographic symmetry
Use the symmetry function to define all the existing mineral phases. As for olivine, the code is
written as:
cs_ol = symmetry('mmm',[4.241, 10.225, 5.994], [90, 90, 90]*degree,
'x||a','z||c*', 'mineral','olivine');
where 'mmm' prescribes the crystal symmetry to be orthorhombic, [4.241, 10.225, 5.994] are
the lattice constants and [90, 90, 90] are the angles between the three crystrallographic basis
vectors, 'x||a','z||c*' indicates that the specimen x-axis is parallel to the a-axis of the olivine
crystal and the specimen z-axis is parallel to the c*-axis (normal to the c-plane).
3. Defining the pixel’s elastic tensor
After prescribing the crystal symmetry for all the mineral phases, a loop is written to rotate
the crystal elastic tensor. Before rotating the tensor, the tensor has to be defined in the crystal
reference system. Use the tensor function in MTex to prescribe the single crystal elastic tensor
for the current pixel. For example:
C
= tensor(M, 'name', 'elastic stiffness', 'unit', 'GPa', cs);
where cs is the crystal symmetry defined before (cs can be cs_ol, cs_opx or cs_cpx etc based
on EBSD automatic indexing). M is the stiffness matrix from literature (Babuska and Cara
1991). For olivine, the result is written as:
C = elastic stiffness tensor
unit
: GPa
rank
: 4 (3 x 3 x 3 x 3)
mineral: olivine (mmm)
tensor in Voigt matrix representation:
323.7 66.4 71.6
0
0
0
66.4 197.6 75.6
0
0
0
71.6 75.6 235.1
0
0
0
0
0
0
64.6
0
0
0
0
0
0
78.7
0
0
0
0
0
0
79.0
4. Defining the pixel orientation
In the rotation loop, use the orientation function to describe the current orientation of a given
pixel. For example:
g = orientation('Euler', phi1, ph, phi2, 'bunge', cs);
where phi1, ph, phi2 are the three Bunge angles for Z, X, Z rotations respectively. The output
for g looks like:
g = orientation
size: 1 x 1
crystal symmetry: olivine (mmm)
sample symmetry : triclinic
Bunge Euler angles in degree
phi1
Phi
phi2
148.825 54.9064 104.698
where 148.825 54.9064 104.698 are the three Bunge angles, translated from radians to
degrees.
5. Rotating the tensor at the current pixel
This can be simply done by combining the reference tensor with the orientation for the current
pixel inside the loop. Use the rotate function in MTex to perform this rotation as:
C_rotated=rotate(C,g);
where C_rotated will be the rotated tensor for this olivine pixel (note that this is not the tensor
for the single olivine grain because olivine can be subject to subgrain rotation or ununiformed
dislocation creep which lead to heterogeneous crystallographic orientation in a single grain).
The result of C_rotated looks like:
C_rotated = tensor
rank: 4 (3 x 3 x 3 x 3)
tensor in Voigt matrix representation:
201.19 74.49
72.19
5.52
1.26
4.51
74.49 238.87 92.17 -18.04
3.08
7.45
72.19 92.17 265.83 -28.97 -0.78
5.95
5.52 -18.04 -28.97 100.17
5.1
0.72
1.26
3.08
-0.78
5.1 75.32 -5.39
4.51
7.45
5.95
0.72 -5.39 72.07
6. Reduce the 3D elastic tensor to 2D for finite element simulation
Since EBSD-data only provide 2D measurements, the above elastic tensor has to be reduced
to 2D in order to be implemented into the finite element code. This is done by simply
eliminating the z-components (column and row 3,4,5) resulting in the 2D elastic tensor as a
3*3 matrix for the components xx, yy and xy.
7. Finite element implementation
In this section, we only deal with the basic equations utilizing the result of EBSD-digitization.
The force balance equation is given by:
𝜕
𝜕
𝜎𝑥𝑥
𝜕𝑦
𝜎
] { 𝑦𝑦 },
𝜕
𝜎𝑥𝑦
𝜕𝑥
0
𝑢̈ 𝑥
𝜕𝑥
𝜌 {𝑢̈ } = [
𝑦
0
𝜕
𝜕𝑦
where 𝜌 is density, 𝑢̈ 𝑥 and üy are the second time derivatives of the displacement vector
with components ux and uy, and 𝜎𝑥𝑥 , yy, and xy are the three independent components of the
symmetric stress tensor defined in 2D. For rheology, we use a pure elastic stress-strain
relation as:
𝜎𝑥𝑥
𝜀𝑥𝑥
𝜎
𝜀
{ 𝑦𝑦 } = 𝐃 { 𝑦𝑦 },
𝜎𝑥𝑦
𝑟𝑥𝑦
where D is the 2D elastic tensor we derived from the EBSD-digitization and 𝜀𝑥𝑥 , yy, and xy
are the three independent components of the symmetric strain tensor (xy=2xy=engineering
strain), which can be defined as:
𝜕
𝜕𝑥
𝜀𝑥𝑥
𝜀
{ 𝑦𝑦 } = 0
𝑟𝑥𝑦
𝜕
[𝜕𝑦
0
𝜕
𝜕𝑦
𝜕
𝑢𝑥
{𝑢 }.
𝑦
𝜕𝑥 ]
After combining the above equations, we have:
𝜌𝐮̈ = 𝐁 𝑇 𝐃𝑩𝐮,
where
𝜕
𝜕𝑥
𝐁= 0
𝜕
[𝜕𝑦
and
0
𝜕
𝜕𝑦
𝜕
𝜕𝑥]
𝑢𝑥
𝐮 = {𝑢 }
𝑦
The advantage of such procedure is that the elastic tensor calculated from the
EBSD-digitization procedure happens to be the property for each finite element. On the other
hand, our finite element mesh will be exactly the same as the EBSD pixel coordinates defined
by the initial resolution. Users should set the EBSD resolution prior to finite element
simulation by considering the tradeoff between computational time and data resolution.