vbi 0.1.3__cp310-cp310-manylinux2014_x86_64.whl → 0.2__cp310-cp310-manylinux2014_x86_64.whl

{vbi-0.1.3.dist-info → vbi-0.2.dist-info}/RECORD

@@ -1,6 +1,6 @@
 vbi/__init__.py,sha256=jrCuk7WXg9m93yeNUpBYd6YU-ardG_ElbYo7PKOXlC4,925
 vbi/_version.py,sha256=HzXy6r3mq7QU6lltj6cO46N68LxvGQfYbUUWiv8OH4o,541
-vbi/inference.py,sha256=hR-egyjG5xDolxFgaRlgzgpY7DIkGEWCqce6OWptQO4,2560
+vbi/inference.py,sha256=BUM5SE_jlLhYOFmYVkvXnDMFdQHI7EpRLogVrex3XJc,3545
 vbi/utils.py,sha256=6jOPoomQbgTP8fv0hnt4pAGqDUUrvDtMqtP8rqNmVNw,10993
 vbi/dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vbi/dataset/connectivity_84/centers.txt,sha256=KJgj_ehlVcq2ydNhI_xmBSh_QJTiFMD_FHAUlv3bobw,3906
@@ -16,8 +16,8 @@ vbi/dataset/connectivity_88/tract_lengths.txt,sha256=T9or8JFl6nETCgF23rOsg2Ldlvg
 vbi/dataset/connectivity_88/weights.txt,sha256=XQcdJPMk7w1cZ6xDexA6Uzfv6kXXs6-YKJVMuXzk9QE,100672
 vbi/feature_extraction/__init__.py,sha256=aoewfgGUCvbPeP6dHoeOtXF6vfysGNf7-YUY6KIA99o,37
 vbi/feature_extraction/calc_features.py,sha256=0LtEMzwRYC47FYP5VRZ-mSKgVf7gXoXgI8ZE1lPDTOE,8777
-vbi/feature_extraction/features.json,sha256=t5DG6JjnspxkJkBoPtKStfEvOo56WVgdCKHRtp2SQ0c,14039
-vbi/feature_extraction/features.py,sha256=SUZeLWWn2zA1AA2xZWo4vAMiNGcqUOykhgTCbngj1Yk,57197
+vbi/feature_extraction/features.json,sha256=PVhuZb6Ut2dDphSY-PgCvVznmH-xrGWrRJa3hQZgObQ,14085
+vbi/feature_extraction/features.py,sha256=hFeQEov_sKE4am2kO58q7zgGA8qCcel9iGlwhfvSb5E,57421
 vbi/feature_extraction/features_settings.py,sha256=ZwT8MLscA0UmMyVU2x0a7NMvZjqD_PfesTneqHpR-mU,9919
 vbi/feature_extraction/features_utils.py,sha256=W5jkkiuf69ny4dK3NSdZ_Y6z5YdHq2y0zXNl2ryG0-E,34256
 vbi/feature_extraction/infodynamics.jar,sha256=_sp1qeyXTVc7TQ-h7xUZxkxsj6S_7iUCodH0IcLYJeo,613523
@@ -25,19 +25,19 @@ vbi/feature_extraction/utility.py,sha256=VI2Io_AAbT8lb_LMuMNK0pZ-Ipc56A0a6qiabqT
 vbi/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vbi/models/cpp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vbi/models/cpp/damp_oscillator.py,sha256=kj5TKNc5obXhZA4pxaP89ymVnEc1h2xKNJ5v4FBdvRo,3976
