pyNIBS 0.2024.8__py3-none-any.whl → 0.2026.1__py3-none-any.whl

pynibs/regression/dual_node_detection.py

@@ -43,12 +43,12 @@ def determine_coil_position_idcs(num_idcs, all_efields, rn_seed):
     selection : ndarray of int
         (n_zaps_used) Indices of chosen coil positions.
    """
-    selection = np.array([],dtype=int)
+    selection = np.array([], dtype=int)
 
     all_idcs = list(range(all_efields.shape[0]))
 
     rn_generator = default_rng(seed=rn_seed)
-    selection = rn_generator.choice(all_idcs,size=num_idcs,replace=False)
+    selection = rn_generator.choice(all_idcs, size=num_idcs, replace=False)
 
     return selection
 
@@ -80,7 +80,7 @@ def determine_detectable_hotspots(e_subset, rn_seed):
         idx0 = np.random.choice(e_subset.shape[1])
         idx1 = np.random.choice(e_subset.shape[1])
 
-        if pynibs.compute_correlation_with_all_elements(e_subset, idx0)[idx1] < corr_thr:
+        if compute_correlation_with_all_elements(e_subset, idx0)[idx1] < corr_thr:
             if np.max(e_subset[:, idx0]) > e_max_thr and np.max(e_subset[:, idx1]) > e_max_thr:
                 finished = True
 
@@ -164,43 +164,43 @@ def create_response_data(efields, config):
                 effect = 0
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/4) * jitter_scale
+                scale = (1 + effect / 4) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale, K=100)
                 data[efield_idx] = idx_prob_dist.rvs()
 
         elif network_type == 'AND':
             for efield_idx in range(0, efields.shape[0]):
-                effect = (effect_indicator[efield_idx, 0] * effect_indicator[efield_idx, 1])**2  # \in [0, 1.44]
+                effect = (effect_indicator[efield_idx, 0] * effect_indicator[efield_idx, 1]) ** 2  # \in [0, 1.44]
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/4) * jitter_scale
+                scale = (1 + effect / 4) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale, K=50)
                 data[efield_idx] = idx_prob_dist.rvs()
 
         elif network_type == '1_INH_0':
             for efield_idx in range(0, efields.shape[0]):
-                effect = max((effect_indicator[efield_idx, 0]**2 - effect_indicator[efield_idx, 1]**2), 0)
+                effect = max((effect_indicator[efield_idx, 0] ** 2 - effect_indicator[efield_idx, 1] ** 2), 0)
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/4) * jitter_scale
+                scale = (1 + effect / 4) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale, K=100)
                 data[efield_idx] = idx_prob_dist.rvs()
 
         elif network_type == 'SH_0':
             for efield_idx in range(0, efields.shape[0]):
-                effect = (effect_indicator[efield_idx, 0])**4
+                effect = (effect_indicator[efield_idx, 0]) ** 4
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/4) * jitter_scale
+                scale = (1 + effect / 4) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale, K=100)
                 data[efield_idx] = idx_prob_dist.rvs()
 
         elif network_type == '0_INH_1':
             for efield_idx in range(0, efields.shape[0]):
-                effect = max((effect_indicator[efield_idx, 1]**2 - effect_indicator[efield_idx, 0]**2), 0)
+                effect = max((effect_indicator[efield_idx, 1] ** 2 - effect_indicator[efield_idx, 0] ** 2), 0)
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/4) * jitter_scale
+                scale = (1 + effect / 4) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale, K=100)
                 data[efield_idx] = idx_prob_dist.rvs()
 
@@ -209,7 +209,7 @@ def create_response_data(efields, config):
                 effect = (effect_indicator[efield_idx, 1]) ** 4
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/4) * jitter_scale
+                scale = (1 + effect / 4) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale, K=100)
                 data[efield_idx] = idx_prob_dist.rvs()
 
@@ -218,21 +218,21 @@ def create_response_data(efields, config):
                 x = effect_indicator[efield_idx, 0]
                 y = effect_indicator[efield_idx, 1]
                 if x > y:
-                    effect = x**2 - y**2
+                    effect = x ** 2 - y ** 2
                 else:
-                    effect = y**2 - x**2
+                    effect = y ** 2 - x ** 2
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/4) * jitter_scale
+                scale = (1 + effect / 4) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale, K=100)
                 data[efield_idx] = idx_prob_dist.rvs()
 
         elif network_type == 'OR':
             for efield_idx in range(0, efields.shape[0]):
-                effect = (effect_indicator[efield_idx, 0]**4 + effect_indicator[efield_idx, 1]**4)/2
+                effect = (effect_indicator[efield_idx, 0] ** 4 + effect_indicator[efield_idx, 1] ** 4) / 2
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/4) * jitter_scale
+                scale = (1 + effect / 4) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale, K=100)
                 data[efield_idx] = idx_prob_dist.rvs()
 
@@ -247,7 +247,7 @@ def create_response_data(efields, config):
                 effect = 0
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/2) * jitter_scale
+                scale = (1 + effect / 2) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale)
                 data[efield_idx] = idx_prob_dist.rvs()
 
@@ -256,7 +256,7 @@ def create_response_data(efields, config):
                 effect = (effect_indicator[efield_idx, 0] * effect_indicator[efield_idx, 1]) ** 2  # \in [0, 1.44]
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/2) * jitter_scale
+                scale = (1 + effect / 2) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale)
                 data[efield_idx] = idx_prob_dist.rvs()
 
@@ -266,7 +266,7 @@ def create_response_data(efields, config):
                 effect = max((effect_indicator[efield_idx, 0] ** 2 - effect_indicator[efield_idx, 1] ** 2), 0)
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/2) * jitter_scale
+                scale = (1 + effect / 2) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale)
                 data[efield_idx] = idx_prob_dist.rvs()
 
@@ -275,7 +275,7 @@ def create_response_data(efields, config):
                 effect = (effect_indicator[efield_idx, 0]) ** 4
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/2) * jitter_scale
+                scale = (1 + effect / 2) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale)
                 data[efield_idx] = idx_prob_dist.rvs()
 
@@ -284,7 +284,7 @@ def create_response_data(efields, config):
                 effect = max((effect_indicator[efield_idx, 1] ** 2 - effect_indicator[efield_idx, 0] ** 2), 0)
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/2) * jitter_scale
+                scale = (1 + effect / 2) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale)
                 data[efield_idx] = idx_prob_dist.rvs()
 
@@ -293,7 +293,7 @@ def create_response_data(efields, config):
                 effect = (effect_indicator[efield_idx, 1]) ** 4
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/2) * jitter_scale
+                scale = (1 + effect / 2) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale)
                 data[efield_idx] = idx_prob_dist.rvs()
 
@@ -307,7 +307,7 @@ def create_response_data(efields, config):
                     effect = y ** 2 - x ** 2
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/2) * jitter_scale
+                scale = (1 + effect / 2) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale)
                 data[efield_idx] = idx_prob_dist.rvs()
 
@@ -316,7 +316,7 @@ def create_response_data(efields, config):
                 effect = (effect_indicator[efield_idx, 0] ** 4 + effect_indicator[efield_idx, 1] ** 4) / 2
 
                 loc = response_shift + response_multiplier * effect
-                scale = (1+effect/2) * jitter_scale
+                scale = (1 + effect / 2) * jitter_scale
                 idx_prob_dist = gen_dist(loc=loc, scale=scale)
                 data[efield_idx] = idx_prob_dist.rvs()
 
@@ -333,7 +333,7 @@ def binarize_response_data(response_values, method, bin_factor):
 
     Parameters
     ----------
-    response_values : numpy.ndarray
+    response_values : np.ndarray
         (n_zaps) Response data.
     method : str
         Method of calculating the binarization threshold. ("mean", "slope", "median")
@@ -343,7 +343,7 @@ def binarize_response_data(response_values, method, bin_factor):
 
     Returns
     -------
-    response_bin : numpy.ndarray
+    response_bin : np.ndarray
         (n_zaps) Binarized response data, where values greater than the threshold are set to 1, and values
         less than or equal to the threshold are set to 0.
     """
