{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UgqzEwle2xCd"
   },
   "source": [
    "## **IMPORT PACKAGES**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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": 2,
   "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": 3,
   "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": 3,
     "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": 4,
   "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": 5,
   "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": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.00025"
      ]
     },
     "execution_count": 6,
     "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": 7,
   "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": 8,
   "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": 9,
   "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": 10,
   "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": 10,
     "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": 11,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aOKRJclb_mDQ"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.06017000000000002"
      ]
     },
     "execution_count": 11,
     "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": 22,
   "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, 5))"
   ]
  },
  {
   "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": 18,
   "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": 23,
   "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[23], 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_TSE_matrx16x16.xml\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_TSE\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', out_folder='C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t1_TSE')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<pypulseq.Sequence.sequence.Sequence at 0x25671affd90>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq"
   ]
  },
  {
   "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.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}