-vbi/models/cpp/jansen_rit.py,sha256=_XULD5iIHlyTeZAo2IGwEKzcmFEHsv-lcm9mfNUExg8,17382
+vbi/models/cpp/jansen_rit.py,sha256=rBuzdDrpnXQUg0Rins8U5CKOTprlJxX2BSnT_bk9ysw,17128
 vbi/models/cpp/km.py,sha256=n4dXC2vvAYzAve9xQX8oSwPFiTQg34zX-TcpiMEn2Vs,6181
 vbi/models/cpp/mpr.py,sha256=lDQCr4n9cAIBrEEtLzNx-JcXoRRC80sHW4rSBygPMO0,8602
 vbi/models/cpp/vep.py,sha256=TsLTERFhU2dc-ORStSacfaFjMpnfA26-WsHHMk0bQhc,4182
 vbi/models/cpp/wc.py,sha256=kriqwzdLlTrqRO4us1LqoaAvGuTwHPeSCaQuPb2H4Zc,6721
 vbi/models/cpp/_src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vbi/models/cpp/_src/_do.cpython-310-x86_64-linux-gnu.so,sha256=p1TPKVSInyCajYizIZnN5W0ko25i1fRNNnHenQJgjFk,317640
-vbi/models/cpp/_src/_jr_sdde.cpython-310-x86_64-linux-gnu.so,sha256=Vur-OfGUU8q8VblLsDxpYrUhmrXtoZVNlUNL_4UPtyg,587144
-vbi/models/cpp/_src/_jr_sde.cpython-310-x86_64-linux-gnu.so,sha256=UwtX_q9wHb0sBXQDFmYN3zKzv8KW0WRJkifF5wbvhlc,353640
-vbi/models/cpp/_src/_km_sde.cpython-310-x86_64-linux-gnu.so,sha256=6sHipPGT3iWYSCK6eNz8lpqsLtaiSZuXUKzqvmk1BAo,506544
-vbi/models/cpp/_src/_mpr_sde.cpython-310-x86_64-linux-gnu.so,sha256=IJaZqHStA5Y7t4PbJMs7aiGpTPsgi-L2U74-fOdFnUw,542264
-vbi/models/cpp/_src/_vep.cpython-310-x86_64-linux-gnu.so,sha256=8h6f7vGZHOnyxFLIj3-JQuMsFzXLNjeg2pLlM6VrhsU,371368
-vbi/models/cpp/_src/_wc_ode.cpython-310-x86_64-linux-gnu.so,sha256=EfqUaZ781JOI9-MK94VMKJxqLgU0-VJ5oy6RGmbcW2Y,652952
+vbi/models/cpp/_src/_do.cpython-310-x86_64-linux-gnu.so,sha256=yXFIIwmdZwXovYUB8svqgAZW5yNiG90vu2s9fS18T6A,350224
+vbi/models/cpp/_src/_jr_sdde.cpython-310-x86_64-linux-gnu.so,sha256=wzdR-q2XuQ7Sprzqr7KzBThQlosWNETnHST9urWEkSE,590224
+vbi/models/cpp/_src/_jr_sde.cpython-310-x86_64-linux-gnu.so,sha256=Bfhdg-1-Q2zyI-WO25zpvbTzKUUllDk99EciV_i-5dI,382256
+vbi/models/cpp/_src/_km_sde.cpython-310-x86_64-linux-gnu.so,sha256=nTgRHrFrvvqxBEnSgE-VTVqCc-4PbDQZLsEF9ijJumI,552128
+vbi/models/cpp/_src/_mpr_sde.cpython-310-x86_64-linux-gnu.so,sha256=mlgsINg-16CUxW74u8W3v7U1zDJndTfcjjCKH6Ceaok,583920
+vbi/models/cpp/_src/_vep.cpython-310-x86_64-linux-gnu.so,sha256=U0nLS4p48RaD_kr2GpeG-5aieLG1Pr_yWwBUMwdFrIQ,370520
+vbi/models/cpp/_src/_wc_ode.cpython-310-x86_64-linux-gnu.so,sha256=M0lDtg7OHI4sL-c92k2FnzqXVFnqbo9mnote2JwuciY,689792
 vbi/models/cpp/_src/bold.hpp,sha256=3yO8mYg3f_zpunpoDGtrBJM6rXpO14fDdTfrgghTkR8,9010
 vbi/models/cpp/_src/do.hpp,sha256=5D4C7mse4c1Z5NMTIASatmMffA3vswut-xKCkTu0dBw,3826
 vbi/models/cpp/_src/do.i,sha256=R3tvlYU99X9JuzBtkvcBi6awRD2cJZ1V9H4s-qrQJnw,311
