This script demonstrates the tools MTEX offers to reconstruct a parent austenite phase from a measured martensite phase. Most of the ideas are from Crystallography, Morphology, and Martensite Transformation of Prior Austenite in Intercritically Annealed High-Aluminum Steel by Tuomo Nyyssönen. We shall use the following sample data set.

## Determine the parent child orientation relationship

It is well known that the phase transformation from austenite to martensite is not described by a fixed orientation relationship. In fact, the actual orientation relationship needs to be determined for each sample individualy. Here, we used the iterative method proposed by Tuomo Nyyssönen and implemented in the function `calcParent2Child`

that starts at an initial guess of the orientation relation ship and iterates towards the true orientation relationship.

Here we use as the initial guess the Kurdjumov Sachs orientation relationship

The function `calcParent2Child`

requires as input a list of child to child misorientations or, equivalently, a two column matrix of child orientations. Here we go with the second option and setup this two column orientation matrix from the mean orientations of neighbouring grains which can be found using the command `neighbours`

Beside the optimized parent to child orientation relationship the command `calcParent2Child`

returns as a second output argument the misfit between all grain to grain misorientations and the theoretical child to child misorientations. In fact, the algorithm assumes that the majority of all boundary misorientations are child to child misorientations and finds the parent to child orientations relationship by minimizing this misfit. The following histogram displays the distribution of the misfit over all grain to grain misorientations.

We may also colorize the grain boundaries according to this misfit. To this end we first compute the relationship between pairs of grains `grainPairs`

and the boundary segments stored in `grains.boundary`

using the command `selectByGrainId`

abd then pass the variable `fit`

as second input argument to the `plot`

command

We observe that the boundary segments with a large misfit form large grain shapes which we want to identify in the next steps as the parent grains.

## Create a similarity matrix

Next we set up a adjacency matrix `A`

that describes the probability that two neighbouring grains belong to the same parent grains. This probability is computed from the misfit of the misorientation between two child grains to the theoretical child to child misorientation. More precisely, we model the probability by a cumulative Gaussian distribution with the mean value `threshold`

which describes the misfit at which the probability is exactly 50 percent and the standard deviation `tol`

The above diagram describes the probability distribution as a function of the misfit. After filling the matrix `A`

with these probabilities

we can split it into clusters using the command `calcCluster`

which implements the Markovian clustering algorithm. Here an important parameter is the so called inflation power, which controls the size of the clusters.

Each connected component of the resulting adjacency matrix describes one parent grain. Hence, we can use this adjacency matrix to merge child grains into parent grains by the command `merge`

.

Let's visualize the first result. Note, that at this stage it is not important to have the parent grains already at their optimal size. Similarly orientated grains can be merged later on.

## Compute parent grain orientations

In the next step we compute for each parent grain its parent austenite orientation. This can be done usig the command `calcParent`

. Note, that we ensure that at least two child grains have been merged and that the misfit is smaller than 5 degree.

Let's plot the resulting parent orientations

## Compute Child Variants

Knowing the parent grain orientations we may compute the |variantId| of each child grain using the command `calcVariantId`

. As a bonus this command returns also the `packetId`

, here defined as the closest {111} plane in austenite to the (011) plane in martensite.

In order to check our parent grain reconstruction we chose the single parent grain outlines in the above map and plot all child variants of its reconstructed parent orientation together with the actually measured child orientations inside the parent grain.

So far our analysis was at the grain level. However, once parent grain orientations have been computed we may also use them to compute parent orientations of each pixel in our original EBSD map. To this end we first find pixels that now belong to an austenite grain.

As a second output argument we obtain the `misfit`

between the parent orientation computed for the pixel and the mean orientation of the corresponding parent grain. Let's plot this misfit as a map.

## Denoise the parent map

Finaly we may apply filtering to the parent map to fill non indexed or not reconstructed pixels. To this end we first run grain reconstruction on the parent map

and then use the command `smooth`

to fill the holes in the reconstructed parent map

## Summary of relevant thresholds

In the above script several parameters are decisive for the success of the reconstruction

- threshold for initial grain segmentation (3 degree)
- theshold (2 degree), tolerance (1.5 degree) and inflation power (p = 1.6) of the Markovian clustering algorithm
- maximum misfit within a parent grain (5 degree)
- minimum number of merged child grains

## Triple Point Based Analysis

A problem of the boundary based reconstuction algorithm is that often child variants of different grains have a misorientation that is close to the theoretical child to child misorientation. One idea to overcome this problem is to analyze triple junctions. Now all three child orientations must fit to a common parent orientations. This fit is computed by the command `calcParent`

.

Lets visualize this misfit by colorizing all triple junctions accordingly.

Again we observe, that triple junctions with large misfit outline the shape of the parent grains. In order to identify these parent grains we proceed analogously as for the boundary based analysis. We first set up a similarity matrix between grains connected to the same triple points and than use the Markovian clustering algorithm to detect clusters of child grains, which are than merged into parent grains.

## Create a similarity matrix and reconstruct parent grains

The setup and the clustering of the similarity matrix is the same as above

Each connected component of the resulting adjacency matrix describes one parent grain. Hence, we can use this adjacency matrix to merge child grains into parent grains by the command `merge`

.

Let's visualize the result. Afterwards, we can proceed analogously as for the boundary based parent grain reconstruction described above.