ETMT_plastic_strain_calculator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ETMT Data Analysis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Load in the ETMT data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Load in the columns from the datafile. \n",
    "\n",
    "*Note, start from zero.*\n",
    "\n",
    "For data collected from Diamond Light Source in 2022 the format for the columns is given as. It is advised that this template is used in future;\n",
    "\n",
    "- A(0) Total Time (s)\n",
    "- B(1) Cycle Elapsed Time (s)\n",
    "- C(2) Total Cycles\n",
    "- D(3) Elapsed Cycles\n",
    "- E(4) Step\n",
    "- F(5) Total Cycle Count(Load Frame Waveform)\n",
    "- G(6) Total Cycle Count(Temperature Waveform)\n",
    "- H(7) Time Stamp(PC)\n",
    "- I(8) Position(Load Frame:Linear Position Encoder) (mm)\n",
    "- J(9) Displacement(Load Frame:Linear Position Encoder) (mm)\n",
    "- K(10) Strain(Load Frame:Linear Position Encoder) (%)\n",
    "- L(11) Force(Load Frame:Load) (N)\n",
    "- M(12) Stress(Load Frame:Load) (MPa)\n",
    "- N(13) Strain(Load Frame:Strain 1) (%)\n",
    "- O(14) User-Defined(Temperature:Temperature) (C)\n",
    "- P(15) Temperature(Temperature Controller 1:Temperature) (C)\n",
    "- Q(16) User-Defined(Temperature:Current) (Amps)\n",
    "- R(17) User-Defined(Temperature:Voltage) (Volts)\n",
    "- S(18) Drive(Load Frame Waveform) (%)\n",
    "- T(19) Command(Load Frame Waveform) (%)\n",
    "- U(20) Error(Load Frame Waveform) (%)\n",
    "- V(21) Command(Temperature Waveform) (%)\n",
    "- W(22) Drive(Temperature Waveform) (%)\n",
    "- X(23) Error(Temperature Waveform) (%)\n",
    "- Y(24) Command(Temperature Controller 1 Waveform) (C)\n",
    "- Z(25) Drive(Temperature Controller 1 Waveform) (%)\n",
    "\n",
    "The main **inputs** are therefore:\n",
    "\n",
    "- A(0) Time (s)\n",
    "- I(8) Position/Displacement (mm)\n",
    "- L(11) Load (N)\n",
    "- 0(14) ETMT Temperature (C)\n",
    "- P(15) Eurotherm Temperature (C)\n",
    "- Q(16) Current (Amps)\n",
    "- R(17) Voltage (V)\n",
    "\n",
    "And we will need the command frame signal to determine the start and end of deformation:\n",
    "\n",
    "- T(19) Command Frame Signal (%)\n",
    "\n",
    "The main **ouptuts** will then be: \n",
    "\n",
    "- 0 = Time (s)\n",
    "- 1 = Position/Displacement (mm)\n",
    "- 2 = Load (N)\n",
    "- 3 = ETMT Temperature (C)\n",
    "- 4 = Eurotherm Temperature (C)\n",
    "- 5 = Current (Amps)\n",
    "- 6 = Voltage (V)\n",
    "- 7 = Command Frame Signal (%)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "use_columns = (0,8,11,14,15,16,17,19)\n",
    "\n",
    "time = 0\n",
    "position = 1\n",
    "load = 2\n",
    "etmt_temperature = 3\n",
    "eurotherm_temperature = 4\n",
    "current = 5\n",
    "voltage = 6\n",
    "frame = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "experiment_number = \"039\"\n",
    "experiment_name = \"039_Ti64_TIFUN-T4_TD_Deform_820C_0p1mms-\"\n",
    "\n",
    "input_file = f\"../../SXRD_raw_data/diamond_2022/rawdata_ETMT/{experiment_name}/Test1/Test1.steps.tracking.csv\"\n",
    "output_folder = f\"../../SXRD_analysis/diamond_2022/{experiment_name}/ETMT-output\"\n",
    "\n",
    "ETMT_data = np.loadtxt(input_file, skiprows=1, delimiter=',', usecols = use_columns)\n",
    "print(ETMT_data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the start and end of the loading test using `Command Frame Signal`, when this is above a *very small* value. Check the ETMT data to see what the command frame value is at the start of deformation, but typically whole number percentages are applied right at the start of deformation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def above_value (array, number: int = 0.0005):\n",
    "    output_array = np.zeros((2,1))\n",
    "    for index in range (len(array)):\n",
    "        if abs(array[index]) > abs (number):\n",
    "            value = array[index]\n",
    "            element = index\n",
    "            output_array = np.append(output_array, [[value], [element]], axis=1)\n",
    "    return output_array\n",
    "\n",
    "def closest_value (array, number):\n",
    "    value = array[0]\n",
    "    for index in range (len(array)):\n",
    "        if abs (number - array[index]) < abs (number - value):\n",
    "            value = array[index]\n",
    "            element = index\n",
    "    return value, element\n",
    "\n",
    "def sequence_checker(array, sequence_length: int = 4):\n",
    "    \"\"\" Check for sequence of consecutive numbers in array\n",
    "    and return array when sequence has been found.\n",
    "    \"\"\"\n",
    "    new_array = []\n",
    "    for i in range(len(array) - 1):\n",
    "        if(array[i] == array[i + 1]):\n",
    "            new_array += [array[i]]\n",
    "            if(len(new_array) == sequence_length):\n",
    "                break\n",
    "        else:\n",
    "            new_array = []\n",
    "    return new_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "frame_signal = ETMT_data[:,frame]\n",
    "frame_non_zero = above_value(frame_signal, 0.03)\n",
    "start_value = frame_non_zero[0][1]\n",
    "start_index = int(frame_non_zero[1][1])\n",
    "end_value = frame_non_zero[0][-1]\n",
    "end_index = int(frame_non_zero[1][-1])\n",
    "print(\"The start of deformation is at index\", start_index, \", with a Command Frame Signal value of\", start_value, \"%\")\n",
    "print(\"The end of deformation is at index\", end_index, \", with a Command Frame Signal value of\", end_value, \"%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If the sample did not go to zero load immediately after deformation, but was held in position control, then we can detect the `Command Frame Signal` for a hold in position, which will be a series of the same value during the hold period."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# frame_position_hold = sequence_checker(ETMT_data[start_index:end_index,frame])\n",
    "# end_value, end_index = closest_value(ETMT_data[:,frame],frame_position_hold[0])\n",
    "\n",
    "# print(\"The end of deformation has been changed to index\", start_index, \", with a Command Frame Signal value of\", start_value, \"%\") \n",
    "# print(\"This is to remove a hold in position immediately after deformation.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting out the ETMT data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate the engineering stress from the load using the `gauge_area` of the sample. And calculate the engineering strain from the length change using the `gauge_length` of the sample."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gauge_area = 8\n",
    "gauge_length = 2\n",
    "\n",
    "time_array = ETMT_data[start_index:end_index,time]\n",
    "load_array = ETMT_data[start_index:end_index, load]\n",
    "position_array = ETMT_data[start_index:end_index,position]\n",
    "displacement_array = position_array - position_array[0]\n",
    "\n",
    "stress_array = load_array / gauge_area\n",
    "strain_array = displacement_array / gauge_length\n",
    "\n",
    "etmt_temperature_array = ETMT_data[start_index:end_index, etmt_temperature]\n",
    "eurotherm_temperature_array = ETMT_data[start_index:end_index, eurotherm_temperature]\n",
    "\n",
    "current_array = ETMT_data[start_index:end_index, current]\n",
    "voltage_array = ETMT_data[start_index:end_index, voltage]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Calculate the true stress and true strain of the sample using the **Resistance Method**. An explanation of this method can be found in this paper by [Roebuck, Cox and Reed](https://www.tms.org/Superalloys/10.7449/2004/Superalloys_2004_523_528.pdf)\n",
    "\n",
    "Using the resistance method we can calculate true strain $\\varepsilon_p = \\ln{ \\sqrt{ \\frac{R_l}{R_s}}}$ where the resistance during the test, $R_l$ and at the start $R_s$ are calculated from the measured voltage and measured current $R=\\frac{V}{I}$. In this case, the current is the amount delivered to the sample by the ETMT, and the voltage drop across the centre of the sample is measured by two resistivity wires (of the same material, typically either pure Pt, Cu, or Ni80Cr wire).\n",
    "\n",
    "*Note, we have already found the start of the deformation part of the test using the `Command Frame Signal`, when it is non-zero, or above a very small value.*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_current = ETMT_data[start_index,current]\n",
    "start_voltage = ETMT_data[start_index,voltage]\n",
    "\n",
    "start_resistance = start_voltage / start_current\n",
    "resistance_array = voltage_array / current_array\n",
    "\n",
    "true_strain_array = np.log(np.sqrt(resistance_array / start_resistance))\n",
    "\n",
    "engineering_strain_array = np.expm1(true_strain_array)\n",
    "\n",
    "true_stress_array = stress_array*(1 + engineering_strain_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Plot out (and save) the figures showing the applied stress, change in temperature and true stress versus true strain response. Check these signals carefully as it is possible the resistivity wires could be noisey or introduce erroneous results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.rc('xtick',labelsize=16)\n",
    "plt.rc('ytick',labelsize=16)\n",
    "plt.rc('legend',fontsize=16)\n",
    "plt.rc('axes',linewidth=1)\n",
    "plt.rc('xtick.major',width=2,size=10)\n",
    "plt.rc('xtick.minor', width=2, size=5)\n",
    "plt.rc('ytick.major',width=2,size=10)\n",
    "plt.rc('ytick.minor',width=2,size=5)\n",
    "\n",
    "fig,((ax1,ax2),(ax3,ax4),(ax5,ax6))=plt.subplots(3, 2, figsize=(20,15))\n",
    "\n",
    "ax1.plot(position_array, stress_array, marker = \"o\", color = \"green\", markersize = 5)\n",
    "ax1.set_xlabel(\"Position (mm)\", fontsize = 20)\n",
    "ax1.set_ylabel(\"Applied Stress, ${\\sigma_E}$ (MPa)\", fontsize = 20)\n",
    "ax1.minorticks_on()\n",
    "\n",
    "ax2.plot(position_array, resistance_array, marker = \"o\", color = \"green\", markersize = 5)\n",
    "ax2.set_xlabel(\"Position (mm)\", fontsize = 20)\n",
    "ax2.set_ylabel(\"Resistance, ${(\\Omega)}$\", fontsize = 20)\n",
    "ax2.minorticks_on()\n",
    "\n",
    "ax3.plot(position_array, etmt_temperature_array, marker = \"o\", color = \"red\", markersize = 5)\n",
    "ax3.set_xlabel(\"Position (mm)\", fontsize = 20)\n",
    "ax3.set_ylabel(\"ETMT Control Temperature, ${^\\circ C}$\", fontsize = 20)\n",
    "ax3.minorticks_on()\n",
    "\n",
    "ax4.plot(position_array, eurotherm_temperature_array, marker = \"o\", color = \"red\", markersize = 5)\n",
    "ax4.set_xlabel(\"Position (mm)\", fontsize = 20)\n",
    "ax4.set_ylabel(\"Eurotherm Temperature, ${^\\circ C}$\", fontsize = 20)\n",
    "ax4.minorticks_on()\n",
    "\n",
    "ax5.plot(strain_array, stress_array, marker = \"o\", color = \"blue\", markersize = 5)\n",
    "ax5.set_ylabel(\"Applied Strain, ${\\epsilon_E}$\", fontsize = 20)\n",
    "ax5.set_ylabel(\"Applied Stress, ${\\sigma_E}$, (MPa)\", fontsize = 20)\n",
    "ax5.minorticks_on()\n",
    "\n",
    "ax6.plot(true_strain_array, true_stress_array, marker = \"o\", color = \"blue\", markersize = 5)\n",
    "ax6.set_xlabel(\"True Strain, ${\\epsilon_T}$\", fontsize = 20)\n",
    "ax6.set_ylabel(\"True Stress, ${\\sigma_T}$, (MPa)\", fontsize = 20)\n",
    "ax6.minorticks_on()\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "# check output folder exists\n",
    "CHECK_FOLDER = os.path.isdir(output_folder)\n",
    "\n",
    "if not CHECK_FOLDER:\n",
    "    os.makedirs(output_folder)\n",
    "    print(\"Created folder : \", output_folder)\n",
    "\n",
    "plt.savefig(\"{output_folder}/ETMT_figures_{experiment_number}.png\".format(output_folder = output_folder, experiment_number = experiment_number))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write out an output ETMT datafile, which can be used for synicing the measured thermomechanical material response with the micromechanical elastic lattice strain response recorded using synchrotron X-ray diffraction (SXRD) pattern images.\n",
    "\n",
    "The output ETMT datafile contains the following:\n",
    "\n",
    "- 0 = Time (s)\n",
    "- 1 = Load (N)\n",
    "- 2 = Displacement (mm)\n",
    "- 3 = Applied Stress (MPa)\n",
    "- 4 = True Strain\n",
    "- 5 = True Stress (MPa)\n",
    "- 6 = ETMT Temperature (C)\n",
    "- 7 = Eurotherm Temperature (C)\n",
    "- 8 = Command Frame Signal (%)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt(\"{output_folder}/ETMT_output_{experiment_number}.txt\".format(output_folder = output_folder, experiment_number = experiment_number), \n",
    "           np.c_[time_array, load_array, displacement_array, stress_array, true_strain_array, true_stress_array,\n",
    "                etmt_temperature_array, eurotherm_temperature_array, ETMT_data[start_index:end_index,frame]], \n",
    "           header = \"Time (s), Load (N), Displacement (mm), Applied Stress (MPa), True Strain, True Stress (MPa), ETMT Temperature (C), Eurotherm Temperature (C), Command Frame Signal (%)\",\n",
    "           delimiter = ',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}