@@ -47,10 +47,10 @@ vbi/models/cpp/_src/jr_sdde.hpp,sha256=gkUDKqr0vGsCXXv4mpe4YddUAwMReFMsEAOjJRPe4
 vbi/models/cpp/_src/jr_sdde.i,sha256=wMB2pN_H4UrfVc7gbYvGWcvgDpGY1NBYlb-1zMNUtEM,423
 vbi/models/cpp/_src/jr_sdde.py,sha256=942Y2ahDr9Pcop5uVzdU7quFSU8IIYBj4U3eegiBHiI,20257
 vbi/models/cpp/_src/jr_sdde_wrap.cxx,sha256=cr6G-95V7GBnTovucXkxj4ptLFsUP68YewPuXrCTpFY,715796
-vbi/models/cpp/_src/jr_sde.hpp,sha256=YdphZl-typ_mU0LEUSsEQAFl7n2lo6oJCR1v705Mpkw,6608
+vbi/models/cpp/_src/jr_sde.hpp,sha256=oOBsv1MTq2Kr6kv1YeWq1eYRP6MCoOO2l0dz2xQNoh8,6576
 vbi/models/cpp/_src/jr_sde.i,sha256=trkSFHmJL2au7u8XfacgHhAgd83gMpbf8HsTHtaPo2U,323
 vbi/models/cpp/_src/jr_sde.py,sha256=RY5-gUGMw6tFU6qMVrQiaRYJiCXneMK1WjnSZOtzWq4,13617
-vbi/models/cpp/_src/jr_sde_wrap.cxx,sha256=whRg-GV27809tl41WG9JsJX_g2e1oi7gdAuJWfnlRJc,486705
+vbi/models/cpp/_src/jr_sde_wrap.cxx,sha256=zwhtI33yZabbrd-0KHR7WOeiTQrw1JK0NFm3KwQkWsM,486985
 vbi/models/cpp/_src/km_sde.hpp,sha256=5Gf8Vm0uSPQJncTUDejg6tg_xL88zX5yDpUxXUzqfwI,3657
 vbi/models/cpp/_src/km_sde.i,sha256=3Mgf0JLu5P9dLjy1qW6W90NrG_1I4h5AA2E2eG090PQ,413
 vbi/models/cpp/_src/km_sde.py,sha256=N7-51Eg2UZOCH2Knv6LJ-MI6zFWVan6jJE1rkXIW5kU,19249
@@ -71,18 +71,22 @@ vbi/models/cpp/_src/wc_ode.py,sha256=fjJ42VxF2cBO94I-zr9G7UaSZ031tPDxGQ_YyN-ZH3w
 vbi/models/cpp/_src/wc_ode_wrap.cxx,sha256=sjGmT0GUOchmM4TApS-AyzcR4xAiDq4Q9QzDIbrzAdU,946453
 vbi/models/cpp/_src/__pycache__/mpr_sde.cpython-310.pyc,sha256=iVa9uKW8InSohi0UMNO2TLWSvwOq83maCCzyQ47G_50,32596
 vbi/models/cupy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vbi/models/cupy/bold.py,sha256=atLRdeUo93_NnkoOjwID2W_4-rqnpeCuQWboNBuq8Z4,3077
+vbi/models/cupy/bold.py,sha256=36Sa_iU5njBawtq0iAmMNcZzllE07OvKanNfqpdXHYQ,6469
 vbi/models/cupy/ghb.py,sha256=azFBqYn2hWS11BjS3M7oGXNRy3pRYhZUNWsJcrqoOZ8,7451
