MRArbGrad 4.1.0__tar.gz → 4.2.0__tar.gz

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0/MRArbGrad.egg-info}/PKG-INFO

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

{mrarbgrad-4.1.0/MRArbGrad.egg-info → mrarbgrad-4.2.0}/PKG-INFO

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

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0}/mrarbgrad_src/Function.py

@@ -371,15 +371,31 @@ 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 setMagGradSamp(x): ext.setMagGradSamp(x)
+def setMagTrajSamp(x): ext.setMagTrajSamp(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)
 
-def loadF64(hdr:str, bin:str) -> list[NDArray]:
+def saveF64(hdr:str, bin:str, arr:NDArray) -> bool:
     """
-    load saved vector file (float64)
+    save vector file (float64)
+
+    Args:
+        hdr (str): header (hdr) file path
+        bin (str): bin file path
+        arr (NDarray): array to be saved
+
+    Returns:
+        bool: True for success
+    """
+    return ext.saveF64(str(hdr), str(bin), arr)
+
+def loadF64(hdr:str, bin:str) -> list[NDArray]|None:
+    """
+    load vector file (float64)
 
     Args:
         hdr (str): header (hdr) file path
@@ -390,9 +406,23 @@ def loadF64(hdr:str, bin:str) -> list[NDArray]:
     """
     return ext.loadF64(str(hdr), str(bin))
 
