bmtool 0.5.4__py3-none-any.whl → 0.5.6__py3-none-any.whl

bmtool/connectors.py

@@ -5,6 +5,8 @@ from scipy.optimize import minimize_scalar
 from functools import partial
 import time
 import types
+import pandas as pd
+import re
 
 rng = np.random.default_rng()
 
@@ -220,7 +222,7 @@ class GaussianDropoff(DistantDependentProbability):
                     "Probability crosses 1 at distance %.3g.\n") % (pmax, d)
             if self.ptotal is not None:
                 warn += " ptotal may not be reached."
-            print(warn)
+            print(warn,flush=True)
             self.probability = lambda dist: np.fmin(probability(dist), 1.)
         else:
             self.probability = probability
@@ -333,7 +335,7 @@ class Timer(object):
         return (time.perf_counter() - self._start) * self.scale
 
     def report(self, msg='Run time'):
-        print((msg + ": %.3f " + self.unit) % self.end())
+        print((msg + ": %.3f " + self.unit) % self.end(),flush=True)
 
 
 def pr_2_rho(p0, p1, pr):
@@ -353,7 +355,7 @@ def rho_2_pr(p0, p1, rho):
         pr0, pr = pr, np.max((0., p0 + p1 - 1, np.min((p0, p1, pr))))
         rho0, rho = rho, (pr - p0 * p1) / (p0 * (1 - p0) * p1 * (1 - p1)) ** .5
         print('rho changed from %.3f to %.3f; pr changed from %.3f to %.3f'
-              % (rho0, rho, pr0, pr))
+              % (rho0, rho, pr0, pr),flush=True)
     return pr
 
 
@@ -532,7 +534,7 @@ class ReciprocalConnector(AbstractConnector):
                  pr=0., pr_arg=None, estimate_rho=True, rho=None,
                  dist_range_forward=None, dist_range_backward=None,
                  n_syn0=1, n_syn1=1, autapses=False,
-                 quick_pop_check=False, cache_data=True, verbose=True):
+                 quick_pop_check=False, cache_data=True, verbose=True,save_report=True,report_name='connection_report.csv'):
         args = locals()
         var_set = ('p0', 'p0_arg', 'p1', 'p1_arg',
                    'pr', 'pr_arg', 'n_syn0', 'n_syn1')
@@ -550,6 +552,8 @@ class ReciprocalConnector(AbstractConnector):
         self.quick = quick_pop_check
         self.cache = self.ConnectorCache(cache_data and self.estimate_rho)
         self.verbose = verbose
+        self.save_report = save_report
+        self.report_name = report_name
 
         self.conn_prop = [{}, {}]
         self.stage = 0
@@ -664,12 +668,12 @@ class ReciprocalConnector(AbstractConnector):
                         fetch = out_len > 0
                         if not fetch:
                             print("\nWarning: Cache did not work properly for "
-                                  + func_name + '\n')
+                                  + func_name + '\n',flush=True)
                         self.fetch_output(func_name, fetch)
                     self.iter_count = 0
                 else:
                     # if output not correct, disable and use original function
-                    print("\nWarning: Cache did not work properly.\n")
+                    print("\nWarning: Cache did not work properly.\n",flush=True)
                     for func_name in self.cache_dict:
                         self.fetch_output(func_name, False)
                     self.enable = False
@@ -828,7 +832,7 @@ class ReciprocalConnector(AbstractConnector):
             self.cache.cache_output(var, name, name in self.callable_set)
         if self.verbose and len(self.cache.cache_dict):
             print('Output of %s will be cached.'
-                  % ', '.join(self.cache.cache_dict))
+                  % ', '.join(self.cache.cache_dict),flush=True)
 
     def setup_dist_range_checker(self):
         # Checker that determines whether to consider a pair for rho estimation
@@ -864,7 +868,7 @@ class ReciprocalConnector(AbstractConnector):
         if self.verbose:
             src_str, trg_str = self.get_nodes_info()
             print("\nStart building connection between: \n  "
-                  + src_str + "\n  " + trg_str)
+                  + src_str + "\n  " + trg_str,flush=True)
         self.initialize()
         cache = self.cache  # write mode
 
@@ -889,11 +893,11 @@ class ReciprocalConnector(AbstractConnector):
                 rho = (self.pr() * n - p0p1_sum) / norm_fac_sum
                 if abs(rho) > 1:
                     print("\nWarning: Estimated value of rho=%.3f "
-                          "outside the range [-1, 1]." % rho)
+                          "outside the range [-1, 1]." % rho,flush=True)
                     rho = np.clip(rho, -1, 1).item()
