{
 "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",
    "\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": {
    "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": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "namespace(t_BW_product_ex=3.8,\n",
       "          t_BW_product_ref=4.2,\n",
       "          t_ex=0.00205,\n",
       "          t_ref=0.00256,\n",
       "          dG=0.00025,\n",
       "          sl_nb=1.0,\n",
       "          sl_thkn=0.004,\n",
       "          sl_gap=100.0,\n",
       "          FoV_f=0.256,\n",
       "          FoV_ph=0.256,\n",
       "          Nf=16.0,\n",
       "          Np=16.0,\n",
       "          BW_pixel=500.0,\n",
       "          TE=0.015000000000000001,\n",
       "          TR=0.4,\n",
       "          FA=90.0,\n",
       "          gamma=42576000.0,\n",
       "          rf_raster_time=1e-06,\n",
       "          grad_raster_time=1e-05,\n",
       "          G_amp_max=37.8,\n",
       "          G_slew_max=121)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open('C:\\MRI_seq_files_mess\\SE_pulsequence_parameters.pickle', 'rb') as f:\n",
    "    params = pickle.load(f, fix_imports=True)\n",
    "\n",
    "\n",
    "params.gamma = 42.576e6 #TODO add to GUI\n",
    "#params.G_amp_max = 37.8*1e-3*params.gamma if necsesary to quantify timings of pulses\n",
    "\n",
    "dG = 256e-6 #TODO: get from GUI correct value!\n",
    "params.rf_raster_time = 1e-6  #TODO add to GUI\n",
    "params.grad_raster_time = 10e-6  #TODO add to GUI\n",
    "\n",
    "params.t_ex = np.ceil(params.t_ex / params.grad_raster_time) * params.grad_raster_time\n",
    "params.TE = np.ceil(params.TE / params.grad_raster_time) * params.grad_raster_time #TODO in GUI correct TE\n",
    "params.t_ref = np.ceil(params.t_ref / params.grad_raster_time) * params.grad_raster_time\n",
    "params.G_amp_max = 37.8 #TODO add to GUI\n",
    "params.G_slew_max = 121 #TODO add to GUI\n",
    "\n",
    "TE = 15e-3  # s\n",
    "TR = params.TR  # s\n",
    "tau = TE / 2  # s  #TODO - introduce in GUI\n",
    "readout_time = round(1/params.BW_pixel, 8)\n",
    "\n",
    "params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "ssnNwiQH4q_0"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "User inputs setup\n"
     ]
    }
   ],
   "source": [
    "params.nsa = 1   #TODO  integer from GUI\n",
    "params.sl_nb = 1  #TODO integer from GUI\n",
    "params.Nf = 16 #TODO integer from GUI\n",
    "params.Np = 16 #TODO integer from GUI\n",
    "print('User inputs setup')\n"
   ]
  },
  {
   "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=params.G_amp_max,  #TODO add to GUI\n",
    "    grad_unit=\"mT/m\",\n",
    "    max_slew=params.G_slew_max,  #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**"
   ]
  },
  {
   "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, gz90, _ = 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",
    "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",
    "gz180 = make_trapezoid(channel=\"z\", system=scanner_parameters, amplitude=gz_ref.amplitude,\n",
    "                         flat_time=t_refwd, rise_time=dG)\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)*gz90.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)*gz180.amplitude\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "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",
    "pulse_offsets90.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **Slice selection gradients**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# gz_reph rephase gradient after gz90\n",
    "t_gz_reph = np.ceil(params.t_ex / 2 / params.grad_raster_time) * params.grad_raster_time\n",
    "gz_reph = make_trapezoid(channel='z', system=scanner_parameters, area=-gz90.area / 2,\n",
    "                         duration=t_gz_reph)\n",
    "t_gz_spoil = np.ceil(params.t_ref / 2 / params.grad_raster_time) * params.grad_raster_time\n",
    "\n",
    "# gz_spoil spoil gradients around \n",
    "#gz_spoil = make_trapezoid(channel='z', system=scanner_parameters, area=gz90.area*3,\n",
    " #                         duration=t_gz_spoil*2.5)\n",
    "\n",
    "\n",
    "gz_spoil = make_trapezoid(channel='z', system=scanner_parameters, area=gz90.area*3)\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": [
    "rf180, gz_sp2 = align(right=[rf180, gz_sp2])"
   ]
  },
  {
   "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": [
    "# k-space readout\n",
    "k_read = np.double(params.Nf)/np.double(params.FoV_f)\n",
    "\n",
    "# generate gx readout gradient\n",
    "t_gx = np.ceil(readout_time / params.grad_raster_time) * params.grad_raster_time\n",
    "gx = make_trapezoid(channel='x', system=scanner_parameters, flat_area=k_read, \n",
    "                    flat_time=t_gx)\n",
    "\n",
    "# generate gx_pre readout prephase gradient\n",
    "t_gx_pre = np.ceil(readout_time / 2 / params.grad_raster_time) * params.grad_raster_time\n",
    "gx_pre = make_trapezoid(channel='x', system=scanner_parameters, flat_area=k_read / 2, \n",
    "                        flat_time=t_gx_pre)\n",
    "\n",
    "# generate gx spoiler gradient\n",
    "t_gx_spoil = np.ceil(readout_time / 2 / params.grad_raster_time) * params.grad_raster_time\n",
    "gx_spoil = make_trapezoid(channel='x', system=scanner_parameters, area=gz90.area * 0.75,\n",
    "                          duration=t_gx_spoil)\n",
    "\n",
    "# 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 / params.grad_raster_time) * params.grad_raster_time\n",
    "gx.flat_time = np.ceil(gx.flat_time / params.grad_raster_time) * params.grad_raster_time\n",
    "\n",
    "\n",
    "adc = make_adc(num_samples=params.Nf, duration=gx.flat_time, delay=gx.rise_time, system=scanner_parameters)\n"
   ]
  },
  {
   "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": [],
   "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))\n",
    "\n",
    "t_gy_pre = np.ceil(params.t_ex / 2 / params.grad_raster_time) * params.grad_raster_time\n",
    "k_phase\n",
    "gy_pre = make_trapezoid(channel='y', system=scanner_parameters, area=k_steps_PE[-1], \n",
    "                        duration=t_gy_pre)"
   ]
  },
  {
   "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": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delay_1: namespace(type='delay', delay=0.00159)\n",
      "delay_2: namespace(type='delay', delay=0.00159)\n",
      "delay_TR: namespace(type='delay', delay=0.37970000000000004)\n"
     ]
    }
   ],
   "source": [
    "delay1 = tau - calc_duration(gz90) / 2 - max(calc_duration(gx_pre),calc_duration(gy_pre),calc_duration(gz_reph))\n",
    "delay1 -= calc_duration(gz_spoil) \n",
    "delay1 -= calc_duration(gz180) / 2\n",
    "delay1 = np.ceil(delay1/seq.grad_raster_time)*seq.grad_raster_time\n",
    "delay1 = make_delay(delay1)\n",
    "\n",
    "delay2 = tau - calc_duration(gz180) / 2 - calc_duration(gz_spoil)\n",
    "delay2 -= calc_duration(gx_spoil) \n",
    "delay2 -= calc_duration(gx) / 2\n",
    "delay2 = np.ceil(delay2/seq.grad_raster_time)*seq.grad_raster_time\n",
    "delay2 = make_delay(delay2)\n",
    "\n",
    "delay_TR = TR - calc_duration(gz90) / 2 - calc_duration(gx) / 2 - TE\n",
    "delay_TR -= max(calc_duration(gy_pre),calc_duration(gz_spoil))\n",
    "delay_TR -= calc_duration(gx_spoil)\n",
    "delay_TR = np.ceil(delay_TR/seq.grad_raster_time)*seq.grad_raster_time\n",
    "delay_TR = make_delay(delay_TR)\n",
    "\n",
    "print(f'delay_1: {delay1}')\n",
    "print(f'delay_2: {delay1}')\n",
    "print(f'delay_TR: {delay_TR}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **CONSTRUCT CONCATINATIONS timings**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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 = TR - delay_TR.delay #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(params.grad_raster_time,params.rf_raster_time)*np.floor(x/max(params.grad_raster_time,params.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": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#working version without concatinations\n",
    "\n",
    "for k in range(params.nsa):  # Averages\n",
    "    for curr_concat in range(required_concats): \n",
    "        for phase_step in range(k_steps_PE.size):\n",
    "            for curr_slice in range(params.sl_nb):  # Slices\n",
    "                # Apply RF offsets\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",
    "                \n",
    "                seq.add_block(rf90, gz90)\n",
    "                t_gy_pre = np.ceil(params.t_ex / 2 / params.grad_raster_time) * params.grad_raster_time      \n",
    "                gy_pre = make_trapezoid(channel='y', system=scanner_parameters, \n",
    "                                        area=k_steps_PE[phase_step], duration = t_gy_pre)\n",
    "                seq.add_block(gx_pre, gy_pre, gz_reph)\n",
    "                seq.add_block(delay1)\n",
    "                seq.add_block(gz_sp1)\n",
    "                seq.add_block(gz_sp2, rf180)\n",
    "                seq.add_block(gz_sp3)\n",
    "                seq.add_block(delay2)\n",
    "                seq.add_block(gx_sp1) \n",
    "                seq.add_block(gx_sp2, adc)\n",
    "                seq.add_block(gx_sp3)\n",
    "                gy_pre = make_trapezoid(channel='y', system=scanner_parameters, \n",
    "                                        area=-k_steps_PE[phase_step], duration = t_gy_pre)\n",
    "                seq.add_block(gy_pre, gz_spoil)\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.0, 0.04))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "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_se\\\\t1_SE_matrx16x16_myGrad.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": 19,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4Q0b5w-lKtfP"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<xml.etree.ElementTree.ElementTree at 0x1ef63a5e470>,\n",
       " 'C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t1_se/t1_SE_matrx16x16_myGrad.xml')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from py2jemris.seq2xml import seq2xml\n",
    "seq2xml(seq, seq_name='t1_SE_matrx16x16_myGrad', out_folder='C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t1_se')"
   ]
  },
  {
   "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
}