-def loadF32(hdr:str, bin:str) -> list[NDArray]:
+def saveF32(hdr:str, bin:str, arr:NDArray) -> bool:
+    """
+    save vector file (float32)
+
+    Args:
+        hdr (str): header (hdr) file path
+        bin (str): bin file path
+        arr (NDarray): array to be saved
+
+    Returns:
+        bool: True for success
+    """
+    return ext.saveF32(str(hdr), str(bin), arr)
+
+def loadF32(hdr:str, bin:str) -> list[NDArray]|None:
     """
-    load saved vector file (float32)
+    load vector file (float32)
 
     Args:
         hdr (str): header (hdr) file path

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0}/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_VDSpiral, getG_VDSpiral_RT, getG_Yarnball, getG_Yarnball_RT
-from .Function import setSolverMtg, setTrajRev, setGoldAng, setShuf, setMaxG0, setMaxG1, setMagOverSamp, setMagSFS, setMagGradRep, setMagTrajRep, setDbgPrint, loadF64, loadF32
+from .Function import setSolverMtg, setTrajRev, setGoldAng, setShuf, setMaxG0, setMaxG1, setMagGradSamp, setMagTrajSamp, setMagOverSamp, setMagSFS, setMagGradRep, setMagTrajRep, setDbgPrint, saveF64, loadF64, saveF32, loadF32
 from .Utility import _calDiaphony, rotate, _calJacElip, _calCompElipInt, _calSphFibPt, cvtGrad2Traj, getGoldang, getGoldrat, rand3d, gradClip
 
 from . import trajfunc

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0}/mrarbgrad_src/ext/mag/Mag.cpp

@@ -8,29 +8,31 @@ i64 gMag_oversamp = -1; // oversample ratio, overwrite the set value
 bool gMag_enSFS = false; // Single Forward Sweep flag
 bool gMag_enGradRep = true; // Gradient Reparameterization
 bool gMag_enTrajRep = true; // use trajectory reparameterization for MAG solver
-i64 gMag_nTrajSamp = 1000; // num. of samp. when doing Traj. Rep.
 
-Mag::Mag()
+Mag::Mag(i64 nGradSampRsv, i64 nTrajSampRsv)
 {
     // for solver
-    m_dt = 10e-6; m_oversamp = 8;
-    i64 nSampReserve = i64(100e-3/m_dt); // reserve for 100ms
+    if (nGradSampRsv)
+    {
+        m_vf64P_Bac.reserve(nGradSampRsv * 8);
+        m_vv3G_Bac.reserve(nGradSampRsv * 8);
+        m_vf64GNorm_Bac.reserve(nGradSampRsv * 8);
 
-    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(nGradSampRsv * 8);
+        m_vv3G_For.reserve(nGradSampRsv * 8);
 
-    m_vf64P_For.reserve(nSampReserve*m_oversamp);
-    m_vv3G_For.reserve(nSampReserve*m_oversamp);
+        m_vf64P.reserve(nGradSampRsv);
+        m_vv3G.reserve(nGradSampRsv);
 
-    m_vf64P.reserve(nSampReserve);
-    m_vv3G.reserve(nSampReserve);
-    
-    // for trajectory reparameterization
-    m_vv3TrajSamp.resize(gMag_nTrajSamp);
+        m_intp.init(nGradSampRsv * 8);
+        m_intp.m_eSearchMode = Intp::ECached;
+    }
 
-    m_intp.init(nSampReserve*m_oversamp);
-    m_intp.m_eSearchMode = Intp::ECached;
+    // for trajectory reparameterization
+    if (gMrTraj_nTrajSampRsv)
+    {
+        m_vv3TrajSamp.resize(gMrTraj_nTrajSampRsv);
+    }
 }
 
 bool Mag::init
@@ -52,9 +54,9 @@ bool Mag::init
     {
         f64 p0 = ptTraj->getP0();
         f64 p1 = ptTraj->getP1();
-        for (i64 i = 0; i < gMag_nTrajSamp; ++i)
+        for (i64 i = 0; i < gMrTraj_nTrajSampRsv; ++i)
         {
-            f64 p = p0 + (p1-p0) * (i)/f64(gMag_nTrajSamp-1);
+            f64 p = p0 + (p1-p0) * (i)/f64(gMrTraj_nTrajSampRsv-1);
             ptTraj->getK(&m_vv3TrajSamp[i], p);
         }
         m_sptfTraj = Spline_TrajFunc(m_vv3TrajSamp);

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0}/mrarbgrad_src/ext/mag/Mag.h

@@ -16,7 +16,7 @@ extern i64 gMag_oversamp;
 extern bool gMag_enSFS;
 extern bool gMag_enGradRep;
 extern bool gMag_enTrajRep;
-extern i64 gMag_nTrajSamp;
+extern i64 gMrTraj_nTrajSampRsv;
 
 // virtual TrajFunc, take in discrete samples and construct a Segmentied Cubic Polynomial function
 class Spline_TrajFunc: public TrajFunc
@@ -24,9 +24,9 @@ class Spline_TrajFunc: public TrajFunc
 public:
     Spline_TrajFunc():
         TrajFunc(0,0),
-        m_intpX(gMag_nTrajSamp),
-        m_intpY(gMag_nTrajSamp),
-        m_intpZ(gMag_nTrajSamp)
+        m_intpX(gMrTraj_nTrajSampRsv),
+        m_intpY(gMrTraj_nTrajSampRsv),
+        m_intpZ(gMrTraj_nTrajSampRsv)
     {}
 
     Spline_TrajFunc(const vv3& vv3K):
@@ -97,19 +97,19 @@ protected:
 class Mag
 {
 public:
-    Mag();
+    Mag(i64 nSampReserve=0, i64 nTrajSampRsv=0);
     bool init
     (
         TrajFunc* ptTraj,
         f64 sLim, f64 gLim,
-        f64 dt=10e-6, i64 oversamp=10, 
+        f64 dt=10e-6, i64 oversamp=8, 
         f64 dG0Norm=0e0, f64 dG1Norm=0e0
     );
     bool init
     (
         const vv3& vv3TrajSamp,
         f64 sLim, f64 gLim,
-        f64 dt=10e-6, i64 oversamp=10, 
+        f64 dt=10e-6, i64 oversamp=8, 
         f64 dG0Norm=0e0, f64 dG1Norm=0e0
     );
     ~Mag();

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0}/mrarbgrad_src/ext/main.cpp

@@ -17,6 +17,8 @@
 #include "traj/Cones.h"
 #include "utility/SplineIntp.h"
 
+typedef std::list<vv3> lvv3;
+
 bool gMain_enTrajRev (0);
 bool gMain_enGoldAng (0);
 bool gMain_enShuffle (0);
@@ -133,14 +135,9 @@ bool cvtNpa2Vf64(PyObject* pNumpyArray, vf64* pvf64Out)
     return true;
 }
 
-bool inline checkNarg(i64 nArg, i64 nArgExp)
+bool inline chkNarg(i64 nArg, i64 nArgExp)
 {
-    if (nArg != nArgExp)
-    {
-        printf("wrong num. of arg, narg=%ld, %ld expected\n", (long)nArg, (long)nArgExp);
-        abort();
-        return false;
-    }
+    ASSERT (nArg == nArgExp);
     return true;
 }
 
@@ -187,18 +184,13 @@ public:
         PyObject* _pPyObj_v3 = pPyObj_v3;
         pPyObj_v3 = PyArray_FROM_OTF(pPyObj_v3, NPY_FLOAT64, NPY_ARRAY_CARRAY);
         Py_DECREF(_pPyObj_v3);
-        if (PyArray_SIZE((PyArrayObject*)pPyObj_v3) != 3)
-        {
-            PyErr_SetString(PyExc_RuntimeError, "the return value of getK / getDkDp / getD2kDp2 must be size-3.\n");
-            PyErr_PrintEx(-1);
-            std::abort();
-            return false;
-        }
+        ASSERT (PyArray_SIZE((PyArrayObject*)pPyObj_v3) == 3);
 
         k->x = *(f64*)PyArray_GETPTR1((PyArrayObject*)pPyObj_v3, 0);
         k->y = *(f64*)PyArray_GETPTR1((PyArrayObject*)pPyObj_v3, 1);
         k->z = *(f64*)PyArray_GETPTR1((PyArrayObject*)pPyObj_v3, 2);
-
+        
+        Py_DECREF(pPyObj_v3);
         return true;
     }
 
@@ -215,18 +207,13 @@ public:
         PyObject* _pPyObj_v3 = pPyObj_v3;
         pPyObj_v3 = PyArray_FROM_OTF(pPyObj_v3, NPY_FLOAT64, NPY_ARRAY_CARRAY);
         Py_DECREF(_pPyObj_v3);
-        if (PyArray_SIZE((PyArrayObject*)pPyObj_v3) != 3)
-        {
-            PyErr_SetString(PyExc_RuntimeError, "the return value of getK / getDkDp / getD2kDp2 must be size-3.\n");
-            PyErr_PrintEx(-1);
-            std::abort();
-            return false;
-        }
+        ASSERT (PyArray_SIZE((PyArrayObject*)pPyObj_v3) == 3);
 
         k->x = *(f64*)PyArray_GETPTR1((PyArrayObject*)pPyObj_v3, 0);
         k->y = *(f64*)PyArray_GETPTR1((PyArrayObject*)pPyObj_v3, 1);
         k->z = *(f64*)PyArray_GETPTR1((PyArrayObject*)pPyObj_v3, 2);
 
+        Py_DECREF(pPyObj_v3);
         return true;
     }
 
@@ -243,18 +230,13 @@ public:
         PyObject* _pPyObj_v3 = pPyObj_v3;
         pPyObj_v3 = PyArray_FROM_OTF(pPyObj_v3, NPY_FLOAT64, NPY_ARRAY_CARRAY);
         Py_DECREF(_pPyObj_v3);
-        if (PyArray_SIZE((PyArrayObject*)pPyObj_v3) != 3)
-        {
-            PyErr_SetString(PyExc_RuntimeError, "the return value of getK / getDkDp / getD2kDp2 must be size-3.\n");
-            PyErr_PrintEx(-1);
-            std::abort();
-            return false;
-        }
+        ASSERT (PyArray_SIZE((PyArrayObject*)pPyObj_v3) != 3);
 
         k->x = *(f64*)PyArray_GETPTR1((PyArrayObject*)pPyObj_v3, 0);
         k->y = *(f64*)PyArray_GETPTR1((PyArrayObject*)pPyObj_v3, 1);
         k->z = *(f64*)PyArray_GETPTR1((PyArrayObject*)pPyObj_v3, 2);
 
+        Py_DECREF(pPyObj_v3);
         return true;
     }
 protected:
@@ -325,7 +307,7 @@ private:
 
 PyObject* calGrad4ExFunc(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 10);
+    chkNarg(narg, 10);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -353,7 +335,7 @@ PyObject* calGrad4ExSamp(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
     try
     {
-        checkNarg(narg, 6);
+        chkNarg(narg, 6);
 
         MrTraj::GeoPara objGeoPara;
         MrTraj::GradPara objGradPara;
@@ -410,7 +392,7 @@ bool getG(MrTraj* pmt, vv3* pvv3M0PE, vvv3* pvvv3GRO)
 
 PyObject* getG_Spiral(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 7);
+    chkNarg(narg, 7);
     
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -430,7 +412,7 @@ PyObject* getG_Spiral(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 
 PyObject* getG_VDSpiral(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 8);
+    chkNarg(narg, 8);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -451,7 +433,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, 7);
+    chkNarg(narg, 7);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -470,7 +452,7 @@ PyObject* getG_VDSpiral_RT(PyObject* self, PyObject* const* args, Py_ssize_t nar
 
 PyObject* getG_Rosette(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 9);
+    chkNarg(narg, 9);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -494,7 +476,7 @@ PyObject* getG_Rosette(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 
 PyObject* getG_Rosette_Trad(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 10);
+    chkNarg(narg, 10);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -518,7 +500,7 @@ PyObject* getG_Rosette_Trad(PyObject* self, PyObject* const* args, Py_ssize_t na
 
 PyObject* getG_Shell3d(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 6);
+    chkNarg(narg, 6);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -536,7 +518,7 @@ PyObject* getG_Shell3d(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 
 PyObject* getG_Yarnball(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 6);
+    chkNarg(narg, 6);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -554,7 +536,7 @@ PyObject* getG_Yarnball(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 
 PyObject* getG_Yarnball_RT(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 6);
+    chkNarg(narg, 6);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -572,7 +554,7 @@ PyObject* getG_Yarnball_RT(PyObject* self, PyObject* const* args, Py_ssize_t nar
 
 PyObject* getG_Seiffert(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 7);
+    chkNarg(narg, 7);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -591,7 +573,7 @@ PyObject* getG_Seiffert(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 
 PyObject* getG_Cones(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 6);
+    chkNarg(narg, 6);
 
     MrTraj::GeoPara objGeoPara;
     MrTraj::GradPara objGradPara;
@@ -610,7 +592,7 @@ PyObject* getG_Cones(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 PyObject* setSolverMtg(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
     extern bool gMrTraj_enMtg;
-    checkNarg(narg, 1);
+    chkNarg(narg, 1);
     gMrTraj_enMtg = PyLong_AsLong(args[0]);
     Py_INCREF(Py_None);
     return Py_None;
@@ -618,7 +600,7 @@ PyObject* setSolverMtg(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 
 PyObject* setTrajRev(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 1);
+    chkNarg(narg, 1);
     gMain_enTrajRev = PyLong_AsLong(args[0]);
     Py_INCREF(Py_None);
     return Py_None;
@@ -626,7 +608,7 @@ PyObject* setTrajRev(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 
 PyObject* setGoldAng(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 1);
+    chkNarg(narg, 1);
     gMain_enGoldAng = PyLong_AsLong(args[0]);
     Py_INCREF(Py_None);
     return Py_None;
@@ -634,7 +616,7 @@ PyObject* setGoldAng(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 
 PyObject* setShuf(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 1);
+    chkNarg(narg, 1);
     gMain_enShuffle = PyLong_AsLong(args[0]);
     Py_INCREF(Py_None);
     return Py_None;
@@ -643,7 +625,7 @@ PyObject* setShuf(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 PyObject* setMaxG0(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
     extern f64 gMrTraj_g0Norm;
-    checkNarg(narg, 1);
+    chkNarg(narg, 1);
     bool enMaxG0 = PyLong_AsLong(args[0]);
     if (enMaxG0) gMrTraj_g0Norm = 1e6;
     else gMrTraj_g0Norm = 0e0;
@@ -654,7 +636,7 @@ PyObject* setMaxG0(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 PyObject* setMaxG1(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
     extern f64 gMrTraj_g1Norm;
-    checkNarg(narg, 1);
+    chkNarg(narg, 1);
     bool enMaxG1 = PyLong_AsLong(args[0]);
     if (enMaxG1) gMrTraj_g1Norm = 1e6;
     else gMrTraj_g1Norm = 0e0;
@@ -662,10 +644,28 @@ PyObject* setMaxG1(PyObject* self, PyObject* const* args, Py_ssize_t narg)
     return Py_None;
 }
 
+PyObject* setMagGradSamp(PyObject* self, PyObject* const* args, Py_ssize_t narg)
+{
+    extern i64 gMrTraj_nGradSampRsv;
+    chkNarg(narg, 1);
+    gMrTraj_nGradSampRsv = PyLong_AsLong(args[0]);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
+PyObject* setMagTrajSamp(PyObject* self, PyObject* const* args, Py_ssize_t narg)
+{
+    extern i64 gMrTraj_nTrajSampRsv;
+    chkNarg(narg, 1);
+    gMrTraj_nTrajSampRsv = PyLong_AsLong(args[0]);
+    Py_INCREF(Py_None);
+    return Py_None;
+}
+
 PyObject* setMagOverSamp(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
     extern i64 gMag_oversamp;
-    checkNarg(narg, 1);
+    chkNarg(narg, 1);
     gMag_oversamp = PyLong_AsLong(args[0]);
     Py_INCREF(Py_None);
     return Py_None;
@@ -674,7 +674,7 @@ PyObject* setMagOverSamp(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 PyObject* setMagSFS(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
     extern bool gMag_enSFS;
-    checkNarg(narg, 1);
+    chkNarg(narg, 1);
     gMag_enSFS = PyLong_AsLong(args[0]);
     Py_INCREF(Py_None);
     return Py_None;
@@ -683,7 +683,7 @@ PyObject* setMagSFS(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 PyObject* setMagGradRep(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
     extern bool gMag_enGradRep;
-    checkNarg(narg, 1);
+    chkNarg(narg, 1);
     gMag_enGradRep = PyLong_AsLong(args[0]);
     Py_INCREF(Py_None);
     return Py_None;
@@ -692,7 +692,7 @@ PyObject* setMagGradRep(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 PyObject* setMagTrajRep(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
     extern bool gMag_enTrajRep;
-    checkNarg(narg, 1);
+    chkNarg(narg, 1);
     gMag_enTrajRep = PyLong_AsLong(args[0]);
     Py_INCREF(Py_None);
     return Py_None;
@@ -701,20 +701,53 @@ PyObject* setMagTrajRep(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 PyObject* setDbgPrint(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
     extern bool glob_enDbgPrint;
-    checkNarg(narg, 1);
+    chkNarg(narg, 1);
     glob_enDbgPrint = PyLong_AsLong(args[0]);
     Py_INCREF(Py_None);
     return Py_None;
 }
 
+PyObject* saveF64(PyObject* self, PyObject* const* args, Py_ssize_t narg)
+{
+    chkNarg(narg, 3);
+    const char* strHdr = PyUnicode_AsUTF8(args[0]);
+    const char* strBin = PyUnicode_AsUTF8(args[1]);
+    FILE* fHdr = fopen(strHdr, "w");
+    FILE* fBin = fopen(strBin, "wb");
+    if (fHdr==NULL || fBin==NULL)
+    {
+        if (fHdr) fclose(fHdr);
+        if (fBin) fclose(fBin);
+        Py_INCREF(Py_False);
+        return Py_False;
+    }
+
+    vv3 vv3Data;
+    i64 n = PyList_GET_SIZE(args[2]);
+    for (i64 i=0; i<n; ++i)
+    {
+        cvtNpa2Vv3(PyList_GET_ITEM(args[2], i), &vv3Data);
+        v3::saveF64(fHdr, fBin, vv3Data);
+    }
+
+    Py_INCREF(Py_True);
+    return Py_True;
+}
+
 PyObject* loadF64(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 2);
+    chkNarg(narg, 2);
     const char* strHdr = PyUnicode_AsUTF8(args[0]);
     const char* strBin = PyUnicode_AsUTF8(args[1]);
-    typedef std::list<vv3> lvv3;
     FILE* fHdr = fopen(strHdr, "r");
-    FILE* fBin = fopen(strHdr, "rb");
+    FILE* fBin = fopen(strBin, "rb");
+    if (fHdr==NULL || fBin==NULL)
+    {
+        if (fHdr) fclose(fHdr);
+        if (fBin) fclose(fBin);
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
 
     lvv3 lvv3Data;
     bool ret; vv3 vv3Data;
@@ -724,18 +757,54 @@ PyObject* loadF64(PyObject* self, PyObject* const* args, Py_ssize_t narg)
         if (vv3Data.empty() || !ret) break;
         lvv3Data.push_back(vv3Data);
     }
+    if (fHdr) fclose(fHdr);
+    if (fBin) fclose(fBin);
     vvv3 vvv3Data(lvv3Data.begin(), lvv3Data.end());
-    Py_BuildValue("%O", cvtVvv3toList(vvv3Data));
+    return cvtVvv3toList(vvv3Data);
+}
+
+PyObject* saveF32(PyObject* self, PyObject* const* args, Py_ssize_t narg)
+{
+    chkNarg(narg, 3);
+    const char* strHdr = PyUnicode_AsUTF8(args[0]);
+    const char* strBin = PyUnicode_AsUTF8(args[1]);
+    FILE* fHdr = fopen(strHdr, "w");
+    FILE* fBin = fopen(strBin, "wb");
+    if (fHdr==NULL || fBin==NULL)
+    {
+        if (fHdr) fclose(fHdr);
+        if (fBin) fclose(fBin);
+        Py_INCREF(Py_False);
+        return Py_False;
+    }
+
+    vv3 vv3Data;
+    i64 n = PyList_GET_SIZE(args[2]);
+    for (i64 i=0; i<n; ++i)
+    {
+        cvtNpa2Vv3(PyList_GET_ITEM(args[2], i), &vv3Data);
+        v3::saveF32(fHdr, fBin, vv3Data);
+    }
+
+    Py_INCREF(Py_True);
+    return Py_True;
 }
 
 PyObject* loadF32(PyObject* self, PyObject* const* args, Py_ssize_t narg)
 {
-    checkNarg(narg, 2);
+    chkNarg(narg, 2);
     const char* strHdr = PyUnicode_AsUTF8(args[0]);
     const char* strBin = PyUnicode_AsUTF8(args[1]);
     typedef std::list<vv3> lvv3;
     FILE* fHdr = fopen(strHdr, "r");
-    FILE* fBin = fopen(strHdr, "rb");
+    FILE* fBin = fopen(strBin, "rb");
+    if (fHdr==NULL || fBin==NULL)
+    {
+        if (fHdr) fclose(fHdr);
+        if (fBin) fclose(fBin);
+        Py_INCREF(Py_None);
+        return Py_None;
+    }
 
     lvv3 lvv3Data;
     bool ret; vv3 vv3Data;
@@ -745,8 +814,10 @@ PyObject* loadF32(PyObject* self, PyObject* const* args, Py_ssize_t narg)
         if (vv3Data.empty() || !ret) break;
         lvv3Data.push_back(vv3Data);
     }
+    if (fHdr) fclose(fHdr);
+    if (fBin) fclose(fBin);
     vvv3 vvv3Data(lvv3Data.begin(), lvv3Data.end());
-    Py_BuildValue("%O", cvtVvv3toList(vvv3Data));
+    return cvtVvv3toList(vvv3Data);
 }
 
 static PyMethodDef aMeth[] = 
@@ -769,12 +840,16 @@ static PyMethodDef aMeth[] =
     {"setShuf", (PyCFunction)setShuf, METH_FASTCALL, ""},
     {"setMaxG0", (PyCFunction)setMaxG0, METH_FASTCALL, ""},
     {"setMaxG1", (PyCFunction)setMaxG1, METH_FASTCALL, ""},
+    {"setMagGradSamp", (PyCFunction)setMagGradSamp, METH_FASTCALL, ""},
+    {"setMagTrajSamp", (PyCFunction)setMagTrajSamp, METH_FASTCALL, ""},
     {"setMagOverSamp", (PyCFunction)setMagOverSamp, METH_FASTCALL, ""},
     {"setMagSFS", (PyCFunction)setMagSFS, METH_FASTCALL, ""},
     {"setMagGradRep", (PyCFunction)setMagGradRep, METH_FASTCALL, ""},
     {"setMagTrajRep", (PyCFunction)setMagTrajRep, METH_FASTCALL, ""},
     {"setDbgPrint", (PyCFunction)setDbgPrint, METH_FASTCALL, ""},
+    {"saveF64", (PyCFunction)saveF64, METH_FASTCALL, ""},
     {"loadF64", (PyCFunction)loadF64, METH_FASTCALL, ""},
+    {"saveF32", (PyCFunction)saveF32, METH_FASTCALL, ""},
     {"loadF32", (PyCFunction)loadF32, METH_FASTCALL, ""},
     {NULL, NULL, 0, NULL}        /* Sentinel */
 };

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0}/mrarbgrad_src/ext/traj/MrTraj.h

@@ -13,6 +13,8 @@
 bool gMrTraj_enMtg = false; // whether to use Lustig's minTimeGrad solver
 f64 gMrTraj_g0Norm = 0e0; // initial gradient amplitude
 f64 gMrTraj_g1Norm = 0e0; // final gradient amplitude
+i64 gMrTraj_nGradSampRsv = 10000; // buffer size of mag solver
+i64 gMrTraj_nTrajSampRsv = 10000; // num. of samp. when doing Traj. Rep.
 
 /* 
  * A set of trajectories sufficient to fully-sample the k-space
@@ -51,7 +53,11 @@ public:
         m_nAcq(m_nAcq),
         m_nSampMax(m_nSampMax)
     {
-        m_mag = Mag();
+        m_mag = Mag
+        (
+            gMrTraj_nGradSampRsv,
+            gMrTraj_nTrajSampRsv
+        );
         m_vv3GRampFront.reserve(1000);
         m_vv3GRampBack.reserve(1000);
     }
@@ -361,8 +367,6 @@ protected:
     bool calGrad(v3* pv3M0PE, vv3* pvv3GRO, vf64* pvf64P, TrajFunc& tfTraj, GradPara& objGradPara, i64 oversamp=8)
     {
         bool ret = true;
-        const f64& sLim = objGradPara.sLim;
-        const f64& dt = objGradPara.dt;
         
         // calculate GRO
         TIC;

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0}/mrarbgrad_src/ext/utility/LinIntp.h

@@ -27,8 +27,6 @@ public:
 
     virtual bool fit(const vf64& vf64X, const vf64& vf64Y)
     {
-        ASSERT((i64)vf64X.size() <= m_sizCache);
-        ASSERT((i64)vf64Y.size() <= m_sizCache);
         ASSERT(vf64X.size() == vf64Y.size());
         const i64 nSamp = vf64X.size();
         ASSERT(nSamp >= 2);

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0}/mrarbgrad_src/ext/utility/SplineIntp.h

@@ -37,8 +37,6 @@ public:
 
     virtual bool fit(const vf64& vf64X, const vf64& vf64Y)
     {
-        ASSERT((i64)vf64X.size() <= m_sizCache);
-        ASSERT((i64)vf64Y.size() <= m_sizCache);
         ASSERT(vf64X.size() == vf64Y.size());
         const i64 nSamp = vf64X.size();
         ASSERT(nSamp >= 2);

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0}/mrarbgrad_src/ext/utility/v3.cpp

@@ -1,6 +1,6 @@
 #include "v3.h"
 #include <array>
-#include <cinttypes>
+#include <cstring> // test
 
 v3::v3() :x(0e0), y(0e0), z(0e0) {}
 v3::v3(f64 _) :x(_), y(_), z(_) {}
@@ -371,35 +371,39 @@ bool v3::saveF64(FILE* pfHdr, FILE* pfBin, const vv3& vv3Data)
     i64 lenData = vv3Data.size();
     fprintf(pfHdr, "float64[%ld][3];\n", (long)lenData);
 
-    f64* bufFile = new f64[lenData*3];
+    f64* bufFile = (f64*)malloc(lenData*3*sizeof(f64));
     for(i64 i=0; i<(i64)lenData; ++i)
     {
         for(i64 j=0; j<3; ++j)
         { bufFile[3*i+j] = (f64)vv3Data[i][j]; }
     }
     ret &= (i64)fwrite(bufFile, sizeof(f64), lenData*3, pfBin)==lenData*3;
-    delete[] bufFile;
+    free(bufFile);
     return ret;
 }
 
 bool v3::loadF64(FILE* pfHdr, FILE* pfBin, vv3* pvv3Data)
 {
     bool ret = true;
-    i64 lenData = 0;
     pvv3Data->clear();
-    int nRead = fscanf(pfHdr, "float64[%" SCNi64 "][3];\n", &lenData);
-    if (nRead==EOF) return true; // EOF
-    else if (nRead!=1) return false;
+    i64 lenData = 0;
+    {
+        long _;
+        int nRead = fscanf(pfHdr, "float64[%ld][3];\n", &_);
+        lenData = (i64)_;
+        if (nRead == EOF) return true; // EOF
+        else if (nRead != 1) return false;
+    }
     pvv3Data->resize(lenData);
 
-    f64* bufFile = new f64[lenData*3];
+    f64* bufFile = (f64*)malloc(lenData*3*sizeof(f64));
     ret &= (i64)fread(bufFile, sizeof(f64), lenData*3, pfBin)==lenData*3;
-    for(i64 i=0; i<(i64)pvv3Data->size(); ++i)
+    for(i64 i=0; i<lenData; ++i)
     {
         for(i64 j=0; j<3; ++j)
         { (*pvv3Data)[i][j] = (f64)bufFile[3*i+j]; }
     }
-    delete[] bufFile;
+    free(bufFile);
     return ret;
 }
 
@@ -409,34 +413,38 @@ bool v3::saveF32(FILE* pfHdr, FILE* pfBin, const vv3& vv3Data)
     i64 lenData = vv3Data.size();
     fprintf(pfHdr, "float32[%ld][3];\n", (long)lenData);
 
-    f32* bufFile = new f32[lenData*3];
+    f32* bufFile = (f32*)malloc(lenData*3*sizeof(f32));
     for(i64 i=0; i<(i64)lenData; ++i)
     {
         for(i64 j=0; j<3; ++j)
         { bufFile[3*i+j] = (f32)vv3Data[i][j]; }
     }
     ret &= (i64)fwrite(bufFile, sizeof(f32), lenData*3, pfBin)==lenData*3;
-    delete[] bufFile;
+    free(bufFile);
     return ret;
 }
 
 bool v3::loadF32(FILE* pfHdr, FILE* pfBin, vv3* pvv3Data)
 {
     bool ret = true;
-    i64 lenData = 0;
     pvv3Data->clear();
-    int nRead = fscanf(pfHdr, "float32[%" SCNi64 "][3];\n", &lenData);
-    if (nRead==EOF) return true; // EOF
-    else if (nRead!=1) return false;
+    i64 lenData = 0;
+    {
+        long _;
+        int nRead = fscanf(pfHdr, "float32[%ld][3];\n", &_);
+        lenData = (i64)_;
+        if (nRead == EOF) return true; // EOF
+        else if (nRead != 1) return false;
+    }
     pvv3Data->resize(lenData);
 
-    f32* bufFile = new f32[lenData*3];
+    f32* bufFile = (f32*)malloc(lenData*3*sizeof(f32));
     ret &= (i64)fread(bufFile, sizeof(f32), lenData*3, pfBin)==lenData*3;
-    for(i64 i=0; i<(i64)pvv3Data->size(); ++i)
+    for(i64 i=0; i<lenData; ++i)
     {
         for(i64 j=0; j<3; ++j)
         { (*pvv3Data)[i][j] = (f64)bufFile[3*i+j]; }
     }
-    delete[] bufFile;
+    free(bufFile);
     return ret;
 }

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MRArbGrad"
-version = "4.1.0"
+version = "4.2.0"
 dependencies = ["numpy"]
 
 description = "Gradient waveform design tool for arbitrary k-space trajectories."

{mrarbgrad-4.1.0 → mrarbgrad-4.2.0}/setup.py

@@ -4,7 +4,6 @@ from os.path import exists
 from ctypes.util import find_library
 
 useMtg = exists("./mrarbgrad_src/ext/mtg/")
-useJemalloc = find_library("jemalloc") is not None
 
 _sources = \
 [
@@ -23,7 +22,6 @@ modExt = Extension\
 (
     "mrarbgrad.ext", 
     sources = _sources,
-    libraries = ['jemalloc'] if useJemalloc else [],
     include_dirs = ["./mrarbgrad_src/ext/", numpy.get_include()],
     define_macros = [("USE_MTG", None)] if useMtg else None,
     language = 'c++'