-vbi/models/cupy/jansen_rit.py,sha256=Whrw8kTfRwUR5jzv24Mlxf6vD9M88wywTYdSCDob2rY,13223
-vbi/models/cupy/km.py,sha256=lj1BhBGR8IGBEJNO04zIErKHdpjeK4p49gdPcyzPMpo,7306
-vbi/models/cupy/mpr.py,sha256=yMiPdtmcUpuSneMAJeWy4H-U58BY2jDysb-Os2GVQ8M,13977
+vbi/models/cupy/jansen_rit.py,sha256=DHS2GRSMhVRBgw6s1Zw_YBYqsZSp3M0uvjggF3hOo-Q,13206
+vbi/models/cupy/km.py,sha256=IltJGnVYtg9vxOVm691n5LzUFXXbAHI-27_kb8mH3Rk,7878
+vbi/models/cupy/mpr.py,sha256=5dyoADaZXEnZbrPCZUAtayXCUid97RXNVShAYNtWfyc,14636
 vbi/models/cupy/mpr_modified_bold.py,sha256=w-mVj0G86GIWTDcUY8rrDz6UgiTAoPZ0vK45VoADEnU,370
-vbi/models/cupy/utils.py,sha256=xb0RTc9qZ6RzQTUnKJPvHb5lL2GvHtss51ZeQbqWMQw,3556
-vbi/models/numba/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vbi/models/numba/_ww_EI.py,sha256=H0LKc4dq4XhYkkg6KIL7qQmxVBsNPW2stqC9xvX5V7Q,11367
+vbi/models/cupy/utils.py,sha256=d_Lo7bguMqxvWDu8bdE5e3J2OVd0LznjiKMeEX5PbMo,7765
+vbi/models/cupy/wilson_cowan.py,sha256=LdRHClPdXDO89lNFyAIZs9zhHIeIYSBup5DEnImToMg,9943
+vbi/models/cupy/ww.py,sha256=_zxLQslY8ni_608gBZPLgjWf2vlkv2LG2YkZaGihtvE,11211
+vbi/models/numba/__init__.py,sha256=NK8M8GGAuy5kslFOPJseoftuPd570Q2R-Pt2tW7qqMY,80
 vbi/models/numba/damp_oscillator.py,sha256=VLCPCcemDBXjbhtf5wkxXqqwWNPvDsdPQ_-4Ev-2YWg,3966
 vbi/models/numba/ghb.py,sha256=weLLfhmrwQ9pXec7HD9X3U8Fg-PR74KNOnjECdTyRvA,5898
-vbi/models/numba/mpr.py,sha256=MRT4jZ2-Hp_JklRzx_PR-gWo3-xOjoGnNFBm65KiD9w,9912
+vbi/models/numba/jansen_rit.py,sha256=yRTFEIId5YAdl-u5wwfl6i3vqW0BW1Fuuah6panBUbI,16812
+vbi/models/numba/mpr.py,sha256=jpfF4ttqWmuYJrKMDlNgDgSCsWedXIbc-JWTtOzf6Dw,10257
+vbi/models/numba/wilson_cowan.py,sha256=mZue7YBlhtPbW0ljz3s3uwUPIsbNTJgln8K23Cq_qFw,12475
+vbi/models/numba/ww.py,sha256=g8RDxzfJQ4KXbF9yKKcwuQNICdjaWO8ZLkbt_r3XEqw,16557
 vbi/models/pytorch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vbi/models/pytorch/ww_sde_kong.py,sha256=M1xm_wCQXAjZ_dJ_aj-g9SYCPH2ReEns2ajUg2mb9oc,17072
 vbi/models/pytorch/data/default_parameters.npz,sha256=7lUMf6btGWzghl8P2OpT3yebYLBxDpQgdTAeBSCXF-U,820846
@@ -114,8 +118,8 @@ vbi/tests/test_ghb_cupy.py,sha256=IglmkfvM76g-IjkRyG1VJq87Nfn1GJPnjMlrV4jyJJE,21
 vbi/tests/test_mpr_cupy.py,sha256=X568kl3TkXvV8e8F1_Gt2WP5t8pC5mGAzsMe0ji8_7A,1118
 vbi/tests/test_mpr_numba.py,sha256=ctaBkGTlzzzM48kKoplJNMJUcMg__F3eNsR47EjJefg,1891
 vbi/tests/test_suite.py,sha256=3D7NBY2ve29ncT59-VVH88fYYrS0Wqu-G2FFj-m8Lc4,654