-                    print("Force rho to be %.0f.\n" % rho)
+                    print("Force rho to be %.0f.\n" % rho,flush=True)
                 elif self.verbose:
-                    print("Estimated value of rho=%.3f" % rho)
+                    print("Estimated value of rho=%.3f" % rho,flush=True)
                 self.rho = rho
             else:
                 self.rho = 0
@@ -945,8 +949,10 @@ class ReciprocalConnector(AbstractConnector):
         if self.verbose:
             self.timer.report('Total time for creating connection matrix')
             if self.wrong_pr:
-                print("Warning: Value of 'pr' outside the bounds occurred.\n")
+                print("Warning: Value of 'pr' outside the bounds occurred.\n",flush=True)
             self.connection_number_info()
+        if self.save_report:
+            self.save_connection_report()
 
     def make_connection(self):
         """ Assign number of synapses per iteration.
@@ -971,7 +977,7 @@ class ReciprocalConnector(AbstractConnector):
             self.stage = 0
             self.initial_all_to_all()
             if self.verbose:
-                print("Assigning forward connections.")
+                print("Assigning forward connections.",flush=True)
                 self.timer.start()
         return self.make_connection()
 
@@ -980,7 +986,7 @@ class ReciprocalConnector(AbstractConnector):
         if self.iter_count == 0:
             self.stage = 1
             if self.verbose:
-                print("Assigning backward connections.")
+                print("Assigning backward connections.",flush=True)
         return self.make_connection()
 
     def free_memory(self):
@@ -1033,15 +1039,39 @@ class ReciprocalConnector(AbstractConnector):
         n_conn, n_poss, n_pair, fraction = self.connection_number()
         conn_type = "(all, reciprocal)" if self.recurrent \
                     else "(forward, backward, reciprocal)"
-        print("Numbers of " + conn_type + " connections:")
-        print("Number of connected pairs: (%s)" % arr2str(n_conn, '%d'))
-        print("Number of possible connections: (%s)" % arr2str(n_poss, '%d'))
+        print("Numbers of " + conn_type + " connections:",flush=True)
+        print("Number of connected pairs: (%s)" % arr2str(n_conn, '%d'),flush=True)
+        print("Number of possible connections: (%s)" % arr2str(n_poss, '%d'),flush=True)
         print("Fraction of connected pairs in possible ones: (%s)"
-              % arr2str(100 * fraction[0], '%.2f%%'))
-        print("Number of total pairs: %d" % n_pair)
+              % arr2str(100 * fraction[0], '%.2f%%'),flush=True)
+        print("Number of total pairs: %d" % n_pair,flush=True)
         print("Fraction of connected pairs in all pairs: (%s)\n"
-              % arr2str(100 * fraction[1], '%.2f%%'))
+              % arr2str(100 * fraction[1], '%.2f%%'),flush=True)
 
+    def save_connection_report(self):
+        """Save connections into a CSV file to be read from later"""
+        src_str, trg_str = self.get_nodes_info()
+        n_conn, n_poss, n_pair, fraction = self.connection_number()
+
+        # Extract the population name from source_str and target_str
+        data = {
+            "Source": [src_str],
+            "Target": [trg_str],
+            "Fraction of connected pairs in possible ones (%)": [fraction[0]*100],
+            "Fraction of connected pairs in all pairs (%)": [fraction[1]*100]
+        }
+        df = pd.DataFrame(data)
+        
+        # Append the data to the CSV file
+        try:
+            # Check if the file exists by trying to read it
+            existing_df = pd.read_csv(self.report_name)
+            # If no exception is raised, append without header
+            df.to_csv(self.report_name, mode='a', header=False, index=False)
+        except FileNotFoundError:
+            # If the file does not exist, write with header
+            df.to_csv(self.report_name, mode='w', header=True, index=False)
+            
 
 class UnidirectionConnector(AbstractConnector):
     """
