MRArbGrad 1.1.6__tar.gz → 2.0.1__tar.gz

{mrarbgrad-1.1.6 → mrarbgrad-2.0.1/MRArbGrad.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MRArbGrad
-Version: 1.1.6
+Version: 2.0.1
 Summary: Gradient waveform design tool for arbitrary k-space trajectories.
 Author-email: Ryan <ryan_shanghaitech@proton.me>
 License-Expression: MIT

{mrarbgrad-1.1.6 → mrarbgrad-2.0.1}/MRArbGrad.egg-info/SOURCES.txt

@@ -4,7 +4,7 @@ README.md
 pyproject.toml
 setup.py
 ./mrarbgrad_src/ext/main.cpp
-./mrarbgrad_src/ext/mag/GradGen.cpp
+./mrarbgrad_src/ext/mag/Mag.cpp
 ./mrarbgrad_src/ext/utility/global.cpp
 ./mrarbgrad_src/ext/utility/v3.cpp
 MRArbGrad.egg-info/PKG-INFO
@@ -23,6 +23,8 @@ mrarbgrad_src/__init__.py
 mrarbgrad_src/ext/main.cpp
 mrarbgrad_src/ext/mag/GradGen.cpp
 mrarbgrad_src/ext/mag/GradGen.h
+mrarbgrad_src/ext/mag/Mag.cpp
+mrarbgrad_src/ext/mag/Mag.h
 mrarbgrad_src/ext/traj/Cones.h
 mrarbgrad_src/ext/traj/MrTraj.h
 mrarbgrad_src/ext/traj/MrTraj_2D.h

{mrarbgrad-1.1.6/MRArbGrad.egg-info → mrarbgrad-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MRArbGrad
-Version: 1.1.6
+Version: 2.0.1
 Summary: Gradient waveform design tool for arbitrary k-space trajectories.
 Author-email: Ryan <ryan_shanghaitech@proton.me>
 License-Expression: MIT

{mrarbgrad-1.1.6 → mrarbgrad-2.0.1}/example/example_BuiltInTraj.py

@@ -6,11 +6,12 @@ from numpy.linalg import norm
 gamma = 42.5756e6
 fov = 0.256
 nPix = 256
-sLim = 50 * gamma * fov/nPix
-gLim = 20e-3 * gamma * fov/nPix
 dtGrad = 10e-6
 dtADC = 2.5e-6
-argCom = dict(dFov=fov, lNPix=nPix, dSLim=sLim, dGLim=gLim, dDt=dtGrad)
+sLim = 50 * gamma * fov/nPix
+gLim = 20e-3 * gamma * fov/nPix
+# gLim = 1/nPix/dtADC
+argCom = dict(fov=fov, nPix=nPix, sLim=sLim, gLim=gLim, dt=dtGrad)
 
 mag.setSolverMtg(0) # set solver, 0 for proposed method, 1 for baseline method, baseline method may be removed due to copyright reason
 mag.setTrajRev(0) # reverse the trajectory
@@ -18,20 +19,20 @@ mag.setGoldAng(1) # enable golden-angle interleaving (only for 2D)
 mag.setShuf(0) # enable TR-shuffling
 mag.setMaxG0(0) # use maximum possible initial gradient amplitude
 mag.setMaxG1(0) # use maximum possible final gradient amplitude
-mag.setExGEnd(0) # restrict end-value of the graident exactly the same as requested (turn off only for benchmark purpose)
-mag.setMagOv(8) # set oversampling ratio (default: 8, reduce only if hardware performance is too low to support real-time)
+mag.setMagOverSamp(8) # set oversampling ratio (default: 8, reduce only if hardware performance is too low to support real-time)
 mag.setMagSFS(0) # disable DTFBS (experimental)
 mag.setMagGradRep(1) # enable gradient reparameterization (experimental)
 mag.setMagTrajRep(1) # enable trajectory reparameterization (experimental)
 mag.setDbgPrint(1) # enable debug info (for benchmark purpose)
 
 # calculate gradient
-# lstArrK0, lstArrGrad = mag.getG_Spiral(bIs3D=0, **argCom); nAx = 2
-# lstArrK0, lstArrGrad = mag.getG_VarDenSpiral(bIs3D=0, **argCom); nAx = 2
-# lstArrK0, lstArrGrad = mag.getG_Rosette(bIs3D=0, **argCom); nAx = 2
-# lstArrK0, lstArrGrad = mag.getG_Rosette_Trad(**argCom, dOm1=10*pi, dOm2=8*pi, dTmax=1, dTacq=2e-03); nAx = 2
+# lstArrK0, lstArrGrad = mag.getG_Spiral(is3D=0, **argCom); nAx = 2
+# lstArrK0, lstArrGrad = mag.getG_VarDenSpiral(is3D=0, **argCom); nAx = 2
+lstArrK0, lstArrGrad = mag.getG_VarDenSpiral_RT(is3D=0, **argCom); nAx = 2
+# lstArrK0, lstArrGrad = mag.getG_Rosette(is3D=0, **argCom); nAx = 2
+# lstArrK0, lstArrGrad = mag.getG_Rosette_Trad(**argCom); nAx = 2
 # lstArrK0, lstArrGrad = mag.getG_Shell3d(**argCom); nAx = 3
-lstArrK0, lstArrGrad = mag.getG_Yarnball(**argCom); nAx = 3
+# lstArrK0, lstArrGrad = mag.getG_Yarnball(**argCom); nAx = 3
 # lstArrK0, lstArrGrad = mag.getG_Seiffert(**argCom); nAx = 3
 # lstArrK0, lstArrGrad = mag.getG_Cones(**argCom); nAx = 3
 

{mrarbgrad-1.1.6 → mrarbgrad-2.0.1}/example/example_ExternalFunction2D.py

@@ -6,10 +6,11 @@ import mrarbgrad as mag
 gamma = 42.5756e6
 fov = 0.256
 nPix = 256
-sLim = 100 * gamma * fov/nPix
-gLim = 120e-3 * gamma * fov/nPix
 dtGrad = 10e-6
 dtADC = 2.5e-6
+sLim = 50 * gamma * fov/nPix
+gLim = 20e-3 * gamma * fov/nPix
+# gLim = 1/nPix/dtADC
 
 # Rosette
 nAx = 2

{mrarbgrad-1.1.6 → mrarbgrad-2.0.1}/example/example_ExternalSamples2D.py

@@ -6,10 +6,11 @@ import mrarbgrad as mag
 gamma = 42.5756e6
 fov = 0.256
 nPix = 256
-sLim = 100 * gamma * fov/nPix
-gLim = 120e-3 * gamma * fov/nPix
 dtGrad = 10e-6
 dtADC = 2.5e-6
+sLim = 50 * gamma * fov/nPix
+gLim = 20e-3 * gamma * fov/nPix
+# gLim = 1/nPix/dtADC
 
 # Rosette
 om1 = 5*pi

{mrarbgrad-1.1.6 → mrarbgrad-2.0.1}/example/example_ExternalSamples3D.py

@@ -6,10 +6,11 @@ import mrarbgrad as mag
 gamma = 42.5756e6
 fov = 0.256
 nPix = 256
-sLim = 100 * gamma * fov/nPix
-gLim = 120e-3 * gamma * fov/nPix
 dtGrad = 10e-6
 dtADC = 2.5e-6
+sLim = 50 * gamma * fov/nPix
+gLim = 20e-3 * gamma * fov/nPix
+# gLim = 1/nPix/dtADC
 
 # Yarnball
 nAx = 3
@@ -19,9 +20,10 @@ Yarnball = lambda sqrtTht: mag.trajfunc.Yarnball(sqrtTht, kRhoPhi)
 pLim = mag.trajfunc.prange_Yarnball(kRhoPhi)
     
 arrP = linspace(pLim[0], pLim[1], 1000)
-arrK = Yarnball(arrP).T
+arrK = Yarnball(arrP)
 
 # derive slew-rate constrained trajectory
+mag.setDbgPrint(1)
 arrG, _ = mag.calGrad4ExSamp(True, fov, nPix, sLim, gLim, dtGrad, arrK)
 nRO, _ = arrG.shape
 
@@ -32,16 +34,14 @@ arrK, _ = mag.cvtGrad2Traj(arrG, dtGrad, dtADC, 0.5)
 
 # derive reference trajectory
 arrP_Ref = linspace(pLim[0], pLim[1], int(1e4))
-arrK_Ref = Yarnball(arrP_Ref).T
+arrK_Ref = Yarnball(arrP_Ref)
 
 # plot
 figure(figsize=(20,10), dpi=120)
 
-subplot(221, projection=None if nAx==2 else "3d")
-if nAx==2: plot(arrK_Ref[:,0], arrK_Ref[:,1], "--", label="K_Ref")
-if nAx==3: plot(arrK_Ref[:,0], arrK_Ref[:,1], arrK_Ref[:,2], "--", label="K_Ref")
-if nAx==2: plot(arrK[:,0], arrK[:,1], ".-", label="K_Imp")
-if nAx==3: plot(arrK[:,0], arrK[:,1], arrK[:,2], ".-", label="K_Imp")
+subplot(221, projection="3d")
+plot(arrK_Ref[:,0], arrK_Ref[:,1], arrK_Ref[:,2], "--", label="K_Ref")
+plot(arrK[:,0], arrK[:,1], arrK[:,2], ".-", label="K_Imp")
 xlim(-0.5,0.5)
 ylim(-0.5,0.5)
 axis("equal")

mrarbgrad-2.0.1/mrarbgrad_src/Function.py

@@ -0,0 +1,369 @@
+from numpy import *
+from matplotlib.pyplot import *
+from numpy.typing import NDArray
+from typing import Callable
+import mrarbgrad.ext as ext
+from .Utility import *
+
+goldang = getGoldang()
+
+def calGrad4ExFunc\
+(
+    is3D: bool = False,
+    fov: float64 = 0.256,
+    nPix: int64 = 256,
+    
+    sLim: float64 = 50 * 42.5756e6 * 0.256 / 256,
+    gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
+    dt: float64 = 10e-6,
+    
+    getK: Callable|None = None,
+    getDkDp: Callable|None = None,
+    getD2kDp2: Callable|None = None,
+    
+    p0:float64 = 0e0, 
+    p1:float64 = 1e0, 
+) -> tuple[NDArray, NDArray]:
+    '''
+    :return: gradient waveform, corresponding parameter
+    :rtype: tuple[NDArray, NDArray]
+    '''
+    return ext.calGrad4ExFunc\
+    (
+        int64(is3D),
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim), 
+        float64(gLim), 
+        float64(dt), 
+        
+        getK,
+        getDkDp,
+        getD2kDp2,
+        
+        float64(p0),
+        float64(p1), 
+    )
+
+def calGrad4ExSamp\
+(
+    is3D: bool = False,
+    fov: float64 = 0.256,
+    nPix: int64 = 256,
+    
+    sLim: float64 = 50 * 42.5756e6 * 0.256 / 256,
+    gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
+    dt: float64 = 10e-6,
+    
+    arrK: NDArray = np.empty((0,3)),
+) -> tuple[NDArray, NDArray]:
+    '''
+    :return: gradient waveform, corresponding parameter
+    :rtype: tuple[NDArray, NDArray]
+    '''
+    return ext.calGrad4ExSamp\
+    (
+        int64(is3D),
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim), 
+        float64(gLim), 
+        float64(dt), 
+        
+        arrK
+    )
+    
+def getG_Spiral\
+(
+    is3D: bool = False,
+    fov: float64 = 0.256,
+    nPix: int64 = 256,
+    
+    sLim: float64 = 50 * 42.5756e6 * 0.256 / 256,
+    gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
+    dt: float64 = 10e-6,
+    
+    kRhoPhi: float64 = 0.5 / (4 * pi)
+) -> tuple[list[NDArray], list[NDArray]]:
+    '''
+    :return: list of trajectory start, list of gradient waveforms
+    :rtype: tuple[list[NDArray], list[NDArray]]
+    '''
+    return ext.getG_Spiral\
+    (
+        int64(is3D),
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim),
+        float64(gLim),
+        float64(dt),
+        
+        float64(kRhoPhi)
+    )
+
+def getG_VarDenSpiral\
+(
+    is3D: bool = False,
+    fov: float64 = 0.256,
+    nPix: int64 = 256,
+    
+    sLim: float64 = 50 * 42.5756e6 * 0.256 / 256,
+    gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
+    dt: float64 = 10e-6,
+    
+    kRhoPhi0: float64 = 0.5 / (8 * pi),
+    kRhoPhi1: float64 = 0.5 / (2 * pi),
+) -> tuple[list[NDArray], list[NDArray]]:
+    '''
+    :return: list of trajectory start, list of gradient waveforms
+    :rtype: tuple[list[NDArray], list[NDArray]]
+    '''
+    return ext.getG_VarDenSpiral\
+    (
+        int64(is3D),
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim),
+        float64(gLim),
+        float64(dt),
+        
+        float64(kRhoPhi0),
+        float64(kRhoPhi1)
+    )
+
+def getG_VarDenSpiral_RT\
+(
+    is3D: bool = False,
+    fov: float64 = 0.256,
+    nPix: int64 = 256,
+    
+    sLim: float64 = 50 * 42.5756e6 * 0.256 / 256,
+    gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
+    dt: float64 = 10e-6,
+    
+    kRhoPhi0: float64 = 0.5 / (8 * pi),
+    kRhoPhi1: float64 = 0.5 / (2 * pi),
+    nAcq: int64 = 1000,
+) -> tuple[list[NDArray], list[NDArray]]:
+    '''
+    :return: list of trajectory start, list of gradient waveforms
+    :rtype: tuple[list[NDArray], list[NDArray]]
+    '''
+    return ext.getG_VarDenSpiral_RT\
+    (
+        int64(is3D),
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim),
+        float64(gLim),
+        float64(dt),
+        
+        float64(kRhoPhi0),
+        float64(kRhoPhi1),
+        
+        int64(nAcq)
+    )
+
+def getG_Rosette\
+(
+    is3D: bool = False,
+    fov: float64 = 0.256,
+    nPix: int64 = 256,
+    
+    sLim: float64 = 50 * 42.5756e6 * 0.256 / 256,
+    gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
+    dt: float64 = 10e-6,
+    
+    om1: float64 = 5*pi, 
+    om2: float64 = 3*pi, 
+    tMax: float64 = 1e0,
+) -> tuple[list[NDArray], list[NDArray]]:
+    '''
+    :return: list of trajectory start, list of gradient waveforms
+    :rtype: tuple[list[NDArray], list[NDArray]]
+    '''
+    return ext.getG_Rosette\
+    (
+        int64(is3D),
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim),
+        float64(gLim),
+        float64(dt),
+        
+        float64(om1),
+        float64(om2),
+        float64(tMax)
+    )
+
+def getG_Rosette_Trad\
+(
+    is3D: bool = False,
+    fov: float64 = 0.256,
+    nPix: int64 = 256,
+    
+    sLim: float64 = 50 * 42.5756e6 * 0.256 / 256,
+    gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
+    dt: float64 = 10e-6,
+    
+    om1: float64 = 5*pi, 
+    om2: float64 = 3*pi, 
+    tMax: float64 = 1e0,
+    tAcq: float64 = 2.523e-3,
+) -> tuple[list[NDArray], list[NDArray]]:
+    '''
+    :return: list of trajectory start, list of gradient waveforms
+    :rtype: tuple[list[NDArray], list[NDArray]]
+    '''
+    return ext.getG_Rosette_Trad\
+    (
+        int64(is3D),
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim),
+        float64(gLim),
+        float64(dt),
+        
+        float64(om1),
+        float64(om2),
+        float64(tMax),
+        float64(tAcq)
+    )
+
+def getG_Shell3d\
+(
+    is3D: bool = False,
+    fov: float64 = 0.256,
+    nPix: int64 = 256,
+    
+    sLim: float64 = 50 * 42.5756e6 * 0.256 / 256,
+    gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
+    dt: float64 = 10e-6,
+    
+    kRhoTht: float64 = 0.5 / (2 * pi),
+) -> tuple[list[NDArray], list[NDArray]]:
+    '''
+    :return: list of trajectory start, list of gradient waveforms
+    :rtype: tuple[list[NDArray], list[NDArray]]
+    '''
+    return ext.getG_Shell3d\
+    (
+        int64(is3D),
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim),
+        float64(gLim),
+        float64(dt),
+        
+        float64(kRhoTht),
+    )
+
+def getG_Yarnball\
+(
+    is3D: bool = False,
+    fov: float64 = 0.256,
+    nPix: int64 = 256,
+    
+    sLim: float64 = 50 * 42.5756e6 * 0.256 / 256,
+    gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
+    dt: float64 = 10e-6,
+    
+    kRhoPhi: float64 = 0.5 / (2 * pi),
+) -> tuple[list[NDArray], list[NDArray]]:
+    '''
+    :return: list of trajectory start, list of gradient waveforms
+    :rtype: tuple[list[NDArray], list[NDArray]]
+    '''
+    return ext.getG_Yarnball\
+    (
+        int64(is3D),
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim),
+        float64(gLim),
+        float64(dt),
+        
+        float64(kRhoPhi),
+    )
+
+def getG_Seiffert\
+(
+    is3D: bool = False,
+    fov: float64 = 0.256,
+    nPix: int64 = 256,
+    
+    sLim: float64 = 50 * 42.5756e6 * 0.256 / 256,
+    gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
+    dt: float64 = 10e-6,
+    
+    m: float64 = 0.07, 
+    uMax: float64 = 20.0, 
+) -> tuple[list[NDArray], list[NDArray]]:
+    '''
+    :return: list of trajectory start, list of gradient waveforms
+    :rtype: tuple[list[NDArray], list[NDArray]]
+    '''
+    return ext.getG_Seiffert\
+    (
+        int64(is3D),
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim),
+        float64(gLim),
+        float64(dt),
+        
+        float64(m),
+        float64(uMax),
+    )
+
+def getG_Cones\
+(
+    is3D: bool = False,
+    fov: float64 = 0.256,
+    nPix: int64 = 256,
+    
+    sLim: float64 = 50 * 42.5756e6 * 0.256 / 256,
+    gLim: float64 = 50e-3 * 42.5756e6 * 0.256 / 256,
+    dt: float64 = 10e-6,
+    
+    kRhoPhi: float64 = 0.5 / (4 * pi),
+) -> tuple[list[NDArray], list[NDArray]]:
+    '''
+    :return: list of trajectory start, list of gradient waveforms
+    :rtype: tuple[list[NDArray], list[NDArray]]
+    '''
+    return ext.getG_Cones\
+    (
+        int64(is3D),
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim),
+        float64(gLim),
+        float64(dt),
+        
+        float64(kRhoPhi),
+    )
+
+def setSolverMtg(x): ext.setSolverMtg(x)
+def setTrajRev(x): ext.setTrajRev(x)
+def setGoldAng(x): ext.setGoldAng(x)
+def setShuf(x): ext.setShuf(x)
+def setMaxG0(x): ext.setMaxG0(x)
+def setMaxG1(x): ext.setMaxG1(x)
+def setExGEnd(x): ext.setExGEnd(x)
+def setMagOverSamp(x): ext.setMagOverSamp(x)
+def setMagSFS(x): ext.setMagSFS(x)
+def setMagGradRep(x): ext.setMagGradRep(x)
+def setMagTrajRep(x): ext.setMagTrajRep(x)
+def setDbgPrint(x): ext.setDbgPrint(x)

