{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UgqzEwle2xCd"
   },
   "source": [
    "## **IMPORT PACKAGES**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "3X7UsV832B6j"
   },
   "outputs": [],
   "source": [
    "from math import pi\n",
    "\n",
    "import numpy as np\n",
    "import pickle\n",
    "import math\n",
    "import json as j\n",
    "\n",
    "from pypulseq.Sequence.sequence import Sequence\n",
    "from pypulseq.calc_rf_center import calc_rf_center\n",
    "from pypulseq.calc_duration import calc_duration\n",
    "from pypulseq.make_adc import make_adc\n",
    "from pypulseq.make_delay import make_delay\n",
    "from pypulseq.make_sinc_pulse import make_sinc_pulse\n",
    "from pypulseq.make_trapezoid import make_trapezoid\n",
    "from pypulseq.make_extended_trapezoid import make_extended_trapezoid\n",
    "from pypulseq.opts import Opts\n",
    "from pypulseq.align import align\n",
    "\n",
    "from pypulseq.utilities import phase_grad_utils as pgu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **temporal functions**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "def TSE_k_space_fill(n_ex, ETL, k_steps, TE_eff_number):\n",
    "    #function defines phase encoding steps for k space filling in liner order \n",
    "    #with shifting according to the TE effective number\n",
    "    \n",
    "    k_space_list_with_zero = []\n",
    "    for i in range(ETL):\n",
    "        k_space_list_with_zero.append((ETL-1)*n_ex - i*n_ex)\n",
    "    #print(k_space_list_with_zero)\n",
    "    central_num = np.int32(k_steps/2)\n",
    "    #print(central_num)\n",
    "    index_central_line = k_space_list_with_zero.index(central_num)\n",
    "    shift = index_central_line - TE_eff_number + 1\n",
    "    \n",
    "    if shift>0:\n",
    "        a = k_space_list_with_zero[:shift]\n",
    "        b = k_space_list_with_zero[shift:]\n",
    "        k_space_list_with_zero = b+a\n",
    "    elif shift<0:\n",
    "        a = k_space_list_with_zero[:shift]\n",
    "        b = k_space_list_with_zero[shift:]\n",
    "        k_space_list_with_zero = b+a\n",
    "        \n",
    "    k_space_order_filing = [k_space_list_with_zero]\n",
    "    for i in range(n_ex-1):\n",
    "        k_space_list_temp = []\n",
    "        for k in k_space_list_with_zero:\n",
    "            k_space_list_temp.append(k+i+1)\n",
    "        k_space_order_filing.append(k_space_list_temp)\n",
    "        \n",
    "    return k_space_order_filing\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UQ4AWw9l4et_"
   },
   "source": [
    "## **USER INPUTS**\n",
    "\n",
    "These parameters are typically on the user interface of the scanner computer console "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'G_amp_max': 1609372.8,\n",
       " 'G_slew_max': 5151696000.0,\n",
       " 'gamma': 42576000.0,\n",
       " 'grad_raster_time': 1e-05,\n",
       " 'rf_raster_time': 1e-06,\n",
       " 't_BW_product_ex': 3.55,\n",
       " 't_BW_product_ref': 3.55,\n",
       " 't_ex': 0.00298,\n",
       " 't_ref': 0.00333,\n",
       " 'rf_ringdown_time': [2e-05],\n",
       " 'rf_dead_time': [0.0001],\n",
       " 'adc_dead_time': [1e-05],\n",
       " 'aapodization': 0.27,\n",
       " 'dG': 0.00025,\n",
       " 'sl_nb': 1.0,\n",
       " 'sl_thkn': 0.005,\n",
       " 'sl_gap': 100.0,\n",
       " 'FoV_f': 0.032,\n",
       " 'FoV_ph': 0.032,\n",
       " 'Nf': 16.0,\n",
       " 'Np': 16.0,\n",
       " 'BW_pixel': 500.0,\n",
       " 'TE': 0.02,\n",
       " 'N_TE': 2.0,\n",
       " 'ES': 0.01,\n",
       " 'TR': 0.5,\n",
       " 'FA': 90.0,\n",
       " 'conct': 1.0,\n",
       " 'ETL': 8.0,\n",
       " 'Average': 1,\n",
       " 'delay_TR': 0.41484}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open('C:\\MRI_seq_files_mess\\TSE_T1.json', 'rb') as f:\n",
    "    params = j.load(f)\n",
    "\n",
    "tau = params['TE'] / 2  # s  #TODO - introduce in GUI\n",
    "readout_time = round(1/params['BW_pixel'], 8)\n",
    "\n",
    "\n",
    "params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PeYeI0V45ZfD"
   },
   "source": [
    "## **SYSTEM LIMITS**\n",
    "Set the hardware limits and initialize sequence object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XHs1LT965kqg"
   },
   "outputs": [],
   "source": [
    "# Set system limits\n",
    "scanner_parameters = Opts(\n",
    "    max_grad=37.8,  #TODO add to GUI\n",
    "    grad_unit=\"mT/m\",\n",
    "    max_slew=121,  #TODO add to GUI\n",
    "    slew_unit=\"T/m/s\",\n",
    "    rf_ringdown_time=20e-6,    #TODO add to GUI     \n",
    "    rf_dead_time=100e-6,     #TODO add to GUI       \n",
    "    adc_dead_time=10e-6,    #TODO add to GUI        \n",
    "    rf_raster_time = params['rf_raster_time'],            \n",
    "    grad_raster_time = params['grad_raster_time'],        \n",
    "    block_duration_raster = params['grad_raster_time'],\n",
    "    adc_raster_time = 1/(params['BW_pixel']*params['Nf'])\n",
    ")\n",
    "seq = Sequence(scanner_parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "OTw7M03g79bH"
   },
   "source": [
    "## **RF & basis gradients**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XDZyQrbL8I3Q"
   },
   "outputs": [],
   "source": [
    "rf90_phase = np.pi / 2\n",
    "rf180_phase = 0\n",
    "\n",
    "flip90 = round(params['FA'] * pi / 180, 3)\n",
    "flip180 = round(180 * pi / 180)\n",
    "rf90, gz_ex, _ = make_sinc_pulse(flip_angle = flip90, system = scanner_parameters, duration = params['t_ex'], \n",
    "                                slice_thickness = params['sl_thkn'], apodization=0.3, \n",
    "                                time_bw_product = round(params['t_BW_product_ex'],8), return_gz = True)\n",
    "\n",
    "rf180, gz_ref, _ = make_sinc_pulse(flip_angle = flip180, system = scanner_parameters, duration = params['t_ref'], \n",
    "                                  slice_thickness = params['sl_thkn'], apodization=0.3, \n",
    "                                  time_bw_product = round(params['t_BW_product_ref'],8), phase_offset=90 * pi/180, return_gz = True)\n",
    "\n",
    "# Prepare RF offsets. This is required for multi-slice acquisition\n",
    "pulse_offsets90 = (np.linspace(0.0,params['sl_nb'] - 1.0,np.int16(params['sl_nb'])) - 0.5*(np.double(params['sl_nb'])  - 1.0))*(params['sl_thkn']*(100.0 + params['sl_gap'])/100.0)*gz_ex.amplitude\n",
    "pulse_offsets180 = (np.linspace(0.0,params['sl_nb'] - 1.0,np.int16(params['sl_nb'])) - 0.5*(np.double(params['sl_nb'])  - 1.0))*(params['sl_thkn']*(100.0 + params['sl_gap'])/100.0)*gz_ref.amplitude\n",
    "\n",
    "\n",
    "# slice selective gradient drafts for complex gradient blocks\n",
    "t_exwd = params['t_ex'] + scanner_parameters.rf_ringdown_time + scanner_parameters.rf_dead_time\n",
    "t_refwd = params['t_ref'] + scanner_parameters.rf_ringdown_time + scanner_parameters.rf_dead_time\n",
    "\n",
    "gz90 = make_trapezoid(channel=\"z\", system=scanner_parameters, amplitude=gz_ex.amplitude,\n",
    "                         flat_time=t_exwd, rise_time=params['dG'])\n",
    "gz180 = make_trapezoid(channel=\"z\", system=scanner_parameters, amplitude=gz_ref.amplitude,\n",
    "                         flat_time=t_refwd, rise_time=params['dG'])\n",
    "\n",
    "# generate basic gx readout gradient - G_read\n",
    "k_read = np.double(params['Nf'])/np.double(params['FoV_f'])\n",
    "t_gx = np.ceil(readout_time / scanner_parameters.grad_raster_time) * scanner_parameters.grad_raster_time\n",
    "gx = make_trapezoid(channel='x', system=scanner_parameters, flat_area=k_read, \n",
    "                    flat_time=t_gx + 2*scanner_parameters.adc_dead_time)\n",
    "\n",
    "# generate gx spoiler gradient - G_crr\n",
    "gx_spoil = make_trapezoid(channel='x', system=scanner_parameters, area=gx.area, flat_time = params['dG'],  \n",
    "                         rise_time=params['dG'])\n",
    "\n",
    "\n",
    "# read prephase gradient - G_pre\n",
    "gx_pre = make_trapezoid(channel=\"x\", system=scanner_parameters, area=gx.area*1.50,\n",
    "                        rise_time=params['dG'])\n",
    "\n",
    "# rephase gradient draft after 90 RF pulse  - G_reph\n",
    "gz_reph = make_trapezoid(channel=\"z\", system=scanner_parameters, area=gz_ex.area*0.25,\n",
    "                        flat_time = calc_duration(gx_pre), rise_time=params['dG'])\n",
    "\n",
    "#spoil gradient around 180 RF pulse - G_crs\n",
    "t_gz_spoil = np.ceil(params['t_ref'] / 2 / scanner_parameters.grad_raster_time) * scanner_parameters.grad_raster_time\n",
    "gz_spoil = make_trapezoid(channel='z', system=scanner_parameters, area=gz90.area*0.75, rise_time=params['dG'], flat_time = params['dG'])\n",
    "\n",
    "#spoil gradient G_sps\n",
    "gz_cr = make_trapezoid(channel='z', system=scanner_parameters, area=gz90.area*4, rise_time=params['dG'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.00025"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# gradient_ramp_time = params.grad_raster_time*np.ceil((scanner_parameters.max_grad/scanner_parameters.max_slew)/params.grad_raster_time)\n",
    "gz_spoil.rise_time"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Slice selection gradients**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creation complex block of SS gradients around 90 and first 180 RF \n",
    "\n",
    "gz_sp4_times = np.array(\n",
    "      [\n",
    "          0,\n",
    "          gz90.rise_time,\n",
    "      ]\n",
    ")           \n",
    "gz_sp4_amp = np.array(\n",
    "      [\n",
    "          0,\n",
    "          gz90.amplitude\n",
    "      ]\n",
    ")\n",
    "gz_sp4 = make_extended_trapezoid(channel='z', system=scanner_parameters, times = gz_sp4_times, amplitudes = gz_sp4_amp)\n",
    "\n",
    "\n",
    "gz_sp5_times = np.array(\n",
    "      [\n",
    "          0,\n",
    "          gz90.flat_time,\n",
    "      ]\n",
    ")           \n",
    "gz_sp5_amp = np.array(\n",
    "      [\n",
    "          gz90.amplitude,\n",
    "          gz90.amplitude\n",
    "      ]\n",
    ")\n",
    "gz_sp5 = make_extended_trapezoid(channel='z', system=scanner_parameters, times = gz_sp5_times, amplitudes = gz_sp5_amp)\n",
    "\n",
    "\n",
    "gz_sp6_times = np.array(\n",
    "      [\n",
    "          0,\n",
    "          gz_reph.rise_time,\n",
    "          gz_reph.rise_time + gz_reph.flat_time,\n",
    "          gz_reph.rise_time + gz_reph.flat_time + gz_reph.fall_time\n",
    "      ]\n",
    ")           \n",
    "gz_sp6_amp = np.array(\n",
    "    [\n",
    "        gz90.amplitude,\n",
    "        gz_reph.amplitude,\n",
    "        gz_reph.amplitude,\n",
    "        gz180.amplitude\n",
    "    ]\n",
    ")\n",
    "gz_sp6 = make_extended_trapezoid(channel='z', system=scanner_parameters, times = gz_sp6_times, amplitudes = gz_sp6_amp)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# creation complex block of SS gradients around 180 RF \n",
    "\n",
    "gz_sp1_times = np.array(\n",
    "      [\n",
    "          0,\n",
    "          gz_spoil.rise_time,\n",
    "          gz_spoil.rise_time + gz_spoil.flat_time,\n",
    "          gz_spoil.rise_time + gz_spoil.flat_time + gz_spoil.fall_time\n",
    "      ]\n",
    ")           \n",
    "gz_sp1_amp = np.array(\n",
    "    [\n",
    "        0,\n",
    "        gz_spoil.amplitude,\n",
    "        gz_spoil.amplitude,\n",
    "        gz180.amplitude\n",
    "    ]\n",
    ")\n",
    "gz_sp1 = make_extended_trapezoid(channel='z', system=scanner_parameters, times = gz_sp1_times, amplitudes = gz_sp1_amp)\n",
    "\n",
    "gz_sp2_times = np.array(\n",
    "    [\n",
    "        0,\n",
    "        gz180.flat_time\n",
    "    ]\n",
    ")\n",
    "gz_sp2_amp = np.array(\n",
    "    [\n",
    "        gz180.amplitude,\n",
    "        gz180.amplitude\n",
    "    ]\n",
    ")\n",
    "gz_sp2 = make_extended_trapezoid(channel='z', system=scanner_parameters, times = gz_sp2_times, amplitudes = gz_sp2_amp)\n",
    "\n",
    "gz_sp3_times = np.array(\n",
    "      [\n",
    "          0,\n",
    "          gz_spoil.rise_time,\n",
    "          gz_spoil.rise_time + gz_spoil.flat_time,\n",
    "          gz_spoil.rise_time + gz_spoil.flat_time + gz_spoil.fall_time\n",
    "      ]\n",
    ")\n",
    "            \n",
    "gz_sp3_amp = np.array(\n",
    "    [\n",
    "        gz180.amplitude,\n",
    "        gz_spoil.amplitude,\n",
    "        gz_spoil.amplitude,\n",
    "        0\n",
    "    ]\n",
    ")\n",
    "gz_sp3 = make_extended_trapezoid(channel='z', system=scanner_parameters, times = gz_sp3_times, amplitudes = gz_sp3_amp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "rf90, gz_sp5 = align(right=[rf90, gz_sp5])\n",
    "rf180, gz_sp2 = align(right=[rf180, gz_sp2])\n",
    "gx_pre, gz_sp6 = align(center=[gx_pre, gz_sp6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RFSHuUOG9LHK"
   },
   "source": [
    "## **READOUT gradients & events**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "Q8p-CttI9dk9"
   },
   "outputs": [],
   "source": [
    "# create \n",
    "gx_sp1_times = np.array(\n",
    "      [\n",
    "          0,\n",
    "          gx_spoil.rise_time,\n",
    "          gx_spoil.rise_time + gx_spoil.flat_time,\n",
    "          gx_spoil.rise_time + gx_spoil.flat_time + gx_spoil.fall_time\n",
    "      ]\n",
    ")           \n",
    "gx_sp1_amp = np.array(\n",
    "    [\n",
    "        0,\n",
    "        gx_spoil.amplitude,\n",
    "        gx_spoil.amplitude,\n",
    "        gx.amplitude\n",
    "    ]\n",
    ")\n",
    "gx_sp1 = make_extended_trapezoid(channel='x', system=scanner_parameters, times = gx_sp1_times, amplitudes = gx_sp1_amp)\n",
    "\n",
    "gx_sp2_times = np.array(\n",
    "    [\n",
    "        0,\n",
    "        gx.flat_time\n",
    "    ]\n",
    ")\n",
    "gx_sp2_amp = np.array(\n",
    "    [\n",
    "        gx.amplitude,\n",
    "        gx.amplitude\n",
    "    ]\n",
    ")\n",
    "gx_sp2 = make_extended_trapezoid(channel='x', system=scanner_parameters, times = gx_sp2_times, amplitudes = gx_sp2_amp)\n",
    "\n",
    "gx_sp3_times = np.array(\n",
    "      [\n",
    "          0,\n",
    "          gx_spoil.rise_time,\n",
    "          gx_spoil.rise_time + gx_spoil.flat_time,\n",
    "          gx_spoil.rise_time + gx_spoil.flat_time + gx_spoil.fall_time\n",
    "      ]\n",
    ")\n",
    "            \n",
    "gx_sp3_amp = np.array(\n",
    "    [\n",
    "        gx.amplitude,\n",
    "        gx_spoil.amplitude,\n",
    "        gx_spoil.amplitude,\n",
    "        0\n",
    "    ]\n",
    ")\n",
    "gx_sp3 = make_extended_trapezoid(channel='x', system=scanner_parameters, times = gx_sp3_times, amplitudes = gx_sp3_amp)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# generate ADC block\n",
    "gx.rise_time = np.ceil(gx.rise_time / scanner_parameters.grad_raster_time) * scanner_parameters.grad_raster_time\n",
    "gx.flat_time = np.ceil(gx.flat_time / scanner_parameters.grad_raster_time) * scanner_parameters.grad_raster_time\n",
    "\n",
    "\n",
    "adc = make_adc(num_samples=params['Nf'], duration=t_gx, delay=scanner_parameters.adc_dead_time, system=scanner_parameters)\n",
    "#adc, gx_sp2 = align(right=[adc, gx_sp2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "o829kzm8kVFB"
   },
   "source": [
    "## **PREPHASE AND REPHASE**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "m5zA1bMakTVs"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[10, 8, 6, 4, 2, 0, 14, 12], [11, 9, 7, 5, 3, 1, 15, 13]]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k_phase = np.double(params['Np'])/np.double(params['FoV_ph'])\n",
    "k_steps_PE = pgu.create_k_steps(k_phase, np.int16(params['Np'])) #list of phase encoding gradients\n",
    "\n",
    "\n",
    "n_ex = math.floor(params['Np'] / params['ETL']) # number of excitations \n",
    "k_space_order_filing = TSE_k_space_fill(n_ex, np.int32(params['ETL']), np.int32(params['Np']), np.int32(params['N_TE'])) #TODO: create function on different k space order filling\n",
    "k_space_order_filing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3F5JUpE9-4lo"
   },
   "source": [
    "## **DELAYS**\n",
    "Echo time (TE) and repetition time (TR). Here, TE is broken down into `delay1` and `delay2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aOKRJclb_mDQ"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.06017000000000002"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "block_duration = 0\n",
    "block_duration = max(calc_duration(rf90), calc_duration(gz_sp5))/2\n",
    "block_duration += max(calc_duration(gx_pre), calc_duration(gz_sp6))\n",
    "for i in range(np.int32(params['ETL'])-1):\n",
    "    block_duration +=  max(calc_duration(rf180), calc_duration(gz_sp2))  \n",
    "    block_duration +=  max(calc_duration(gx_sp1), calc_duration(gz_sp3))  \n",
    "    block_duration +=  max(calc_duration(gx_sp2), calc_duration(adc))\n",
    "    block_duration +=  calc_duration(gz_sp1)\n",
    "block_duration +=  max(calc_duration(rf180), calc_duration(gz_sp2))  \n",
    "block_duration +=  max(calc_duration(gx_sp1), calc_duration(gz_sp3))  \n",
    "block_duration +=  max(calc_duration(gx_sp2), calc_duration(adc))\n",
    "block_duration +=  calc_duration(gz_cr)    \n",
    "    \n",
    "    \n",
    "    \n",
    "block_duration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.43983"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.5 - block_duration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **CONSTRUCT CONCATINATIONS timings**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Quantification of Effective TE loop\n",
    "#eff_time = TE + calc_duration(gx) / 2 + max(calc_duration(gy_pre),calc_duration(gz_spoil)) + calc_duration(gx_spoil) + calc_duration(gz90) / 2\n",
    "eff_time = block_duration #equal to previous!\n",
    "\n",
    "max_slices_per_TR = np.floor(params['TR']/eff_time)\n",
    "required_concats = np.int32(np.ceil(params['sl_nb']/max_slices_per_TR))\n",
    "slice_list = list(range(np.int32(params['sl_nb'])))\n",
    "slice_list = [slice_list[x::required_concats] for x in range(required_concats)]\n",
    "    \n",
    "# Calculate the TR fillers\n",
    "tr_pauses = [(params['TR']/np.double(len(x))) - eff_time for x in slice_list]\n",
    "tr_pauses = [max(seq.grad_raster_time,seq.rf_raster_time)*np.floor(x/max(seq.grad_raster_time,seq.rf_raster_time)) for x in tr_pauses]\n",
    "    \n",
    "# Generate the TR fillers\n",
    "tr_fillers = [make_delay(x) for x in tr_pauses]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6Dq4wT-UAEOR"
   },
   "source": [
    "## **CONSTRUCT SEQUENCE**\n",
    "Construct sequence for one phase encode and multiple slices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "curr_concat_0\n",
      "curr_slice_0\n",
      "phase step_10\n",
      "phase step_8\n",
      "phase step_6\n",
      "phase step_4\n",
      "phase step_2\n",
      "phase step_0\n",
      "phase step_14\n",
      "phase step_12\n",
      "curr_concat_0\n",
      "curr_slice_0\n",
      "phase step_11\n",
      "phase step_9\n",
      "phase step_7\n",
      "phase step_5\n",
      "phase step_3\n",
      "phase step_1\n",
      "phase step_15\n",
      "phase step_13\n"
     ]
    }
   ],
   "source": [
    "#working version without concatinations\n",
    "\n",
    "for k in range(params['Average']):  # Averages\n",
    "    for curr_concat in range(required_concats): \n",
    "        for phase_steps in k_space_order_filing: # in stead of phase steps list of phase steps\n",
    "            for curr_slice in range(np.int32(params['sl_nb'])):  # Slices\n",
    "                # Apply RF offsets\n",
    "                n_echo_temp = 0\n",
    "                rf90.freq_offset = pulse_offsets90[curr_slice]\n",
    "                rf180.freq_offset = pulse_offsets180[curr_slice]\n",
    "                rf90.phase_offset = (rf90_phase - 2 * np.pi * rf90.freq_offset * calc_rf_center(rf90)[0])\n",
    "                rf180.phase_offset = (rf180_phase - 2 * np.pi * rf180.freq_offset * calc_rf_center(rf180)[0])\n",
    "                print('curr_concat_' + str(curr_concat))\n",
    "                print('curr_slice_' + str(curr_slice))\n",
    "                \n",
    "                seq.add_block(gz_sp4)\n",
    "                seq.add_block(gz_sp5, rf90)\n",
    "                seq.add_block(gz_sp6, gx_pre)\n",
    "                for phase_step in phase_steps:\n",
    "                    print('phase step_' + str(phase_step))\n",
    "                    seq.add_block(gz_sp2, rf180)      \n",
    "                    gy_pre = make_trapezoid(channel='y', system=scanner_parameters, \n",
    "                                            area=-k_steps_PE[phase_step], duration = calc_duration(gz_sp3),\n",
    "                                            rise_time=params['dG'])\n",
    "                      \n",
    "                    seq.add_block(gz_sp3,gx_sp1,gy_pre)\n",
    "                    seq.add_block(gx_sp2, adc)\n",
    "                    n_echo_temp += 1                    \n",
    "                    gy_pre = make_trapezoid(channel='y', system=scanner_parameters, \n",
    "                                            area=k_steps_PE[phase_step], duration = calc_duration(gz_sp3),\n",
    "                                            rise_time=params['dG'])\n",
    "                    if n_echo_temp == np.int32(params['ETL']):\n",
    "                        seq.add_block(gz_cr,gx_sp3,gy_pre)\n",
    "                    else:\n",
    "                        seq.add_block(gz_sp1,gx_sp3,gy_pre)\n",
    "                seq.add_block(tr_fillers[curr_concat])\n",
    "    \n",
    "  \n",
    "     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "l-YP9djBJCpC"
   },
   "source": [
    "## **PLOTTING TIMNG DIAGRAM**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "d_iCUR4nfoH9"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "seq.plot(time_range=(-0.01, 0.06))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Timing check passed successfully\n"
     ]
    }
   ],
   "source": [
    "ok, error_report = seq.check_timing()\n",
    "if ok:\n",
    "    print(\"Timing check passed successfully\")\n",
    "else:\n",
    "    print(\"Timing check failed. Error listing follows:\")\n",
    "    [print(e) for e in error_report]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "fYNgdWc_KiK7"
   },
   "source": [
    "## **GENERATING `.SEQ` FILE**\n",
    "Uncomment the code in the cell below to generate a `.seq` file and download locally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6iN0aeuuqKRe"
   },
   "outputs": [],
   "source": [
    "seq.write('C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t1_TSE\\\\t1_TSE_matrx16x16.seq')  # Save to disk\n",
    "# from google.colab import files\n",
    "# files.download('t2_se_pypulseq_colab.seq')  # Download locally\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4Q0b5w-lKtfP"
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "1",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[123], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mpy2jemris\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mseq2xml\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m seq2xml\n\u001b[1;32m----> 2\u001b[0m \u001b[43mseq2xml\u001b[49m\u001b[43m(\u001b[49m\u001b[43mseq\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mseq_name\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mt1_SE_matrx16x16_myGrad\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mout_folder\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mC:\u001b[39;49m\u001b[38;5;130;43;01m\\\\\u001b[39;49;00m\u001b[38;5;124;43mMRI_seq\u001b[39;49m\u001b[38;5;130;43;01m\\\\\u001b[39;49;00m\u001b[38;5;124;43mnew_MRI_pulse_seq\u001b[39;49m\u001b[38;5;130;43;01m\\\\\u001b[39;49;00m\u001b[38;5;124;43mt1_se\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n",
      "File \u001b[1;32mC:\\MRI_seq\\py2jemris\\seq2xml.py:148\u001b[0m, in \u001b[0;36mseq2xml\u001b[1;34m(seq, seq_name, out_folder)\u001b[0m\n\u001b[0;32m    145\u001b[0m grad_name_ind \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m    147\u001b[0m g_atom\u001b[38;5;241m.\u001b[39mset(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAxis\u001b[39m\u001b[38;5;124m\"\u001b[39m, key\u001b[38;5;241m.\u001b[39mupper())\n\u001b[1;32m--> 148\u001b[0m g_atom\u001b[38;5;241m.\u001b[39mset(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFilename\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[43mgrad_shapes_path_dict\u001b[49m\u001b[43m[\u001b[49m\u001b[43mg_id\u001b[49m\u001b[43m]\u001b[49m)\n\u001b[0;32m    149\u001b[0m g_atom\u001b[38;5;241m.\u001b[39mset(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mScale\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m1\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m    150\u001b[0m g_atom\u001b[38;5;241m.\u001b[39mset(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mInterpolate\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m0\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n",
      "\u001b[1;31mKeyError\u001b[0m: 1"
     ]
    }
   ],
   "source": [
    "from py2jemris.seq2xml import seq2xml\n",
    "seq2xml(seq, seq_name='t1_TSE_matrx16x16_myGrad', out_folder='C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t1_TSE')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k_steps_PE.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "write_t2_se.ipynb",
   "private_outputs": true,
   "provenance": []
  },
  "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}