{
 "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",
    "from pypulseq.traj_to_grad import traj_to_grad\n",
    "\n",
    "from pypulseq.utilities import phase_grad_utils as pgu\n",
    "\n",
    "from py2jemris.seq2xml import seq2xml"
   ]
  },
  {
   "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": "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": 17,
   "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': 16.0,\n",
       " 'Average': 5,\n",
       " 'delay_TR': 0.33484}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weightning = 'T1'\n",
    "\n",
    "if weightning == 'T1':\n",
    "    with open('C:\\MRI_seq_files_mess\\TSE_T1.json', 'rb') as f:\n",
    "        params = j.load(f)\n",
    "        \n",
    "elif weightning == 'T2':\n",
    "    with open('C:\\MRI_seq_files_mess\\TSE_T2.json', 'rb') as f:\n",
    "        params = j.load(f)\n",
    "        \n",
    "elif weightning == 'T1':\n",
    "    with open('C:\\MRI_seq_files_mess\\TSE_T1.json', 'rb') as f:\n",
    "        params = j.load(f)    \n",
    "else:\n",
    "    print('Please choose image weightning')\n",
    "    \n",
    "\n",
    "tau = params['TE'] / 2  # s  #TODO - introduce in GUI\n",
    "readout_time = round(1/params['BW_pixel'], 8)\n",
    "\n",
    "\n",
    "params['Average'] = 5\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": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "XHs1LT965kqg"
   },
   "outputs": [],
   "source": [
    "# Set system limits\n",
    "scanner_parameters = Opts(\n",
    "    max_grad=37.8,  \n",
    "    grad_unit=\"mT/m\",\n",
    "    max_slew=121,  \n",
    "    slew_unit=\"T/m/s\",\n",
    "    rf_ringdown_time = params['rf_ringdown_time'],   \n",
    "    rf_dead_time = params['rf_dead_time'],          \n",
    "    adc_dead_time = params['adc_dead_time'],            \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": 7,
   "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",
    "\n",
    "# Creation of ADC\n",
    "adc = make_adc(num_samples=params['Nf'], duration=t_gx, delay=scanner_parameters.adc_dead_time, system=scanner_parameters)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "o829kzm8kVFB"
   },
   "source": [
    "## **k-space filling quantification**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "m5zA1bMakTVs"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14, 13, 12, 11, 10]]"
      ]
     },
     "execution_count": 8,
     "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_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": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "Np = 16 \n",
    "part_fourier_factor = 1\n",
    "\n",
    "num_k_lines = Np*part_fourier_factor\n",
    "\n",
    "\n",
    "np.int32(num_k_lines)\n",
    "if (np.int32(num_k_lines) % 2) == 0:\n",
    "    num_k_lines = np.int32(num_k_lines)\n",
    "else: \n",
    "    num_k_lines = np.int32(num_k_lines) + 1\n",
    "    \n",
    "num_k_lines"
   ]
  },
  {
   "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": 9,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aOKRJclb_mDQ"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.12317999999999996"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "block_duration = 0\n",
    "block_duration = max(calc_duration(rf90), calc_duration(gz90))/2\n",
    "block_duration += max(calc_duration(gx_pre), calc_duration(gz_spoil))\n",
    "for i in range(np.int32(params['ETL'])-1):\n",
    "    block_duration +=  max(calc_duration(rf180), calc_duration(gz180))  \n",
    "    block_duration +=  max(calc_duration(gx_spoil), calc_duration(gz_spoil))  \n",
    "    block_duration +=  max(calc_duration(gx_spoil), calc_duration(adc))\n",
    "    block_duration +=  calc_duration(gz_spoil)\n",
    "block_duration +=  max(calc_duration(rf180), calc_duration(gz_spoil))  \n",
    "block_duration +=  max(calc_duration(gx_spoil), calc_duration(gz_spoil))  \n",
    "block_duration +=  max(calc_duration(gx_spoil), calc_duration(adc))\n",
    "block_duration +=  calc_duration(gz_cr)    \n",
    "    \n",
    "    \n",
    "    \n",
    "block_duration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.37682000000000004"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.5 - block_duration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **CONSTRUCT CONCATINATIONS timings**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "curr_concat_0\n",
      "curr_slice_0\n",
      "phase step_9\n",
      "-31.25\n",
      "phase step_8\n",
      "0.0\n",
      "phase step_7\n",
      "31.25\n",
      "phase step_6\n",
      "62.5\n",
      "phase step_5\n",
      "93.75\n",
      "phase step_4\n",
      "125.0\n",
      "phase step_3\n",
      "156.25\n",
      "phase step_2\n",
      "187.5\n",
      "phase step_1\n",
      "218.75\n",
      "phase step_0\n",
      "250.0\n",
      "phase step_15\n",
      "-218.75\n",
      "phase step_14\n",
      "-187.5\n",
      "phase step_13\n",
      "-156.25\n",
      "phase step_12\n",
      "-125.0\n",
      "phase step_11\n",
      "-93.75\n",
      "phase step_10\n",
      "-62.5\n",
      "curr_concat_0\n",
      "curr_slice_0\n",
      "phase step_9\n",
      "-31.25\n",
      "phase step_8\n",
      "0.0\n",
      "phase step_7\n",
      "31.25\n",
      "phase step_6\n",
      "62.5\n",
      "phase step_5\n",
      "93.75\n",
      "phase step_4\n",
      "125.0\n",
      "phase step_3\n",
      "156.25\n",
      "phase step_2\n",
      "187.5\n",
      "phase step_1\n",
      "218.75\n",
      "phase step_0\n",
      "250.0\n",
      "phase step_15\n",
      "-218.75\n",
      "phase step_14\n",
      "-187.5\n",
      "phase step_13\n",
      "-156.25\n",
      "phase step_12\n",
      "-125.0\n",
      "phase step_11\n",
      "-93.75\n",
      "phase step_10\n",
      "-62.5\n",
      "curr_concat_0\n",
      "curr_slice_0\n",
      "phase step_9\n",
      "-31.25\n",
      "phase step_8\n",
      "0.0\n",
      "phase step_7\n",
      "31.25\n",
      "phase step_6\n",
      "62.5\n",
      "phase step_5\n",
      "93.75\n",
      "phase step_4\n",
      "125.0\n",
      "phase step_3\n",
      "156.25\n",
      "phase step_2\n",
      "187.5\n",
      "phase step_1\n",
      "218.75\n",
      "phase step_0\n",
      "250.0\n",
      "phase step_15\n",
      "-218.75\n",
      "phase step_14\n",
      "-187.5\n",
      "phase step_13\n",
      "-156.25\n",
      "phase step_12\n",
      "-125.0\n",
      "phase step_11\n",
      "-93.75\n",
      "phase step_10\n",
      "-62.5\n",
      "curr_concat_0\n",
      "curr_slice_0\n",
      "phase step_9\n",
      "-31.25\n",
      "phase step_8\n",
      "0.0\n",
      "phase step_7\n",
      "31.25\n",
      "phase step_6\n",
      "62.5\n",
      "phase step_5\n",
      "93.75\n",
      "phase step_4\n",
      "125.0\n",
      "phase step_3\n",
      "156.25\n",
      "phase step_2\n",
      "187.5\n",
      "phase step_1\n",
      "218.75\n",
      "phase step_0\n",
      "250.0\n",
      "phase step_15\n",
      "-218.75\n",
      "phase step_14\n",
      "-187.5\n",
      "phase step_13\n",
      "-156.25\n",
      "phase step_12\n",
      "-125.0\n",
      "phase step_11\n",
      "-93.75\n",
      "phase step_10\n",
      "-62.5\n",
      "curr_concat_0\n",
      "curr_slice_0\n",
      "phase step_9\n",
      "-31.25\n",
      "phase step_8\n",
      "0.0\n",
      "phase step_7\n",
      "31.25\n",
      "phase step_6\n",
      "62.5\n",
      "phase step_5\n",
      "93.75\n",
      "phase step_4\n",
      "125.0\n",
      "phase step_3\n",
      "156.25\n",
      "phase step_2\n",
      "187.5\n",
      "phase step_1\n",
      "218.75\n",
      "phase step_0\n",
      "250.0\n",
      "phase step_15\n",
      "-218.75\n",
      "phase step_14\n",
      "-187.5\n",
      "phase step_13\n",
      "-156.25\n",
      "phase step_12\n",
      "-125.0\n",
      "phase step_11\n",
      "-93.75\n",
      "phase step_10\n",
      "-62.5\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",
    "\n",
    "                seq.add_block(gz90, rf90)\n",
    "                seq.add_block(gz_reph, gx_pre)\n",
    "                for phase_step in phase_steps:\n",
    "                    print('phase step_' + str(phase_step))\n",
    "                    seq.add_block(gz180, rf180)      \n",
    "                    gy_pre = make_trapezoid(channel='y', system=scanner_parameters, \n",
    "                                            area=-k_steps_PE[phase_step], duration = calc_duration(gz_spoil),\n",
    "                                            rise_time=params['dG'])\n",
    "                    print(k_steps_PE[phase_step])\n",
    "                      \n",
    "                    seq.add_block(gz_spoil,gx_spoil,gy_pre)\n",
    "                    seq.add_block(gx, 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_spoil),\n",
    "                                            rise_time=params['dG'])\n",
    "                    if n_echo_temp == np.int32(params['ETL']):\n",
    "                        seq.add_block(gz_cr,gx_spoil,gy_pre)\n",
    "                    else:\n",
    "                        seq.add_block(gz_spoil,gx_spoil,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": 13,
   "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.8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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": 15,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "6iN0aeuuqKRe"
   },
   "outputs": [],
   "source": [
    "if weightning == 'T1':\n",
    "    seq.write('C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t1_TSE\\\\t1_TSE_matrx16x16.seq')  # Save to disk\n",
    "    seq2xml(seq, seq_name='t1_TSE_matrx16x16_myGrad', out_folder='C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t1_TSE')\n",
    "    \n",
    "elif weightning == 'T2':\n",
    "    seq.write('C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t2_TSE\\\\t2_TSE_matrx16x16.seq')  # Save to disk\n",
    "    seq2xml(seq, seq_name='t2_TSE_matrx16x16_myGrad', out_folder='C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t2_TSE')\n",
    "    \n",
    "elif weightning == 'PD':\n",
    "    seq.write('C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\pd_TSE\\\\pd_TSE_matrx16x16.seq')  # Save to disk \n",
    "    seq2xml(seq, seq_name='t2_TSE_matrx16x16_myGrad', out_folder='C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t2_TSE')\n",
    "\n",
    "else:\n",
    "    print('Please choose image weightning')\n",
    "\n"
   ]
  }
 ],
 "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
}