{mrarbgrad-1.1.6 → mrarbgrad-2.0.1}/mrarbgrad_src/Utility.py

@@ -8,12 +8,13 @@ goldang = (2*pi)/(1+goldrat)
 getGoldrat = lambda: goldrat
 getGoldang = lambda: goldang
 
-def rand2d(i:int|NDArray) -> NDArray:
-    ky = goldrat
-    kx = sqrt(3)
-    y = (i**1 * 1/(1+ky))%1
-    x = (i**2 * 1/(1+kx))%1
-    return vstack([y,x]).T
+def rand3d(i:int|NDArray, nAx:int=3, kx=sqrt(2), ky=sqrt(3), kz=sqrt(7)) -> NDArray:
+    return (hstack if size(i)==1 else vstack)\
+    ([
+        (i**1 * 1/(1+kx))%1,
+        (i**2 * 1/(1+ky))%1,
+        (i**3 * 1/(1+kz))%1
+    ][:nAx]).T
 
 def cvtGrad2Traj(arrG:NDArray, dtGrad:int|float, dtADC:int|float, nShift:int|float=1.0) -> tuple[NDArray, NDArray]:
     """

{mrarbgrad-1.1.6 → mrarbgrad-2.0.1}/mrarbgrad_src/__init__.py

@@ -1,6 +1,6 @@
 from .Function import calGrad4ExFunc, calGrad4ExSamp
-from .Function import getG_Cones, getG_Rosette, getG_Rosette_Trad, getG_Seiffert, getG_Shell3d, getG_Spiral, getG_VarDenSpiral, getG_Yarnball
-from .Function import setSolverMtg, setTrajRev, setGoldAng, setShuf, setMaxG0, setMaxG1, setExGEnd, setMagOv, setMagSFS, setMagGradRep, setMagTrajRep, setDbgPrint
-from .Utility import _calDiaphony, rotate, _calJacElip, _calCompElipInt, _calSphFibPt, cvtGrad2Traj, getGoldang, getGoldrat, rand2d
+from .Function import getG_Cones, getG_Rosette, getG_Rosette_Trad, getG_Seiffert, getG_Shell3d, getG_Spiral, getG_VarDenSpiral, getG_VarDenSpiral_RT, getG_Yarnball
+from .Function import setSolverMtg, setTrajRev, setGoldAng, setShuf, setMaxG0, setMaxG1, setExGEnd, setMagOverSamp, setMagSFS, setMagGradRep, setMagTrajRep, setDbgPrint
+from .Utility import _calDiaphony, rotate, _calJacElip, _calCompElipInt, _calSphFibPt, cvtGrad2Traj, getGoldang, getGoldrat, rand3d
 
 from . import trajfunc