window-lstm-predictions.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "from sklearn.metrics import r2_score \n",
    "from sklearn.model_selection import train_test_split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_data(dataset):\n",
    "    OUT_FILE_PATH = \"/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/%s/out.csv\" % dataset\n",
    "    DATA_FILE_PATH = \"/home/sarthak/projects/model_training/new_data/%s.csv\" % dataset\n",
    "    print(OUT_FILE_PATH)\n",
    "    print(DATA_FILE_PATH)\n",
    "\n",
    "    out_file = pd.read_csv(OUT_FILE_PATH)\n",
    "    lim = 0.00\n",
    "    timesteps = []\n",
    "    time = []\n",
    "    for i in range(len(out_file)):\n",
    "        if(out_file[\"eff_strain\"][i] >= lim):\n",
    "            timesteps.append(i+1)\n",
    "            time.append(out_file[\"time\"][i])\n",
    "            lim = lim + 0.01\n",
    "\n",
    "    print(\"Reading %s \\n\" % dataset)\n",
    "    # Reading data\n",
    "    df = pd.read_csv(DATA_FILE_PATH)\n",
    "    df_dropped = df.drop(columns=['strain_yy', 'phases', 'pressure', 'sdv22', 'sdv23',\n",
    "                                  'total_strain_xy', 'elem_id', 'blk_id', 'total_stress_xx', 'total_stress_yy',\n",
    "                                  'total_strain_xx', 'total_strain_yy' ])\n",
    "    df_norm = (df_dropped-df_dropped.min())/(df_dropped.max()-df_dropped.min())\n",
    "    df_norm.tail()\n",
    "    scale_steps = int(np.ceil(len(out_file)/(len(df_dropped)/160000)))\n",
    "    steps = np.ceil((np.array(timesteps)/scale_steps))\n",
    "    df_steps = df_dropped[df_dropped[\"time\"].isin(steps)] \n",
    "    df_steps_norm = (df_steps-df_steps.min())/(df_steps.max()-df_steps.min())\n",
    "    df_steps_norm = df_steps_norm.drop(columns=['time'])\n",
    "    df_group = df_steps_norm.groupby([\"elem_x\", \"elem_y\"])\n",
    "    return df_group"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def series_to_supervised(sequences, n_steps_in, n_steps_out, dropnan=True):\n",
    "    X, y = list(), list()\n",
    "    for i in range(len(sequences)):\n",
    "        # find the end of this pattern\n",
    "        end_ix = i + n_steps_in\n",
    "        out_end_ix = end_ix + n_steps_out\n",
    "        # check if we beyond the dataset\n",
    "        if out_end_ix > len(sequences):\n",
    "            break\n",
    "        # gather input and output parts of the pattern\n",
    "        seq_x, seq_y = sequences[i:end_ix, :], sequences[end_ix: out_end_ix, :]\n",
    "        X.append(seq_x)\n",
    "        y.append(seq_y)\n",
    "    return np.array(X), np.array(y)\n",
    "\n",
    "def structure_data(df_group):\n",
    "    x_raw_list = []\n",
    "    y_raw_list = []\n",
    "    for name, group in df_group:\n",
    "        strain_vals = group['eff_strain'].values\n",
    "        stress_vals = group['vonmises'].values\n",
    "        tri_vals = group['triaxiality'].values\n",
    "        all_vals = np.stack((strain_vals, stress_vals, tri_vals), axis = 1 )\n",
    "        x, y = series_to_supervised(all_vals, 2, 13)\n",
    "        x_raw_list.append(x)\n",
    "        y_raw_list.append(y)\n",
    "    x_vals = np.concatenate(x_raw_list)\n",
    "    y_vals = np.concatenate(y_raw_list)\n",
    "    return x_vals, y_vals, x_raw_list, y_raw_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_path = '/home/sarthak/projects/model_training/trained_models/window_lstm'\n",
    "model = tf.keras.models.load_model(base_path+'/the_model_5_datasets')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Strain partitioning plot\n",
    "\n",
    "The first part of this functions is similar to the `read_data` function. It loads the data for a new microsructure and structures it in the format used by the model.\n",
    "\n",
    "Strain parititioning is commonly observed in dual phase microstructures. Strain partitioning plots shows the comparison of the LSTM predicted and FE predicted average effective strains in the soft and hard phases as a function of applied strain. The following few code snippets extract the data needed for these plots.\n",
    "\n",
    "In our exodus file, the grain id are called blk_id. In the snippet below we store the grain ids for every elements in the other in which they appear in the microstructure.\n",
    "Effective strain values for each of the phases are also calculated in the snippet below. Grain id greater than 1297 (for this case, can be obtained from Paraview) belong to the martensite phase. For every timestep, the strain values for both the phases are caculated and stored from the LSTM predictions \n",
    "\n",
    "- `one_step`: a vector with values for all the 16,000 elements at a particular timestep.\n",
    "- `one_step_scaled`: vector with effective strain values for every element at a single timestep on the standard scale.\n",
    "- `martensite_step`: summation of strain values for all the martensite (hard) phase elements at a single timestep\n",
    "- `ferrite_step`:  summation of strain values for all the ferrite (soft) phase elements at a single timestep\n",
    "- `martensite_count`: number of martensite (hard) elements\n",
    "- `ferrite_count`: numbero of ferrite (soft) elements\n",
    "- `martensite_strain_steps`: list of average strain values of martensite (hard) elements at all timesteps\n",
    "- `ferrite_strain_steps`: list of average strain values of ferrible (soft) elements at all timesteps\n",
    "\n",
    "- `blk_id_ordered`: list of grain id of all elements, in the order they appear on the microstructure\n",
    "\n",
    "The actual plotting takes place at the end of function\n",
    "\n",
    "- `martensite`: FE values for the martensite (hard) phase \n",
    "- `ferrite`: FE values for the ferrite (soft) phase\n",
    "- `martensite_strain`: FE effective strain values for the martensite (hard) phase at all timesteps\n",
    "- `ferrite_strain`: FE effective strain values for the ferrite (soft) phase at all timesteps\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_partition(dataset, start, stop, model):\n",
    "    OUT_FILE_PATH = \"/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/%s/out.csv\" % dataset\n",
    "    DATA_FILE_PATH = \"/home/sarthak/projects/model_training/new_data/%s.csv\" % dataset\n",
    "    PLOTS_PATH = \"/home/sarthak/projects/model_training/trained_models/window_lstm/predictions/good\"\n",
    "    print(OUT_FILE_PATH)\n",
    "    print(DATA_FILE_PATH)\n",
    "\n",
    "    out_file = pd.read_csv(OUT_FILE_PATH)\n",
    "    lim = 0.00\n",
    "    timesteps = []\n",
    "    time = []\n",
    "    for i in range(len(out_file)):\n",
    "        if(out_file[\"eff_strain\"][i] >= lim):\n",
    "            timesteps.append(i+1)\n",
    "            time.append(out_file[\"time\"][i])\n",
    "            lim = lim + 0.01\n",
    "\n",
    "    print(\"Reading %s \\n\" % dataset)\n",
    "    # Reading data\n",
    "    df = pd.read_csv(DATA_FILE_PATH)\n",
    "    df_dropped = df.drop(columns=['phases', 'pressure', 'sdv22', 'sdv23',\n",
    "                                  'total_strain_xy', 'elem_id', 'blk_id', 'total_stress_xx', 'total_stress_yy',\n",
    "                                  'total_strain_xx', 'total_strain_yy' ])\n",
    "    df_norm = (df_dropped-df_dropped.min())/(df_dropped.max()-df_dropped.min())\n",
    "    df_norm.tail()\n",
    "    scale_steps = int(np.ceil(len(out_file)/(len(df_dropped)/160000)))\n",
    "    steps = np.ceil((np.array(timesteps)/scale_steps))\n",
    "    df_steps = df_dropped[df_dropped[\"time\"].isin(steps)] \n",
    "    df_steps_norm = (df_steps-df_steps.min())/(df_steps.max()-df_steps.min())\n",
    "    df_steps_norm = df_steps_norm.drop(columns=['time'])\n",
    "    df_group = df_steps_norm.groupby([\"elem_x\", \"elem_y\"])\n",
    "    \n",
    "    x_vals, y_vals, x_raw_list, y_raw_list = structure_data(df_group)\n",
    "    input_step = np.array(x_raw_list)[:,start,:,:]\n",
    "    next_step = model.predict(input_step)\n",
    "    input_step = np.concatenate(((np.delete(input_step, 0, 1)), next_step), axis = 1)\n",
    "    true_val = np.array(y_raw_list)\n",
    "    ans = true_val[:,0,:,:]\n",
    "    blk_group = df.groupby([\"elem_x\", \"elem_y\"])\n",
    "    blk_id_ordered = []\n",
    "    for name, group in blk_group:\n",
    "        blk_id_ordered.append(group['blk_id'].values[0])\n",
    "    \n",
    "    martensite_strain_steps = [0]\n",
    "    ferrite_strain_steps = [0]\n",
    "    \n",
    "    for j in range(0,13):\n",
    "        var_name = 'eff_strain'\n",
    "        one_step_scaled = (next_step[:,j,0]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        martensite_step = 0\n",
    "        ferrite_step = 0\n",
    "        martensite_count = 0\n",
    "        ferrite_count = 0\n",
    "        for i in range(len(one_step_scaled)):\n",
    "            #print(i)\n",
    "            if blk_id_ordered[i] >= 1297:\n",
    "                martensite_step += one_step_scaled[i]\n",
    "                martensite_count += 1\n",
    "            elif blk_id_ordered[i] < 1297:\n",
    "                ferrite_step += one_step_scaled[i]\n",
    "                ferrite_count += 1\n",
    "        martensite_strain_steps.append(martensite_step/martensite_count)\n",
    "        ferrite_strain_steps.append(ferrite_step/ferrite_count)\n",
    "    \n",
    "    variables = [\"eff_strain\", \"vonmises\", \"triaxiality\"]\n",
    "    print(martensite_strain_steps)\n",
    "    strain_yy_steps = df_steps.strain_yy.unique()\n",
    "    strain_yy_steps[0] = 0\n",
    "    martensite = df.loc[df['blk_id']>=1297]\n",
    "    ferrite = df.loc[df['blk_id']<1297]\n",
    "    martensite_strain = martensite.groupby('time').mean()['eff_strain']\n",
    "    strain_yy = df.groupby('time').mean()['strain_yy']\n",
    "    ferrite_strain = ferrite.groupby('time').mean()['eff_strain']\n",
    "\n",
    "    print(len(strain_yy_steps), len(ferrite_strain_steps))\n",
    "    plt.figure()\n",
    "    plt.rcParams.update({'font.size': 15})\n",
    "    plt.plot(strain_yy, ferrite_strain, 'b', label='Soft (FE)')\n",
    "    plt.scatter(strain_yy_steps[2:16], ferrite_strain_steps, marker='o', c='blue', label=\"Soft (LSTM)\")\n",
    "    plt.plot(strain_yy, martensite_strain, 'r', label=\"Hard (FE)\")\n",
    "    plt.scatter(strain_yy_steps[2:16], martensite_strain_steps, marker='^', c='red', label=\"Hard (LSTM)\")\n",
    "    plt.xlabel(r'$\\bar{\\epsilon}_{app}$')\n",
    "    plt.ylabel(r'$\\bar{\\epsilon}$')\n",
    "    plt.legend()\n",
    "    plt.savefig(PLOTS_PATH+'/strain_paritioning.png', dpi=700, bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test24/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test24.csv\n",
      "Reading test24 \n",
      "\n",
      "[0, 0.008031036832635785, 0.010450619408203344, 0.013668112849121537, 0.01696018127181049, 0.020601042905033777, 0.024467537696929127, 0.028627347170166448, 0.032937617039692745, 0.037420683420420896, 0.042042631765200005, 0.04681990477461067, 0.0517486423973726, 0.05681845823272015]\n",
      "16 14\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "make_partition('test24', 0, 12, model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Cross Correlation Plots\n",
    "\n",
    "The first part of this functions is similar to the `read_data` function. It loads the data for a new microsructure and structures it in the format used by the model.\n",
    "\n",
    "The function plots of LSTM predicted values vs FE values for all the 3 variables and saves them in the location defined by `PLOTS_PATH`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_r2(dataset, start, stop, model):\n",
    "    OUT_FILE_PATH = \"/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/%s/out.csv\" % dataset\n",
    "    DATA_FILE_PATH = \"/home/sarthak/projects/model_training/new_data/%s.csv\" % dataset\n",
    "    PLOTS_PATH = \"/home/sarthak/projects/model_training/trained_models/window_lstm/predictions/good\"\n",
    "    print(OUT_FILE_PATH)\n",
    "    print(DATA_FILE_PATH)\n",
    "\n",
    "    out_file = pd.read_csv(OUT_FILE_PATH)\n",
    "    lim = 0.00\n",
    "    timesteps = []\n",
    "    time = []\n",
    "    for i in range(len(out_file)):\n",
    "        if(out_file[\"eff_strain\"][i] >= lim):\n",
    "            timesteps.append(i+1)\n",
    "            time.append(out_file[\"time\"][i])\n",
    "            lim = lim + 0.01\n",
    "\n",
    "    print(\"Reading %s \\n\" % dataset)\n",
    "    # Reading data\n",
    "    df = pd.read_csv(DATA_FILE_PATH)\n",
    "    df_dropped = df.drop(columns=['strain_yy', 'phases', 'pressure', 'sdv22', 'sdv23',\n",
    "                                  'total_strain_xy', 'elem_id', 'blk_id', 'total_stress_xx', 'total_stress_yy',\n",
    "                                  'total_strain_xx', 'total_strain_yy' ])\n",
    "    df_norm = (df_dropped-df_dropped.min())/(df_dropped.max()-df_dropped.min())\n",
    "    df_norm.tail()\n",
    "    scale_steps = int(np.ceil(len(out_file)/(len(df_dropped)/160000)))\n",
    "    steps = np.ceil((np.array(timesteps)/scale_steps))\n",
    "    df_steps = df_dropped[df_dropped[\"time\"].isin(steps)] \n",
    "    df_steps_norm = (df_steps-df_steps.min())/(df_steps.max()-df_steps.min())\n",
    "    df_steps_norm = df_steps_norm.drop(columns=['time'])\n",
    "    df_group = df_steps_norm.groupby([\"elem_x\", \"elem_y\"])\n",
    "    \n",
    "    x_vals, y_vals, x_raw_list, y_raw_list = structure_data(df_group)\n",
    "    input_step = np.array(x_raw_list)[:,start,:,:]\n",
    "    next_step = model.predict(input_step)\n",
    "    input_step = np.concatenate(((np.delete(input_step, 0, 1)), next_step), axis = 1)\n",
    "    true_val = np.array(y_raw_list)\n",
    "    ans = true_val[:,0,:,:]\n",
    "    variables = [\"eff_strain\", \"vonmises\", \"triaxiality\"]\n",
    "    for j in range(0,3):\n",
    "        var_name = variables[j]\n",
    "        true_scaled = (ans[:,stop,j]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        pred_scaled = (next_step[:,stop,j]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        print(r2_score(true_scaled, pred_scaled))\n",
    "        print(np.sum(abs(true_scaled - pred_scaled))/160000)\n",
    "        plt.rcParams.update({'font.size': 14})\n",
    "        plt.figure()\n",
    "\n",
    "        a = plt.axes(aspect='equal')\n",
    "        a.text(min(pred_scaled), 0.9*max(pred_scaled), \"$R^2$ = %0.2f\" %(r2_score(true_scaled, pred_scaled)), fontsize=15)\n",
    "        plt.scatter(true_scaled.reshape(1, 160000), pred_scaled.reshape(1, 160000))\n",
    "        xp = [min(pred_scaled),max(pred_scaled)]\n",
    "        yp = xp\n",
    "        plt.plot(xp,yp, 'r')\n",
    "        plt.xlabel('FE Values')\n",
    "        plt.ylabel('LSTM Predictions')\n",
    "        plt.savefig(PLOTS_PATH+\"/\"+var_name+\".eps\", format='eps') \n",
    "        print(var_name+\" done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Box Plots\n",
    "\n",
    "To depict the accuracy of our models across all timesteps, we have plotted box plots of mean absolute error at all timesteps for all all the microstructures. The following functions prepares the data for the box plots. It calculates the mean absolute error in the predicted timesteps for each datastructure and stores them in 3 csv files. Each csv files corresponds to a variable and has 25 columns (microstructures) and 13 rows (MAE values)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_box(dataset, start, stop, model):\n",
    "    OUT_FILE_PATH = \"/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/%s/out.csv\" % dataset\n",
    "    DATA_FILE_PATH = \"/home/sarthak/projects/model_training/new_data/%s.csv\" % dataset\n",
    "    PLOTS_PATH = \"/home/sarthak/projects/model_training/trained_models/window_lstm/predictions/good\"\n",
    "    print(OUT_FILE_PATH)\n",
    "    print(DATA_FILE_PATH)\n",
    "\n",
    "    out_file = pd.read_csv(OUT_FILE_PATH)\n",
    "    lim = 0.00\n",
    "    timesteps = []\n",
    "    time = []\n",
    "    for i in range(len(out_file)):\n",
    "        if(out_file[\"eff_strain\"][i] >= lim):\n",
    "            timesteps.append(i+1)\n",
    "            time.append(out_file[\"time\"][i])\n",
    "            lim = lim + 0.01\n",
    "\n",
    "    print(\"Reading %s \\n\" % dataset)\n",
    "    # Reading data\n",
    "    df = pd.read_csv(DATA_FILE_PATH)\n",
    "    df_dropped = df.drop(columns=['strain_yy', 'phases', 'pressure', 'sdv22', 'sdv23',\n",
    "                                  'total_strain_xy', 'elem_id', 'blk_id', 'total_stress_xx', 'total_stress_yy',\n",
    "                                  'total_strain_xx', 'total_strain_yy' ])\n",
    "    df_norm = (df_dropped-df_dropped.min())/(df_dropped.max()-df_dropped.min())\n",
    "    df_norm.tail()\n",
    "    scale_steps = int(np.ceil(len(out_file)/(len(df_dropped)/160000)))\n",
    "    steps = np.ceil((np.array(timesteps)/scale_steps))\n",
    "    df_steps = df_dropped[df_dropped[\"time\"].isin(steps)] \n",
    "    df_steps_norm = (df_steps-df_steps.min())/(df_steps.max()-df_steps.min())\n",
    "    df_steps_norm = df_steps_norm.drop(columns=['time'])\n",
    "    df_group = df_steps_norm.groupby([\"elem_x\", \"elem_y\"])\n",
    "    \n",
    "    x_vals, y_vals, x_raw_list, y_raw_list = structure_data(df_group)\n",
    "    input_step = np.array(x_raw_list)[:,start,:,:]\n",
    "    next_step = model.predict(input_step)\n",
    "    input_step = np.concatenate(((np.delete(input_step, 0, 1)), next_step), axis = 1)\n",
    "    true_val = np.array(y_raw_list)\n",
    "    ans = true_val[:,0,:,:]\n",
    "    variables = [\"eff_strain\", \"vonmises\", \"triaxiality\"]\n",
    "    eff_strain_mae = []\n",
    "    for i in range(0,13):\n",
    "        var_name = variables[0]\n",
    "        true_scaled = (ans[:,i,0]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        pred_scaled = (next_step[:,i,0]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "\n",
    "        eff_strain_mae.append(np.sum(abs(true_scaled - pred_scaled))/160000)   \n",
    "    \n",
    "    vonmises_mae = []\n",
    "    for i in range(0,13):\n",
    "        var_name = variables[1]\n",
    "        true_scaled = (ans[:,i,1]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        pred_scaled = (next_step[:,i,1]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "\n",
    "        vonmises_mae.append(np.sum(abs(true_scaled - pred_scaled))/160000) \n",
    "        \n",
    "    triaxiality_mae = []\n",
    "    for i in range(0,13):\n",
    "        var_name = variables[2]\n",
    "        true_scaled = (ans[:,i,2]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        pred_scaled = (next_step[:,i,2]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "\n",
    "        triaxiality_mae.append(np.sum(abs(true_scaled - pred_scaled))/160000)\n",
    "    return np.array(eff_strain_mae), np.array(vonmises_mae), np.array(triaxiality_mae)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/AR1/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/AR1.csv\n",
      "Reading AR1 \n",
      "\n",
      "AR1 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/AR2/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/AR2.csv\n",
      "Reading AR2 \n",
      "\n",
      "AR2 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/AR3/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/AR3.csv\n",
      "Reading AR3 \n",
      "\n",
      "AR3 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/AR4/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/AR4.csv\n",
      "Reading AR4 \n",
      "\n",
      "AR4 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/AR5/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/AR5.csv\n",
      "Reading AR5 \n",
      "\n",
      "AR5 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test11/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test11.csv\n",
      "Reading test11 \n",
      "\n",
      "test11 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test12/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test12.csv\n",
      "Reading test12 \n",
      "\n",
      "test12 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test13/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test13.csv\n",
      "Reading test13 \n",
      "\n",
      "test13 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test14/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test14.csv\n",
      "Reading test14 \n",
      "\n",
      "test14 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test15/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test15.csv\n",
      "Reading test15 \n",
      "\n",
      "test15 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test21/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test21.csv\n",
      "Reading test21 \n",
      "\n",
      "test21 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test22/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test22.csv\n",
      "Reading test22 \n",
      "\n",
      "test22 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test23/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test23.csv\n",
      "Reading test23 \n",
      "\n",
      "test23 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test24/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test24.csv\n",
      "Reading test24 \n",
      "\n",
      "test24 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test25/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test25.csv\n",
      "Reading test25 \n",
      "\n",
      "test25 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test51/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test51.csv\n",
      "Reading test51 \n",
      "\n",
      "test51 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test52/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test52.csv\n",
      "Reading test52 \n",
      "\n",
      "test52 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test53/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test53.csv\n",
      "Reading test53 \n",
      "\n",
      "test53 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test54/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test54.csv\n",
      "Reading test54 \n",
      "\n",
      "test54 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test55/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test55.csv\n",
      "Reading test55 \n",
      "\n",
      "test55 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test61/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test61.csv\n",
      "Reading test61 \n",
      "\n",
      "test61 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test62/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test62.csv\n",
      "Reading test62 \n",
      "\n",
      "test62 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test63/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test63.csv\n",
      "Reading test63 \n",
      "\n",
      "test63 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test64/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test64.csv\n",
      "Reading test64 \n",
      "\n",
      "test64 Done!\n",
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test65/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test65.csv\n",
      "Reading test65 \n",
      "\n",
      "test65 Done!\n"
     ]
    }
   ],
   "source": [
    "dataset_names = ['AR1','AR2', 'AR3', 'AR4', 'AR5',\n",
    "                'test11', 'test12', 'test13', 'test14', 'test15', \n",
    "                'test21', 'test22', 'test23', 'test24', 'test25', \n",
    "                'test51', 'test52', 'test53', 'test54', 'test55',\n",
    "                'test61', 'test62', 'test63', 'test64', 'test65']\n",
    "dict_strain = {}\n",
    "dict_stress = {}\n",
    "dict_tri = {}\n",
    "for dataset in dataset_names:\n",
    "    a,b,c = make_box(dataset, 0, 12, model)\n",
    "    dict_strain[dataset] = a\n",
    "    dict_stress[dataset] = b\n",
    "    dict_tri[dataset] = c\n",
    "    print(dataset + \" Done!\")\n",
    "pd.DataFrame.from_dict(dict_stress).to_csv(\"/home/sarthak/projects/model_training/trained_models/window_lstm/predictions/time_stress.csv\", index = False)\n",
    "pd.DataFrame.from_dict(dict_strain).to_csv(\"/home/sarthak/projects/model_training/trained_models/window_lstm/predictions/time_strain.csv\", index = False)\n",
    "pd.DataFrame.from_dict(dict_tri).to_csv(\"/home/sarthak/projects/model_training/trained_models/window_lstm/predictions/time_triaxiality.csv\", index = False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Contour Plots\n",
    "\n",
    "The following code reads the data and plots the predicted contour plots for the 3 variables at the final timestep."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_contours(dataset, start, stop, model):\n",
    "    OUT_FILE_PATH = \"/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/%s/out.csv\" % dataset\n",
    "    DATA_FILE_PATH = \"/home/sarthak/projects/model_training/new_data/%s.csv\" % dataset\n",
    "    PLOTS_PATH = \"/home/sarthak/projects/model_training/trained_models/window_lstm/predictions/good\"\n",
    "    print(OUT_FILE_PATH)\n",
    "    print(DATA_FILE_PATH)\n",
    "\n",
    "    out_file = pd.read_csv(OUT_FILE_PATH)\n",
    "    lim = 0.00\n",
    "    timesteps = []\n",
    "    time = []\n",
    "    for i in range(len(out_file)):\n",
    "        if(out_file[\"eff_strain\"][i] >= lim):\n",
    "            timesteps.append(i+1)\n",
    "            time.append(out_file[\"time\"][i])\n",
    "            lim = lim + 0.01\n",
    "\n",
    "    print(\"Reading %s \\n\" % dataset)\n",
    "    # Reading data\n",
    "    df = pd.read_csv(DATA_FILE_PATH)\n",
    "    df_dropped = df.drop(columns=['strain_yy', 'phases', 'pressure', 'sdv22', 'sdv23',\n",
    "                                  'total_strain_xy', 'elem_id', 'blk_id', 'total_stress_xx', 'total_stress_yy',\n",
    "                                  'total_strain_xx', 'total_strain_yy' ])\n",
    "    df_norm = (df_dropped-df_dropped.min())/(df_dropped.max()-df_dropped.min())\n",
    "    df_norm.tail()\n",
    "    scale_steps = int(np.ceil(len(out_file)/(len(df_dropped)/160000)))\n",
    "    steps = np.ceil((np.array(timesteps)/scale_steps))\n",
    "    df_steps = df_dropped[df_dropped[\"time\"].isin(steps)] \n",
    "    df_steps_norm = (df_steps-df_steps.min())/(df_steps.max()-df_steps.min())\n",
    "    df_steps_norm = df_steps_norm.drop(columns=['time'])\n",
    "    df_group = df_steps_norm.groupby([\"elem_x\", \"elem_y\"])\n",
    "    \n",
    "    x_vals, y_vals, x_raw_list, y_raw_list = structure_data(df_group)\n",
    "    input_step = np.array(x_raw_list)[:,start,:,:]\n",
    "    next_step = model.predict(input_step)\n",
    "    input_step = np.concatenate(((np.delete(input_step, 0, 1)), next_step), axis = 1)\n",
    "    true_val = np.array(y_raw_list)\n",
    "    ans = true_val[:,0,:,:]\n",
    "    variables = [\"eff_strain\", \"vonmises\", \"triaxiality\"]\n",
    "    for j in range(0,3):\n",
    "        var_name = variables[j]\n",
    "        true_scaled = (ans[:,stop,j]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        pred_scaled = (next_step[:,stop,j]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        yy_levels = [-1.2, -0.9, -0.6, -0.3, 0.0, 0.3, 0.6, 0.9, 1.2, 1.5]\n",
    "        # Contour of LSTM Values\n",
    "        plt.rcParams.update({'font.size': 14})\n",
    "        xlist = np.arange(0.25, 100.25, 0.25)\n",
    "        ylist = np.arange(0.25, 100.25, 0.25)\n",
    "        X,Y = np.meshgrid(xlist, ylist)\n",
    "        Z = pred_scaled.reshape(400, 400)\n",
    "        fig,ax=plt.subplots(1,1)\n",
    "        mycmap1 = plt.get_cmap('rainbow')\n",
    "        cp = ax.contourf(X, Y, Z, cmap=mycmap1, levels = yy_levels)\n",
    "        cbar = fig.colorbar(cp) # Add a colorbar to a plot\n",
    "        ax.set_aspect('equal', adjustable='box')\n",
    "        ax.set_xlabel('x ($\\mu m$)')\n",
    "        ax.set_ylabel('y ($\\mu m$)')\n",
    "        plt.savefig(PLOTS_PATH+'/contour_lstm_'+var_name+'.eps', format='eps')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test24/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test24.csv\n",
      "Reading test24 \n",
      "\n"
     ]
    }
   ],
   "source": [
    "make_contours(\"test24\", 0, 12, model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Stress Strain Curve\n",
    "\n",
    "The following function reads the data and plots a stress strain curve for the predicted as well as the FE values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_stress_strain(dataset, start, stop, model):\n",
    "    OUT_FILE_PATH = \"/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/%s/out.csv\" % dataset\n",
    "    DATA_FILE_PATH = \"/home/sarthak/projects/model_training/new_data/%s.csv\" % dataset\n",
    "    PLOTS_PATH = \"/home/sarthak/projects/model_training/trained_models/window_lstm/predictions/good\"\n",
    "    print(OUT_FILE_PATH)\n",
    "    print(DATA_FILE_PATH)\n",
    "\n",
    "    out_file = pd.read_csv(OUT_FILE_PATH)\n",
    "    lim = 0.00\n",
    "    timesteps = []\n",
    "    time = []\n",
    "    for i in range(len(out_file)):\n",
    "        if(out_file[\"eff_strain\"][i] >= lim):\n",
    "            timesteps.append(i+1)\n",
    "            time.append(out_file[\"time\"][i])\n",
    "            lim = lim + 0.01\n",
    "\n",
    "    print(\"Reading %s \\n\" % dataset)\n",
    "    # Reading data\n",
    "    df = pd.read_csv(DATA_FILE_PATH)\n",
    "    df_dropped = df.drop(columns=['strain_yy', 'phases', 'pressure', 'sdv22', 'sdv23',\n",
    "                                  'total_strain_xy', 'elem_id', 'blk_id', 'total_stress_xx', 'total_stress_yy',\n",
    "                                  'total_strain_xx', 'total_strain_yy' ])\n",
    "    df_norm = (df_dropped-df_dropped.min())/(df_dropped.max()-df_dropped.min())\n",
    "    df_norm.tail()\n",
    "    scale_steps = int(np.ceil(len(out_file)/(len(df_dropped)/160000)))\n",
    "    steps = np.ceil((np.array(timesteps)/scale_steps))\n",
    "    df_steps = df_dropped[df_dropped[\"time\"].isin(steps)] \n",
    "    df_steps_norm = (df_steps-df_steps.min())/(df_steps.max()-df_steps.min())\n",
    "    df_steps_norm = df_steps_norm.drop(columns=['time'])\n",
    "    df_group = df_steps_norm.groupby([\"elem_x\", \"elem_y\"])\n",
    "    \n",
    "    x_vals, y_vals, x_raw_list, y_raw_list = structure_data(df_group)\n",
    "    #df_group = df_group[[\"eff_strain\", \"vonmises\", \"triaxiality\"]]\n",
    "    #first_step = df_group.nth(start).values.reshape(160000, 1, 3)\n",
    "    input_step = np.array(x_raw_list)[:,start,:,:]\n",
    "    #next_step = model.predict(first_step)\n",
    "    next_step = model.predict(input_step)\n",
    "    input_step = np.concatenate(((np.delete(input_step, 0, 1)), next_step), axis = 1)\n",
    "    true_val = np.array(y_raw_list)\n",
    "    ans = true_val[:,0,:,:]\n",
    "    variables = [\"eff_strain\", \"vonmises\", \"triaxiality\"]\n",
    "    eff_strain = []\n",
    "    vonmises = []\n",
    "    for i in range(0,2):\n",
    "        var_name = variables[0]\n",
    "        pred_scaled = (input_step[:,i,0]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        eff_strain.append(np.sum(pred_scaled)/160000)\n",
    "        \n",
    "        var_name = variables[1]\n",
    "        pred_scaled = (input_step[:,i,1]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        vonmises.append(np.sum(pred_scaled)/160000) \n",
    "    \n",
    "    for i in range(0,13):\n",
    "        var_name = variables[0]\n",
    "        true_scaled = (ans[:,i,0]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        pred_scaled = (next_step[:,i,0]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        eff_strain.append(np.sum(pred_scaled)/160000)   \n",
    "    \n",
    "  \n",
    "    for i in range(0,13):\n",
    "        var_name = variables[1]\n",
    "        true_scaled = (ans[:,i,1]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "        pred_scaled = (next_step[:,i,1]*(df_steps[var_name].max() - df_steps[var_name].min())) + df_steps[var_name].min()\n",
    "\n",
    "        vonmises.append(np.sum(pred_scaled)/160000) \n",
    "    df = pd.read_csv(OUT_FILE_PATH)\n",
    "    plt.figure()\n",
    "    plt.rcParams.update({'font.size': 15})\n",
    "    plt.plot(df['eff_strain'], df['vonmises'], label='FE Values')\n",
    "    plt.xlabel(r'$\\bar{\\epsilon}$')\n",
    "    plt.ylabel(r'$\\bar{\\sigma}$  (MPa)')\n",
    "    plt.scatter(eff_strain, vonmises, label='LSTM Predictions')\n",
    "    plt.legend()\n",
    "    plt.savefig(PLOTS_PATH+'/pred_stress_strain.png', dpi=700, bbox_inches=\"tight\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/sarthak/projects/seacas-exodus/lib/soudip_dataset/test24/out.csv\n",
      "/home/sarthak/projects/model_training/new_data/test24.csv\n",
      "Reading test24 \n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "make_stress_strain(\"test24\", 0, 12, model)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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": 2
}