{
 "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 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.opts import Opts\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": [
       "{'G_amp_max': 37.8,\n",
       " 'G_slew_max': 121,\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.0031,\n",
       " 't_ref': 0.00388,\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",
       " 'TR': 0.5,\n",
       " 'FA': 90.0,\n",
       " 'conct': 1.0,\n",
       " 'Average': 1.0,\n",
       " 'delay_TR': 0.47479}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with open('C:\\MRI_seq_files_mess\\SE_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",
    "#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": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "PeYeI0V45ZfD"
   },
   "source": [
    "## **SYSTEM LIMITS**\n",
    "Set the hardware limits and initialize sequence object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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'][0],   \n",
    "    rf_dead_time = params['rf_dead_time'][0],          \n",
    "    adc_dead_time = params['adc_dead_time'][0],            \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": 11,
   "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, gz180, _ = 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)*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": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 12,
     "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": 13,
   "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",
    "gz_spoil = make_trapezoid(channel='z', system=scanner_parameters, area=gz90.area*0.75)\n",
    "gz_sps = make_trapezoid(channel='z', system=scanner_parameters, area=gz90.area*4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "RFSHuUOG9LHK"
   },
   "source": [
    "## **READOUT gradients & events**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "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, area=gx.area*1.5)\n",
    "\n",
    "# generate gx spoile 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=gx.area)\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": 15,
   "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": 18,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "aOKRJclb_mDQ"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "delay_1: namespace(type='delay', delay=0.00417)\n",
      "delay_2: namespace(type='delay', delay=0.00417)\n",
      "delay_TR: namespace(type='delay', delay=0.47457000000000005)\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/params['grad_raster_time'])*params['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/params['grad_raster_time'])*params['grad_raster_time']\n",
    "delay2 = make_delay(delay2)\n",
    "\n",
    "delay_TR = params['TR'] - calc_duration(gz90) / 2 - calc_duration(gx) / 2 - params['TE']\n",
    "delay_TR -= max(calc_duration(gy_pre),calc_duration(gz_sps))\n",
    "delay_TR -= calc_duration(gx_spoil)\n",
    "delay_TR = np.ceil(delay_TR/params['grad_raster_time'])*params['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": 19,
   "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 = params['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": "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": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "#working version without concatinations\n",
    "\n",
    "for k in range(np.int32(params['Average'])):  # 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(np.int32(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_spoil)\n",
    "                seq.add_block(rf180, gz180)\n",
    "                seq.add_block(gz_spoil)\n",
    "                seq.add_block(delay2)\n",
    "                seq.add_block(gx_spoil) \n",
    "                seq.add_block(gx, adc)\n",
    "                seq.add_block(gx_spoil)\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_sps)\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": 21,
   "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": 22,
   "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": 23,
   "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": 24,
   "metadata": {
    "colab": {},
    "colab_type": "code",
    "id": "4Q0b5w-lKtfP"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<xml.etree.ElementTree.ElementTree at 0x21a8c3601c0>,\n",
       " 'C:\\\\MRI_seq\\\\new_MRI_pulse_seq\\\\t1_se/t1_SE_matrx16x16_myGrad.xml')"
      ]
     },
     "execution_count": 24,
     "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
}