This page provides documentation for the modules, structs, functions, methods, and additional components available when importing the KomaMRI package. It serves as a valuable reference when using the Julia REPL directly and when creating custom Julia scripts. Be sure not to overlook the section How to read the API docs, which contains important information for understanding the general structure of docstrings. The following is the table of contents for the API Documentation:
The API documentation includes predefined "template patterns" to assist users in understanding how to use modules, structs, functions, methods, and all the necessary aspects to make the most of what KomaMRI has to offer.
These documentation "template patterns" are based on the JJulia Blue Style documentation and other GitHub repositories that deal with MRI topics. However, some custom considerations were added to enhance understanding and provide a broader perspective.
When you encounter a docstring documentation, it will have the following structure:
This page provides documentation for the modules, structs, functions, methods, and additional components available when importing the KomaMRI package. It serves as a valuable reference when using the Julia REPL directly and when creating custom Julia scripts. Be sure not to overlook the section How to read the API docs, which contains important information for understanding the general structure of docstrings. The following is the table of contents for the API Documentation:
The API documentation includes predefined "template patterns" to assist users in understanding how to use modules, structs, functions, methods, and all the necessary aspects to make the most of what KomaMRI has to offer.
These documentation "template patterns" are based on the JJulia Blue Style documentation and other GitHub repositories that deal with MRI topics. However, some custom considerations were added to enhance understanding and provide a broader perspective.
When you encounter a docstring documentation, it will have the following structure:
The preceding docstring block will always start with the way the component is called (outputs = component_name(inputs), followed by a brief description of what the component does. If necessary, a note block will be displayed. In general, the following subsections are optional: Arguments, Keywords, Returns, References, and Examples, but they will be provided as needed. These subsections are self-explanatory, making it intuitive to understand their purpose.
Please note that every subitem in the sections Arguments, Keywords, and Returns represents variables. They include practical information along with a description. The information enclosed in parentheses is optional but highly useful when provided.
::type: is the suggested type for the variable. If the input variable is of type ::type, there won't be any issues, but it's always possible to test other subtypes. If the variable is an output, it will be forced to the type ::type whenever possible.
=value: sometimes, for the inputs, a default value is defined if it is not assigned by the user.
[unit]: this is the suggested physical unit of measure for the variable. Everything will be fine if you stick with these units of measure.
opts: [opt1, opt2, ...]: sometimes, the input value can only be interpreted if it is one of the predefined values.
return_window: (::Bool, =false) make the out be either 'nothing' or the Blink window, depending on whether the return_window keyword argument is set to true
show_window: (::Bool, =true) display the Blink window
Returns
out: (::Nothing or ::Blink.AtomShell.Window) returns either 'nothing' or the Blink window, depending on whether the return_window keyword argument is set to true.
return_window: (::Bool, =false) make the out be either 'nothing' or the Blink window, depending on whether the return_window keyword argument is set to true
show_window: (::Bool, =true) display the Blink window
Returns
out: (::Nothing or ::Blink.AtomShell.Window) returns either 'nothing' or the Blink window, depending on whether the return_window keyword argument is set to true.
@@ -17,11 +17,11 @@
window.PLOTLYENV = window.PLOTLYENV || {}
- if (document.getElementById('9ad8cdbe-2227-44a7-8fd7-5de25e329b7a')) {
+ if (document.getElementById('de276b70-6328-4ec4-83c9-54f86e192692')) {
Plotly.newPlot(
- '9ad8cdbe-2227-44a7-8fd7-5de25e329b7a',
- [{"y":[null,null,null,null,null],"type":"scatter","name":"Gx","hovertemplate":"(%{x:.4f} ms, %{y:.2f} mT/m)","x":[0.0,0.0,0.0,0.0,0.0]},{"y":[null,null,null,null,null],"type":"scatter","name":"Gy","hovertemplate":"(%{x:.4f} ms, %{y:.2f} mT/m)","x":[0.0,0.0,0.0,0.0,0.0]},{"y":[null,null,null,null,null],"type":"scatter","name":"Gz","hovertemplate":"(%{x:.4f} ms, %{y:.2f} mT/m)","x":[0.0,0.0,0.0,0.0,0.0]},{"y":[null,0.0,0.0,0.0,668.2066312775996,668.2066312775996,1164.3488132933187,1164.3488132933187,1261.3778810677616,1261.3778810677616,850.4448034442171,850.4448034442171,0.0,0.0,1039.4325375429328,1039.4325375429328,1892.0668216016427,1892.0668216016427,2162.3620818304485,2162.3620818304485,1559.1488063143984,1559.1488063143984,0.0,0.0,2338.7232094715982,2338.7232094715982,5045.511524271046,5045.511524271046,7568.267286406571,7568.267286406571,9354.892837886391,9354.892837886391,10000.0,10000.0,9354.892837886391,9354.892837886391,7568.267286406571,7568.267286406571,5045.511524271046,5045.511524271046,2338.7232094715982,2338.7232094715982,0.0,0.0,1559.1488063143984,1559.1488063143984,2162.3620818304485,2162.3620818304485,1892.0668216016427,1892.0668216016427,1039.4325375429328,1039.4325375429328,0.0,0.0,850.4448034442171,850.4448034442171,1261.3778810677616,1261.3778810677616,1164.3488132933187,1164.3488132933187,668.2066312775996,668.2066312775996,0.0,0.0,0.0],"type":"scatter","name":"|RF_1|","hovertemplate":"(%{x:.4f} ms, %{y:.2f} μT)","x":[0.0,0.1,0.1,0.11612903225806452,0.11612903225806452,0.13225806451612904,0.13225806451612904,0.14838709677419357,0.14838709677419357,0.16451612903225807,0.16451612903225807,0.18064516129032257,0.18064516129032257,0.1967741935483871,0.1967741935483871,0.21290322580645163,0.21290322580645163,0.22903225806451616,0.22903225806451616,0.2451612903225807,0.2451612903225807,0.2612903225806452,0.2612903225806452,0.2774193548387097,0.2774193548387097,0.2935483870967743,0.2935483870967743,0.3096774193548388,0.3096774193548388,0.32580645161290334,0.32580645161290334,0.34193548387096784,0.34193548387096784,0.35806451612903234,0.35806451612903234,0.37419354838709684,0.37419354838709684,0.39032258064516134,0.39032258064516134,0.4064516129032259,0.4064516129032259,0.4225806451612904,0.4225806451612904,0.43870967741935496,0.43870967741935496,0.45483870967741946,0.45483870967741946,0.470967741935484,0.470967741935484,0.4870967741935485,0.4870967741935485,0.5032258064516131,0.5032258064516131,0.5193548387096777,0.5193548387096777,0.5354838709677422,0.5354838709677422,0.5516129032258067,0.5516129032258067,0.5677419354838712,0.5677419354838712,0.5838709677419357,0.5838709677419357,0.6000000000000003,0.6000000000000003]},{"y":[null,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,-3.141592653589793,-3.141592653589793,-3.141592653589793,-3.141592653589793,-3.141592653589793,-3.141592653589793,-3.141592653589793,-3.141592653589793,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,-3.141592653589793,-3.141592653589793,-3.141592653589793,-3.141592653589793,-3.141592653589793,-3.141592653589793,-3.141592653589793,-3.141592653589793,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0],"type":"scatter","name":"
-
\ No newline at end of file
+
\ No newline at end of file
diff --git a/dev/assets/event-shapes-gr-horizontal.svg b/dev/assets/event-shapes-gr-horizontal.svg
index 399effd65..df03992fd 100644
--- a/dev/assets/event-shapes-gr-horizontal.svg
+++ b/dev/assets/event-shapes-gr-horizontal.svg
@@ -1,4 +1,4 @@
-
\ No newline at end of file
+
\ No newline at end of file
diff --git a/dev/assets/event-shapes-rf-horizontal.svg b/dev/assets/event-shapes-rf-horizontal.svg
index d7d616592..82b761cf3 100644
--- a/dev/assets/event-shapes-rf-horizontal.svg
+++ b/dev/assets/event-shapes-rf-horizontal.svg
@@ -1,4 +1,4 @@
-
\ No newline at end of file
+
\ No newline at end of file
diff --git a/dev/assets/examples/1-seq.html b/dev/assets/examples/1-seq.html
index 85e295ca1..53dca1dce 100644
--- a/dev/assets/examples/1-seq.html
+++ b/dev/assets/examples/1-seq.html
@@ -9,7 +9,7 @@
In this section, we will create a custom Phantom struct. While the example is presented in 2D, the concepts discussed here can be readily extended to 3D phantoms.
In KomaMRI, the creation of a Phantom struct involves defining spin position arrays (x, y, z) and spin property arrays. The indices of these arrays are then associated with independent spins.
For instance, you can create a Phantom with one spin like so:
# Define arrays of positions (spin at zero position)
+Create Your Own Phantom · KomaMRI.jl: General MRI simulation framework
In this section, we will create a custom Phantom struct. While the example is presented in 2D, the concepts discussed here can be readily extended to 3D phantoms.
In KomaMRI, the creation of a Phantom struct involves defining spin position arrays (x, y, z) and spin property arrays. The indices of these arrays are then associated with independent spins.
For instance, you can create a Phantom with one spin like so:
# Define arrays of positions (spin at zero position)
x = [0.0]
y = [0.0]
z = [0.0]
@@ -111,4 +111,4 @@
T2 = T2[ρ.!=0],
T2s = T2s[ρ.!=0],
Δw = Δw[ρ.!=0],
-)
We can display the Phantom struct with the plot_phantom_map function. In this case we select the proton density to be displayed, but you can choose other property to be displayed:
plot_phantom_map(obj, :ρ)
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
+)
We can display the Phantom struct with the plot_phantom_map function. In this case we select the proton density to be displayed, but you can choose other property to be displayed:
plot_phantom_map(obj, :ρ)
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
diff --git a/dev/create-your-own-sequence/index.html b/dev/create-your-own-sequence/index.html
index 2c5ea6e77..20d0fd9ce 100644
--- a/dev/create-your-own-sequence/index.html
+++ b/dev/create-your-own-sequence/index.html
@@ -1,5 +1,5 @@
-Create Your Own Sequence · KomaMRI.jl: General MRI simulation framework
This section is currently under construction, and some details on how to construct a Sequence may be missing.
This is an example of how to create a Sequence struct:
# Export necessary modules
using KomaMRI
# Create the function that creates a phantom
@@ -44,4 +44,4 @@
# Plot the sequence in time and its kspace
plot_seq(seq; range=[0 30])
-plot_kspace(seq)
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
+plot_kspace(seq)
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
y = getproperty(x::Vector{Grad}, f::Symbol)
y = getproperty(x::Matrix{Grad}, f::Symbol)
Overloads Base.getproperty(). It is meant to access properties of the Grad vector x directly without the need to iterate elementwise.
Arguments
x: (::Vector{Grad} or ::Matrix{Grad}) vector or matrix of Grad structs
f: (::Symbol, opts: [:x, :y, :z, :T, :delay, :rise, :delay, :dur, :A, f]) input symbol that represents a property of the vector or matrix of Grad structs
Returns
y: (::Vector{Any} or ::Matrix{Any}) vector or matrix with the property defined by the symbol f for all elements of the Grad vector or matrix x
As we already know, a Sequence struct contains field names that store arrays of RF, Grad and ADC structs. To create a Sequence, it's essential to understand how to create these fundamental events.
In the following subsections, we will provide detailed explanations of event parameters and how to create a Sequence using RF, Grad and ADC events.
As we already know, a Sequence struct contains field names that store arrays of RF, Grad and ADC structs. To create a Sequence, it's essential to understand how to create these fundamental events.
In the following subsections, we will provide detailed explanations of event parameters and how to create a Sequence using RF, Grad and ADC events.
We can include multiple events within a single block of a sequence. The example below demonstrates how to combine an RF struct, three Grad structs for the x-y-z components, and an ADC struct in a single block of a sequence:
# Define an RF struct
+julia> plot_seq(seq; slider=false)
We can include multiple events within a single block of a sequence. The example below demonstrates how to combine an RF struct, three Grad structs for the x-y-z components, and an ADC struct in a single block of a sequence:
Once the struct events are defined, it's important to note that to create a single block sequence, you need to provide 2D matrices of Grad and RF structs, as well as a vector of ADC structs as arguments in the Sequence constructor.
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
+julia> plot_seq(seq; slider=false)
Once the struct events are defined, it's important to note that to create a single block sequence, you need to provide 2D matrices of Grad and RF structs, as well as a vector of ADC structs as arguments in the Sequence constructor.
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
Finally, to simulate we will need to use the function simulate.
raw = simulate(obj, seq, sys)
RawAcquisitionData[SeqName: NoName | 1 Profile(s) of 8192×1]
To plot the results we will need to use the plot_signal function
p2 = plot_signal(raw; slider=false, height=300)
"../../assets/examples/1-signal.html"
Nice!, we can see that $S(t)$ follows an exponential decay $\exp(-t/T_2)$ as expected.
For a little bit of spiciness, let's add off-resonance to our example. We will use $\Delta f=-100\,\mathrm{Hz}$. For this, we will need to add a definition for Δw in our Phantom
obj = Phantom{Float64}(x=[0.], T1=[1000e-3], T2=[100e-3], Δw=[-2π*100])# and simulate again.
raw = simulate(obj, seq, sys)
-p3 = plot_signal(raw; slider=false, height=300)
"../../assets/examples/1-signal2.html"
The signal now follows an exponential of the form $\exp(-t/T_2)\cdot\exp(-i\Delta\omega t)$. The addition of $\exp(-i\Delta\omega t)$ to the signal will generate a shift in the image space (Fourier shifting property). This effect will be better visualized and explained in later examples.
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
+p3 = plot_signal(raw; slider=false, height=300)
"../../assets/examples/1-signal2.html"
The signal now follows an exponential of the form $\exp(-t/T_2)\cdot\exp(-i\Delta\omega t)$. The addition of $\exp(-i\Delta\omega t)$ to the signal will generate a shift in the image space (Fourier shifting property). This effect will be better visualized and explained in later examples.
Based on the results in page 41 of the book "Handbook of MRI Pulse Sequences" by Bernstein et al.
50
In this example, we will showcase a common approximation in MRI, the small tip angle approximation. For this, we will simulate a slice profile for spins with positions $z\in[-2,\,2]\,\mathrm{cm}$ and with a gradient $G_{z}$ so their frequencies are mapped to $f\in[-5,\,5]\,\mathrm{kHz}$. To start, we define an RF pulse with a flip angle of 30 deg and pulse duration of $T_{\mathrm{rf}}=3.2\,\mathrm{ms}$.
B1 = 4.92e-6
+Small Tip Angle Approximation · KomaMRI.jl: General MRI simulation framework
Based on the results in page 41 of the book "Handbook of MRI Pulse Sequences" by Bernstein et al.
50
In this example, we will showcase a common approximation in MRI, the small tip angle approximation. For this, we will simulate a slice profile for spins with positions $z\in[-2,\,2]\,\mathrm{cm}$ and with a gradient $G_{z}$ so their frequencies are mapped to $f\in[-5,\,5]\,\mathrm{kHz}$. To start, we define an RF pulse with a flip angle of 30 deg and pulse duration of $T_{\mathrm{rf}}=3.2\,\mathrm{ms}$.
For this case, the small tip angle approximation breaks 😢, thus, the reason for its name!
This basic sinc pulse is not designed to be $B_{1}$-insensitive. Some adiabatic RF pulses have been proposed to achieve this. Watch out for a future example showing these adiabatic RF pulses 👀.
For this case, the small tip angle approximation breaks 😢, thus, the reason for its name!
This basic sinc pulse is not designed to be $B_{1}$-insensitive. Some adiabatic RF pulses have been proposed to achieve this. Watch out for a future example showing these adiabatic RF pulses 👀.
KomaMRI was written in Julia, so the first thing you should do is to install it! The latest version of Julia can be downloaded at the Julia Downloads page. It is advisable you add julia to the PATH, which can be done during the installation process.
KomaMRI was written in Julia, so the first thing you should do is to install it! The latest version of Julia can be downloaded at the Julia Downloads page. It is advisable you add julia to the PATH, which can be done during the installation process.
For our first simulation we will use KomaMRI's graphical user interface (GUI). For this, you will first need to load KomaMRI by typing using KomaMRI, and then launch the GUI with KomaUI().
julia> using KomaMRI
-julia> KomaUI()
The first time you use this command it may take more time than usual, but a window with the Koma GUI will pop up:
The user interface has some basic definitions for the scanner, phantom, and sequence already preloaded. So you can immediately interact with the simulation and reconstruction processes, and then visualize the results.
As a simple demonstration, press the Simulate! button and wait until the simulation is ready. Now you have acquired the Raw Signal and you should see the following:
Then, press the Reconstruct! button and wait until the reconstruction ends. Now you have reconstructed an Image from the Raw Signal and you should see the following in the GUI:
Congratulations, you successfully simulated an MRI acquisition! 🎊
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
+julia> KomaUI()
The first time you use this command it may take more time than usual, but a window with the Koma GUI will pop up:
The user interface has some basic definitions for the scanner, phantom, and sequence already preloaded. So you can immediately interact with the simulation and reconstruction processes, and then visualize the results.
As a simple demonstration, press the Simulate! button and wait until the simulation is ready. Now you have acquired the Raw Signal and you should see the following:
Then, press the Reconstruct! button and wait until the reconstruction ends. Now you have reconstructed an Image from the Raw Signal and you should see the following in the GUI:
Congratulations, you successfully simulated an MRI acquisition! 🎊
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
KomaMRI is a Julia package meant to simulate general Magnetic Resonance Imaging (MRI) scenarios. Its name comes from the Japanese word for spinning-top こま (ko-ma) as they precess due to gravity like spins in a magnetic field.
KomaMRI generates raw data by solving the Bloch equations using the specified scanner, phantom and sequence. It also provides a Graphical User Interface (GUI) that encapsulates the whole imaging pipeline (simulation and reconstruction).
-
KomaMRI can be used by either:
User Interface: User-friendly interaction. No Julia programming skills are required. Refer to Simulation with User Interface to dive into the details of how to use the GUI.
Scripts : Basic knowledge of Julia is required. Refer to Simulation with Scripts to follow a basic workflow on how to work with KomaMRI.
If you are new to KomaMRI, we recommend starting with the "Getting Started" section to install Julia, KomaMRI, and perform your first simulation.
KomaMRI is a Julia package meant to simulate general Magnetic Resonance Imaging (MRI) scenarios. Its name comes from the Japanese word for spinning-top こま (ko-ma) as they precess due to gravity like spins in a magnetic field.
KomaMRI generates raw data by solving the Bloch equations using the specified scanner, phantom and sequence. It also provides a Graphical User Interface (GUI) that encapsulates the whole imaging pipeline (simulation and reconstruction).
+
KomaMRI can be used in different environments:
User Interface: User-friendly interaction. No Julia programming skills are required. Refer to the User Interface Section to dive into the details of how to use the GUI.
Scripts : Basic knowledge of Julia is required. Refer to the Scripts Section to follow a basic workflow on how to work with KomaMRI.
Notebooks: Basic knowledge of Julia is required. This serves as an alternative development environment featuring user-friendly interactive tools. For guidance on setting up these environments, refer to the Notebooks Section.
If you are new to KomaMRI, we recommend starting with the "Getting Started" section to install Julia, KomaMRI, and perform your first simulation.
This section is meant to be a general overview or summary of the main MRI concepts and insights. It is a good starting point to show up the most relevant components involved and how they are related for raw signal acquisition and image reconstruction. The idea is to have a fresh and clear understanding of what is happening behind the scenes when using the KomaMRI.jl package. Some light background in Differential Equations, Signal Processing and Fourier Theory is advisable to follow along.
In order to generate an image from a phantom object with a scanner system and sequence signals, its necessary to acquire a raw signal$s(t)$. This signal can be though as the sum of all spin magnetizations $M$ of the object:
\[s(t) =
+
MRI Theory · KomaMRI.jl: General MRI simulation framework
This section is meant to be a general overview or summary of the main MRI concepts and insights. It is a good starting point to show up the most relevant components involved and how they are related for raw signal acquisition and image reconstruction. The idea is to have a fresh and clear understanding of what is happening behind the scenes when using the KomaMRI.jl package. Some light background in Differential Equations, Signal Processing and Fourier Theory is advisable to follow along.
In order to generate an image from a phantom object with a scanner system and sequence signals, its necessary to acquire a raw signal$s(t)$. This signal can be though as the sum of all spin magnetizations $M$ of the object:
KomaMRI simulates the magnetization of each spin of a Phantom for variable magnetic fields given by a Sequence. It is assumed that a single spin is independent of the state of the other spins in the system (a key feature that enables parallelization). Furthermore, there are defined two regimes in the Sequence: excitation and precession. During the latter, the excitation fields are nulled and are useful for simplifying some physical equations.
The are more internal considerations in the KomaMRI implementation. The Figure 1 summarizes the functions called to perform the simulation.
+
Simulation · KomaMRI.jl: General MRI simulation framework
KomaMRI simulates the magnetization of each spin of a Phantom for variable magnetic fields given by a Sequence. It is assumed that a single spin is independent of the state of the other spins in the system (a key feature that enables parallelization). Furthermore, there are defined two regimes in the Sequence: excitation and precession. During the latter, the excitation fields are nulled and are useful for simplifying some physical equations.
The are more internal considerations in the KomaMRI implementation. The Figure 1 summarizes the functions called to perform the simulation.
Figure 1: The sequence ${\tt seq }$ is discretized after calculating the required time points in the wrapper function ${\tt simulate}$. The time points are then divided into ${\tt Nblocks}$ to reduce the amount of memory used. The phantom ${\tt obj}$ is divided into ${\tt Nthreads}$, and ${\bf KomaMRI}$ will use either ${\tt run\_spin\_excitation!}$ or ${\tt run\_spin\_precession!}$ depending on the regime. If an ${\tt ADC}$ object is present, the simulator will add the signal contributions of each thread to construct the acquired signal ${\tt sig[t]}$. All the parameters: ${\tt Nthreads}$, ${\tt Nblocks}$, ${\tt Δt_{rf}}$, and ${\tt Δt}$, are passed through a dictionary called ${\tt sim\_params}$ as an optional parameter of the simulate function.
@@ -47,4 +47,4 @@
Figure 2: Solution of the Bloch equations for one time step can be described by (2) a rotation and (3) a relaxation step.
-
This is another simulation method defined in the source code of KomaMRI. It can be specified by setting the sim_method = BlochDict() entry of the sim_params dictionary.
Note
This section is under construction. More explanation of this simulation method is required.
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
This is another simulation method defined in the source code of KomaMRI. It can be specified by setting the sim_method = BlochDict() entry of the sim_params dictionary.
Note
This section is under construction. More explanation of this simulation method is required.
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
You can use KomaMRI with popular programming environments such as Pluto and Jupyter notebooks. The following sections show how to set up these notebooks and test KomaMRI with them.
You can use KomaMRI with popular programming environments such as Pluto and Jupyter notebooks. The following sections show how to set up these notebooks and test KomaMRI with them.
First, install the Pluto module in your Julia environment. Remember to press the ] button to open the Package Manager Session:
julia>
@(1.9) pkg> add Pluto
Afterward, return to the Julia Session by pressing the backspace button, and then execute the Pluto.run() function:
julia> using Pluto
-julia> Pluto.run()
This should automatically open the Pluto dashboard in your default web browser:
Next, create a new notebook by clicking on + Create a new notebook:
Write and run the following code, which is identical to the Free Induction Decay example. Pluto automatically installs the required modules if they are not present on your system. Additionally, note that we do not use KomaMRI directly since we won't be utilizing the KomaUI() function. Instead, we rely on the KomaMRICore and KomaMRIPlots dependencies. To display plots in Pluto, ensure that you import the PlutoPlots package:"
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
+plot_seq(seq; slider=false, height=300)
This should be sufficient, and now you can start working with KomaMRI using Jupyter notebooks.
If you encounter the issue of WebIO not being detected:
You should already be familiar with the Graphical User Interface of KomaMRI. However, you can also use this package directly from the Julia REPL or write your own Julia scripts. This allows you to unlock the full potential of KomaMRI, enabling you to utilize more of its functionalities and even test your own MRI ideas.
This section demonstrates a basic workflow with KomaMRI through writing your own scripts or entering commands directly into the Julia REPL. Let's begin.
You should already be familiar with the Graphical User Interface of KomaMRI. However, you can also use this package directly from the Julia REPL or write your own Julia scripts. This allows you to unlock the full potential of KomaMRI, enabling you to utilize more of its functionalities and even test your own MRI ideas.
This section demonstrates a basic workflow with KomaMRI through writing your own scripts or entering commands directly into the Julia REPL. Let's begin.
Let's replicate these previous steps in a Julia script. You will obtain the following code, which you can copy and paste into the Julia REPL:
# Import the package
using KomaMRI
# Define scanner, object and sequence
@@ -106,4 +106,4 @@
raw = simulate(obj, seq, sys; sim_params)
# Save the .mat file in the temp directory
-matwrite(joinpath(tempdir(), "koma-raw.mat"), Dict("raw" => raw))
Note that we need to simulate to return an array type (not the default RawAcquisitionData), and then we utilize the matwrite function to save a file named "koma-raw.mat" in your computer's temporary directory. Now, you can navigate to your temporary directory (which you can find by displaying the result of tempdir() in the Julia REPL) and locate the "koma-raw.mat" file.
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
Note that we need to simulate to return an array type (not the default RawAcquisitionData), and then we utilize the matwrite function to save a file named "koma-raw.mat" in your computer's temporary directory. Now, you can navigate to your temporary directory (which you can find by displaying the result of tempdir() in the Julia REPL) and locate the "koma-raw.mat" file.
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
+Search · KomaMRI.jl: General MRI simulation framework
Loading search...
Settings
This document was generated with Documenter.jl version 0.27.25 on Thursday 16 November 2023. Using Julia version 1.9.4.
diff --git a/dev/search_index.js b/dev/search_index.js
index b2d2706d1..7d6926693 100644
--- a/dev/search_index.js
+++ b/dev/search_index.js
@@ -1,3 +1,3 @@
var documenterSearchIndex = {"docs":
-[{"location":"notebooks/#Notebooks","page":"Notebooks","title":"Notebooks","text":"","category":"section"},{"location":"notebooks/","page":"Notebooks","title":"Notebooks","text":"You can use KomaMRI with popular programming environments such as Pluto and Jupyter notebooks. The following sections show how to set up these notebooks and test KomaMRI with them.","category":"page"},{"location":"notebooks/#Using-KomaMRI-with-Pluto","page":"Notebooks","title":"Using KomaMRI with Pluto","text":"","category":"section"},{"location":"notebooks/","page":"Notebooks","title":"Notebooks","text":"First, install the Pluto module in your Julia environment. Remember to press the ] button to open the Package Manager Session:\"","category":"page"},{"location":"notebooks/","page":"Notebooks","title":"Notebooks","text":"julia>\n\n@(1.9) pkg> add Pluto","category":"page"},{"location":"notebooks/","page":"Notebooks","title":"Notebooks","text":"Afterward, return to the Julia Session by pressing the backspace button, and then execute the Pluto.run() function:","category":"page"},{"location":"notebooks/","page":"Notebooks","title":"Notebooks","text":"julia> using Pluto\n\njulia> Pluto.run()","category":"page"},{"location":"notebooks/","page":"Notebooks","title":"Notebooks","text":"This should automatically open the Pluto dashboard in your default web browser:","category":"page"},{"location":"notebooks/","page":"Notebooks","title":"Notebooks","text":"
","category":"page"},{"location":"notebooks/","page":"Notebooks","title":"Notebooks","text":"Next, create a new notebook by clicking on + Create a new notebook:","category":"page"},{"location":"notebooks/","page":"Notebooks","title":"Notebooks","text":"
","category":"page"},{"location":"notebooks/","page":"Notebooks","title":"Notebooks","text":"Write and run the following code, which is identical to the Free Induction Decay example. Pluto automatically installs the required modules if they are not present on your system. Additionally, note that we do not use KomaMRI directly since we won't be utilizing the KomaUI() function. Instead, we rely on the KomaMRICore and KomaMRIPlots dependencies. To display plots in Pluto, ensure that you import the PlutoPlots package:\"","category":"page"},{"location":"notebooks/","page":"Notebooks","title":"Notebooks","text":"
![\"\"](\"../assets/pluto-dashboard.png\")
![\"\"](\"../assets/pluto-empty-notebook.png\"){kind=spacer}