@@ -1074,12 +1104,14 @@ class UnidirectionConnector(AbstractConnector):
             This is useful in similar manner as in ReciprocalConnector.
     """
 
-    def __init__(self, p=1., p_arg=None, n_syn=1, verbose=True):
+    def __init__(self, p=1., p_arg=None, n_syn=1, verbose=True,save_report=True,report_name='connection_report.csv'):
         args = locals()
         var_set = ('p', 'p_arg', 'n_syn')
         self.vars = {key: args[key] for key in var_set}
 
         self.verbose = verbose
+        self.save_report = save_report
+        self.report_name = report_name
         self.conn_prop = {}
         self.iter_count = 0
 
@@ -1136,7 +1168,7 @@ class UnidirectionConnector(AbstractConnector):
             if self.verbose:
                 src_str, trg_str = self.get_nodes_info()
                 print("\nStart building connection \n  from "
-                      + src_str + "\n  to " + trg_str)
+                      + src_str + "\n  to " + trg_str,flush=True)
 
         # Make random connections
         p_arg = self.p_arg(source, target)
@@ -1157,6 +1189,9 @@ class UnidirectionConnector(AbstractConnector):
             if self.verbose:
                 self.connection_number_info()
                 self.timer.report('Done! \nTime for building connections')
+            if self.save_report:
+                self.save_connection_report()
+
         return nsyns
 
     # *** Helper functions for verbose ***
@@ -1168,13 +1203,37 @@ class UnidirectionConnector(AbstractConnector):
 
     def connection_number_info(self):
         """Print connection numbers after connections built"""
-        print("Number of connected pairs: %d" % self.n_conn)
-        print("Number of possible connections: %d" % self.n_poss)
+        print("Number of connected pairs: %d" % self.n_conn,flush=True)
+        print("Number of possible connections: %d" % self.n_poss,flush=True)
         print("Fraction of connected pairs in possible ones: %.2f%%"
               % (100. * self.n_conn / self.n_poss) if self.n_poss else 0.)
-        print("Number of total pairs: %d" % self.n_pair)
+        print("Number of total pairs: %d" % self.n_pair,flush=True)
         print("Fraction of connected pairs in all pairs: %.2f%%\n"
-              % (100. * self.n_conn / self.n_pair))
+              % (100. * self.n_conn / self.n_pair),flush=True)
+    
+    def save_connection_report(self):
+        """Save connections into a CSV file to be read from later"""
+        src_str, trg_str = self.get_nodes_info()
+        n_conn, n_poss, n_pair, fraction = self.connection_number()
+
+        # Extract the population name from source_str and target_str
+        data = {
+            "Source": [src_str],
+            "Target": [trg_str],
+            "Fraction of connected pairs in possible ones (%)": [fraction[0]*100],
+            "Fraction of connected pairs in all pairs (%)": [fraction[1]*100]
+        }
+        df = pd.DataFrame(data)
+        
+        # Append the data to the CSV file
+        try:
+            # Check if the file exists by trying to read it
+            existing_df = pd.read_csv(self.report_name)
+            # If no exception is raised, append without header
+            df.to_csv(self.report_name, mode='a', header=False, index=False)
+        except FileNotFoundError:
+            # If the file does not exist, write with header
+            df.to_csv(self.report_name, mode='w', header=True, index=False)
 
 
 class GapJunction(UnidirectionConnector):
@@ -1198,8 +1257,8 @@ class GapJunction(UnidirectionConnector):
         Similar to `UnidirectionConnector`.
     """
 
-    def __init__(self, p=1., p_arg=None, verbose=True):
-        super().__init__(p=p, p_arg=p_arg, verbose=verbose)
+    def __init__(self, p=1., p_arg=None, verbose=True,report_name='connection_report.csv'):
+        super().__init__(p=p, p_arg=p_arg, verbose=verbose,report_name=report_name)
 
     def setup_nodes(self, source=None, target=None):
         super().setup_nodes(source=source, target=target)
@@ -1215,7 +1274,7 @@ class GapJunction(UnidirectionConnector):
             self.initialize()
             if self.verbose:
                 src_str, _ = self.get_nodes_info()
-                print("\nStart building gap junction \n  in " + src_str)
+                print("\nStart building gap junction \n  in " + src_str,flush=True)
 
         # Consider each pair only once
         nsyns = 0
@@ -1239,6 +1298,8 @@ class GapJunction(UnidirectionConnector):
             if self.verbose:
                 self.connection_number_info()
                 self.timer.report('Done! \nTime for building connections')
+            if self.save_report:
+                self.save_connection_report()
         return nsyns
 
     def connection_number_info(self):
@@ -1247,6 +1308,32 @@ class GapJunction(UnidirectionConnector):
         super().connection_number_info()
         self.n_pair = n_pair
 