@@ -393,17 +393,18 @@ def binarize_real_meps(meps, method='kde'):
 
     Parameters
     ----------
-    meps : numpy.ndarray
+    meps : np.ndarray
         (n_zaps) The MEP measurements.
     method : str
         The method for determining the binarization threshold. Valid options are:
-        - 'kde': Determine the threshold based on the density of the measurement points.
-                 The point density is low when the value of the MEPs is rapidly changing.
-        - 'slope': Determine the threshold based on the derivative/slope.
+
+        - ``kde``: Determine the threshold based on the density of the measurement points.
+          The point density is low when the value of the MEPs is rapidly changing.
+        - ``slope``: Determine the threshold based on the derivative/slope.
 
     Returns
     -------
-    numpy.ndarray
+    np.ndarray
         An array of the same shape as `meps` with 1 for data points below the determined threshold,
         and 0 otherwise.
     """
@@ -417,8 +418,8 @@ def binarize_real_meps(meps, method='kde'):
         bandwidth = .9 * min(np.std(meps), q75 - q25) * pow(meps.shape[0], -0.2)
 
         kde = KernelDensity(
-            kernel='gaussian',
-            bandwidth=bandwidth
+                kernel='gaussian',
+                bandwidth=bandwidth
         ).fit(np.reshape(meps, (-1, 1)))
 
         x_grid = np.linspace(0, max(meps))
@@ -455,8 +456,8 @@ def binarize_real_meps(meps, method='kde'):
         plt.figure()
         plt.scatter(x=range(0, meps_sorted.shape[0]), y=meps_sorted)
         plt.scatter(
-            x=range(meps_sorted_smoothed.shape[0] + int(num_discarded_values / 2)),
-            y=np.pad(meps_sorted_smoothed, (int(num_discarded_values / 2), 0))
+                x=range(meps_sorted_smoothed.shape[0] + int(num_discarded_values / 2)),
+                y=np.pad(meps_sorted_smoothed, (int(num_discarded_values / 2), 0))
         )
         plt.figure()
         plt.scatter(x=range(0, meps_sorted_smoothed_gradient.shape[0]), y=meps_sorted_smoothed_gradient)
@@ -598,11 +599,11 @@ def plot_data_clf(response_data_bin, e_field0, e_field1):
     grid_y_min, grid_y_max = np.min(e_field1), np.max(e_field1)
     # define a regular grid between the boundaries of the data
     grid_x_coords, grid_y_coords = \
-        np.meshgrid(np.arange(grid_x_min, grid_x_max+0.005, .005),
-                    np.arange(grid_y_min, grid_y_max+0.005, .005))
+        np.meshgrid(np.arange(grid_x_min, grid_x_max + 0.005, .005),
+                    np.arange(grid_y_min, grid_y_max + 0.005, .005))
     # have the classifier determine the class of the grid points
     grid_points_predicted = clf.predict(
-        np.c_[grid_x_coords.ravel(), grid_y_coords.ravel()]
+            np.c_[grid_x_coords.ravel(), grid_y_coords.ravel()]
     )
     # Put the result into a color plot
     grid_points_predicted = grid_points_predicted.reshape(grid_x_coords.shape)
@@ -634,18 +635,18 @@ def plot_data_clf(response_data_bin, e_field0, e_field1):
 def write_effect_map_hdf5(datatype, e_matrix, roi_surf, detection_result, base_path, config):
     """
     Create effect maps for result validation. The idea is that given a detection result, especially the hotspot_idcs and
-     network_type, a prediction can be made about where the response is supposed to be affected most.
+    network_type, a prediction can be made about where the response is supposed to be affected most.
     Comparing these predictions and real response measurements is a possibility for result validation.
     See output_documentation.md for more.
 
     Parameters
     ----------
     datatype : str
-        Whether the response data is 'real' or 'artificial'.
+        Whether the response data is "real" or "artificial".
     e_matrix : np.ndarray of float
         (n_zaps, n_elms) The efield magnitudes of all available coil positions across all ROI elements.
     roi_surf : ROI obj
-       ROI surface object.
+        ROI surface object.
     detection_result : np.ndarray
         (7) contains the result of the detection, consisting of
         (found_network_type, found_idcs, found_acc, found_distance, found_scores, network_type_certainty, shape_vector).
