MRArbGrad 3.0.1__tar.gz → 4.0.0__tar.gz

{mrarbgrad-3.0.1 → mrarbgrad-4.0.0/MRArbGrad.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MRArbGrad
-Version: 3.0.1
+Version: 4.0.0
 Summary: Gradient waveform design tool for arbitrary k-space trajectories.
 Author-email: Ryan <ryan_shanghaitech@proton.me>
 License-Expression: MIT
@@ -27,13 +27,13 @@ $ conda install python==3.12 -y
 
 This package is **NOT** restricted to use `Python 3.12`. Feel free to adjust at your convenience, just if the package works.
 
-To install the pip package of the proposed algorithm (including the trajectory library built on it):
+To install this package from PyPI:
 ```bash
-$ bash install.bash
+$ pip install mrarbgrad
 ```
-or
+To install this package from a local repository:
 ```bash
-$ pip install mrarbgrad
+$ bash install.bash
 ```
 
 You can also install via `pip install .` but remember to delete `*.egg-info` or pip will run into bug when uninstalling this package in current folder (see comments in `install.bash`).
@@ -41,7 +41,8 @@ You can also install via `pip install .` but remember to delete `*.egg-info` or
 ## Examples & Usages
 Examples for generating gradient waveforms for either built-in trajectory (trajectory library) or external trajectory (expressed by trajectory function or trajectory samples) can be found in the `example` folder.
 
-## Citation
-If this project helps you, please cite [our paper](https://arxiv.org/abs/2507.21625):
+## Reference
+If this project helps you, please cite [our paper](https://ieeexplore.ieee.org/document/11352950):
+
+[1] Luo R, Huang H, Miao Q, Xu J, Hu P, Qi H. Real-Time Gradient Waveform Design for Arbitrary k-Space Trajectories. IEEE Transactions on Biomedical Engineering. 2026;1–12. 
 
-[1] R. Luo, H. Huang, Q. Miao, J. Xu, P. Hu, and H. Qi, “Real-Time Gradient Waveform Design for Arbitrary k-Space Trajectories,” Sep 9, 2025, arXiv preprint arXiv:2507.21625.

{mrarbgrad-3.0.1/MRArbGrad.egg-info → mrarbgrad-4.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MRArbGrad
-Version: 3.0.1
+Version: 4.0.0
 Summary: Gradient waveform design tool for arbitrary k-space trajectories.
 Author-email: Ryan <ryan_shanghaitech@proton.me>
 License-Expression: MIT
@@ -27,13 +27,13 @@ $ conda install python==3.12 -y
 
 This package is **NOT** restricted to use `Python 3.12`. Feel free to adjust at your convenience, just if the package works.
 
-To install the pip package of the proposed algorithm (including the trajectory library built on it):
+To install this package from PyPI:
 ```bash
-$ bash install.bash
+$ pip install mrarbgrad
 ```
-or
+To install this package from a local repository:
 ```bash
-$ pip install mrarbgrad
+$ bash install.bash
 ```
 
 You can also install via `pip install .` but remember to delete `*.egg-info` or pip will run into bug when uninstalling this package in current folder (see comments in `install.bash`).
@@ -41,7 +41,8 @@ You can also install via `pip install .` but remember to delete `*.egg-info` or
 ## Examples & Usages
 Examples for generating gradient waveforms for either built-in trajectory (trajectory library) or external trajectory (expressed by trajectory function or trajectory samples) can be found in the `example` folder.
 
-## Citation
-If this project helps you, please cite [our paper](https://arxiv.org/abs/2507.21625):
+## Reference
+If this project helps you, please cite [our paper](https://ieeexplore.ieee.org/document/11352950):
+
+[1] Luo R, Huang H, Miao Q, Xu J, Hu P, Qi H. Real-Time Gradient Waveform Design for Arbitrary k-Space Trajectories. IEEE Transactions on Biomedical Engineering. 2026;1–12. 
 
-[1] R. Luo, H. Huang, Q. Miao, J. Xu, P. Hu, and H. Qi, “Real-Time Gradient Waveform Design for Arbitrary k-Space Trajectories,” Sep 9, 2025, arXiv preprint arXiv:2507.21625.

{mrarbgrad-3.0.1 → mrarbgrad-4.0.0}/README.md

@@ -13,13 +13,13 @@ $ conda install python==3.12 -y
 
 This package is **NOT** restricted to use `Python 3.12`. Feel free to adjust at your convenience, just if the package works.
 
-To install the pip package of the proposed algorithm (including the trajectory library built on it):
+To install this package from PyPI:
 ```bash
-$ bash install.bash
+$ pip install mrarbgrad
 ```
-or
+To install this package from a local repository:
 ```bash
-$ pip install mrarbgrad
+$ bash install.bash
 ```
 
 You can also install via `pip install .` but remember to delete `*.egg-info` or pip will run into bug when uninstalling this package in current folder (see comments in `install.bash`).
@@ -27,7 +27,8 @@ You can also install via `pip install .` but remember to delete `*.egg-info` or
 ## Examples & Usages
 Examples for generating gradient waveforms for either built-in trajectory (trajectory library) or external trajectory (expressed by trajectory function or trajectory samples) can be found in the `example` folder.
 
-## Citation
-If this project helps you, please cite [our paper](https://arxiv.org/abs/2507.21625):
+## Reference
+If this project helps you, please cite [our paper](https://ieeexplore.ieee.org/document/11352950):
+
+[1] Luo R, Huang H, Miao Q, Xu J, Hu P, Qi H. Real-Time Gradient Waveform Design for Arbitrary k-Space Trajectories. IEEE Transactions on Biomedical Engineering. 2026;1–12. 
 
-[1] R. Luo, H. Huang, Q. Miao, J. Xu, P. Hu, and H. Qi, “Real-Time Gradient Waveform Design for Arbitrary k-Space Trajectories,” Sep 9, 2025, arXiv preprint arXiv:2507.21625.

{mrarbgrad-3.0.1 → mrarbgrad-4.0.0}/example/example_BuiltInTraj.py

@@ -29,10 +29,10 @@ mag.setDbgPrint(1) # enable debug info (for benchmark purpose)
 # lstArrK0, lstArrGrad = mag.getG_Spiral(**argCom); nAx = 2
 # lstArrK0, lstArrGrad = mag.getG_VDSpiral(**argCom); nAx = 2
 # lstArrK0, lstArrGrad = mag.getG_VDSpiral_RT(**argCom); nAx = 2
-lstArrK0, lstArrGrad = mag.getG_Rosette(**argCom); nAx = 2
+# lstArrK0, lstArrGrad = mag.getG_Rosette(**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-3.0.1 → mrarbgrad-4.0.0}/mrarbgrad_src/Function.py

@@ -142,7 +142,6 @@ def getG_VDSpiral_RT\
     
     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
@@ -158,9 +157,7 @@ def getG_VDSpiral_RT\
         float64(dt),
         
         float64(kRhoPhi0),
-        float64(kRhoPhi1),
-        
-        int64(nAcq)
+        float64(kRhoPhi1)
     )
 
 def getG_Rosette\
@@ -285,6 +282,33 @@ def getG_Yarnball\
         float64(kRhoPhi),
     )
 
+def getG_Yarnball_RT\
+(
+    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_RT\
+    (
+        float64(fov),
+        int64(nPix),
+        
+        float64(sLim),
+        float64(gLim),
+        float64(dt),
+        
+        float64(kRhoPhi)
+    )
+
 def getG_Seiffert\
 (
     fov: float64 = 0.256,

{mrarbgrad-3.0.1 → mrarbgrad-4.0.0}/mrarbgrad_src/__init__.py

@@ -1,5 +1,5 @@
 from .Function import calGrad4ExFunc, calGrad4ExSamp
-from .Function import getG_Cones, getG_Rosette, getG_Rosette_Trad, getG_Seiffert, getG_Shell3d, getG_Spiral, getG_VDSpiral, getG_VDSpiral_RT, getG_Yarnball
+from .Function import getG_Cones, getG_Rosette, getG_Rosette_Trad, getG_Seiffert, getG_Shell3d, getG_Spiral, getG_VDSpiral, getG_VDSpiral_RT, getG_Yarnball, getG_Yarnball_RT
 from .Function import setSolverMtg, setTrajRev, setGoldAng, setShuf, setMaxG0, setMaxG1, setMagOverSamp, setMagSFS, setMagGradRep, setMagTrajRep, setDbgPrint
 from .Utility import _calDiaphony, rotate, _calJacElip, _calCompElipInt, _calSphFibPt, cvtGrad2Traj, getGoldang, getGoldrat, rand3d, gradClip
 

{mrarbgrad-3.0.1 → mrarbgrad-4.0.0}/mrarbgrad_src/ext/mag/Mag.cpp

@@ -2,9 +2,7 @@
 #include <algorithm>
 #include <cstdio>
 #include "../utility/global.h"
-#include "../utility/LinIntp.h"
 #include "Mag.h"
-#include "../utility/SplineIntp.h"
 
 i64 gMag_oversamp = -1; // oversample ratio, overwrite the set value
 bool gMag_enSFS = false; // Single Forward Sweep flag
@@ -14,18 +12,28 @@ i64 gMag_nTrajSamp = 1000; // num. of samp. when doing Traj. Rep.
 
 Mag::Mag()
 {
+    // for solver
     m_dt = 10e-6; m_oversamp = 8;
-    i64 nSampReserve = i64(100e-3/m_dt*m_oversamp); // reserve for 100ms
+    i64 nSampReserve = i64(100e-3/m_dt); // reserve for 100ms
 
-    m_vf64P_Bac.reserve(nSampReserve);
-    m_vv3G_Bac.reserve(nSampReserve);
-    m_vf64GNorm_Bac.reserve(nSampReserve);
+    m_vf64P_Bac.reserve(nSampReserve*m_oversamp);
+    m_vv3G_Bac.reserve(nSampReserve*m_oversamp);
+    m_vf64GNorm_Bac.reserve(nSampReserve*m_oversamp);
 
-    m_vf64P_For.reserve(nSampReserve);
-    m_vv3G_For.reserve(nSampReserve);
+    m_vf64P_For.reserve(nSampReserve*m_oversamp);
+    m_vv3G_For.reserve(nSampReserve*m_oversamp);
+
+    m_vf64P.reserve(nSampReserve);
+    m_vv3G.reserve(nSampReserve);
+    
+    // for trajectory reparameterization
+    m_vv3TrajSamp.resize(gMag_nTrajSamp);
+
+    m_intp.init(nSampReserve*m_oversamp);
+    m_intp.m_eSearchMode = Intp::ECached;
 }
 
-bool Mag::setup
+bool Mag::init
     (
         TrajFunc* ptTraj,
         f64 sLim, f64 gLim,
@@ -42,15 +50,14 @@ bool Mag::setup
 
     if (gMag_enTrajRep)
     {
-        vv3 vv3TrajSamp(gMag_nTrajSamp);
         f64 p0 = ptTraj->getP0();
         f64 p1 = ptTraj->getP1();
         for (i64 i = 0; i < gMag_nTrajSamp; ++i)
         {
             f64 p = p0 + (p1-p0) * (i)/f64(gMag_nTrajSamp-1);
-            ptTraj->getK(&vv3TrajSamp[i], p);
+            ptTraj->getK(&m_vv3TrajSamp[i], p);
         }
-        m_sptfTraj = Spline_TrajFunc(vv3TrajSamp);
+        m_sptfTraj = Spline_TrajFunc(m_vv3TrajSamp);
         m_ptfTraj = &m_sptfTraj;
     }
     else
@@ -61,7 +68,7 @@ bool Mag::setup
     return true;
 }
 
-bool Mag::setup
+bool Mag::init
     (
         const vv3& vv3TrajSamp,
         f64 sLim, f64 gLim,
@@ -166,8 +173,8 @@ bool Mag::solve(vv3* pvv3G, vf64* pvf64P)
     bool ret = true;
     f64 p0 = m_ptfTraj->getP0();
     f64 p1 = m_ptfTraj->getP1();
-    vv3 vv3G; if (!pvv3G) pvv3G = &vv3G;
-    vf64 vf64P; if (!pvf64P) pvf64P = &vf64P;
+    m_vv3G.clear(); if (!pvv3G) pvv3G = &m_vv3G;
+    m_vf64P.clear(); if (!pvf64P) pvf64P = &m_vf64P;
     bool isQDESucc = true; (void)isQDESucc;
     i64 nIter = 0;
 
@@ -217,10 +224,7 @@ bool Mag::solve(vv3* pvv3G, vf64* pvf64P)
     std::reverse(m_vf64P_Bac.begin(), m_vf64P_Bac.end());
     std::reverse(m_vf64GNorm_Bac.begin(), m_vf64GNorm_Bac.end());
 
-    LinIntp intp;
-    // SplineIntp intp;
-    intp.m_eSearchMode = Intp::ECached;
-    if (!gMag_enSFS) intp.fit(m_vf64P_Bac, m_vf64GNorm_Bac);
+    if (!gMag_enSFS) m_intp.fit(m_vf64P_Bac, m_vf64GNorm_Bac);
     
     nIter += m_vf64P_Bac.size();
 
@@ -231,7 +235,7 @@ bool Mag::solve(vv3* pvv3G, vf64* pvf64P)
     f64 g0Norm = m_g0Norm;
     g0Norm = std::min(g0Norm, m_gLim);
     g0Norm = std::min(g0Norm, std::sqrt(m_sLim*getCurRad(p0)));
-    g0Norm = std::min(g0Norm, gMag_enSFS?1e15:intp.eval(p0));
+    g0Norm = std::min(g0Norm, gMag_enSFS?1e15:m_intp.eval(p0));
     v3 g0 = g0Unit * g0Norm;
 
     m_vf64P_For.clear(); m_vf64P_For.push_back(p0);
@@ -252,7 +256,7 @@ bool Mag::solve(vv3* pvv3G, vf64* pvf64P)
         }
         else
         {
-            f64 gNormBac = intp.eval(p);
+            f64 gNormBac = m_intp.eval(p);
             gNorm = std::min(gNorm, gNormBac);
             if (gNormBac<=0)
             {
@@ -410,17 +414,19 @@ f64 Mag::ramp_back(vv3* pvv3GRamp, const v3& g1, const v3& g1Des, i64 nSamp, f64
 bool Mag::revGrad(v3* pv3M0Dst, vv3* pvv3Dst, const v3& v3M0Src, const vv3& vv3Src, f64 dt)
 {
     bool ret = true;
+    i64 nSamp = vv3Src.size();
 
-    if(vv3Src.size() <= 1) ret = false;
+    ASSERT(nSamp > 1);
+    ASSERT((i64)pvv3Dst->capacity() >= nSamp);
 
     // derive Total M0
     *pv3M0Dst = v3M0Src + calM0(vv3Src, dt);
     
     // reverse gradient
-    *pvv3Dst = vv3(vv3Src.rbegin(), vv3Src.rend());
-    for (int64_t i = 0; i < (i64)pvv3Dst->size(); ++i)
+    pvv3Dst->resize(nSamp);
+    for (int64_t i = 0; i < nSamp; ++i)
     {
-        (*pvv3Dst)[i] *= -1;
+        (*pvv3Dst)[i] = vv3Src[nSamp-1-i]*(-1);
     }
 
     return ret;

{mrarbgrad-3.0.1 → mrarbgrad-4.0.0}/mrarbgrad_src/ext/mag/Mag.h

@@ -10,45 +10,58 @@
 #include "../utility/v3.h"
 #include "../traj/TrajFunc.h"
 #include "../utility/SplineIntp.h"
+#include "../utility/LinIntp.h"
+
+extern i64 gMag_oversamp;
+extern bool gMag_enSFS;
+extern bool gMag_enGradRep;
+extern bool gMag_enTrajRep;
+extern i64 gMag_nTrajSamp;
 
 // virtual TrajFunc, take in discrete samples and construct a Segmentied Cubic Polynomial function
 class Spline_TrajFunc: public TrajFunc
 {
 public:
     Spline_TrajFunc():
-        TrajFunc(0,0)
+        TrajFunc(0,0),
+        m_intpX(gMag_nTrajSamp),
+        m_intpY(gMag_nTrajSamp),
+        m_intpZ(gMag_nTrajSamp)
     {}
 
     Spline_TrajFunc(const vv3& vv3K):
-        TrajFunc(0,0)
+        TrajFunc(0,0),
+        m_intpX(vv3K.size()),
+        m_intpY(vv3K.size()),
+        m_intpZ(vv3K.size())
     {
         i64 lNTrajSamp = vv3K.size();
 
-        vf64 vdP(lNTrajSamp);
-        vdP[0] = 0;
+        vf64 vf64P(lNTrajSamp);
+        vf64P[0] = 0;
         for (i64 i = 1; i < lNTrajSamp; ++i)
         {
-            vdP[i] = vdP[i-1] + v3::norm(vv3K[i] - vv3K[i-1]);
+            vf64P[i] = vf64P[i-1] + v3::norm(vv3K[i] - vv3K[i-1]);
         }
 
-        vf64 vdX(lNTrajSamp), vdY(lNTrajSamp), vdZ(lNTrajSamp);
+        vf64 vf64X(lNTrajSamp), vf64Y(lNTrajSamp), vf64Z(lNTrajSamp);
         for (i64 i = 0; i < lNTrajSamp; ++i)
         {
-           vdX[i] =  vv3K[i].x;
-           vdY[i] =  vv3K[i].y;
-           vdZ[i] =  vv3K[i].z;
+           vf64X[i] =  vv3K[i].x;
+           vf64Y[i] =  vv3K[i].y;
+           vf64Z[i] =  vv3K[i].z;
         }
 
         m_intpX.m_eSearchMode = Intp::ECached;
         m_intpY.m_eSearchMode = Intp::ECached;
         m_intpZ.m_eSearchMode = Intp::ECached;
 
-        m_intpX.fit(vdP, vdX); 
-        m_intpY.fit(vdP, vdY);
-        m_intpZ.fit(vdP, vdZ);
+        m_intpX.fit(vf64P, vf64X); 
+        m_intpY.fit(vf64P, vf64Y);
+        m_intpZ.fit(vf64P, vf64Z);
 
-        m_p0 = *vdP.begin();
-        m_p1 = *vdP.rbegin();
+        m_p0 = *vf64P.begin();
+        m_p1 = *vf64P.rbegin();
     }
     
     bool getK(v3* k, f64 p)
@@ -60,20 +73,20 @@ public:
         return true;
     }
 
-    bool getDkDp(v3* pv3K, f64 p) const
+    bool getDkDp(v3* dkdp, f64 p) const
     {
-        pv3K->x = m_intpX.eval(p, 1);
-        pv3K->y = m_intpY.eval(p, 1);
-        pv3K->z = m_intpZ.eval(p, 1);
+        dkdp->x = m_intpX.eval(p, 1);
+        dkdp->y = m_intpY.eval(p, 1);
+        dkdp->z = m_intpZ.eval(p, 1);
 
         return true;
     }
 
-    bool getD2kDp2(v3* pv3K, f64 p) const
+    bool getD2kDp2(v3* d2kdp2, f64 p) const
     {
-        pv3K->x = m_intpX.eval(p, 2);
-        pv3K->y = m_intpY.eval(p, 2);
-        pv3K->z = m_intpZ.eval(p, 2);
+        d2kdp2->x = m_intpX.eval(p, 2);
+        d2kdp2->y = m_intpY.eval(p, 2);
+        d2kdp2->z = m_intpZ.eval(p, 2);
 
         return true;
     }
@@ -85,14 +98,14 @@ class Mag
 {
 public:
     Mag();
-    bool setup
+    bool init
     (
         TrajFunc* ptTraj,
         f64 sLim, f64 gLim,
         f64 dt=10e-6, i64 oversamp=10, 
         f64 dG0Norm=0e0, f64 dG1Norm=0e0
     );
-    bool setup
+    bool init
     (
         const vv3& vv3TrajSamp,
         f64 sLim, f64 gLim,
@@ -129,9 +142,12 @@ private:
     vf64 m_vf64P_Bac;
     vv3 m_vv3G_Bac;
     vf64 m_vf64GNorm_Bac;
-
     vf64 m_vf64P_For;
     vv3 m_vv3G_For;
+    vf64 m_vf64P;
+    vv3 m_vv3G;
+    vv3 m_vv3TrajSamp;
+    LinIntp m_intp; // SplineIntp m_intp;
 
     bool sovQDE(f64* psol0, f64* psol1, f64 a, f64 b, f64 c);
     f64 getCurRad(f64 p);

{mrarbgrad-3.0.1 → mrarbgrad-4.0.0}/mrarbgrad_src/ext/main.cpp

@@ -304,15 +304,10 @@ public:
         }
     }
 
-    virtual bool getGRO(vv3* pvv3G, i64 iAcq)
+    virtual bool getGrad(v3* pv3M0PE, vv3* pvv3G, i64 iAcq)
     {
-        *pvv3G = m_vv3G;
-        return true;
-    }
-
-    virtual bool getM0PE(v3* pv3M0PE, i64 iAcq)
-    {
-        ptfTrajFunc->getK0(pv3M0PE);
+        if (pv3M0PE) ptfTrajFunc->getK0(pv3M0PE);
+        if (pvv3G) *pvv3G = m_vv3G;
         return true;
     }
 
@@ -347,7 +342,7 @@ PyObject* calGrad4ExFunc(PyObject* self, PyObject* const* args, Py_ssize_t narg)
     );
 
     vv3 vv3G;
-    traj.getGRO(&vv3G, 0);
+    traj.getGrad(NULL, &vv3G, 0);
     vf64 vf64P;
     traj.getPRO(&vf64P, 0);
 
@@ -373,7 +368,7 @@ PyObject* calGrad4ExSamp(PyObject* self, PyObject* const* args, Py_ssize_t narg)
         );
         
         vv3 vv3G;
-        traj.getGRO(&vv3G, 0);
+        traj.getGrad(NULL, &vv3G, 0);
         vf64 vf64P;
         traj.getPRO(&vf64P, 0);
 
@@ -400,8 +395,9 @@ bool getG(MrTraj* pmt, vv3* pvv3M0PE, vvv3* pvvv3GRO)
         i64 _i = enShuf?vi64ShufSeq[i]:i;
         
         // get M0PE and GRO
-        vv3 vv3GRO; ret &= pmt->getGRO(&vv3GRO, _i);
-        v3 v3M0PE; ret &= pmt->getM0PE(&v3M0PE, _i);
+        vv3 vv3GRO;
+        v3 v3M0PE;
+        ret &= pmt->getGrad(&v3M0PE, &vv3GRO, _i);
 
         // reverse gradient if needed
         if (gMain_enTrajRev) ret &= Mag::revGrad(&v3M0PE, &vv3GRO, v3M0PE, vv3GRO, dt);
@@ -455,7 +451,7 @@ PyObject* getG_VDSpiral(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 
 PyObject* getG_VDSpiral_RT(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 8);
+    checkNarg(narg, 7);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -463,8 +459,7 @@ PyObject* getG_VDSpiral_RT(PyObject* self, PyObject* const* args, Py_ssize_t nar
 
     f64 kRhoPhi0 = (f64)PyFloat_AsDouble(args[5]);
     f64 kRhoPhi1 = (f64)PyFloat_AsDouble(args[6]);
-    i64 nAcq = (i64)PyLong_AsLong(args[7]);
-    VDSpiral_RT traj(objGeoPara, objGradPara, kRhoPhi0, kRhoPhi1, nAcq);
+    VDSpiral_RT traj(objGeoPara, objGradPara, kRhoPhi0, kRhoPhi1);
 
     vv3 vv3K0;
     vvv3 vvv3G;
@@ -557,6 +552,24 @@ PyObject* getG_Yarnball(PyObject* self, PyObject* const* args, Py_ssize_t narg)
     return Py_BuildValue("OO", cvtVv3toList(vv3K0), cvtVvv3toList(vvv3G));
 }
 
+PyObject* getG_Yarnball_RT(PyObject* self, PyObject* const* args, Py_ssize_t narg)
+{
+    checkNarg(narg, 6);
+
+    MrTraj::GeoPara objGeoPara;
+    MrTraj::GradPara objGradPara;
+    getGeoGradPara(args, &objGeoPara, &objGradPara);
+
+    f64 kRhoPhi = (f64)PyFloat_AsDouble(args[5]);
+    Yarnball_RT traj(objGeoPara, objGradPara, kRhoPhi);
+
+    vv3 vv3K0;
+    vvv3 vvv3G;
+    getG(&traj, &vv3K0, &vvv3G);
+
+    return Py_BuildValue("OO", cvtVv3toList(vv3K0), cvtVvv3toList(vvv3G));
+}
+
 PyObject* getG_Seiffert(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
     checkNarg(narg, 7);
@@ -634,7 +647,6 @@ PyObject* setMaxG0(PyObject* self, PyObject* const* args, Py_ssize_t narg)
     bool enMaxG0 = PyLong_AsLong(args[0]);
     if (enMaxG0) gMrTraj_g0Norm = 1e6;
     else gMrTraj_g0Norm = 0e0;
-    PRINT(gMrTraj_g0Norm); // test
     Py_INCREF(Py_None);
     return Py_None;
 }
@@ -646,7 +658,6 @@ PyObject* setMaxG1(PyObject* self, PyObject* const* args, Py_ssize_t narg)
     bool enMaxG1 = PyLong_AsLong(args[0]);
     if (enMaxG1) gMrTraj_g1Norm = 1e6;
     else gMrTraj_g1Norm = 0e0;
-    PRINT(gMrTraj_g1Norm); // test
     Py_INCREF(Py_None);
     return Py_None;
 }
@@ -714,6 +725,7 @@ static PyMethodDef aMeth[] =
     {"getG_Rosette_Trad", (PyCFunction)getG_Rosette_Trad, METH_FASTCALL, ""},
     {"getG_Shell3d", (PyCFunction)getG_Shell3d, METH_FASTCALL, ""},
     {"getG_Yarnball", (PyCFunction)getG_Yarnball, METH_FASTCALL, ""},
+    {"getG_Yarnball_RT", (PyCFunction)getG_Yarnball_RT, METH_FASTCALL, ""},
     {"getG_Seiffert", (PyCFunction)getG_Seiffert, METH_FASTCALL, ""},
     {"getG_Cones", (PyCFunction)getG_Cones, METH_FASTCALL, ""},
     {"setSolverMtg", (PyCFunction)setSolverMtg, METH_FASTCALL, ""},

{mrarbgrad-3.0.1 → mrarbgrad-4.0.0}/mrarbgrad_src/ext/traj/Cones.h

@@ -55,7 +55,7 @@ public:
         {
             f64 tht0 = getTht0_Cones(i, m_nSet);
             m_vptfBaseTraj[i] = new Cones_TrajFun(kRhoPhi, tht0);
-            if(!m_vptfBaseTraj[i]) throw std::runtime_error("out of memory");
+            ASSERT(m_vptfBaseTraj[i]!=NULL);
 
             calGrad(&m_vv3BaseM0PE[i], &m_vvv3BaseGRO[i], NULL, *m_vptfBaseTraj[i], m_objGradPara);
             m_nSampMax = std::max(m_nSampMax, (i64)m_vvv3BaseGRO[i].size());
@@ -95,7 +95,7 @@ public:
         }
     }
     
-    virtual bool getGRO(vv3* pvv3GRO, i64 iAcq)
+    virtual bool getGrad(v3* pv3M0PE, vv3* pvv3GRO, i64 iAcq)
     {
         bool ret = true;
         iAcq %= m_nAcq;
@@ -103,22 +103,16 @@ public:
         i64 iRot = m_vi64RotIdx[iAcq];
         f64 phiStep = calRotAng(m_vi64NRot[iSet]);
 
-        *pvv3GRO = m_vvv3BaseGRO[iSet];
-        ret &= v3::rotate(pvv3GRO, 2, phiStep*iRot, *pvv3GRO);
-
-        return ret;
-    }
-
-    virtual bool getM0PE(v3* pv3M0PE, i64 iAcq)
-    {
-        bool ret = true;
-        iAcq %= m_nAcq;
-        i64 iSet = m_vi64SetIdx[iAcq];
-        i64 iRot = m_vi64RotIdx[iAcq];
-        f64 phiStep = calRotAng(m_vi64NRot[iSet]);
-
-        *pv3M0PE = m_vv3BaseM0PE[iSet];
-        ret &= v3::rotate(pv3M0PE, 2, phiStep*iRot, *pv3M0PE);
+        if (pv3M0PE)
+        {
+            *pv3M0PE = m_vv3BaseM0PE[iSet];
+            ret &= v3::rotate(pv3M0PE, 2, phiStep * iRot, *pv3M0PE);
+        }
+        if (pvv3GRO)
+        {
+            *pvv3GRO = m_vvv3BaseGRO[iSet];
+            ret &= v3::rotate(pvv3GRO, 2, phiStep * iRot, *pvv3GRO);
+        }
 
         return ret;
     }