+    def save_connection_report(self):
+        """Save connections into a CSV file to be read from later"""
+        src_str, trg_str = self.get_nodes_info()
+        n_pair = self.n_pair
+        fraction_0 = self.n_conn / self.n_poss if self.n_poss else 0.
+        fraction_1 = self.n_conn / self.n_pair
+
+        # Convert fraction to percentage and prepare data for the DataFrame
+        data = {
+            "Source": [src_str+"Gap"],
+            "Target": [trg_str+"Gap"],
+            "Fraction of connected pairs in possible ones (%)": [fraction_0*100],
+            "Fraction of connected pairs in all pairs (%)": [fraction_1*100]
+        }
+        df = pd.DataFrame(data)
+        
+        # Append the data to the CSV file
+        try:
+            # Check if the file exists by trying to read it
+            existing_df = pd.read_csv(self.report_name)
+            # If no exception is raised, append without header
+            df.to_csv(self.report_name, mode='a', header=False, index=False)
+        except FileNotFoundError:
+            # If the file does not exist, write with header
+            df.to_csv(self.report_name, mode='w', header=True, index=False)
+
 
 class CorrelatedGapJunction(GapJunction):
     """
@@ -1314,7 +1401,7 @@ class CorrelatedGapJunction(GapJunction):
             self.initialize()
             if self.verbose:
                 src_str, _ = self.get_nodes_info()
-                print("\nStart building gap junction \n  in " + src_str)
+                print("\nStart building gap junction \n  in " + src_str,flush=True)
 
         # Consider each pair only once
         nsyns = 0
@@ -1340,6 +1427,8 @@ class CorrelatedGapJunction(GapJunction):
             if self.verbose:
                 self.connection_number_info()
                 self.timer.report('Done! \nTime for building connections')
+            if self.save_report:
+                self.save_connection_report()
         return nsyns
 
 
@@ -1422,7 +1511,7 @@ class OneToOneSequentialConnector(AbstractConnector):
 
         if self.verbose and self.idx_range[-1] == self.n_source:
             print("All " + ("source" if self.partition_source else "target")
-                  + " population partitions are filled.")
+                  + " population partitions are filled.",flush=True)
 
     def edge_params(self, target_pop_idx=-1):
         """Create the arguments for BMTK add_edges() method"""
@@ -1447,14 +1536,14 @@ class OneToOneSequentialConnector(AbstractConnector):
                 self.target_count = 0
                 src_str, trg_str = self.get_nodes_info()
                 print("\nStart building connection " +
-                      ("to " if self.partition_source else "from ") + src_str)
+                      ("to " if self.partition_source else "from ") + src_str,flush=True)
                 self.timer = Timer()
 
             if self.iter_count == self.idx_range[self.target_count]:
                 # Beginning of each target population
                 src_str, trg_str = self.get_nodes_info(self.target_count)
                 print(("  %d. " % self.target_count) +
-                      ("from " if self.partition_source else "to ") + trg_str)
+                      ("from " if self.partition_source else "to ") + trg_str,flush=True)
                 self.target_count += 1
                 self.timer_part = Timer()
 
@@ -1491,6 +1580,18 @@ FLUC_STDEV = 0.2  # ms
 DELAY_LOWBOUND = 0.2  # ms must be greater than h.dt
 DELAY_UPBOUND = 2.0  # ms
 
+def syn_const_delay(source=None, target = None, dist=100, 
+                    min_delay=SYN_MIN_DELAY, velocity=SYN_VELOCITY,
+                    fluc_stdev=FLUC_STDEV, delay_bound=(DELAY_LOWBOUND, DELAY_UPBOUND),
+                    connector=None): 
+    """Synapse delay constant with some random fluctuation.
+    """
+    del_fluc = fluc_stdev * rng.normal()
+    delay = dist / SYN_VELOCITY + SYN_MIN_DELAY + del_fluc
+    delay = min(max(delay, DELAY_LOWBOUND), DELAY_UPBOUND)
+    return delay
+
+
 def syn_dist_delay_feng(source, target, min_delay=SYN_MIN_DELAY,
                         velocity=SYN_VELOCITY, fluc_stdev=FLUC_STDEV,
                         delay_bound=(DELAY_LOWBOUND, DELAY_UPBOUND),
@@ -1520,6 +1621,14 @@ def syn_section_PN(source, target, p=0.9,
     return sec_id[syn_loc], sec_x[syn_loc]
 
 
+def syn_const_delay_feng_section_PN(source, target, p=0.9,
+                                   sec_id=(1, 2), sec_x=(0.4, 0.6), **kwargs):
+    """Assign both synapse delay and location with constant distance assumed"""
+    delay = syn_const_delay(source, target,**kwargs)
+    s_id, s_x = syn_section_PN(source, target, p=p, sec_id=sec_id, sec_x=sec_x)
+    return delay, s_id, s_x
+
+
 def syn_dist_delay_feng_section_PN(source, target, p=0.9,
                                    sec_id=(1, 2), sec_x=(0.4, 0.6), **kwargs):
     """Assign both synapse delay and location"""

bmtool/graphs.py

@@ -1,5 +1,4 @@
 import networkx as nx
-import plotly.graph_objects as go
 import pandas as pd
 import bmtool.util.util as u
 import pandas as pd
@@ -24,7 +23,7 @@ def generate_graph(config,source,target):
     edges = edges[edge_to_grap]
 
     # Create an empty graph
-    G = nx.Graph()
+    G = nx.DiGraph()
 
     # Add nodes to the graph with their positions and labels
     for index, node_data in nodes.iterrows():
@@ -36,122 +35,124 @@ def generate_graph(config,source,target):
 
     return G
 
-
-def plot_graph(Graph=None,show_edges = False,title = None):
-    """
-    Generate an interactive plot of the network
-    Graph: A Graph object
-    show_edges: Boolean to show edges in graph plot
-    title: A string for the title of the graph
+# import plotly.graph_objects as go
+# def plot_graph(Graph=None,show_edges = False,title = None):
+#     """
+#     Generate an interactive plot of the network
+#     Graph: A Graph object
+#     show_edges: Boolean to show edges in graph plot
+#     title: A string for the title of the graph
     
