bmtool 0.5.4__tar.gz → 0.5.5__tar.gz

{bmtool-0.5.4 → bmtool-0.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bmtool
-Version: 0.5.4
+Version: 0.5.5
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 
@@ -28,7 +28,8 @@ Requires-Dist: numpy
 Requires-Dist: pandas
 Requires-Dist: questionary
 Requires-Dist: pynmodlt
-Requires-Dist: plotly
+Requires-Dist: xarray
+Requires-Dist: fooof
 
 # bmtool
 A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/neuron/) and [BMTK](https://alleninstitute.github.io/bmtk/) models easier.

bmtool-0.5.5/bmtool/SLURM.py

@@ -0,0 +1,294 @@
+import time
+import os
+import subprocess
+import json
+
+
+def check_job_status(job_id):
+    """
+    Checks the status of a SLURM job using scontrol.
+
+    Args:
+        job_id (str): The SLURM job ID.
+
+    Returns:
+        str: The state of the job.
+    """
+    try:
+        result = subprocess.run(['scontrol', 'show', 'job', job_id], capture_output=True, text=True)
+        if result.returncode != 0:
+            # this check is not needed if check_interval is less than 5 min (~300 seconds)
+            #if 'slurm_load_jobs error: Invalid job id specified' in result.stderr:
+            #    return 'COMPLETED'  # Treat invalid job ID as completed because scontrol expires and removed job info when done.
+            raise Exception(f"Error checking job status: {result.stderr}")
+
+        job_state = None
+        for line in result.stdout.split('\n'):
+            if 'JobState=' in line:
+                job_state = line.strip().split('JobState=')[1].split()[0]
+                break
+
+        if job_state is None:
+            raise Exception(f"Failed to retrieve job status for job ID: {job_id}")
+
+        return job_state
+    except Exception as e:
+        print(f"Exception while checking job status: {e}", flush=True)
+        return 'UNKNOWN'
+
+
+def submit_job(script_path):
+    """
+    Submits a SLURM job script.
+
+    Args:
+        script_path (str): The path to the SLURM job script.
+
+    Returns:
+        str: The job ID of the submitted job.
+
+    Raises:
+        Exception: If there is an error in submitting the job.
+    """
+    result = subprocess.run(['sbatch', script_path], capture_output=True, text=True)
+    if result.returncode != 0:
+        raise Exception(f"Error submitting job: {result.stderr}")
+    job_id = result.stdout.strip().split()[-1]
+    return job_id
+
+
+class seedSweep:
+    def __init__(self, json_file_path, param_name):
+        """
+        Initializes the seedSweep instance.
+
+        Args:
+            json_file_path (str): Path to the JSON file to be updated.
+            param_name (str): The name of the parameter to be modified.
+        """
+        self.json_file_path = json_file_path
+        self.param_name = param_name
+
+    def edit_json(self, new_value):
+        """
+        Updates the JSON file with a new parameter value.
+
+        Args:
+            new_value: The new value for the parameter.
+        """
+        with open(self.json_file_path, 'r') as f:
+            data = json.load(f)
+        
+        data[self.param_name] = new_value
+        
+        with open(self.json_file_path, 'w') as f:
+            json.dump(data, f, indent=4)
+        
+        print(f"JSON file '{self.json_file_path}' modified successfully with {self.param_name}={new_value}.", flush=True)
+        
+    
+    def change_json_file_path(self,new_json_file_path):
+        self.json_file_path = new_json_file_path
+
+
+# class could just be added to seedSweep but for now will make new class since it was easier
+class multiSeedSweep(seedSweep):
+    """
+    MultSeedSweeps are centered around some base JSON cell file. When that base JSON is updated, the other JSONs
+    change according to their ratio with the base JSON.
+    """
+    def __init__(self, base_json_file_path, param_name, syn_dict_list=[], base_ratio=1):
+        """
+        Initializes the multipleSeedSweep instance.
+
+        Args:
+            base_json_file_path (str): File path for the base JSON file.
+            param_name (str): The name of the parameter to be modified.
+            syn_dict_list (list): A list containing dictionaries with the 'json_file_path' and 'ratio' (in comparison to the base_json) for each JSON file.
+            base_ratio (float): The ratio between the other JSONs; usually the current value for the parameter.
+        """
+        super().__init__(base_json_file_path, param_name)
+        self.syn_dict_list = syn_dict_list
+        self.base_ratio = base_ratio
+
+    def edit_all_jsons(self, new_value):
+        """
+        Updates the base JSON file with a new parameter value and then updates the other JSON files based on the ratio.
+
+        Args:
+            new_value: The new value for the parameter in the base JSON.
+        """
+        self.edit_json(new_value)
+        base_ratio = self.base_ratio
+        for syn_dict in self.syn_dict_list:
+            json_file_path = syn_dict['json_file_path']
+            new_ratio = syn_dict['ratio'] / base_ratio
+            
+            with open(json_file_path, 'r') as f:
+                data = json.load(f)
+            altered_value = new_ratio * new_value
+            data[self.param_name] = altered_value
+        
+            with open(json_file_path, 'w') as f:
+                json.dump(data, f, indent=4)
+        
+            print(f"JSON file '{json_file_path}' modified successfully with {self.param_name}={altered_value}.", flush=True)
+
+
+class SimulationBlock:
+    def __init__(self, block_name, time, partition, nodes, ntasks, mem, simulation_cases, output_base_dir,account=None,additional_commands=None,
+                 status_list = ['COMPLETED', 'FAILED', 'CANCELLED']):
+        """
+        Initializes the SimulationBlock instance.
+
+        Args:
+            block_name (str): Name of the block.
+            time (str): Time limit for the job.
+            partition (str): Partition to submit the job to.
+            nodes (int): Number of nodes to request.
+            ntasks (int): Number of tasks.
+            mem (int) : Number of gigabytes (per node)
+            simulation_cases (dict): Dictionary of simulation cases with their commands.
+            output_base_dir (str): Base directory for the output files.
+            account (str) : account to charge on HPC 
+            additional commands (list): commands to run before bmtk model starts useful for loading modules
+            status_list (list): List of things to check before running next block. 
+                Adding RUNNING runs blocks faster but uses MUCH more resources and is only recommended on large HPC 
+        """
+        self.block_name = block_name
+        self.time = time
+        self.partition = partition
+        self.nodes = nodes
+        self.ntasks = ntasks
+        self.mem = mem
+        self.simulation_cases = simulation_cases
+        self.output_base_dir = output_base_dir
+        self.account = account 
+        self.additional_commands = additional_commands if additional_commands is not None else []
+        self.status_list = status_list
+        self.job_ids = []
+
+    def create_batch_script(self, case_name, command):
+        """
+        Creates a SLURM batch script for the given simulation case.
+
+        Args:
+            case_name (str): Name of the simulation case.
+            command (str): Command to run the simulation.
+        
+        Returns:
+            str: Path to the batch script file.
+        """
+        block_output_dir = os.path.join(self.output_base_dir, self.block_name)  # Create block-specific output folder
+        case_output_dir = os.path.join(block_output_dir, case_name)  # Create case-specific output folder
+        os.makedirs(case_output_dir, exist_ok=True)
+
+        batch_script_path = os.path.join(block_output_dir, 'script.sh')
+        additional_commands_str = "\n".join(self.additional_commands)
+        # Conditional account linegit
+        account_line = f"#SBATCH --account={self.account}\n" if self.account else ""
+
+        # Write the batch script to the file
+        with open(batch_script_path, 'w') as script_file:
+            script_file.write(f"""#!/bin/bash
+#SBATCH --job-name={self.block_name}_{case_name}
+#SBATCH --output={block_output_dir}/%x_%j.out
+#SBATCH --error={block_output_dir}/%x_%j.err
+#SBATCH --time={self.time}
+#SBATCH --partition={self.partition}
+#SBATCH --nodes={self.nodes}
+#SBATCH --ntasks={self.ntasks}
+#SBATCH --mem={self.mem}
+{account_line}
+
+# Additional user-defined commands
+{additional_commands_str}
+
+export OUTPUT_DIR={case_output_dir}
+
+{command}
+""")
+
+        #print(f"Batch script created: {batch_script_path}", flush=True)
+
+        return batch_script_path
+
+    def submit_block(self):
+        """
+        Submits all simulation cases in the block as separate SLURM jobs.
+        """
+        for case_name, command in self.simulation_cases.items():
+            script_path = self.create_batch_script(case_name, command)
+            result = subprocess.run(['sbatch', script_path], capture_output=True, text=True)
+            if result.returncode == 0:
+                job_id = result.stdout.strip().split()[-1]
+                self.job_ids.append(job_id)
+                print(f"Submitted {case_name} with job ID {job_id}", flush=True)
+            else:
+                print(f"Failed to submit {case_name}: {result.stderr}", flush=True)
+
+    def check_block_status(self):
+        """
+        Checks the status of all jobs in the block.
+
+        Returns:
+            bool: True if all jobs in the block are completed, False otherwise.
+        """
+        for job_id in self.job_ids:
+            status = check_job_status(job_id)
+            if status not in self.status_list:
+                return False
+        return True
+
+
+class SequentialBlockRunner:
+    """
+    Class to handle submitting multiple blocks sequentially.
+
+    Attributes:
+        blocks (list): List of SimulationBlock instances to be run.
+        json_editor (seedSweep or multiSweep): Instance of seedSweep to edit JSON file.
+        param_values (list): List of values for the parameter to be modified.
+    """
+
+    def __init__(self, blocks, json_editor=None, param_values=None, check_interval=200):
+        self.blocks = blocks
+        self.json_editor = json_editor
+        self.param_values = param_values
+        self.check_interval = check_interval
+
+    def submit_blocks_sequentially(self):
+        """
+        Submits all blocks sequentially, ensuring each block starts only after the previous block has completed.
+        Updates the JSON file with new parameters before each block run.
+        """
+        for i, block in enumerate(self.blocks):
+            # Update JSON file with new parameter value
+            if self.json_editor == None and self.param_values == None:
+                print(f"skipping json editing for block {block.block_name}",flush=True)
+            else:
+                if len(self.blocks) != len(self.param_values):
+                    raise Exception("Number of blocks needs to each number of params given")
+                new_value = self.param_values[i]
+                # NGL didnt test the multi but should work
+                if isinstance(self.json_editor, multiSeedSweep):
+                    self.json_editor.edit_all_jsons(new_value)
+                elif isinstance(self.json_editor,seedSweep):
+                    print(f"Updating JSON file with parameter value for block: {block.block_name}", flush=True)
+                    self.json_editor.edit_json(new_value)
+                else:
+                    raise Exception("json editor provided but not a seedSweep class not sure what your doing?!?")
+                
+
+            # Submit the block
+            print(f"Submitting block: {block.block_name}", flush=True)
+            block.submit_block()
+            
+            # Wait for the block to complete
+            while not block.check_block_status():
+                print(f"Waiting for block {block.block_name} to complete...", flush=True)
+                time.sleep(self.check_interval)
+            
+            print(f"Block {block.block_name} completed.", flush=True)
+        print("All blocks are done!",flush=True)
+

{bmtool-0.5.4 → bmtool-0.5.5}/bmtool/connectors.py

@@ -222,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
@@ -335,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):
@@ -355,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
 
 
@@ -534,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,save_report=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')
@@ -553,6 +553,7 @@ class ReciprocalConnector(AbstractConnector):
         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