-vbi-0.1.3.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-vbi-0.1.3.dist-info/METADATA,sha256=aazba6jWhC6bQN5t8d2fJCVP56MtXOwxX8j4lW2Fv84,7613
-vbi-0.1.3.dist-info/WHEEL,sha256=6Av-02TEI2DNLcOcRjGCxh8k-G28nMv3SqT1sYCGOuI,112
-vbi-0.1.3.dist-info/top_level.txt,sha256=fbMk9hUFp5f8kQ5xOFIHlcqpHDO70CUHeJZtSp81RMM,4
-vbi-0.1.3.dist-info/RECORD,,
+vbi-0.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+vbi-0.2.dist-info/METADATA,sha256=vgkTzDNdm7xlvqlKW9hVYvok438FAeDAT87QGGdbjVM,7795
+vbi-0.2.dist-info/WHEEL,sha256=7Cj2XrhsdKMjPi7T0xvQDc5HEcioDLTsKmSWBd8-0YY,112
+vbi-0.2.dist-info/top_level.txt,sha256=fbMk9hUFp5f8kQ5xOFIHlcqpHDO70CUHeJZtSp81RMM,4
+vbi-0.2.dist-info/RECORD,,

{vbi-0.1.3.dist-info → vbi-0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (79.0.1)
+Generator: setuptools (80.1.0)
 Root-Is-Purelib: false
 Tag: cp310-cp310-manylinux2014_x86_64
 

vbi/models/numba/_ww_EI.py

@@ -1,444 +0,0 @@
-import warnings
-import numpy as np
-from numba import njit
-from numba.experimental import jitclass
-from numba.core.errors import NumbaPerformanceWarning
-from numba import float64, boolean, int64, types
-
-warnings.simplefilter("ignore", category=NumbaPerformanceWarning)
-
-
-w_spec = [
-    ("G", float64),
-    
-    ("a_I", float64),
-    ("b_I", float64),
-    ("d_I", float64),
-    ("tau_I", float64),
-    
-    ("a_E", float64),
-    ("b_E", float64),
-    ("d_E", float64),
-    ("tau_E", float64),
-    
-    ("w_II", float64),
-    ("w_EE", float64),
-    ("w_IE", float64),
-    ("w_EI", float64),
-    
-    ("W_E", float64),
-    ("W_I", float64),
-    
-    ("gamma", float64),
-    ("dt", float64),
-    ("J_NMDA", float64),
-    ("J_I", float64),
-    
-    ("I_I", float64[:]),
-    ("I_E", float64[:]),
-    
-    # ("sigma_I", float64),
-    # ("sigma_E", float64),
-    
-    ("initial_state", float64[:]),
-    ("weights", float64[:, :]),
-    ("seed", int64),
-    ("method", types.string),
-    ("t_end", float64),
-    ("t_cut", float64),
-    ("nn", int64),
-    ("ts_decimate", int64),
-    ("fmri_decimate", int64),
-    ("RECORD_TS", boolean),
-    ("RECORD_FMRI", boolean),
-]
-
-b_spec = [
-    ("eps", float64),
-    ("E0", float64),
-    ("V0", float64),
-    ("alpha", float64),
-    ("inv_alpha", float64),
-    ("K1", float64),
-    ("K2", float64),
-    ("K3", float64),
-    ("taus", float64),
-    ("tauo", float64),
-    ("tauf", float64),
-    ("inv_tauo", float64),
-    ("inv_taus", float64),
-    ("inv_tauf", float64),
-    ("nn", int64),
-    ("dt_bold", float64),
-]
-
-
-@jitclass(w_spec)
-class ParWW:
-    def __init__(
-        self,
-        G=0.0,
-        a_I=615.0,
-        b_I=177.0,
-        d_I=0.087,
-        tau_I=0.01,
-        
-        a_E=310.0,
-        b_E=125.0,
-        d_E=0.16,
-        tau_E=0.1,
-        
-        gamma=0.641,
-        
-        w_II=1.0,
-        w_IE=1.4,
-        w_EI=1.0,
-        w_EE=1.0,
-        dt=0.01,
-        
-        W_E=1.0,
-        W_I =0.7,
-        
-        I0 = 0.382,
-        J_NMDA=0.15,
-        
-        
-        I_I=np.array([0.296]),  # 0.296
-        I_E=np.array([0.377]),  # 0.377
-        sigma_I=0.001,
-        sigma_E=0.001,
-        initial_state=np.array([]),
-        weights=np.array([[], []]),
-        seed=-1,
-        method="heun",
-        t_end=300.0,
-        t_cut=0.0,
-        ts_decimate=10,
-        fmri_decimate=10,
-        RECORD_TS=True,
-        RECORD_FMRI=True,
-    ):
-        self.G = G
-        self.a_I = a_I
-        self.b_I = b_I
-        self.d_I = d_I
-        self.tau_I = tau_I
-        
-        self.a_E = a_E
-        self.b_E = b_E
-        self.d_E = d_E
-        self.tau_E = tau_E
-
-        self.w_II = w_II
-        self.w_IE = w_IE
-        self.w_EI = w_EI
-        self.w_EE = w_EE
-        self.gamma = gamma
-
-        self.dt = dt
-        
-        self.W_E = W_E
-        self.W_I = W_I
-        
-        self.I0 = I0
-        self.I_E = I_E
-        self.I_I = I_I
-        self.J_NMDA = J_NMDA
-
-        self.sigma_I = sigma_I
-        self.sigma_E = sigma_E
-
-        self.initial_state = initial_state
-        self.weights = weights
-        self.seed = seed
-        self.method = method
-        self.t_end = t_end
-        self.t_cut = t_cut
-        self.ts_decimate = ts_decimate
-        self.fmri_decimate = fmri_decimate
-        self.RECORD_TS = RECORD_TS
-        self.RECORD_FMRI = RECORD_FMRI
-        if len(initial_state) > 0:
-            self.nn = len(initial_state)
-        else:
-            self.nn = -1
-
-
-@jitclass(b_spec)
-class ParBaloon:
-    def __init__(
-        self, eps=0.5, E0=0.4, V0=4.0, 
-        alpha=0.32, taus=1.54, tauo=0.98, tauf=1.44
-    ):
-        self.eps = eps
-        self.E0 = E0
-        self.V0 = V0
-        self.alpha = alpha
-        self.inv_alpha = 1.0 / alpha
-        self.K1 = 7.0 * E0
-        self.K2 = 2 * E0
-        self.K3 = 1 - eps
-        self.taus = taus
-        self.tauo = tauo
-        self.tauf = tauf
-        self.inv_tauo = 1.0 / tauo
-        self.inv_taus = 1.0 / taus
-        self.inv_tauf = 1.0 / tauf
-        self.dt_bold = 0.01
-
-
-@njit
-def f_ww(S, P):
-    """
-    system function for Wong-Wang model.
-    """
-    coupling = np.dot(P.weights, S)
-    x = P.w * P.J_N * S + P.I_o + P.G * P.J_N * coupling
-    H = (P.a * x - P.b) / (1 - np.exp(-P.d * (P.a * x - P.b)))
-    dS = -(S / P.tau_s) + (1 - S) * H * P.gamma
-    return dS
-
-
-@njit
-def f_fmri(xin, x, t, B):
-    """
-    system function for Balloon model.
-    """
-    E0 = B.E0
-    nn = B.nn
-    inv_tauf = B.inv_tauf
-    inv_tauo = B.inv_tauo
-    inv_taus = B.inv_taus
-    inv_alpha = B.inv_alpha
-
-    dxdt = np.zeros(4 * nn)
-    s = x[:nn]
-    f = x[nn : 2 * nn]
-    v = x[2 * nn : 3 * nn]
-    q = x[3 * nn :]
-
-    dxdt[:nn] = xin - inv_taus * s - inv_tauf * (f - 1.0)
-    dxdt[nn : (2 * nn)] = s
-    dxdt[(2 * nn) : (3 * nn)] = inv_tauo * (f - v ** (inv_alpha))
-    dxdt[3 * nn :] = (inv_tauo) * (
-        (f * (1.0 - (1.0 - E0) ** (1.0 / f)) / E0) - (v ** (inv_alpha)) * (q / v)
-    )
-    return dxdt
-
-
-@njit
-def euler_sde_step(S, P):
-    dW = np.sqrt(P.dt) * P.sigma_noise * np.random.randn(P.nn)
-    return S + P.dt * f_ww(S, P) + dW
-
-
-@njit
-def heun_sde_step(S, P):
-    dW = np.sqrt(P.dt) * P.sigma_noise * np.random.randn(P.nn)
-    k0 = f_ww(S, P)
-    S1 = S + P.dt * k0 + dW
-    k1 = f_ww(S1, P)
-    return S + 0.5 * P.dt * (k0 + k1) + dW
-
-
-@njit
-def heun_ode_step(yin, y, t, B):
-    """Heun scheme."""
-
-    dt = B.dt_bold
-    k1 = f_fmri(yin, y, t, B)
-    tmp = y + dt * k1
-    k2 = f_fmri(yin, tmp, t + dt, B)
-    y += 0.5 * dt * (k1 + k2)
-    return y
-
-
-@njit
-def integrate_fmri(yin, y, t, B):
-    """
-    Integrate Balloon model
-
-    Parameters
-    ----------
-    yin : array [nn]
-        r and v time series, r is used as input
-    y : array [4*nn]
-        state, update in place
-    t : float
-        time
-
-    Returns
-    -------
-    yb : array [nn]
-        BOLD signal
-
-    """
-
-    V0 = B.V0
-    K1 = B.K1
-    K2 = B.K2
-    K3 = B.K3
-
-    nn = yin.shape[0]
-    y = heun_ode_step(yin, y, t, B)
-    yb = V0 * (
-        K1 * (1.0 - y[(3 * nn) :])
-        + K2 * (1.0 - y[(3 * nn) :] / y[(2 * nn) : (3 * nn)])
-        + K3 * (1.0 - y[(2 * nn) : (3 * nn)])
-    )
-    return y, yb
-
-
-@njit
-def integrate(P, B, intg=heun_sde_step):
-    """
-    integrate Wong-Wang model and Balloon model.
-    """
-    t = np.arange(0, P.t_end, P.dt)
-    nt = len(t)
-    nn = P.nn
-
-    if P.RECORD_TS:
-        T = np.empty(int(np.ceil(nt / P.ts_decimate)))
-        S = np.empty((int(np.ceil(nt / P.ts_decimate)), nn))
-    else:
-        T = np.empty(0)
-        S = np.empty((0, 1))
-
-    if P.RECORD_FMRI:
-        t_fmri = np.empty(int(np.ceil(nt / P.fmri_decimate)))
-        d_fmri = np.empty((int(np.ceil(nt / P.fmri_decimate)), nn))
-    else:
-        t_fmri = np.empty(0)
-        d_fmri = np.empty((0, 1))
-
-    x0 = P.initial_state
-    y0 = np.zeros((4 * nn))
-    y0[nn:] = 1.0
-
-    jj = 0
-    ii = 0
-    for i in range(1, nt):
-
-        t = i * P.dt
-        t_bold = i * B.dt_bold
-        x0 = intg(x0, P)
-
-        if P.RECORD_TS:
-            if i % P.ts_decimate == 0:
-                S[ii, :] = x0
-                T[ii] = t
-                ii += 1
-        if P.RECORD_FMRI:
-            y0, fmri_i = integrate_fmri(x0, y0, t, B)
-            if i % P.fmri_decimate == 0:
-                d_fmri[jj, :] = fmri_i
-                # t_fmri[jj] = t[i]
-                t_fmri[jj] = t_bold
-                jj += 1
-    S = S[T >= P.t_cut, :]
-    T = T[T >= P.t_cut]
-    d_fmri = d_fmri[t_fmri >= P.t_cut, :]
-    t_fmri = t_fmri[t_fmri >= P.t_cut]
-
-    return T, S, t_fmri, d_fmri
-
-
-class WW_sde(object):
-    r"""
-    Wong-Wang model.
-    
-    .. math::
-                    x_k       &=   w\,J_N \, S_k + I_o + G\,J_N \sum_j \, C_{kj} \,Sj \\
-                    H(x_k)    &=  \dfrac{ax_k - b}{1 - \exp(-d(ax_k -b))}\\
-                    \dot{S}_k &= -\dfrac{S_k}{\tau_s} + (1 - S_k) \, H(x_k) \, \gamma + \sigma \, \Xi_k
-                    
-    - Kong-Fatt Wong and Xiao-Jing Wang, A Recurrent Network Mechanism of Time Integration in Perceptual Decisions. Journal of Neuroscience 26(4), 1314-1328, 2006.       
-    - Deco Gustavo, Ponce Alvarez Adrian, Dante Mantini, Gian Luca Romani, Patric Hagmann and Maurizio Corbetta. Resting-State Functional Connectivity Emerges from Structurally and Dynamically Shaped Slow Linear Fluctuations. The Journal of Neuroscience 32(27), 11239-11252, 2013. Equations taken from DPA 2013 , page 11242.
-    """
-
-    def __init__(self, par: dict = {}, parB: dict = {}) -> None:
-
-        self.valid_parW = [w_spec[i][0] for i in range(len(w_spec))]
-        self.valid_parB = [b_spec[i][0] for i in range(len(b_spec))]
-        self.valid_par = self.valid_parW + self.valid_parB
-
-        self.check_parameters(par)
-        self.P = self.get_par_WW_obj(par)
-        self.B = self.get_par_Baloon_obj(parB)
-
-    def __str__(self):
-        print("Wong-Wang model of neural population dynamics")
-        print("Parameters:----------------------------")
-        for key in self.valid_parW:
-            print(key, ": ", getattr(self.P, key))
-        print("---------------------------------------")
-        for key in self.valid_parB:
-            print(key, ": ", getattr(self.B, key))
-        return ""
-
-    def get_par_WW_obj(self, par: dict = {}) -> ParWW:
-        """
-        return default parameters for Wong-Wang model.
-        """
-        if "initial_state" in par.keys():
-            par["initial_state"] = np.array(par["initial_state"])
-        if "weights" in par.keys():
-            assert par["weights"] is not None
-            par["weights"] = np.array(par["weights"])
-            assert par["weights"].shape[0] == par["weights"].shape[1]
-        parobj = ParWW(**par)
-
-        return parobj
-
-    def get_par_Baloon_obj(self, par: dict = {}) -> ParBaloon:
-        """
-        return default parameters for Balloon model.
-        """
-        parobj = ParBaloon(**par)
-        return parobj
-
-    def check_parameters(self, par: dict) -> None:
-        for key in par.keys():
-            if key not in self.valid_par:
-                raise ValueError(f"Invalid parameter {key}")
-
-    def set_initial_state(self, seed=None):
-        if seed is not None:
-            np.random.seed(seed)
-        self.P.nn = self.P.weights.shape[0]
-        self.initial_state = np.random.rand(self.P.nn)
-        self.B.nn = self.P.nn
-
-    def check_input(self):
-
-        assert self.P.weights is not None
-        assert self.P.weights.shape[0] == self.P.weights.shape[1]
-        assert self.P.initial_state is not None
-        assert len(self.P.initial_state) == self.P.weights.shape[0]
-        self.B.nn = self.P.nn
-        # self.B.dt = self.P.dt
-
-    def run(self, par={}, parB={}, x0=None, verbose=True):
-
-        if x0 is None:
-            self.seed = self.P.seed if self.P.seed > 0 else None
-            self.set_initial_state(self.seed)
-            self.P.initial_state = self.initial_state
-        else:
-            self.P.initial_state = x0
-            self.P.nn = len(x0)
-
-        if par:
-            self.check_parameters(par)
-            for key in par.keys():
-                setattr(self.P, key, par[key])
-        if parB:
-            self.check_parameters(parB)
-            for key in parB.keys():
-                setattr(self.B, key, parB[key])
-        self.check_input()
-
-        T, S, t_fmri, d_fmri = integrate(self.P, self.B)
-
-        return {"t": T, "s": S, "t_fmri": t_fmri, "d_fmri": d_fmri}