@@ -654,7 +655,6 @@ def write_effect_map_hdf5(datatype, e_matrix, roi_surf, detection_result, base_p
     config : dict
         YAML configuration file content as a dictionary.
     """
-
     print("Effect values are being calculated.")
 
     effect_full = config['effect_full']
@@ -672,7 +672,7 @@ def write_effect_map_hdf5(datatype, e_matrix, roi_surf, detection_result, base_p
 
         # can also go with different stimulation position from here, instead of the proxy
         effect_vals = [np.zeros(e_matrix.shape[1]), np.zeros(e_matrix.shape[1])]
-        for idx in [0,1]:
+        for idx in [0, 1]:
             if not np.isnan(found_idcs[idx]):
                 effect_vals[idx] = min(e_subset[found_idcs[idx]] / effect_full, effect_saturation)
 
@@ -694,7 +694,7 @@ def write_effect_map_hdf5(datatype, e_matrix, roi_surf, detection_result, base_p
             else:
                 effect[elm] = effect_vals[1] ** 2 - effect_vals[0] ** 2
         elif network_type == 8:
-            effect[elm] = (effect_vals[0] ** 4 + effect_vals[1] ** 4)/2
+            effect[elm] = (effect_vals[0] ** 4 + effect_vals[1] ** 4) / 2
         else:
             raise NotImplementedError()
 
@@ -714,15 +714,15 @@ def write_effect_map_hdf5(datatype, e_matrix, roi_surf, detection_result, base_p
     while True:
         try:
             pynibs.write_geo_hdf5_surf(out_fn=fn_out_roi_geo,
-                                                points=roi_surf.node_coord_mid,
-                                                con=roi_surf.node_number_list,
-                                                replace=True,
-                                                hdf5_path='/mesh')
+                                       points=roi_surf.node_coord_mid,
+                                       con=roi_surf.node_number_list,
+                                       replace=True,
+                                       hdf5_path='/mesh')
             pynibs.write_data_hdf5_surf(data=effect,
-                                                 data_names=['effect_map'],
-                                                 data_hdf_fn_out=fn_out_roi_effectmap,
-                                                 geo_hdf_fn=fn_out_roi_geo,
-                                                 replace=True)
+                                        data_names=['effect_map'],
+                                        data_hdf_fn_out=fn_out_roi_effectmap,
+                                        geo_hdf_fn=fn_out_roi_geo,
+                                        replace=True)
             break
         except:
             print('problem accessing effectmap hdf5')
@@ -772,11 +772,11 @@ def write_network_detection_data_hdf5(datatype, e_matrix, response_values, base_
         fn_out_data = f"{base_path}/data_jitter_{jitter}_seed_{rn_seed}.hdf5"  # nnn
 
         # (1.1) Pick e-fields as random samples from coil positions and orientations
-        idcs = pynibs.determine_coil_position_idcs(num_idcs=num_coil_samples, all_efields=e_matrix, rn_seed=rn_seed)
+        idcs = determine_coil_position_idcs(num_idcs=num_coil_samples, all_efields=e_matrix, rn_seed=rn_seed)
         e_subset = e_matrix[idcs]
 
         # (1.2) generate  response data
-        response_values = pynibs.create_response_data(efields=e_subset, config=config)
+        response_values = create_response_data(efields=e_subset, config=config)
 
     if datatype == 'real':
         print('Real data will now be binarized.')
@@ -784,8 +784,8 @@ def write_network_detection_data_hdf5(datatype, e_matrix, response_values, base_
         fn_out_data = f"{base_path}/data_{flag}.hdf5"  # nnn
         e_subset = e_matrix
 
-    response_bin = pynibs.binarize_response_data(response_values, config['bin_method'],
-                                                 bin_factor=config['bin_factor'])
+    response_bin = binarize_response_data(response_values, config['bin_method'],
+                                          bin_factor=config['bin_factor'])
     response = np.vstack((response_values, response_bin))
     stop = time.time()
     runtime_gen = np.round(stop - start, 2)
@@ -797,12 +797,12 @@ def write_network_detection_data_hdf5(datatype, e_matrix, response_values, base_
             try:
                 with h5py.File(fn_out_data, 'w') as f:
                     f.create_dataset(
-                        'response_data',
-                        data=response
+                            'response_data',
+                            data=response
                     )
                     f.create_dataset(
-                        'e_subset',
-                        data=e_subset
+                            'e_subset',
+                            data=e_subset
                     )
                 break
             except:
@@ -814,13 +814,13 @@ def write_network_detection_data_hdf5(datatype, e_matrix, response_values, base_
     if datatype == 'artificial':
         flag = f'jitter_{jitter}_seed_{rn_seed}_hotspots'
         if config['plot_std']:
-            std_plt = pynibs.plot_data_std(response[0], e_subset[:, hotspot_idcs[0]], e_subset[:, hotspot_idcs[1]])
+            std_plt = plot_data_std(response[0], e_subset[:, hotspot_idcs[0]], e_subset[:, hotspot_idcs[1]])
             fn_std_plt = os.path.join(base_path,
                                       f'plot_std_{flag}.png')  # nnn
             std_plt.savefig(fn_std_plt, dpi=600)
             std_plt.close()
         if config['plot_bin']:
-            bin_plt = pynibs.plot_data_bin(response[1], e_subset[:, hotspot_idcs[0]], e_subset[:, hotspot_idcs[1]])
+            bin_plt = plot_data_bin(response[1], e_subset[:, hotspot_idcs[0]], e_subset[:, hotspot_idcs[1]])
             fn_bin_plt = os.path.join(base_path,
                                       f'plot_bin_{flag}.png')  # nnn
             bin_plt.savefig(fn_bin_plt, dpi=600)
@@ -828,14 +828,14 @@ def write_network_detection_data_hdf5(datatype, e_matrix, response_values, base_
         if config['plot_curves']:
             plot_idx0 = hotspot_idcs[0]
 
-            plt_curve = pynibs.plot_data_bin(np.zeros(response[1].shape), e_subset[:, plot_idx0], response[0])
+            plt_curve = plot_data_bin(np.zeros(response[1].shape), e_subset[:, plot_idx0], response[0])
             plt_curve.ylabel('response')
             plt_curve.savefig(f'{base_path}/plot_{plot_idx0}_curve_{flag}.png', dpi=600)
             plt_curve.close()
 
             plot_idx1 = hotspot_idcs[1]
 
-            plt_curve1 = pynibs.plot_data_bin(np.zeros(response[1].shape), e_subset[:, plot_idx1], response[0])
+            plt_curve1 = plot_data_bin(np.zeros(response[1].shape), e_subset[:, plot_idx1], response[0])
             plt_curve1.ylabel('response')
             plt_curve1.xlabel('E-field $h_1')
             plt_curve1.savefig(f'{base_path}/plot_{plot_idx1}_curve_{flag}.png', dpi=600)
@@ -862,9 +862,9 @@ def determine_scoring_idcs(e_subset, scoring_emag_thr=0, scoring_interval=22, me
     method : str, default: 'optimized'
         Specify method for selecting scoring indices.
 
-        ** Random elements across the ROI are picked ('random'),
-        ** Optimal elements are chosen by maximizing the distances between them. ('optimized') (Only applicable without
-        scoring emag threshold. Requires fn_geo.)
+        * `random`: Random elements across the ROI are picked ('random'),
+        * `optimized`: Optimal elements are chosen by maximizing the distances between them. ('optimized') (Only applicable without
+          scoring emag threshold. Requires fn_geo.)
 
     fn_geo : str, optional
         Required to compute element distances if method='optimized'.
@@ -895,13 +895,13 @@ def determine_scoring_idcs(e_subset, scoring_emag_thr=0, scoring_interval=22, me
         if method == 'optimized':
             with h5py.File(fn_geo, 'r') as f:
                 mesh = trimesh.Trimesh(
-                    vertices=f['mesh/nodes/node_coord'][:],
-                    faces=f['mesh/elm/triangle_number_list'][:]
+                        vertices=f['mesh/nodes/node_coord'][:],
+                        faces=f['mesh/elm/triangle_number_list'][:]
                 )
 
                 pts, scoring_idcs = trimesh.sample.sample_surface_even(
-                    mesh=mesh,
-                    count=num_subsample)
+                        mesh=mesh,
+                        count=num_subsample)
         # add additional desired index
         if required_idcs is not None:
             scoring_idcs = np.append(scoring_idcs, required_idcs)
@@ -934,13 +934,13 @@ def compute_scores_with_single_element_clf(element_idx, efields, data, weights=N
         A tuple with the index of the investigated element and an array containing the scores of this element with each
         other array element.
     """
-    dim    = efields.shape[1]
+    dim = efields.shape[1]
     scores = np.zeros(dim)
 
     num_coil_samples = data.shape[0]
-    min_samples_leaf = max(int(0.05*num_coil_samples), 1)
+    min_samples_leaf = max(int(0.05 * num_coil_samples), 1)
 
-    clf = tree.DecisionTreeClassifier(max_depth=2, min_samples_leaf=min_samples_leaf)   # ccc
+    clf = tree.DecisionTreeClassifier(max_depth=2, min_samples_leaf=min_samples_leaf)  # ccc
     # tried different parameter settings and adding max_leaf_nodes=3, didn't improve performance
 
     elmts_to_iterate_over = scoring_idcs if scoring_idcs is not None else range(dim)
@@ -979,10 +979,10 @@ def compute_scores_with_single_element_regression(element_idx, efields, data, we
         A tuple with the index of the investigated element and an array containing the scores of this element with each
         other array element.
     """
-    dim    = efields.shape[1]
+    dim = efields.shape[1]
     scores = np.zeros(dim)
     num_coil_samples = data.shape[0]
-    min_samples_leaf = max(int(0.05*num_coil_samples), 1)
+    min_samples_leaf = max(int(0.05 * num_coil_samples), 1)
     if VERBOSE:
         print(f'min_samples_leaf for scoring: {min_samples_leaf}')
 
@@ -990,7 +990,6 @@ def compute_scores_with_single_element_regression(element_idx, efields, data, we
 
     for i in elmts_to_iterate_over:
         if i > element_idx:
-
             data_var = np.var(data)
             df = pd.DataFrame({
                 'a': pd.Series(efields[:, element_idx]),
@@ -1004,11 +1003,11 @@ def compute_scores_with_single_element_regression(element_idx, efields, data, we
             #fit = model.fit(df['target'], x=df['a'], y=df['b'])
             #scores[i] = 1 - np.var(fit.residual) / data_var
 
-            def gaussian_multi(x,y,amp=1,x0=0,y0=0,sigma_x=1,sigma_y=1):
-                return amp * np.exp(-0.5* (((x-x0) / sigma_x)**2 + ((y-y0)/sigma_y)**2))
+            def gaussian_multi(x, y, amp=1, x0=0, y0=0, sigma_x=1, sigma_y=1):
+                return amp * np.exp(-0.5 * (((x - x0) / sigma_x) ** 2 + ((y - y0) / sigma_y) ** 2))
 
-            model = lmfit.Model(gaussian_multi, independent_vars=['x','y'])
-            fit = model.fit(df['target'],x=df['a'], y=df['b'])
+            model = lmfit.Model(gaussian_multi, independent_vars=['x', 'y'])
+            fit = model.fit(df['target'], x=df['a'], y=df['b'])
 
             scores[i] = 1 - np.var(fit.residual) / data_var
 
@@ -1040,16 +1039,18 @@ def compute_scores_with_all_elements(efields, data, weights=None, scoring_idcs=N
     np.ndarray of float
         (n_elms, n_elms) An upper triangle matrix containing the scores of each ROI element with all others.
     """
-    dim    = efields.shape[1]
-    scores = np.zeros((dim,dim))
+    dim = efields.shape[1]
+    scores = np.zeros((dim, dim))
 
     if scoring_method == 'clf':
         for j in range(dim):
-            element_idx, scores_row = pynibs.compute_scores_with_single_element_clf(j,efields, data[1], weights, scoring_idcs)
+            element_idx, scores_row = compute_scores_with_single_element_clf(j, efields, data[1], weights,
+                                                                             scoring_idcs)
             scores[element_idx] = scores_row
     elif scoring_method == 'regression':
         for j in range(dim):
-            element_idx, scores_row = pynibs.compute_scores_with_single_element_regression(j,efields, data[0], weights, scoring_idcs)
+            element_idx, scores_row = compute_scores_with_single_element_regression(j, efields, data[0], weights,
+                                                                                    scoring_idcs)
             scores[element_idx] = scores_row
 
     return scores
@@ -1075,28 +1076,27 @@ def compute_scores_with_all_elements_MP(efields, data, weights=None, scoring_idc
         Select 'clf' for Decision Tree Classifier, 'regression' for multivariable regression method,
         'regress_data' for one-dimensional regression method.
 
-
     Returns
     -------
     np.ndarray of float
         An upper triangle matrix containing the scores of each ROI element with all others.
     """
-    dim    = efields.shape[1]
-    scores = np.zeros((dim,dim))
+    dim = efields.shape[1]
+    scores = np.zeros((dim, dim))
 
     elmts_to_iterate_over = scoring_idcs if scoring_idcs is not None else range(dim)
 
     if scoring_method == 'clf':  # clf version: data[1] is used (binarized)
-        num_processes=multiprocessing.cpu_count()
+        num_processes = multiprocessing.cpu_count()
         with multiprocessing.Pool(processes=num_processes) as pool:
             # @TODO: monitor if chunksize=1 impairs performance; it was set to 1 to have a smoother tdqm-progress bar.
             mp_res = pool.starmap(
-                pynibs.compute_scores_with_single_element_clf,
-                tqdm(
-                    [(j,efields,data[1],weights,scoring_idcs) for j in elmts_to_iterate_over],
-                    total=len(elmts_to_iterate_over)
-                ),
-                chunksize=1
+                    compute_scores_with_single_element_clf,
+                    tqdm(
+                            [(j, efields, data[1], weights, scoring_idcs) for j in elmts_to_iterate_over],
+                            total=len(elmts_to_iterate_over)
+                    ),
+                    chunksize=1
             )
             pool.close()
             pool.join()
@@ -1106,12 +1106,12 @@ def compute_scores_with_all_elements_MP(efields, data, weights=None, scoring_idc
         with multiprocessing.Pool(processes=num_processes) as pool:
             # @TODO: monitor if chunksize=1 impairs performance; it was set to 1 to have a smoother tdqm-progress bar.
             mp_res = pool.starmap(
-                pynibs.compute_scores_with_single_element_regression,
-                tqdm(
-                    [(j, efields, data[0], weights, scoring_idcs) for j in elmts_to_iterate_over],
-                    total=len(elmts_to_iterate_over)
-                ),
-                chunksize=1
+                    compute_scores_with_single_element_regression,
+                    tqdm(
+                            [(j, efields, data[0], weights, scoring_idcs) for j in elmts_to_iterate_over],
+                            total=len(elmts_to_iterate_over)
+                    ),
+                    chunksize=1
             )
             pool.close()
             pool.join()
@@ -1170,12 +1170,12 @@ def hotspots_by_score_percentiles(scores, accumulated=False):
         Array with dimensions equal to the number of ROI elements, where elements are marked as hotspots.
     """
     # choose number of score accuracies that should contribute to the computed percentile
-    num_desired_elements  = 100
+    num_desired_elements = 100
     # each score is associated with two elements - so if we want n-elements as hotspots,
     # we must threshold n/2 scores.                 # n x n matrix of scores
-    fraction_from_all_elements = (num_desired_elements/(scores.shape[0]**2))*100
+    fraction_from_all_elements = (num_desired_elements / (scores.shape[0] ** 2)) * 100
     # somehow num_desired_element doesn't have the desired effect, but threshold still works well
-    percentile = np.percentile(scores,100-fraction_from_all_elements)
+    percentile = np.percentile(scores, 100 - fraction_from_all_elements)
 
     hotspot_idcs = np.array(np.where(scores >= percentile))
     hotspots = np.zeros(scores.shape[0])
@@ -1183,7 +1183,7 @@ def hotspots_by_score_percentiles(scores, accumulated=False):
     if accumulated:
         np.add.at(hotspots, hotspot_idcs.flatten(), 1)
     else:
-        hotspots[ hotspot_idcs.flatten() ] = 1
+        hotspots[hotspot_idcs.flatten()] = 1
 
     return hotspots, hotspot_idcs
 
@@ -1247,29 +1247,29 @@ def write_hotspot_scoremap_hdf5(datatype, e_subset, data, roi_surf, fn_geo, base
     # select the relevant idcs
     scoring_emag_thr = config['scoring_emag_thr']
     scoring_interval = config['scoring_interval']
-    scoring_idcs = pynibs.determine_scoring_idcs(e_subset, scoring_emag_thr, scoring_interval,
-                                                 method='optimized', fn_geo=fn_geo, required_idcs=required_idcs)
+    scoring_idcs = determine_scoring_idcs(e_subset, scoring_emag_thr, scoring_interval,
+                                          method='optimized', fn_geo=fn_geo, required_idcs=required_idcs)
 
     # calculate scores and potential hotspots
     # SINGLE NODE METHODS: regress_data and mutual information score
     if config['scoring_method'] == 'regress_data':  # only for single node case
         con = roi_surf.node_number_list
         score_map = np.zeros(e_subset.shape[1])
-        score_map[scoring_idcs] = pynibs.regress_data(e_matrix=e_subset,
-                                        mep=data[0],
-                                        elm_idx_list=scoring_idcs,
-                                        # fun='linear',
-                                        n_cpu=160,
-                                        con=con,
-                                        n_refit=0,
-                                        return_fits=False,
-                                        score_type='R2',
-                                        verbose=True,
-                                        pool=None,
-                                        refit_discontinuities=False,
-                                        select_signed_data=False)
+        score_map[scoring_idcs] = pynibs.regression.regress_data(e_matrix=e_subset,
+                                                                 mep=data[0],
+                                                                 elm_idx_list=scoring_idcs,
+                                                                 # fun='linear',
+                                                                 n_cpu=160,
+                                                                 con=con,
+                                                                 n_refit=0,
+                                                                 return_fits=False,
+                                                                 score_type='R2',
+                                                                 verbose=True,
+                                                                 pool=None,
+                                                                 refit_discontinuities=False,
+                                                                 select_signed_data=False)
         scores = score_map
-        hotspots = score_map # only because in dual node approaches, this variable is needed
+        hotspots = score_map  # only because in dual node approaches, this variable is needed
 
     elif config['scoring_method'] == 'mi':  # only for single node case
         # Compute Mutual Information for each feature
@@ -1277,17 +1277,17 @@ def write_hotspot_scoremap_hdf5(datatype, e_subset, data, roi_surf, fn_geo, base
         # subsampling
         scores = np.zeros(e_subset.shape[1])
         scores[scoring_idcs] = mi_scores
-        hotspots = scores # only because in dual node approaches, this variable is needed
+        hotspots = scores  # only because in dual node approaches, this variable is needed
         score_map = scores
 
     # DUAL NODE METHODS: classifier and regression based scoring
-    else: # dual nodes expected
-        scores = pynibs.compute_scores_with_all_elements_MP(e_subset, data, scoring_idcs=scoring_idcs,
-                                                            scoring_method=config['scoring_method'])
+    else:  # dual nodes expected
+        scores = compute_scores_with_all_elements_MP(e_subset, data, scoring_idcs=scoring_idcs,
+                                                     scoring_method=config['scoring_method'])
 
         score_map = np.max(scores, axis=0)
 
-        hotspots = pynibs.hotspots_by_score_percentiles(scores, accumulated=True)[0]
+        hotspots = hotspots_by_score_percentiles(scores, accumulated=True)[0]
 
     if config['save_files']:
         # save data as hdf5 _geo file (mapped)
@@ -1295,20 +1295,20 @@ def write_hotspot_scoremap_hdf5(datatype, e_subset, data, roi_surf, fn_geo, base
         while True:
             try:
                 pynibs.write_geo_hdf5_surf(out_fn=fn_out_roi_geo,
-                                                    points=roi_surf.node_coord_mid,
-                                                    con=roi_surf.node_number_list,
-                                                    replace=True,
-                                                    hdf5_path='/mesh')
+                                           points=roi_surf.node_coord_mid,
+                                           con=roi_surf.node_number_list,
+                                           replace=True,
+                                           hdf5_path='/mesh')
                 pynibs.write_data_hdf5_surf(data=hotspots,
-                                                     data_names='res_hotspots',
-                                                     data_hdf_fn_out=fn_out_roi_hotpot_data,
-                                                     geo_hdf_fn=fn_out_roi_geo,
-                                                     replace=True)
+                                            data_names='res_hotspots',
+                                            data_hdf_fn_out=fn_out_roi_hotpot_data,
+                                            geo_hdf_fn=fn_out_roi_geo,
+                                            replace=True)
                 pynibs.write_data_hdf5_surf(data=score_map,
-                                                     data_names='res_scoremap',
-                                                     data_hdf_fn_out=fn_out_roi_scoremap,
-                                                     geo_hdf_fn=fn_out_roi_geo,
-                                                     replace=True)
+                                            data_names='res_scoremap',
+                                            data_hdf_fn_out=fn_out_roi_scoremap,
+                                            geo_hdf_fn=fn_out_roi_geo,
+                                            replace=True)
                 break
             except:
                 print('problem writing score hdf5')
@@ -1336,7 +1336,6 @@ def compute_correlation_with_all_elements(e_subset, elm_idx):
     corr_coeff : np.ndarray
         (n_elms) Array containing the absolute Pearson correlation coefficients of elm_idx with each other element.
     """
-
     corr_coeff = np.zeros(e_subset.shape[1])
     x = e_subset[:, elm_idx]
     for idx in range(0, e_subset.shape[1]):
@@ -1345,7 +1344,7 @@ def compute_correlation_with_all_elements(e_subset, elm_idx):
             pearson_res = scipy.stats.pearsonr(x, y)
             corr_coeff[idx] = abs(pearson_res[0])
         else:
-            corr_coeff[idx] = (x==y)
+            corr_coeff[idx] = (x == y)
     return corr_coeff
 
 
@@ -1385,11 +1384,11 @@ def find_distinct_hotspots(scorematrix, hotspot_mask, e_subset, acc_thr, corr_th
     found_bool = [False, False]
 
     # first hotspot: take the max score, if multiple maximums the one with the max accuracy
-    
+
     # Find the indices of the maximum values in hotspot_mask
     max_indices = np.argwhere(hotspot_mask == np.max(hotspot_mask))
     # Create a list of (max_indices, accuracy) pairs
-    hotspot_info = [(idx, np.nanmax(scorematrix[:,idx])) for idx in max_indices]
+    hotspot_info = [(idx, np.nanmax(scorematrix[:, idx])) for idx in max_indices]
     # Find the entry with the highest accuracy
     max_entry = max(hotspot_info, key=lambda x: x[1])
     # Extract the max_index
@@ -1399,12 +1398,12 @@ def find_distinct_hotspots(scorematrix, hotspot_mask, e_subset, acc_thr, corr_th
     # check whether hotspot 0 meets hotspot criteria: accuracy threshold and score threshold.
     # The score threshold is hardcoded because it is mostly to keep very strong single hotspot cases from running too
     # long: they often have one hotspot with a very high score and every other element has score 1.
-    found_bool[0] = bool((hotspot_scores[0]>=2 and hotspot_acc[0]>=acc_thr))
+    found_bool[0] = bool((hotspot_scores[0] >= 2 and hotspot_acc[0] >= acc_thr))
 
     # second hotspot: next maximum score checking hotspot and correlation criteria
     if found_bool[0]:
         hotspot_mask[hotspot_idcs[0]] = 0
-        correlations = pynibs.compute_correlation_with_all_elements(e_subset, hotspot_idcs[0])
+        correlations = compute_correlation_with_all_elements(e_subset, hotspot_idcs[0])
 
         while np.max(hotspot_mask) > 1 and not found_bool[1]:
             # Find the indices of the maximum values in hotspot_mask
@@ -1419,13 +1418,13 @@ def find_distinct_hotspots(scorematrix, hotspot_mask, e_subset, acc_thr, corr_th
             hot_candi_scores = hotspot_mask[hot_candi]
 
             # check whether hotspot candidate meets hotspot criteria, if not: ignore this one and keep looking
-            if correlations[hot_candi] < corr_thr and bool((hot_candi_scores>=2 and hot_candi_acc>=acc_thr)):
+            if correlations[hot_candi] < corr_thr and bool((hot_candi_scores >= 2 and hot_candi_acc >= acc_thr)):
                 hotspot_idcs[1] = hot_candi
                 hotspot_scores[1] = hot_candi_scores
                 hotspot_acc[1] = hot_candi_acc
                 found_bool[1] = True
             else:
-                hotspot_mask[hot_candi] = 0 # ignore this one
+                hotspot_mask[hot_candi] = 0  # ignore this one
 
     return hotspot_idcs, hotspot_scores, hotspot_acc, found_bool
 
@@ -1464,7 +1463,7 @@ def find_distinct_single_hotspot(hotspot_mask, acc_thr):
 
     hotspot_acc[0] = hotspot_mask[hotspot_idcs[0]]
     hotspot_scores[0] = hotspot_mask[hotspot_idcs[0]]
-    found_bool[0] = bool(hotspot_acc[0]>=acc_thr)
+    found_bool[0] = bool(hotspot_acc[0] >= acc_thr)
 
     return hotspot_idcs, hotspot_scores, hotspot_acc, found_bool
 
@@ -1493,11 +1492,11 @@ def calc_dist_pairwise(fn_geo, idx0, idx1):
     roi_tris = roi_geo_h5["mesh/elm/triangle_number_list"][:]
     roi_nodes = roi_geo_h5["mesh/nodes/node_coord"][:]
 
-    distances = pynibs.geodesic_dist(
-        tris=roi_tris,
-        nodes=roi_nodes,
-        source=idx0,
-        source_is_node=False
+    distances = pynibs.util.quality_measures.geodesic_dist(
+            tris=roi_tris,
+            nodes=roi_nodes,
+            source=idx0,
+            source_is_node=False
     )[1]
     distance = distances[idx1]
 
@@ -1505,11 +1504,11 @@ def calc_dist_pairwise(fn_geo, idx0, idx1):
         print(f'****** Attention! ****** \n'
               f'Distance between {idx0} and {idx1} could not be measured geodesically, euclidean distance is used. \n'
               f'******************')
-        distances = pynibs.euclidean_dist(
-            tris=roi_tris,
-            nodes=roi_nodes,
-            source=idx0,
-            source_is_node=False
+        distances = pynibs.util.quality_measures.euclidean_dist(
+                tris=roi_tris,
+                nodes=roi_nodes,
+                source=idx0,
+                source_is_node=False
         )[1]
         distance = distances[idx1]
 
@@ -1538,8 +1537,8 @@ def assign_found_hotspot_single(fn_geo, hotspot_idcs, found_idx):
     print('Hotspot is assigned.')
 
     # a and b real hotspots, c found hotspot
-    dist_ac = pynibs.calc_dist_pairwise(fn_geo, hotspot_idcs[0], found_idx)
-    dist_bc = pynibs.calc_dist_pairwise(fn_geo, hotspot_idcs[1], found_idx)
+    dist_ac = calc_dist_pairwise(fn_geo, hotspot_idcs[0], found_idx)
+    dist_bc = calc_dist_pairwise(fn_geo, hotspot_idcs[1], found_idx)
 
     if dist_ac <= dist_bc:
         # then a gets assigned c
@@ -1571,10 +1570,10 @@ def assign_found_hotspots(fn_geo, hotspot_idcs, found_idcs):
     print('Hotspots are assigned.')
 
     # a and b real hotspots, c and d found hotspots
-    dist_ac = pynibs.calc_dist_pairwise(fn_geo, hotspot_idcs[0], found_idcs[0])
-    dist_bc = pynibs.calc_dist_pairwise(fn_geo, hotspot_idcs[1], found_idcs[0])
-    dist_ad = pynibs.calc_dist_pairwise(fn_geo, hotspot_idcs[0], found_idcs[1])
-    dist_bd = pynibs.calc_dist_pairwise(fn_geo, hotspot_idcs[1], found_idcs[1])
+    dist_ac = calc_dist_pairwise(fn_geo, hotspot_idcs[0], found_idcs[0])
+    dist_bc = calc_dist_pairwise(fn_geo, hotspot_idcs[1], found_idcs[0])
+    dist_ad = calc_dist_pairwise(fn_geo, hotspot_idcs[0], found_idcs[1])
+    dist_bd = calc_dist_pairwise(fn_geo, hotspot_idcs[1], found_idcs[1])
 
     if dist_ac + dist_bd <= dist_bc + dist_ad:
         # then a gets assigned c and b gets assigned d
@@ -1610,21 +1609,21 @@ def get_quadrant_samples(e_field0, e_field1):
 
     # First get portion of distances horizontally and vertically to shift the four values slightly into the middle
     # (offset). No offset would mean the reference points are at the corners of the rectangle spanned by the data.
-    h = (max(e_field0) - min(e_field0))/24
-    v = (max(e_field1) - min(e_field1))/24
+    h = (max(e_field0) - min(e_field0)) / 24
+    v = (max(e_field1) - min(e_field1)) / 24
 
     # 1 (bottom left)
-    x = np.array(min(e_field0)+h)
-    y = np.array(min(e_field1)+v)
+    x = np.array(min(e_field0) + h)
+    y = np.array(min(e_field1) + v)
     # 2 (top left)
-    x = np.append(x, min(e_field0)+h)
-    y = np.append(y, max(e_field1)-v)
+    x = np.append(x, min(e_field0) + h)
+    y = np.append(y, max(e_field1) - v)
     # 3 (bottom right)
-    x = np.append(x, max(e_field0)-h)
-    y = np.append(y, min(e_field1)+v)
+    x = np.append(x, max(e_field0) - h)
+    y = np.append(y, min(e_field1) + v)
     # 4 (top right)
-    x = np.append(x, max(e_field0)-h)
-    y = np.append(y, max(e_field1)-v)
+    x = np.append(x, max(e_field0) - h)
+    y = np.append(y, max(e_field1) - v)
 
     return np.vstack((x, y)).transpose()
 
@@ -1652,7 +1651,7 @@ def identify_shape(idx, scorematrix, e_subset, response):
         Vector indicating shape of decision trees used in scoring the element in question (network type vector).
     """
     num_coil_samples = int(response[0].shape[0])
-    min_samples_leaf = max(int(0.05*num_coil_samples), 1)
+    min_samples_leaf = max(int(0.05 * num_coil_samples), 1)
     if VERBOSE:
         print(f'min_samples_leaf for identify_shape: {min_samples_leaf}')
 
@@ -1664,7 +1663,7 @@ def identify_shape(idx, scorematrix, e_subset, response):
     # get indices of those elements that 'gave' element 'idx' its hotspot score (meaning: with these elements a score
     # higher than a calculated threshold was achieved)
     # because those are the elements the network identification is based on
-    hotspot_idcs = pynibs.hotspots_by_score_percentiles(scorematrix, accumulated=False)[1]
+    hotspot_idcs = hotspots_by_score_percentiles(scorematrix, accumulated=False)[1]
     hotspot_pairs = hotspot_idcs.transpose()
     for i in np.arange(0, hotspot_pairs.shape[0], 1):
         if hotspot_pairs[i, 0] == idx:
@@ -1677,9 +1676,9 @@ def identify_shape(idx, scorematrix, e_subset, response):
         iterate_idcs = np.argpartition(scorematrix[idx], -500)[-500:]
         print(f'Because of a exceptionally many elements element {idx} has a high accuracy with, only the 500 ones with'
               ' highest accuracy were used for network type computation.')
-        shape[0]=-500
+        shape[0] = -500
 
-    elmts_to_iterate_over = iterate_idcs[iterate_idcs!=idx]
+    elmts_to_iterate_over = iterate_idcs[iterate_idcs != idx]
 
     clf = tree.DecisionTreeClassifier(max_depth=2, min_samples_leaf=min_samples_leaf)  # ccc
     # tried different parameter settings and adding max_leaf_nodes=3, didn't improve performance
@@ -1699,10 +1698,10 @@ def identify_shape(idx, scorematrix, e_subset, response):
         # shape parameter has 9 entries, ignore shape[0], shape[1:8] represent the 8 network types
         q_samples = get_quadrant_samples(e_field0, e_field1)
         pred = clf.predict(q_samples)
-        network_nr = 1 + pred[3] + 2*pred[2] + 4*pred[1]
+        network_nr = 1 + pred[3] + 2 * pred[2] + 4 * pred[1]
         # shape[1] += pred[0] - worth a try
         # could use pred[0] for multiple things, like help distinguish shape 5 and 6
-        shape[int(network_nr)] +=1
+        shape[int(network_nr)] += 1
 
     if VERBOSE:
         print(shape)
@@ -1735,8 +1734,8 @@ def identify_network_type(found_idcs, scorematrix, e_subset, response):
         value of the second most probable network)
     """
     # calculate network type vectors
-    shape_0 = pynibs.identify_shape(found_idcs[0], scorematrix, e_subset, response)
-    shape_1 = pynibs.identify_shape(found_idcs[1], scorematrix, e_subset, response)
+    shape_0 = identify_shape(found_idcs[0], scorematrix, e_subset, response)
+    shape_1 = identify_shape(found_idcs[1], scorematrix, e_subset, response)
 
     # axes are wrong for hotspot 1 (since it is on the y axis in the quadrant logic that the shape parameter is based
     # on), switch the asymmetric types: type 4<->6 and type 3<->5
@@ -1830,12 +1829,12 @@ def whole_network_detection(e_subset, response_data, scorematrix, hotspot_mask,
     network_type_certainty = np.nan
     shape_vector = np.full(9, np.nan)
     found_distance = [np.nan, np.nan]
-    if config['scoring_method'] == 'regress_data' or config['scoring_method'] == 'mi':   # single node approaches
+    if config['scoring_method'] == 'regress_data' or config['scoring_method'] == 'mi':  # single node approaches
         found_idcs, found_scores, found_acc, found_bool = \
-            pynibs.find_distinct_single_hotspot(hotspot_mask, acc_thr)
+            find_distinct_single_hotspot(hotspot_mask, acc_thr)
     else:  # dual node approach
         found_idcs, found_scores, found_acc, found_bool = \
-            pynibs.find_distinct_hotspots(scorematrix, hotspot_mask, e_subset, acc_thr, corr_thr)
+            find_distinct_hotspots(scorematrix, hotspot_mask, e_subset, acc_thr, corr_thr)
 
     # 1 hotspot found
     if found_bool[0] and not found_bool[1]:
@@ -1847,7 +1846,7 @@ def whole_network_detection(e_subset, response_data, scorematrix, hotspot_mask,
     elif found_bool[0] and found_bool[1]:
         print('Two potential hotspots were detected.')
         (found_network_type, shape_vector, network_type_certainty) = \
-            pynibs.identify_network_type(found_idcs, scorematrix, e_subset, response_data)
+            identify_network_type(found_idcs, scorematrix, e_subset, response_data)
         print(f'Identified network type: ({found_network_type}) for hotspots {found_idcs}')
 
     else:
@@ -1860,13 +1859,13 @@ def whole_network_detection(e_subset, response_data, scorematrix, hotspot_mask,
     # plot response data on plain spanned by both hotspot efields
     if found_bool[0] and found_bool[1]:
         if config['plot_std']:
-            std_plt = pynibs.plot_data_std(response_data[0], e_subset[:, found_idcs[0]], e_subset[:, found_idcs[1]])
+            std_plt = plot_data_std(response_data[0], e_subset[:, found_idcs[0]], e_subset[:, found_idcs[1]])
             fn_std_plt = os.path.join(base_path,
                                       f'plot_std_found_hotspots_{found_idcs[0]}_{found_idcs[1]}.png')  # nnn
             std_plt.savefig(fn_std_plt, dpi=600)
             std_plt.close()
         if config['plot_bin']:
-            bin_plt = pynibs.plot_data_bin(response_data[1], e_subset[:, found_idcs[0]], e_subset[:, found_idcs[1]])
+            bin_plt = plot_data_bin(response_data[1], e_subset[:, found_idcs[0]], e_subset[:, found_idcs[1]])
             fn_bin_plt = os.path.join(base_path,
                                       f'plot_bin_found_hotspots_{found_idcs[0]}_{found_idcs[1]}.png')  # nnn
             bin_plt.savefig(fn_bin_plt, dpi=600)
@@ -1874,13 +1873,14 @@ def whole_network_detection(e_subset, response_data, scorematrix, hotspot_mask,
     if config['plot_curves']:
         if found_bool[0]:
             plot_idx0 = found_idcs[0]
-            plt_curve = pynibs.plot_data_bin(np.zeros(response_data[1].shape), e_subset[:, plot_idx0], response_data[0])
+            plt_curve = plot_data_bin(np.zeros(response_data[1].shape), e_subset[:, plot_idx0], response_data[0])
             plt_curve.ylabel('response')
             plt_curve.savefig(f'{base_path}/plot_found_hotspot_{plot_idx0}_curve.png', dpi=600)
             plt_curve.close()
         if found_bool[1]:
             plot_idx1 = found_idcs[1]
-            plt_curve1 = pynibs.plot_data_bin(np.zeros(response_data[1].shape), e_subset[:, plot_idx1], response_data[0])
+            plt_curve1 = plot_data_bin(np.zeros(response_data[1].shape), e_subset[:, plot_idx1],
+                                       response_data[0])
             plt_curve1.ylabel('response')
             plt_curve1.xlabel('E-field $h_1')
             plt_curve1.savefig(f'{base_path}/plot_found_hotspot_{plot_idx1}_curve.png', dpi=600)
@@ -1924,7 +1924,7 @@ def write_nda_test_results_csv(runtimes, e_subset, response_data, hotspot_mask,
     # (1) read config params and results
     hotspot_idcs = (config['hotspot_elm0'], config['hotspot_elm1'])
     found_network_type, found_idcs, found_acc, found_distance, found_scores, \
-        network_type_certainty, shape_vector  = detection_result
+        network_type_certainty, shape_vector = detection_result
 
     # (2) hotspot assignment to enable network identification evaluation
 
@@ -1946,7 +1946,7 @@ def write_nda_test_results_csv(runtimes, e_subset, response_data, hotspot_mask,
 
     # 2 hotspots found: assign hotspots so that total distances are minimized for more precise evaluation
     elif found_network_type != 1:
-        assignment = pynibs.assign_found_hotspots(fn_geo, hotspot_idcs, found_idcs)
+        assignment = assign_found_hotspots(fn_geo, hotspot_idcs, found_idcs)
         found_distance = [np.round(assignment[0], 2), np.round(assignment[1], 2)]
         # switch hotspot order if reassignment necessary
         if found_idcs[1] == assignment[2][0]:
@@ -1967,33 +1967,35 @@ def write_nda_test_results_csv(runtimes, e_subset, response_data, hotspot_mask,
 
     # (3) evaluation
     # collect additional info for result evaluation
-    real_hotspot_dist = np.round(pynibs.calc_dist_pairwise(fn_geo, hotspot_idcs[0], hotspot_idcs[1]), 2)
-    real_hotspot_corr = np.round(pynibs.compute_correlation_with_all_elements(e_subset, hotspot_idcs[0])[hotspot_idcs[1]], 2)
+    real_hotspot_dist = np.round(calc_dist_pairwise(fn_geo, hotspot_idcs[0], hotspot_idcs[1]), 2)
+    real_hotspot_corr = np.round(
+            compute_correlation_with_all_elements(e_subset, hotspot_idcs[0])[hotspot_idcs[1]], 2)
     hotspot_0_emax = np.round(np.max(e_subset[:, hotspot_idcs[0]]), 3)
     hotspot_1_emax = np.round(np.max(e_subset[:, hotspot_idcs[1]]), 3)
     num_hotspot_candidates = np.count_nonzero(hotspot_mask)
     found_accuracy = (np.round(found_acc[0], 3), np.round(found_acc[1], 3))
     if found_network_type in [4, 6, 1]:
-        found_hotspots_dist, found_hotspots_corr = np.nan,np.nan
+        found_hotspots_dist, found_hotspots_corr = np.nan, np.nan
     else:  # compute found hotspot distance and correlation for dual hotspot types
-        found_hotspots_dist = np.round(pynibs.calc_dist_pairwise(fn_geo, found_idcs[0], found_idcs[1]), 2)
+        found_hotspots_dist = np.round(calc_dist_pairwise(fn_geo, found_idcs[0], found_idcs[1]), 2)
         found_hotspots_corr = np.round(
-            pynibs.compute_correlation_with_all_elements(e_subset, found_idcs[0])[found_idcs[1]], 2)
+                compute_correlation_with_all_elements(e_subset, found_idcs[0])[found_idcs[1]], 2)
 
     # evaluate network type identification: 1 means the network was correctly identified, 0 otherwise
     network_types = ['NO', 'AND', '1_INH_0', 'SH_0', '0_INH_1', 'SH_1', 'XOR', 'OR']
-    real_network_type = network_types.index(config['network_type'])+1
-    identification_evaluation = pynibs.evaluate_network_identification(real_hotspot_dist, real_network_type, found_network_type)
+    real_network_type = network_types.index(config['network_type']) + 1
+    identification_evaluation = evaluate_network_identification(real_hotspot_dist, real_network_type,
+                                                                found_network_type)
 
     # evaluate hotspot localization: 1 means active hotspots were localized within 10mm, 0 otherwise
     if real_network_type == 1:
-        localization_evaluation=identification_evaluation
+        localization_evaluation = identification_evaluation
     elif real_network_type == 4:
         localization_evaluation = int(found_distance[0] < 10)
     elif real_network_type == 6:
         localization_evaluation = int(found_distance[1] < 10)
     else:
-        localization_evaluation = int((found_distance[0] < 10) and (found_distance[1]<10))
+        localization_evaluation = int((found_distance[0] < 10) and (found_distance[1] < 10))
 
     # save information about the response
     response_max = np.round(np.max(response_data[0]), 3)
@@ -2018,8 +2020,8 @@ def write_nda_test_results_csv(runtimes, e_subset, response_data, hotspot_mask,
                             np.round(found_scores[0], 2), np.round(found_scores[1], 2),
                             found_accuracy[0], found_accuracy[1],
                             found_hotspots_corr, found_hotspots_dist,
-                           found_network_type, np.round(network_type_certainty, 2)])
-    output_csv=np.append(output_csv, shape_vector)
+                            found_network_type, np.round(network_type_certainty, 2)])
+    output_csv = np.append(output_csv, shape_vector)
     # evaluation results (only in case of artificial data / testing reasons)
     output_csv = np.append(output_csv,
                            [identification_evaluation, localization_evaluation,
@@ -2051,7 +2053,8 @@ def write_nda_test_results_csv(runtimes, e_subset, response_data, hotspot_mask,
     print(f'Saved results and evaluation in {fn_results}.csv \n **** \n ')
 
 
-def write_nda_application_results_csv(runtimes, e_subset, response_data, hotspot_mask, detection_result, fn_geo, config):
+def write_nda_application_results_csv(runtimes, e_subset, response_data, hotspot_mask, detection_result, fn_geo,
+                                      config):
     """
     Writes network detection results to a CSV file based on the provided parameters and configuration for real data.
     See output_documentation.md for more.
@@ -2083,13 +2086,13 @@ def write_nda_application_results_csv(runtimes, e_subset, response_data, hotspot
     found_accuracy = (np.round(found_acc[0], 3), np.round(found_acc[1], 3))
     # translate real network type id name into network name
     network_types = ['NO', 'AND', '1_INH_0', 'SH_0', '0_INH_1', 'SH_1', 'XOR', 'OR']
-    found_network_name = network_types[found_network_type-1]
+    found_network_name = network_types[found_network_type - 1]
     if found_network_type in [4, 6, 1]:
         found_hotspots_dist, found_hotspots_corr = np.nan, np.nan
     else:  # compute found hotspot distance and correlation for dual hotspot types
-        found_hotspots_dist = np.round(pynibs.calc_dist_pairwise(fn_geo, found_idcs[0], found_idcs[1]), 2)
+        found_hotspots_dist = np.round(calc_dist_pairwise(fn_geo, found_idcs[0], found_idcs[1]), 2)
         found_hotspots_corr = np.round(
-            pynibs.compute_correlation_with_all_elements(e_subset, found_idcs[0])[found_idcs[1]], 2)
+                compute_correlation_with_all_elements(e_subset, found_idcs[0])[found_idcs[1]], 2)
 
     # read relevant parameters from config file
     values = config.values()
@@ -2124,7 +2127,8 @@ def write_nda_application_results_csv(runtimes, e_subset, response_data, hotspot
         fn_results = config['fn_results']
         try:
             # open the evaluation csv file in write mode
-            with open(f'/data/pt_01756/studies/network_mapping/evaluation_files_realdata/{fn_results}.csv', 'a', newline='',
+            with open(f'/data/pt_01756/studies/network_mapping/evaluation_files_realdata/{fn_results}.csv', 'a',
+                      newline='',
                       encoding='UTF8') as f:
                 # create the csv writer
                 writer = csv.writer(f)
@@ -2165,13 +2169,15 @@ def network_detection_algorithm_testing(e_matrix, roi_surf, fn_geo, base_path, c
     runtimes = np.zeros(shape=3)
     # apply network detection algorithm (steps 1-3) to artificially generated data and evaluate results:
     # (0) generate and (1) binarize response data
-    e_subset, response = pynibs.write_network_detection_data_hdf5('artificial', e_matrix, None, base_path, config)
+    e_subset, response = write_network_detection_data_hdf5('artificial', e_matrix, None, base_path, config)
     # (2) scoring
-    runtimes[1], scorematrix, hotspot_mask = pynibs.write_hotspot_scoremap_hdf5('artificial', e_subset, response, roi_surf, fn_geo, base_path, config)
+    runtimes[1], scorematrix, hotspot_mask = write_hotspot_scoremap_hdf5('artificial', e_subset, response,
+                                                                         roi_surf, fn_geo, base_path, config)
     # (3) detection (localization and identification)
-    runtimes[2], detection_result = pynibs.whole_network_detection(e_subset, response, scorematrix, hotspot_mask, base_path, config)
+    runtimes[2], detection_result = whole_network_detection(e_subset, response, scorematrix, hotspot_mask,
+                                                            base_path, config)
     # automatically evaluate results
-    pynibs.write_nda_test_results_csv(runtimes, e_subset, response, hotspot_mask, detection_result, fn_geo, config)
+    write_nda_test_results_csv(runtimes, e_subset, response, hotspot_mask, detection_result, fn_geo, config)
 
 
 def network_detection_algorithm_application(e_matrix, response_values, roi_surf, fn_geo, base_path, config):
@@ -2201,16 +2207,20 @@ def network_detection_algorithm_application(e_matrix, response_values, roi_surf,
 
     # apply network detection algorithm
     # (1) binarization:
-    e_subset, response  = pynibs.write_network_detection_data_hdf5('real', e_matrix, response_values, base_path, config)
+    e_subset, response = write_network_detection_data_hdf5('real', e_matrix, response_values, base_path, config)
     # (2) score calculation
-    runtimes[1], scorematrix, hotspot_mask = pynibs.write_hotspot_scoremap_hdf5('real', e_subset, response, roi_surf, fn_geo, base_path, config)
+    runtimes[1], scorematrix, hotspot_mask = write_hotspot_scoremap_hdf5('real', e_subset, response, roi_surf,
+                                                                         fn_geo, base_path, config)
     # (3) detection
-    runtimes[2], detection_result = pynibs.whole_network_detection(e_subset, response, scorematrix, hotspot_mask, base_path, config)
+    runtimes[2], detection_result = whole_network_detection(e_subset, response, scorematrix, hotspot_mask,
+                                                            base_path, config)
 
     # save results in .csv (and write effect map if wanted)
-    pynibs.write_nda_application_results_csv(runtimes, e_subset, response, hotspot_mask, detection_result, fn_geo, config)
+    write_nda_application_results_csv(runtimes, e_subset, response, hotspot_mask, detection_result, fn_geo,
+                                      config)
     if config['write_effect_map']:
-        pynibs.write_effect_map_hdf5('real', e_matrix, roi_surf, detection_result, base_path, config)
+        write_effect_map_hdf5('real', e_matrix, roi_surf, detection_result, base_path, config)
+
 
 #
 # ARCHIVE
@@ -2372,4 +2382,4 @@ def compute_scores_and_shape_with_single_element(element_idx, efields, data, wei
 
 
 
-'''
+'''