-    """
-
-    # Extract node positions
-    node_positions = nx.get_node_attributes(Graph, 'pos')
-    node_x = [data[0] for data in node_positions.values()]
-    node_y = [data[1] for data in node_positions.values()]
-    node_z = [data[2] for data in node_positions.values()]
-
-    # Create edge traces
-    edge_x = []
-    edge_y = []
-    edge_z = []
-    for edge in Graph.edges():
-        x0, y0, z0 = node_positions[edge[0]]
-        x1, y1, z1 = node_positions[edge[1]]
-        edge_x.extend([x0, x1, None])
-        edge_y.extend([y0, y1, None])
-        edge_z.extend([z0, z1, None])
-
-    # Create edge trace
-    edge_trace = go.Scatter3d(
-        x=edge_x,
-        y=edge_y,
-        z=edge_z,
-        line=dict(width=1, color='#888'),
-        hoverinfo='none',
-        mode='lines',
-        opacity=0.2)
-
-    # Create node trace
-    node_trace = go.Scatter3d(
-        x=node_x,
-        y=node_y,
-        z=node_z,
-        mode='markers',
-        hoverinfo='text',
-        marker=dict(
-            showscale=True,
-            colorscale='YlGnBu',  # Adjust color scale here
-            reversescale=True,
-            color=[len(list(Graph.neighbors(node))) for node in Graph.nodes()],  # Assign color data here
-            size=5,  # Adjust the size of the nodes here
-            colorbar=dict(
-                thickness=15,
-                title='Node Connections',
-                xanchor='left',
-                titleside='right'
-            ),
-            line_width=2,
-            cmin=0,  # Adjust color scale range here
-            cmax=max([len(list(Graph.neighbors(node))) for node in Graph.nodes()])   # Adjust color scale range here
-        ))
-
-    # Define hover text for nodes
-    node_hover_text = [f'Node ID: {node_id}<br>Population Name: {node_data["label"]}<br># of Connections: {len(list(Graph.neighbors(node_id)))}' for node_id, node_data in Graph.nodes(data=True)]
-    node_trace.hovertext = node_hover_text
-
-    # Create figure
-    if show_edges:
-        graph_prop = [edge_trace,node_trace]
-    else:
-        graph_prop = [node_trace]
-
-    if title == None:
-        title = '3D plot'
+#     """
+
+#     # Extract node positions
+#     node_positions = nx.get_node_attributes(Graph, 'pos')
+#     node_x = [data[0] for data in node_positions.values()]
+#     node_y = [data[1] for data in node_positions.values()]
+#     node_z = [data[2] for data in node_positions.values()]
+
+#     # Create edge traces
+#     edge_x = []
+#     edge_y = []
+#     edge_z = []
+#     for edge in Graph.edges():
+#         x0, y0, z0 = node_positions[edge[0]]
+#         x1, y1, z1 = node_positions[edge[1]]
+#         edge_x.extend([x0, x1, None])
+#         edge_y.extend([y0, y1, None])
+#         edge_z.extend([z0, z1, None])
+
+#     # Create edge trace
+#     edge_trace = go.Scatter3d(
+#         x=edge_x,
+#         y=edge_y,
+#         z=edge_z,
+#         line=dict(width=1, color='#888'),
+#         hoverinfo='none',
+#         mode='lines',
+#         opacity=0.2)
+
+#     # Create node trace
+#     node_trace = go.Scatter3d(
+#         x=node_x,
+#         y=node_y,
+#         z=node_z,
+#         mode='markers',
+#         hoverinfo='text',
+#         marker=dict(
+#             showscale=True,
+#             colorscale='YlGnBu',  # Adjust color scale here
+#             reversescale=True,
+#             color=[len(list(Graph.neighbors(node))) for node in Graph.nodes()],  # Assign color data here
+#             size=5,  # Adjust the size of the nodes here
+#             colorbar=dict(
+#                 thickness=15,
+#                 title='Node Connections',
+#                 xanchor='left',
+#                 titleside='right'
+#             ),
+#             line_width=2,
+#             cmin=0,  # Adjust color scale range here
+#             cmax=max([len(list(Graph.neighbors(node))) for node in Graph.nodes()])   # Adjust color scale range here
+#         ))
+
+#     # Define hover text for nodes
+#     node_hover_text = [f'Node ID: {node_id}<br>Population Name: {node_data["label"]}<br># of Connections: {len(list(Graph.neighbors(node_id)))}' for node_id, node_data in Graph.nodes(data=True)]
+#     node_trace.hovertext = node_hover_text
+
+#     # Create figure
+#     if show_edges:
+#         graph_prop = [edge_trace,node_trace]
+#     else:
+#         graph_prop = [node_trace]
+
+#     if title == None:
+#         title = '3D plot'
     