@@ -667,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
@@ -831,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
@@ -867,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
 
@@ -892,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
@@ -948,7 +949,7 @@ 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()
@@ -976,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()
 
@@ -985,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):
@@ -1038,14 +1039,14 @@ 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"""
@@ -1064,15 +1065,14 @@ class ReciprocalConnector(AbstractConnector):
         # Append the data to the CSV file
         try:
             # Check if the file exists by trying to read it
-            existing_df = pd.read_csv('connection_report.csv')
+            existing_df = pd.read_csv(self.report_name)
             # If no exception is raised, append without header
-            df.to_csv('connection_report.csv', mode='a', header=False, index=False)
+            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('connection_report.csv', mode='w', header=True, index=False)
+            df.to_csv(self.report_name, mode='w', header=True, index=False)
             
 
-
 class UnidirectionConnector(AbstractConnector):
     """
     Object for buiilding unidirectional connections in bmtk network model with
@@ -1104,13 +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,save_report=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
 
@@ -1167,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)
@@ -1202,39 +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_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
+        n_conn, n_poss, n_pair, fraction = self.connection_number()
 
-        # Convert fraction to percentage and prepare data for the DataFrame
+        # 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]
+            "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('connection_report.csv')
+            existing_df = pd.read_csv(self.report_name)
             # If no exception is raised, append without header
