diff --git a/.ipynb_checkpoints/Twin_reorientation_check-checkpoint.ipynb b/.ipynb_checkpoints/Twin_reorientation_check-checkpoint.ipynb new file mode 100644 index 0000000..e1ac0b4 --- /dev/null +++ b/.ipynb_checkpoints/Twin_reorientation_check-checkpoint.ipynb @@ -0,0 +1,805 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "e2ae546c-570b-4245-99fa-60519f448e1e", + "metadata": {}, + "source": [ + "# Code to verify and visualize reorientation caused twinning in the deformation gradient.\n", + "## Using the correspondence matrix method.\n", + "By Satyapriya Gupta, Achal H P\n", + "\n", + "Reference Niewczas, Acta Materialia, 2010" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "8faa8558-2109-45ed-b795-94150b3c998d", + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "import numpy as np\n", + "import scipy.linalg\n", + "from numpy.linalg import inv\n", + "import damask" + ] + }, + { + "cell_type": "markdown", + "id": "bc185fbf-e55d-445e-b8aa-f17abdd93b9a", + "metadata": {}, + "source": [ + "### Test Case: Extension Twinning $( \\bar{1} 0 1 2)$ $[1 0 \\bar{1} 1] $\n", + "\n", + "Conversion to Miller indices: $ (\\bar{1} 0 2) [2 1 1] $" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "fee7fbb5-3a4b-421c-bbe7-636c3fd412e9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.3743159014756228\n", + "1.6881920256873888\n", + "[0.63176092 0.36474734 0.68398649]\n", + "[-0.59234968 -0.34199325 0.72949468]\n" + ] + } + ], + "source": [ + "# Twin direction:\n", + "m = np.array([2, 1, 1])\n", + "# Habit plane normal\n", + "n = np.array([-1, 0, 2])\n", + "# Mapping from Miller indes to cartesian coordinate system\n", + "matA=np.array([[1, -0.5, 0],[0, 0.5*np.sqrt(3), 0],[0, 0, 1.624]])\n", + "#norm of twin direction\n", + "norm_mcart=np.linalg.norm(np.matmul(matA,m))\n", + "# norm of twin plane\n", + "norm_ncart=np.linalg.norm(np.matmul(n,inv(matA)))\n", + "# normalized unit vectors:\n", + "unit_mcart = np.matmul(matA,m)/norm_mcart\n", + "unit_ncart = np.matmul(n, inv(matA))/norm_ncart\n", + "# Characteristic shear for Extension twin of Mg\n", + "s = 0.128917\n", + "print(norm_mcart)\n", + "print(norm_ncart)\n", + "print(unit_mcart)\n", + "print(unit_ncart)" + ] + }, + { + "cell_type": "markdown", + "id": "716495ad-76ca-4790-b1f4-a2f249e452db", + "metadata": {}, + "source": [ + "### Please provide Euler Angles Here:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "eaa69469-71ca-42fc-a4ed-afa0fb84a230", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.06435814 0.99792687 0. ]\n", + " [-0.99792687 0.06435814 0. ]\n", + " [ 0. 0. 1. ]]\n" + ] + } + ], + "source": [ + "phi_1 = 86.31\n", + "phi_ = 0\n", + "phi_2 = 0\n", + "\n", + "init = damask.Orientation.from_Euler_angles(phi=[phi_1,phi_,phi_2],degrees=True,family='hexagonal',lattice='hP',a=1.0,b=1.0,c=1.6235).as_matrix()\n", + "print(init)\n" + ] + }, + { + "cell_type": "markdown", + "id": "1262386a-1d9c-4bb0-a147-c409f45ec751", + "metadata": {}, + "source": [ + "### Initial Undeformed Condition, $ F = Identity matrix $" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "689c6399-fd48-4456-be57-a8f7f7e16276", + "metadata": {}, + "outputs": [], + "source": [ + "F = np.identity(3)" + ] + }, + { + "cell_type": "markdown", + "id": "64b46853-7012-432f-93c1-4acb1fe4dc9a", + "metadata": {}, + "source": [ + "### If $F = I$, then inverse of $F$ gives $F_e$." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "3c3bfb00-2af0-4754-8d4e-89ee10d62519", + "metadata": {}, + "outputs": [], + "source": [ + "Fp=init\n", + "Fe=inv(Fp)\n", + "Rinv = inv(init)" + ] + }, + { + "cell_type": "markdown", + "id": "6786e80d-c9b2-41de-9fc1-40e8d3fc5acd", + "metadata": {}, + "source": [ + "### Shape change by twinning in the reference configuration:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "83c683bf-e3b8-4ec3-9e59-d0a25a55ca0e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "deformation gradient of shape change= \n", + " [[ 0.9873633 0.02555718 -0.03040754]\n", + " [ 0.02555718 0.94831169 0.06149796]\n", + " [ 0.02673204 -0.05406441 1.06432501]]\n" + ] + } + ], + "source": [ + "S_ref= s * np.einsum('i,j',np.matmul(Rinv,unit_mcart),np.matmul(Rinv,unit_ncart)) + np.identity(3)\n", + "print(\"deformation gradient of shape change= \\n\", S_ref)" + ] + }, + { + "cell_type": "markdown", + "id": "eb708c6b-38ea-4f4a-ac59-91e31b55df95", + "metadata": {}, + "source": [ + "### After twinning, $ F_1 = Fe_1 * {F_p}_1 $ , where $ {F_p}_1 = C * {F_p}$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b1ad7d3a-fcf2-4116-9339-0451961ece5d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "with determinant of 1.0000001660951485\n" + ] + } + ], + "source": [ + "F1=S_ref\n", + "C=np.array([[-0.25,0.433013,-0.923645],[0.433013,-0.75,-0.533267],[-0.812, -0.468808, 0]])\n", + "Fe1=np.matmul(F1,inv(np.matmul(C,Fp)))\n", + "print (\"with determinant of \",np.linalg.det(Fe1))" + ] + }, + { + "cell_type": "markdown", + "id": "d21c31d5-72b1-43ed-91e4-2b194cd4eaaf", + "metadata": {}, + "source": [ + "### Right polar decomposition of $F_e$, $ F_e = R U $ gives the rotation of deformed voxel." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9e5edf14-8645-4816-86ee-89d0fb02335e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[300.00001112 86.31191012 153.69000584]\n" + ] + } + ], + "source": [ + "(R_,U_) = scipy.linalg.polar(Fe1,'right')\n", + "check = damask.Orientation.from_matrix(R=R_,family='hexagonal',lattice='hP',a=1.0,b=1.0,c=1.6235).as_Euler_angles(degrees=True)\n", + "print(check)" + ] + }, + { + "cell_type": "markdown", + "id": "749c4997-c181-41c7-8359-f0fd37ee1a38", + "metadata": {}, + "source": [ + "### Get the orientation details" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "e6e8b162-7e0b-45dc-a37f-bee3071ce353", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ 26.30999416 86.31191012 239.99998888]\n" + ] + } + ], + "source": [ + "new_ori = damask.Orientation.from_matrix(R=np.linalg.inv(R_),family='hexagonal',lattice='hP',a=1.0,b=1.0,c=1.6235)\n", + "print(damask.Orientation.from_matrix(R=np.linalg.inv(R_),family='hexagonal',lattice='hP',a=1.0,b=1.0,c=1.6235).as_Euler_angles(degrees=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "80ac2638-3ebd-47c6-8e80-243a1c69fce1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Crystal family: hexagonal\n", + "Bravais lattice: hP\n", + "a=1 m, b=1 m, c=1.6235 m\n", + "α=90°, β=90°, γ=120°\n", + "Quaternion [0.72950604 0. 0. 0.68397436]\n" + ] + } + ], + "source": [ + "old_ori = damask.Orientation.from_Euler_angles(phi=[phi_1,phi_,phi_2],degrees=True,family='hexagonal',lattice='hP',a=1.0,b=1.0,c=1.6235)\n", + "print(old_ori)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "cc1b231c-16e6-4d7d-bda2-8d0a4799839f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Crystal family: hexagonal\n", + "Bravais lattice: hP\n", + "a=1 m, b=1 m, c=1.6235 m\n", + "α=90°, β=90°, γ=120°\n", + "Quaternion [7.29494643e-01 6.83986524e-01 3.14974751e-08 1.07984812e-07]\n", + "[ 0. 86.31191012 0. ]\n" + ] + } + ], + "source": [ + "dis = old_ori.disorientation(new_ori)\n", + "print(dis)\n", + "print(dis.as_Euler_angles(degrees=True))" + ] + }, + { + "cell_type": "markdown", + "id": "3efee0a1-5ebe-42bd-bb05-61721097458d", + "metadata": {}, + "source": [ + "## Result: Print the disorientation between undeformed and deformed voxel." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "10b562ea-c067-4ec0-8b26-59dd8722305a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "disorientation = 86.31191011698503 degrees\n" + ] + } + ], + "source": [ + "print('disorientation =',dis.as_axis_angle(degrees=True,pair=True)[1],'degrees')" + ] + }, + { + "cell_type": "markdown", + "id": "10bdf007-9926-4e38-9195-dd3fd349f634", + "metadata": {}, + "source": [ + "# Code to visualization of lattice reorientation caused by twinning.\n", + "\n", + "First cell below gives HCP unit cell with euler angles 0,0,0.\n", + "\n", + "Second cell below rotates unit cell by provided euler angles.\n", + "\n", + "Third cell below shows reorientation done after twinning." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "37f8aa5b-a6df-45be-861f-46bdd218154a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "from math import cos, sin, radians\n", + "\n", + "# Define the line\n", + "x = np.linspace(0, 1.2, 100)\n", + "y = np.zeros_like(x)\n", + "z = np.zeros_like(x)\n", + "\n", + "x1 = np.zeros_like(x)\n", + "y1 = np.zeros_like(x)\n", + "z1 = np.linspace(0, 1.2, 100)\n", + "\n", + "x2 = np.zeros_like(x)\n", + "y2 = np.linspace(0, 1.2, 100)\n", + "z2 = np.zeros_like(x)\n", + "\n", + "h11 = np.linspace(1,0.5,100)\n", + "h12 = h11*np.sqrt(3) - np.sqrt(3)\n", + "h13 = np.zeros_like(h11)\n", + "\n", + "h21 = np.linspace(-0.5, 0.5, 100)\n", + "h22 = np.ones_like(h21) * np.sqrt(3) / 2\n", + "h23 = np.zeros_like(h21)\n", + "\n", + "h31 = np.linspace(-0.5, 0.5, 100)\n", + "h32 = - np.ones_like(h31) * np.sqrt(3) / 2\n", + "h33 = np.zeros_like(h31)\n", + "\n", + "h41 = np.linspace(1,0.5,100)\n", + "h42 = - h41*np.sqrt(3) + np.sqrt(3)\n", + "h43 = np.zeros_like(h41)\n", + "\n", + "h51 = np.linspace(-1,-0.5,100)\n", + "h52 = - h51*np.sqrt(3) - np.sqrt(3)\n", + "h53 = np.zeros_like(h51)\n", + "\n", + "h61 = np.linspace(-1,-0.5,100)\n", + "h62 = h61*np.sqrt(3) + np.sqrt(3)\n", + "h63 = np.zeros_like(h61)\n", + "\n", + "k11 = np.linspace(1,0.5,100)\n", + "k12 = k11*np.sqrt(3) - np.sqrt(3)\n", + "k13 = np.ones_like(k11)\n", + "\n", + "k21 = np.linspace(-0.5, 0.5, 100)\n", + "k22 = np.ones_like(k21) * np.sqrt(3) / 2\n", + "k23 = np.ones_like(k21)\n", + "\n", + "k31 = np.linspace(-0.5, 0.5, 100)\n", + "k32 = - np.ones_like(k31) * np.sqrt(3) / 2\n", + "k33 = np.ones_like(k31)\n", + "\n", + "k41 = np.linspace(1,0.5,100)\n", + "k42 = - k41*np.sqrt(3) + np.sqrt(3)\n", + "k43 = np.ones_like(k41)\n", + "\n", + "k51 = np.linspace(-1,-0.5,100)\n", + "k52 = - k51*np.sqrt(3) - np.sqrt(3)\n", + "k53 = np.ones_like(k51)\n", + "\n", + "k61 = np.linspace(-1,-0.5,100)\n", + "k62 = k61*np.sqrt(3) + np.sqrt(3)\n", + "k63 = np.ones_like(k61)\n", + "\n", + "\n", + "\n", + "v11 = np.ones_like(x) * 0.5\n", + "v12 = np.ones_like(x) * np.sqrt(3) / 2\n", + "v13 = np.linspace(0, 1, 100)\n", + "\n", + "v21 = - np.ones_like(x) * 0.5\n", + "v22 = np.ones_like(x) * np.sqrt(3) / 2\n", + "v23 = np.linspace(0, 1, 100)\n", + "\n", + "v31 = - np.ones_like(x) * 0.5\n", + "v32 = - np.ones_like(x) * np.sqrt(3) / 2\n", + "v33 = np.linspace(0, 1, 100)\n", + "\n", + "v41 = np.ones_like(x) * 0.5\n", + "v42 = - np.ones_like(x) * np.sqrt(3) / 2\n", + "v43 = np.linspace(0, 1, 100)\n", + "\n", + "v51 = - np.ones_like(x)\n", + "v52 = np.zeros_like(x)\n", + "v53 = np.linspace(0, 1, 100)\n", + "\n", + "v61 = np.ones_like(x)\n", + "v62 = np.zeros_like(x)\n", + "v63 = np.linspace(0, 1, 100)\n", + "\n", + "# Plot the line\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "ax.plot(x, y, z)\n", + "ax.plot(x1, y1, z1)\n", + "#ax.plot(x2, y2, z2)\n", + "ax.plot(h11, h12, h13, 'k-')\n", + "ax.plot(h21, h22, h23, 'k-')\n", + "ax.plot(h31, h32, h33, 'k-')\n", + "ax.plot(h41, h42, h43, 'k-')\n", + "ax.plot(h51, h52, h53, 'k-')\n", + "ax.plot(h61, h62, h63, 'k-')\n", + "ax.plot(k11, k12, k13, 'k-')\n", + "ax.plot(k21, k22, k23, 'k-')\n", + "ax.plot(k31, k32, k33, 'k-')\n", + "ax.plot(k41, k42, k43, 'k-')\n", + "ax.plot(k51, k52, k53, 'k-')\n", + "ax.plot(k61, k62, k63, 'k-')\n", + "ax.plot(v11, v12, v13, 'k-')\n", + "ax.plot(v21, v22, v23, 'k-')\n", + "ax.plot(v31, v32, v33, 'k-')\n", + "ax.plot(v41, v42, v43, 'k-')\n", + "ax.plot(v51, v52, v53, 'k-')\n", + "ax.plot(v61, v62, v63, 'k-')\n", + "\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "ax.set_zticks([])\n", + "\n", + "ax.set_xlabel('')\n", + "ax.set_ylabel('')\n", + "ax.set_zlabel('')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a523f432-ce0a-4506-9d83-bd469e1c9ba3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define the rotation angles (in radians)\n", + "alpha = radians(phi_1) # Rotation around the x-axis\n", + "beta = radians(phi_) # Rotation around the y-axis\n", + "gamma = radians(phi_2) # Rotation around the z-axis\n", + "\n", + "# Create the rotation matrices\n", + "Rx = np.array([[1, 0, 0],\n", + " [0, cos(alpha), -sin(alpha)],\n", + " [0, sin(alpha), cos(alpha)]])\n", + "\n", + "Ry = np.array([[cos(beta), 0, sin(beta)],\n", + " [0, 1, 0],\n", + " [-sin(beta), 0, cos(beta)]])\n", + "\n", + "Rz = np.array([[cos(gamma), -sin(gamma), 0],\n", + " [sin(gamma), cos(gamma), 0],\n", + " [0, 0, 1]])\n", + "\n", + "# Combine the rotation matrices\n", + "R = Rz @ Ry @ Rx\n", + "\n", + "# Apply the rotation to the line\n", + "point1 = np.column_stack((x, y, z))\n", + "point2 = np.column_stack((x1, y1, z1))\n", + "point3 = np.column_stack((h11,h12,h13))\n", + "point4 = np.column_stack((h21, h22, h23))\n", + "point5 = np.column_stack((h31, h32, h33))\n", + "point6 = np.column_stack((h41, h42, h43))\n", + "point7 = np.column_stack((h51, h52, h53))\n", + "point8 = np.column_stack((h61, h62, h63))\n", + "point9 = np.column_stack((k11, k12, k13))\n", + "point10 = np.column_stack((k21, k22, k23))\n", + "point11 = np.column_stack((k31, k32, k33))\n", + "point12 = np.column_stack((k41, k42, k43))\n", + "point13 = np.column_stack((k51, k52, k53))\n", + "point14 = np.column_stack((k61, k62, k63))\n", + "point15 = np.column_stack((v11, v12, v13))\n", + "point16 = np.column_stack((v21, v22, v23))\n", + "point17 = np.column_stack((v31, v32, v33))\n", + "point18 = np.column_stack((v41, v42, v43))\n", + "point19 = np.column_stack((v51, v52, v53))\n", + "point20 = np.column_stack((v61, v62, v63))\n", + "point21 = np.column_stack((x2, y2, z2))\n", + "\n", + "rotated_point1 = np.dot(R, point1.T).T\n", + "rotated_point2 = np.dot(R, point2.T).T\n", + "rotated_point3 = np.dot(R, point3.T).T\n", + "rotated_point4 = np.dot(R, point4.T).T\n", + "rotated_point5 = np.dot(R, point5.T).T\n", + "rotated_point6 = np.dot(R, point6.T).T\n", + "rotated_point7 = np.dot(R, point7.T).T\n", + "rotated_point8 = np.dot(R, point8.T).T\n", + "rotated_point9 = np.dot(R, point9.T).T\n", + "rotated_point10 = np.dot(R, point10.T).T\n", + "rotated_point11 = np.dot(R, point11.T).T\n", + "rotated_point12 = np.dot(R, point12.T).T\n", + "rotated_point13 = np.dot(R, point13.T).T\n", + "rotated_point14 = np.dot(R, point14.T).T\n", + "rotated_point15 = np.dot(R, point15.T).T\n", + "rotated_point16 = np.dot(R, point16.T).T\n", + "rotated_point17 = np.dot(R, point17.T).T\n", + "rotated_point18 = np.dot(R, point18.T).T\n", + "rotated_point19 = np.dot(R, point19.T).T\n", + "rotated_point20 = np.dot(R, point20.T).T\n", + "rotated_point21 = np.dot(R, point21.T).T\n", + "\n", + "# Extract the rotated coordinates\n", + "x_rotated1, y_rotated1, z_rotated1 = rotated_point1.T\n", + "x_rotated2, y_rotated2, z_rotated2 = rotated_point2.T\n", + "x_rotated3, y_rotated3, z_rotated3 = rotated_point3.T\n", + "x_rotated4, y_rotated4, z_rotated4 = rotated_point4.T\n", + "x_rotated5, y_rotated5, z_rotated5 = rotated_point5.T\n", + "x_rotated6, y_rotated6, z_rotated6 = rotated_point6.T\n", + "x_rotated7, y_rotated7, z_rotated7 = rotated_point7.T\n", + "x_rotated8, y_rotated8, z_rotated8 = rotated_point8.T\n", + "x_rotated9, y_rotated9, z_rotated9 = rotated_point9.T\n", + "x_rotated10, y_rotated10, z_rotated10 = rotated_point10.T\n", + "x_rotated11, y_rotated11, z_rotated11 = rotated_point11.T\n", + "x_rotated12, y_rotated12, z_rotated12 = rotated_point12.T\n", + "x_rotated13, y_rotated13, z_rotated13 = rotated_point13.T\n", + "x_rotated14, y_rotated14, z_rotated14 = rotated_point14.T\n", + "x_rotated15, y_rotated15, z_rotated15 = rotated_point15.T\n", + "x_rotated16, y_rotated16, z_rotated16 = rotated_point16.T\n", + "x_rotated17, y_rotated17, z_rotated17 = rotated_point17.T\n", + "x_rotated18, y_rotated18, z_rotated18 = rotated_point18.T\n", + "x_rotated19, y_rotated19, z_rotated19 = rotated_point19.T\n", + "x_rotated20, y_rotated20, z_rotated20 = rotated_point20.T\n", + "x_rotated21, y_rotated21, z_rotated21 = rotated_point21.T\n", + "\n", + "\n", + "# Plot the line\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(projection='3d')\n", + "ax.plot(x_rotated1, y_rotated1, z_rotated1)\n", + "ax.plot(x_rotated2, y_rotated2, z_rotated2)\n", + "#ax.plot(x_rotated21, y_rotated21, z_rotated21)\n", + "ax.plot(x_rotated3, y_rotated3, z_rotated3, 'k-')\n", + "ax.plot(x_rotated4, y_rotated4, z_rotated4, 'k-')\n", + "ax.plot(x_rotated5, y_rotated5, z_rotated5, 'k-')\n", + "ax.plot(x_rotated6, y_rotated6, z_rotated6, 'k-')\n", + "ax.plot(x_rotated7, y_rotated7, z_rotated7, 'k-')\n", + "ax.plot(x_rotated8, y_rotated8, z_rotated8, 'k-')\n", + "ax.plot(x_rotated9, y_rotated9, z_rotated9, 'k-')\n", + "ax.plot(x_rotated10, y_rotated10, z_rotated10, 'k-')\n", + "ax.plot(x_rotated11, y_rotated11, z_rotated11, 'k-')\n", + "ax.plot(x_rotated12, y_rotated12, z_rotated12, 'k-')\n", + "ax.plot(x_rotated13, y_rotated13, z_rotated13, 'k-')\n", + "ax.plot(x_rotated14, y_rotated14, z_rotated14, 'k-')\n", + "ax.plot(x_rotated15, y_rotated15, z_rotated15, 'k-')\n", + "ax.plot(x_rotated16, y_rotated16, z_rotated16, 'k-')\n", + "ax.plot(x_rotated17, y_rotated17, z_rotated17, 'k-')\n", + "ax.plot(x_rotated18, y_rotated18, z_rotated18, 'k-')\n", + "ax.plot(x_rotated19, y_rotated19, z_rotated19, 'k-')\n", + "ax.plot(x_rotated20, y_rotated20, z_rotated20, 'k-')\n", + "\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "ax.set_zticks([])\n", + "\n", + "ax.set_xlabel('')\n", + "ax.set_ylabel('')\n", + "ax.set_zlabel('')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0f461c1e-f9db-4880-8ed3-2a4c841b2251", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Define the rotation angles (in radians)\n", + "alpha = damask.Orientation.from_matrix(R=np.linalg.inv(R_),family='hexagonal',lattice='hP',a=1.0,b=1.0,c=1.6235).as_Euler_angles(degrees=False)[0] \n", + "beta = damask.Orientation.from_matrix(R=np.linalg.inv(R_),family='hexagonal',lattice='hP',a=1.0,b=1.0,c=1.6235).as_Euler_angles(degrees=False)[1] \n", + "gamma = damask.Orientation.from_matrix(R=np.linalg.inv(R_),family='hexagonal',lattice='hP',a=1.0,b=1.0,c=1.6235).as_Euler_angles(degrees=False)[2] \n", + "\n", + "# Create the rotation matrices\n", + "Rx = np.array([[1, 0, 0],\n", + " [0, cos(alpha), -sin(alpha)],\n", + " [0, sin(alpha), cos(alpha)]])\n", + "\n", + "Ry = np.array([[cos(beta), 0, sin(beta)],\n", + " [0, 1, 0],\n", + " [-sin(beta), 0, cos(beta)]])\n", + "\n", + "Rz = np.array([[cos(gamma), -sin(gamma), 0],\n", + " [sin(gamma), cos(gamma), 0],\n", + " [0, 0, 1]])\n", + "\n", + "# Combine the rotation matrices\n", + "R = Rz @ Ry @ Rx\n", + "\n", + "# Apply the rotation to the line\n", + "point21 = np.column_stack((x_rotated1, y_rotated1, z_rotated1))\n", + "point22 = np.column_stack((x_rotated2, y_rotated2, z_rotated2))\n", + "point23 = np.column_stack((x_rotated3, y_rotated3, z_rotated3))\n", + "point24 = np.column_stack((x_rotated4, y_rotated4, z_rotated4))\n", + "point25 = np.column_stack((x_rotated5, y_rotated5, z_rotated5))\n", + "point26 = np.column_stack((x_rotated6, y_rotated6, z_rotated6))\n", + "point27 = np.column_stack((x_rotated7, y_rotated7, z_rotated7))\n", + "point28 = np.column_stack((x_rotated8, y_rotated8, z_rotated8))\n", + "point29 = np.column_stack((x_rotated9, y_rotated9, z_rotated9))\n", + "point30 = np.column_stack((x_rotated10, y_rotated10, z_rotated10))\n", + "point31 = np.column_stack((x_rotated11, y_rotated11, z_rotated11))\n", + "point32 = np.column_stack((x_rotated12, y_rotated12, z_rotated12))\n", + "point33 = np.column_stack((x_rotated13, y_rotated13, z_rotated13))\n", + "point34 = np.column_stack((x_rotated14, y_rotated14, z_rotated14))\n", + "point35 = np.column_stack((x_rotated15, y_rotated15, z_rotated15))\n", + "point36 = np.column_stack((x_rotated16, y_rotated16, z_rotated16))\n", + "point37 = np.column_stack((x_rotated17, y_rotated17, z_rotated17))\n", + "point38 = np.column_stack((x_rotated18, y_rotated18, z_rotated18))\n", + "point39 = np.column_stack((x_rotated19, y_rotated19, z_rotated19))\n", + "point40 = np.column_stack((x_rotated20, y_rotated20, z_rotated20))\n", + "point41 = np.column_stack((x_rotated21, y_rotated21, z_rotated21))\n", + "\n", + "rotated_point21 = np.dot(R, point21.T).T\n", + "rotated_point22 = np.dot(R, point22.T).T\n", + "rotated_point23 = np.dot(R, point23.T).T\n", + "rotated_point24 = np.dot(R, point24.T).T\n", + "rotated_point25 = np.dot(R, point25.T).T\n", + "rotated_point26 = np.dot(R, point26.T).T\n", + "rotated_point27 = np.dot(R, point27.T).T\n", + "rotated_point28 = np.dot(R, point28.T).T\n", + "rotated_point29 = np.dot(R, point29.T).T\n", + "rotated_point30 = np.dot(R, point30.T).T\n", + "rotated_point31 = np.dot(R, point31.T).T\n", + "rotated_point32 = np.dot(R, point32.T).T\n", + "rotated_point33 = np.dot(R, point33.T).T\n", + "rotated_point34 = np.dot(R, point34.T).T\n", + "rotated_point35 = np.dot(R, point35.T).T\n", + "rotated_point36 = np.dot(R, point36.T).T\n", + "rotated_point37 = np.dot(R, point37.T).T\n", + "rotated_point38 = np.dot(R, point38.T).T\n", + "rotated_point39 = np.dot(R, point39.T).T\n", + "rotated_point40 = np.dot(R, point40.T).T\n", + "rotated_point41 = np.dot(R, point41.T).T\n", + "\n", + "# Extract the rotated coordinates\n", + "x_rotated21, y_rotated21, z_rotated21 = rotated_point21.T\n", + "x_rotated22, y_rotated22, z_rotated22 = rotated_point22.T\n", + "x_rotated23, y_rotated23, z_rotated23 = rotated_point23.T\n", + "x_rotated24, y_rotated24, z_rotated24 = rotated_point24.T\n", + "x_rotated25, y_rotated25, z_rotated25 = rotated_point25.T\n", + "x_rotated26, y_rotated26, z_rotated26 = rotated_point26.T\n", + "x_rotated27, y_rotated27, z_rotated27 = rotated_point27.T\n", + "x_rotated28, y_rotated28, z_rotated28 = rotated_point28.T\n", + "x_rotated29, y_rotated29, z_rotated29 = rotated_point29.T\n", + "x_rotated30, y_rotated30, z_rotated30 = rotated_point30.T\n", + "x_rotated31, y_rotated31, z_rotated31 = rotated_point31.T\n", + "x_rotated32, y_rotated32, z_rotated32 = rotated_point32.T\n", + "x_rotated33, y_rotated33, z_rotated33 = rotated_point33.T\n", + "x_rotated34, y_rotated34, z_rotated34 = rotated_point34.T\n", + "x_rotated35, y_rotated35, z_rotated35 = rotated_point35.T\n", + "x_rotated36, y_rotated36, z_rotated36 = rotated_point36.T\n", + "x_rotated37, y_rotated37, z_rotated37 = rotated_point37.T\n", + "x_rotated38, y_rotated38, z_rotated38 = rotated_point38.T\n", + "x_rotated39, y_rotated39, z_rotated39 = rotated_point39.T\n", + "x_rotated40, y_rotated40, z_rotated40 = rotated_point40.T\n", + "x_rotated41, y_rotated41, z_rotated41 = rotated_point41.T\n", + "\n", + "\n", + "# Plot the line\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "ax.plot(x_rotated21, y_rotated21, z_rotated21)\n", + "ax.plot(x_rotated22, y_rotated22, z_rotated22)\n", + "ax.plot(x_rotated23, y_rotated23, z_rotated23, 'k-')\n", + "ax.plot(x_rotated24, y_rotated24, z_rotated24, 'k-')\n", + "ax.plot(x_rotated25, y_rotated25, z_rotated25, 'k-')\n", + "ax.plot(x_rotated26, y_rotated26, z_rotated26, 'k-')\n", + "ax.plot(x_rotated27, y_rotated27, z_rotated27, 'k-')\n", + "ax.plot(x_rotated28, y_rotated28, z_rotated28, 'k-')\n", + "ax.plot(x_rotated29, y_rotated29, z_rotated29, 'k-')\n", + "ax.plot(x_rotated30, y_rotated30, z_rotated30, 'k-')\n", + "ax.plot(x_rotated31, y_rotated31, z_rotated31, 'k-')\n", + "ax.plot(x_rotated32, y_rotated32, z_rotated32, 'k-')\n", + "ax.plot(x_rotated33, y_rotated33, z_rotated33, 'k-')\n", + "ax.plot(x_rotated34, y_rotated34, z_rotated34, 'k-')\n", + "ax.plot(x_rotated35, y_rotated35, z_rotated35, 'k-')\n", + "ax.plot(x_rotated36, y_rotated36, z_rotated36, 'k-')\n", + "ax.plot(x_rotated37, y_rotated37, z_rotated37, 'k-')\n", + "ax.plot(x_rotated38, y_rotated38, z_rotated38, 'k-')\n", + "ax.plot(x_rotated39, y_rotated39, z_rotated39, 'k-')\n", + "ax.plot(x_rotated40, y_rotated40, z_rotated40, 'k-')\n", + "ax.plot(x_rotated40, y_rotated40, z_rotated40, 'k-')\n", + "#ax.plot(x_rotated41, y_rotated41, z_rotated41)\n", + "\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "ax.set_zticks([])\n", + "\n", + "ax.set_xlabel('')\n", + "ax.set_ylabel('')\n", + "ax.set_zlabel('')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Twin_reorientation_check.ipynb b/Twin_reorientation_check.ipynb index fe29ebb..e1ac0b4 100644 --- a/Twin_reorientation_check.ipynb +++ b/Twin_reorientation_check.ipynb @@ -5,8 +5,10 @@ "id": "e2ae546c-570b-4245-99fa-60519f448e1e", "metadata": {}, "source": [ - "# Code to verify and visualize Reorientation by Correspondence Matrix\n", + "# Code to verify and visualize reorientation caused twinning in the deformation gradient.\n", + "## Using the correspondence matrix method.\n", "By Satyapriya Gupta, Achal H P\n", + "\n", "Reference Niewczas, Acta Materialia, 2010" ] }, @@ -111,7 +113,7 @@ "id": "1262386a-1d9c-4bb0-a147-c409f45ec751", "metadata": {}, "source": [ - "### Initial Undeformed Condition, F = Identity matrix" + "### Initial Undeformed Condition, $ F = Identity matrix $" ] }, { @@ -129,7 +131,7 @@ "id": "64b46853-7012-432f-93c1-4acb1fe4dc9a", "metadata": {}, "source": [ - "### If F = I, then inverse of F gives Fe." + "### If $F = I$, then inverse of $F$ gives $F_e$." ] }, { @@ -208,7 +210,7 @@ "id": "d21c31d5-72b1-43ed-91e4-2b194cd4eaaf", "metadata": {}, "source": [ - "### Right polar decomposition of Fe, $ F_e = R U $ gives the rotation of deformed voxel." + "### Right polar decomposition of $F_e$, $ F_e = R U $ gives the rotation of deformed voxel." ] }, { @@ -339,8 +341,10 @@ "source": [ "# Code to visualization of lattice reorientation caused by twinning.\n", "\n", - "First cell below gives HCP unit cell with euler angles 0,0,0\n", + "First cell below gives HCP unit cell with euler angles 0,0,0.\n", + "\n", "Second cell below rotates unit cell by provided euler angles.\n", + "\n", "Third cell below shows reorientation done after twinning." ] },