-    fig = go.Figure(data=graph_prop,
-                    layout=go.Layout(
-                        title=title,
-                        titlefont_size=16,
-                        showlegend=False,
-                        hovermode='closest',
-                        margin=dict(b=20, l=5, r=5, t=40),
-                        scene=dict(
-                            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-                            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
-                            zaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
-                        ),
-                        width=800,
-                        height=800
-                    ))
-
-    # Show figure
-    fig.show()
+#     fig = go.Figure(data=graph_prop,
+#                     layout=go.Layout(
+#                         title=title,
+#                         titlefont_size=16,
+#                         showlegend=False,
+#                         hovermode='closest',
+#                         margin=dict(b=20, l=5, r=5, t=40),
+#                         scene=dict(
+#                             xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+#                             yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+#                             zaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
+#                         ),
+#                         width=800,
+#                         height=800
+#                     ))
+
+#     # Show figure
+#     fig.show()
 
 
 def export_node_connections_to_csv(Graph, filename):
     """
-    Generates a csv file with node type and all connections that node receives 
-    Graph: a Graph object
-    filename: A string for the name of output must end in .csv
+    Generates a CSV file with node type and all outgoing connections that node has.
+    
+    Parameters:
+    Graph: a DiGraph object (directed graph)
+    filename: A string for the name of output, must end in .csv
     """
     # Create an empty dictionary to store the connections for each node
     node_connections = {}
 
     # Iterate over each node in the graph
     for node in Graph.nodes():
-        # Initialize a dictionary to store the connections for the current node
+        # Initialize a dictionary to store the outgoing connections for the current node
         connections = {}
         node_label = Graph.nodes[node]['label']
 
-        # Iterate over each neighbor of the current node
-        for neighbor in Graph.neighbors(node):
-            # Get the label of the neighbor node
-            neighbor_label = Graph.nodes[neighbor]['label']
+        # Iterate over each presuccessor (ingoing neighbor) of the current node
+        for successor in Graph.predecessors(node):
+            # Get the label of the successor node
+            successor_label = Graph.nodes[successor]['label']
 
-            # Increment the connection count for the current node and neighbor label
-            connections[f'{neighbor_label} Connections'] = connections.get(f'{neighbor_label} Connections', 0) + 1
+            # Increment the connection count for the current node and successor label
+            connections[f'{successor_label} incoming Connections'] = connections.get(f'{successor_label} incoming Connections', 0) + 1
 
         # Add the connections information for the current node to the dictionary
         connections['Node Label'] = node_label
@@ -166,5 +167,4 @@ def export_node_connections_to_csv(Graph, filename):
     df = df[cols]
 
     # Write the DataFrame to a CSV file
-    df.to_csv(filename)
-
+    df.to_csv(filename)