-            df.to_csv('connection_report.csv', mode='a', header=False, index=False)
+            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('connection_report.csv', mode='w', header=True, index=False)
+            df.to_csv(self.report_name, mode='w', header=True, index=False)
 
 
 class GapJunction(UnidirectionConnector):
@@ -1258,8 +1257,8 @@ class GapJunction(UnidirectionConnector):
         Similar to `UnidirectionConnector`.
     """
 
-    def __init__(self, p=1., p_arg=None, verbose=True,save_report=True):
-        super().__init__(p=p, p_arg=p_arg, verbose=verbose,save_report=save_report)
+    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)
@@ -1275,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
@@ -1328,12 +1327,12 @@ class GapJunction(UnidirectionConnector):
         # Append the data to the CSV file
         try:
             # Check if the file exists by trying to read it
-            existing_df = pd.read_csv('connection_report.csv')
+            existing_df = pd.read_csv(self.report_name)
             # If no exception is raised, append without header
-            df.to_csv('connection_report.csv', mode='a', header=False, index=False)
+            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('connection_report.csv', mode='w', header=True, index=False)
+            df.to_csv(self.report_name, mode='w', header=True, index=False)
 
 
 class CorrelatedGapJunction(GapJunction):
@@ -1364,8 +1363,8 @@ class CorrelatedGapJunction(GapJunction):
     """
 
     def __init__(self, p_non=1., p_uni=1., p_rec=1., p_arg=None,
-                 connector=None, verbose=True,save_report=True):
-        super().__init__(p=p_non, p_arg=p_arg, verbose=verbose,save_report=save_report)
+                 connector=None, verbose=True):
+        super().__init__(p=p_non, p_arg=p_arg, verbose=verbose)
         self.vars['p_non'] = self.vars.pop('p')
         self.vars['p_uni'] = p_uni
         self.vars['p_rec'] = p_rec
@@ -1402,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
@@ -1512,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"""
@@ -1537,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()
 
@@ -1581,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),
@@ -1610,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"""