pyLoopSage 1.0.22__tar.gz → 1.0.23__tar.gz

pyloopsage-1.0.23/MANIFEST.in

@@ -0,0 +1 @@
+exclude loopsage/knots.py

{pyloopsage-1.0.22/pyLoopSage.egg-info → pyloopsage-1.0.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyLoopSage
-Version: 1.0.22
+Version: 1.0.23
 Summary: An energy-based stochastic model of loop extrusion in chromatin.
 Home-page: https://github.com/SFGLab/pyLoopSage
 Author: Sebastian Korsak
@@ -305,6 +305,7 @@ An example, illustrated with Chimera software, simulated trajectory of structure
 | ANGLE_FF_STRENGTH     | Angle force strength.                                                                                          | float      | 200.0               |
 | LE_FF_LENGTH         | Equilibrium distance of loop forces.                                                                          | float      | 0.1                 |
 | LE_FF_STRENGTH       | Interaction Strength of loop forces.                                                                          | float      | 50000.0             |
+| CONTINUOUS_TOP       | True if the topological constraints are applied continuously during the simulation.                           | bool       | False               |
 | EV_P                 | Probability that excluded volume is disabled. Enable it only in case of topoisomerase activity simulation.    | float      | 0.0                 |
 | EV_FF_STRENGTH       | Excluded-volume strength.                                                                                     | float      | 100.0               |
 | EV_FF_POWER          | Excluded-volume power.                                                                                        | float      | 3.0                 |

{pyloopsage-1.0.22 → pyloopsage-1.0.23}/README.md

@@ -260,6 +260,7 @@ An example, illustrated with Chimera software, simulated trajectory of structure
 | ANGLE_FF_STRENGTH     | Angle force strength.                                                                                          | float      | 200.0               |
 | LE_FF_LENGTH         | Equilibrium distance of loop forces.                                                                          | float      | 0.1                 |
 | LE_FF_STRENGTH       | Interaction Strength of loop forces.                                                                          | float      | 50000.0             |
+| CONTINUOUS_TOP       | True if the topological constraints are applied continuously during the simulation.                           | bool       | False               |
 | EV_P                 | Probability that excluded volume is disabled. Enable it only in case of topoisomerase activity simulation.    | float      | 0.0                 |
 | EV_FF_STRENGTH       | Excluded-volume strength.                                                                                     | float      | 100.0               |
 | EV_FF_POWER          | Excluded-volume power.                                                                                        | float      | 3.0                 |

{pyloopsage-1.0.22 → pyloopsage-1.0.23}/loopsage/__init__.py

@@ -1,4 +1,4 @@
 # Importing specific functions or classes from submodules
 from .run import main
 
-__version__ = "1.0.22"
+__version__ = "1.0.23"

{pyloopsage-1.0.22 → pyloopsage-1.0.23}/loopsage/args_definition.py

@@ -170,6 +170,7 @@ args = ListOfArgs([
     Arg('ANGLE_FF_STRENGTH', help="Angle force strength.", type=float, default='200.0', val='200.0'),
     Arg('LE_FF_LENGTH', help="Equillibrium distance of loop forces.", type=float, default='0.1', val='0.1'),
     Arg('LE_FF_STRENGTH', help="Interaction Strength of loop forces.", type=float, default='50000.0', val='50000.0'),
+    Arg('CONTINUOUS_TOP', help="True if topoisomerase disables EV in a continuous region rather than a discrete set of points.", type=bool, default='False', val='False'),
     Arg('EV_P', help="Probability that randomly excluded volume may be disabled.", type=float, default='0.0', val='0.0'),
     Arg('EV_FF_STRENGTH', help="Excluded-volume strength.", type=float, default='100.0', val='100.0'),
     Arg('EV_FF_POWER', help="Excluded-volume power.", type=float, default='3.0', val='3.0'),

{pyloopsage-1.0.22 → pyloopsage-1.0.23}/loopsage/md.py

@@ -36,18 +36,19 @@ class MD_LE:
         self.ev_ff_power = ev_ff_power
         self.tolerance = tolerance
     
-    def run_pipeline(self,run_MD=True, friction=0.1, integrator_step=10 * mm.unit.femtosecond, sim_step=100, ff_path = 'forcefields/classic_sm_ff.xml', init_struct='rw', temperature=310, p_ev=0, plots=False):
+    def run_pipeline(self, run_MD=True, friction=0.1, integrator_step=10 * mm.unit.femtosecond, sim_step=100, ff_path='forcefields/classic_sm_ff.xml', init_struct='rw', temperature=310, p_ev=0, plots=False, continuous_topoisomerase=False):
         '''
         This is the basic function that runs the molecular simulation pipeline.
         '''
         # Parameters
         self.p_ev = p_ev
+        self.continuous_topoisomerase = continuous_topoisomerase
 
         # Define initial structure
         print('Building initial structure...')
-        points = compute_init_struct(self.N_beads,mode='rw')
-        write_mmcif(points,self.path+'/LE_init_struct.cif')
-        generate_psf(self.N_beads,self.path+'/other/LE_init_struct.psf')
+        points = compute_init_struct(self.N_beads, mode='rw')
+        write_mmcif(points, self.path+'/LE_init_struct.cif')
+        generate_psf(self.N_beads, self.path+'/other/LE_init_struct.psf')
         print('Done brother ;D\n')
 
         # Define System
@@ -79,32 +80,39 @@ class MD_LE:
             start = time.time()
             heats = list()
             for i in range(self.N_steps):
-                # Define probabilities that EV would be disabled
-                if p_ev>0: self.ps_ev = np.random.rand(self.N_beads)
+                # Define probabilities or regions that EV would be disabled
+                if self.continuous_topoisomerase:
+                    region_length = max(1, int(self.p_ev * self.N_beads))  # Determine region length from p_ev
+                    start_idx = np.random.randint(0, self.N_beads - region_length -1)
+                    end_idx = start_idx + region_length
+                    self.ps_ev = np.zeros(self.N_beads)
+                    self.ps_ev[start_idx:end_idx] = 1
+                elif p_ev > 0:
+                    self.ps_ev = np.random.rand(self.N_beads)
                 self.change_loop(i)
                 self.change_ev()
                 self.simulation.step(sim_step)
                 self.state = self.simulation.context.getState(getPositions=True)
                 PDBxFile.writeFile(pdb.topology, self.state.getPositions(), open(self.path+f'/ensemble/MDLE_{i+1}.cif', 'w'))
-                heats.append(get_heatmap(self.state.getPositions(),save=False))
+                heats.append(get_heatmap(self.state.getPositions(), save=False))
             end = time.time()
             elapsed = end - start
-            print(f'Everything is done! Simulation finished succesfully!\nMD finished in {elapsed/60:.2f} minutes.\n')
+            print(f'Everything is done! Simulation finished successfully!\nMD finished in {elapsed/60:.2f} minutes.\n')
 
-            self.avg_heat = np.average(heats,axis=0)
-            self.std_heat = np.std(heats,axis=0)
+            self.avg_heat = np.average(heats, axis=0)
+            self.std_heat = np.std(heats, axis=0)
             
             if plots:
-                np.save(self.path+f'/other/avg_heatmap.npy',self.avg_heat)
-                np.save(self.path+f'/other/std_heatmap.npy',self.std_heat)
-                self.plot_heat(self.avg_heat,f'/plots/avg_heatmap.svg')
-                self.plot_heat(self.std_heat,f'/plots/std_heatmap.svg')
+                np.save(self.path+f'/other/avg_heatmap.npy', self.avg_heat)
+                np.save(self.path+f'/other/std_heatmap.npy', self.std_heat)
+                self.plot_heat(self.avg_heat, f'/plots/avg_heatmap.svg')
+                self.plot_heat(self.std_heat, f'/plots/std_heatmap.svg')
         return self.avg_heat
 
     def change_ev(self):
-        ev_strength = (self.ps_ev>self.p_ev).astype(int)*np.sqrt(self.ev_ff_strength) if self.p_ev>0 else np.sqrt(self.ev_ff_strength)*np.ones(self.N_beads)
+        ev_strength = (self.ps_ev > self.p_ev).astype(int) * np.sqrt(self.ev_ff_strength) if self.p_ev > 0 else np.sqrt(self.ev_ff_strength) * np.ones(self.N_beads)
         for n in range(self.N_beads):
-            self.ev_force.setParticleParameters(n,[ev_strength[n],0.05])
+            self.ev_force.setParticleParameters(n, [ev_strength[n], 0.05])
         self.ev_force.updateParametersInContext(self.simulation.context)
     
     def change_loop(self,i):

{pyloopsage-1.0.22 → pyloopsage-1.0.23}/loopsage/run.py

@@ -86,7 +86,7 @@ def main():
     if args.SIMULATION_TYPE=='EM':
         sim.run_EM(args.PLATFORM,args.ANGLE_FF_STRENGTH,args.LE_FF_LENGTH,args.LE_FF_STRENGTH,args.EV_FF_STRENGTH,args.EV_FF_POWER,args.TOLERANCE,args.FRICTION,args.INTEGRATOR_STEP,args.SIM_TEMP,args.INITIAL_STRUCTURE_TYPE,args.VIZ_HEATS,args.FORCEFIELD_PATH)
     elif args.SIMULATION_TYPE=='MD':
-        sim.run_MD(args.PLATFORM,args.ANGLE_FF_STRENGTH,args.LE_FF_LENGTH,args.LE_FF_STRENGTH,args.EV_FF_STRENGTH,args.EV_FF_POWER,args.TOLERANCE,args.FRICTION,args.INTEGRATOR_STEP,args.SIM_TEMP,args.INITIAL_STRUCTURE_TYPE,args.SIM_STEP,args.VIZ_HEATS,args.FORCEFIELD_PATH,args.EV_P)
+        sim.run_MD(args.PLATFORM,args.ANGLE_FF_STRENGTH,args.LE_FF_LENGTH,args.LE_FF_STRENGTH,args.EV_FF_STRENGTH,args.EV_FF_POWER,args.TOLERANCE,args.FRICTION,args.INTEGRATOR_STEP,args.SIM_TEMP,args.INITIAL_STRUCTURE_TYPE,args.SIM_STEP,args.VIZ_HEATS,args.FORCEFIELD_PATH,args.EV_P,args.CONTINUOUS_TOPOISOMERASE)
     elif args.SIMULATION_TYPE==None:
         print('\n3D simulation did not run because it was not specified. Please specify argument SIMULATION_TYPE as EM or MD.')
     else:

{pyloopsage-1.0.22 → pyloopsage-1.0.23}/loopsage/stochastic_simulation.py

@@ -251,21 +251,21 @@ class StochasticSimulation:
         end = time.time()
         elapsed = end - start
         print(f'Computation finished succesfully in {elapsed//3600:.0f} hours, {elapsed%3600//60:.0f} minutes and  {elapsed%60:.0f} seconds.')
-
+        
         # Save simulation info
         if save:
             save_dir = os.path.join(self.path, 'other') + '/'
-            with open(save_dir + 'info.txt', "w") as f:
-                f.write(f'Number of beads {self.N_beads}.\n')
-                f.write(f'Number of cohesins {self.N_lef}. Number of cohesins in second family {self.N_lef2}. Number of CTCFs {self.N_CTCF}. \n')
-                f.write(f'Bedpe file for CTCF binding is {self.bedpe_file}.\n')
-                f.write(f'Initial temperature {T}. Minimum temperature {T_min}.\n')
-                f.write(f'Monte Carlo optimization method: {mode}.\n')
-                f.write(f'Monte Carlo steps {N_steps}. Sampling frequency {self.MC_step}. Burnin period {burnin}.\n')
-                f.write(f'Crossing energy in equilibrium is {np.average(self.Ks[burnin//MC_step:]):.2f}. Crossing coefficient kappa={kappa}.\n')
-                f.write(f'Folding energy in equilibrium is {np.average(self.Fs[burnin//MC_step:]):.2f}. Folding coefficient f={f}. Folding coefficient for the second family f2={f2}\n')
-                f.write(f'Binding energy in equilibrium is {np.average(self.Bs[burnin//MC_step:]):.2f}. Binding coefficient b={b}.\n')
-                f.write(f'Energy at equillibrium: {np.average(self.Es[self.burnin//MC_step:]):.2f}.\n')
+            with open(save_dir + 'info.txt', "w") as file:
+                file.write(f'Number of beads {self.N_beads}.\n')
+                file.write(f'Number of cohesins {self.N_lef}. Number of cohesins in second family {self.N_lef2}. Number of CTCFs {self.N_CTCF}. \n')
+                file.write(f'Bedpe file for CTCF binding is {self.bedpe_file}.\n')
+                file.write(f'Initial temperature {T}. Minimum temperature {T_min}.\n')
+                file.write(f'Monte Carlo optimization method: {mode}.\n')
+                file.write(f'Monte Carlo steps {N_steps}. Sampling frequency {self.MC_step}. Burnin period {burnin}.\n')
+                file.write(f'Crossing energy in equilibrium is {np.average(self.Ks[burnin//MC_step:]):.2f}. Crossing coefficient kappa={kappa}.\n')
+                file.write(f'Folding energy in equilibrium is {np.average(self.Fs[burnin//MC_step:]):.2f}. Folding coefficient f={f}. Folding coefficient for the second family f2={f2}\n')
+                file.write(f'Binding energy in equilibrium is {np.average(self.Bs[burnin//MC_step:]):.2f}. Binding coefficient b={b}.\n')
+                file.write(f'Energy at equillibrium: {np.average(self.Es[self.burnin//MC_step:]):.2f}.\n')
             np.save(save_dir + 'Ms.npy', self.Ms)
             np.save(save_dir + 'Ns.npy', self.Ns)
             np.save(save_dir + 'ufs.npy', self.ufs)
@@ -292,9 +292,9 @@ class StochasticSimulation:
         sim_heat = em.run_pipeline(plots=save_plots,friction=friction,integrator_step=integrator_step,temperature=temperature,ff_path=ff_path,init_struct=init_struct)
         corr_exp_heat(sim_heat,self.bedpe_file,self.region,self.chrom,self.N_beads,self.path)
     
-    def run_MD(self,platform='CPU',angle_ff_strength=200,le_distance=0.1,le_ff_strength=50000.0,ev_ff_strength=100.0,ev_ff_power=3.0,tolerance=0.001,friction=0.1,integrator_step=100*mm.unit.femtosecond,temperature=310,init_struct='rw',sim_step=1000,save_plots=True,ff_path=default_xml_path,p_ev=0):
+    def run_MD(self,platform='CPU',angle_ff_strength=200,le_distance=0.1,le_ff_strength=50000.0,ev_ff_strength=100.0,ev_ff_power=3.0,tolerance=0.001,friction=0.1,integrator_step=100*mm.unit.femtosecond,temperature=310,init_struct='rw',sim_step=1000,save_plots=True,ff_path=default_xml_path,p_ev=0,continuous_topoisomerase=False):
         md = MD_LE(self.Ms,self.Ns,self.N_beads,self.path,platform,angle_ff_strength,le_distance,le_ff_strength,ev_ff_strength,ev_ff_power,tolerance)
-        sim_heat = md.run_pipeline(plots=save_plots,sim_step=sim_step,friction=friction,integrator_step=integrator_step,temperature=temperature,ff_path=ff_path,p_ev=p_ev,init_struct=init_struct)
+        sim_heat = md.run_pipeline(plots=save_plots,sim_step=sim_step,friction=friction,integrator_step=integrator_step,temperature=temperature,ff_path=ff_path,p_ev=p_ev,init_struct=init_struct,continuous_topoisomerase=continuous_topoisomerase)
         corr_exp_heat(sim_heat,self.bedpe_file,self.region,self.chrom,self.N_beads,self.path)
 
 def main():
@@ -311,12 +311,12 @@ def main():
     region, chrom = [15550000,16850000], 'chr6'
     
     # Definition of data
-    output_name='../HiChIP_Annealing_T1_MD_region'
+    output_name='tmp'
     bedpe_file = '/home/skorsak/Data/HiChIP/Maps/hg00731_smc1_maps_2.bedpe'
     
     sim = StochasticSimulation(region,chrom,bedpe_file,out_dir=output_name,N_beads=1000,N_lef=N_lef,N_lef2=N_lef2)
     Es, Ms, Ns, Bs, Ks, Fs, ufs = sim.run_energy_minimization(N_steps,MC_step,burnin,T,T_min,mode=mode,viz=True,save=True,f=f,f2=f2, b=b, kappa=kappa, lef_rw=lew_rw)
-    sim.run_EM('CUDA')
+    sim.run_MD('CUDA',continuous_topoisomerase=True, p_ev=0.1)
 
 if __name__=='__main__':
-    main()
+    main()

{pyloopsage-1.0.22 → pyloopsage-1.0.23/pyLoopSage.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyLoopSage
-Version: 1.0.22
+Version: 1.0.23
 Summary: An energy-based stochastic model of loop extrusion in chromatin.
 Home-page: https://github.com/SFGLab/pyLoopSage
 Author: Sebastian Korsak
@@ -305,6 +305,7 @@ An example, illustrated with Chimera software, simulated trajectory of structure
 | ANGLE_FF_STRENGTH     | Angle force strength.                                                                                          | float      | 200.0               |
 | LE_FF_LENGTH         | Equilibrium distance of loop forces.                                                                          | float      | 0.1                 |
 | LE_FF_STRENGTH       | Interaction Strength of loop forces.                                                                          | float      | 50000.0             |
+| CONTINUOUS_TOP       | True if the topological constraints are applied continuously during the simulation.                           | bool       | False               |
 | EV_P                 | Probability that excluded volume is disabled. Enable it only in case of topoisomerase activity simulation.    | float      | 0.0                 |
 | EV_FF_STRENGTH       | Excluded-volume strength.                                                                                     | float      | 100.0               |
 | EV_FF_POWER          | Excluded-volume power.                                                                                        | float      | 3.0                 |

{pyloopsage-1.0.22 → pyloopsage-1.0.23}/pyLoopSage.egg-info/SOURCES.txt

@@ -1,11 +1,11 @@
 LICENSE
+MANIFEST.in
 README.md
 setup.py
 loopsage/__init__.py
 loopsage/args_definition.py
 loopsage/em.py
 loopsage/initial_structures.py
-loopsage/knots.py
 loopsage/md.py
 loopsage/plots.py
 loopsage/preproc.py

{pyloopsage-1.0.22 → pyloopsage-1.0.23}/setup.py

@@ -6,7 +6,7 @@ with open('README.md', 'r', encoding='utf-8') as f:
 
 setup(
     name='pyLoopSage',  # Package name
-    version='1.0.22',  # Version of the software
+    version='1.0.23',  # Version of the software
     description='An energy-based stochastic model of loop extrusion in chromatin.',
     long_description=long_description,
     long_description_content_type='text/markdown',

pyloopsage-1.0.22/loopsage/knots.py

@@ -1,193 +0,0 @@
-import topoly as tp
-import numpy as np
-import matplotlib
-from tqdm import tqdm
-import matplotlib
-import matplotlib.pyplot as plt
-from mpl_toolkits.mplot3d import Axes3D
-from mpl_toolkits.mplot3d.art3d import Line3DCollection
-import matplotlib.colors as mcolors
-import scipy.interpolate as si
-from scipy.spatial.distance import pdist, squareform
-from scipy.integrate import dblquad
-from scipy.interpolate import splprep, splev, CubicSpline
-from .uts import *
-
-def trivial_knot(N=100, radius=1.0):
-    """
-    Generate a 3D trivial (unknot) structure as a simple circle.
-
-    Parameters:
-        N (int): Number of points in the loop.
-        radius (float): Radius of the circular unknot.
-
-    Returns:
-        numpy.ndarray: Nx3 array representing the 3D coordinates of the unknot.
-    """
-    t = np.linspace(0, 2 * np.pi, N)  # Parameter along the circle
-    x = radius * np.cos(t)  # Circle in the xy-plane
-    y = radius * np.sin(t)
-    z = np.zeros_like(t)  # No variation in z (flat circle)
-
-    return np.vstack((x, y, z)).T  # Return as Nx3 matrix
-
-def toroidal_knot(p, q, num_points=500, R=2, r=1):
-    """
-    Generate a toroidal (p, q) knot.
-    
-    Parameters:
-        p (int): Number of turns around the torus' central axis.
-        q (int): Number of turns around the torus' inner axis.
-        num_points (int): Number of points to plot.
-        R (float): Major radius of the torus (distance from center to torus tube).
-        r (float): Minor radius of the torus tube.
-    
-    Returns:
-        np.ndarray: Array of shape (num_points, 3) representing 3D coordinates of the knot.
-    """
-    t = np.linspace(0, 2 * np.pi, num_points, endpoint=False)
-    
-    # Parametric equations for the toroidal knot
-    x = (R + r * np.cos(q * t)) * np.cos(p * t)
-    y = (R + r * np.cos(q * t)) * np.sin(p * t)
-    z = r * np.sin(q * t)
-    V = np.column_stack((x, y, z))
-    V = np.vstack((V,[x[0],y[0],z[0]]))
-    return V
-
-def trefoil_knot(N=200, scale=0.8, offset=(0, 0, 0), rotation=None):
-    """Generate a 3D Trefoil Knot with transformations."""
-    t = np.linspace(0, 2 * np.pi-np.pi/36, N)
-    x = scale * (np.sin(t) + 2 * np.sin(2 * t)) + offset[0]
-    y = scale * (np.cos(t) - 2 * np.cos(2 * t)) + offset[1]
-    z = scale * (-np.sin(3 * t)) + offset[2]
-    
-    V = np.vstack((x, y, z)).T
-
-    if rotation is not None:
-        V = np.dot(V, rotation)  # Apply rotation matrix
-
-    return V
-
-def cinquefoil_knot(N=300, scale=0.8, offset=(0, 0, 0), rotation=None):
-    """Generate a 3D Cinquefoil (5_1) Knot with transformations."""
-    t = np.linspace(0, 2 * np.pi, N)
-    x = scale * (np.sin(2*t) + 2*np.sin(3*t))
-    y = scale * (np.cos(2*t) - 2*np.cos(3*t))
-    z = scale * (-np.sin(5*t))
-
-    V = np.vstack((x, y, z)).T
-    if rotation is not None:
-        V = np.dot(V, rotation)  # Apply rotation
-    return V + np.array(offset)  # Apply position offset
-
-def random_rotation_matrix():
-    """Generate a random 3D rotation matrix."""
-    theta, phi, z = np.random.uniform(0, 2*np.pi-np.pi/36, 3)
-    r = np.sqrt(z)
-    V = np.array([
-        [np.cos(theta) * np.cos(phi), -np.sin(theta), np.cos(theta) * np.sin(phi)],
-        [np.sin(theta) * np.cos(phi), np.cos(theta), np.sin(theta) * np.sin(phi)],
-        [-np.sin(phi), 0, np.cos(phi)]
-    ])
-    return V
-
-def smooth_linkage(start, end, N=50):
-    """Generate a smooth linking curve between two knots."""
-    t = np.linspace(0, 1, N)
-    x = (1 - t) * start[0] + t * end[0]
-    y = (1 - t) * start[1] + t * end[1]
-    z = (1 - t) * start[2] + t * end[2]
-    return np.vstack((x, y, z)).T
-
-def generate_knotted_structure(num_knots=5, N_per_knot=300):
-    """Generate a large 3D knotted structure by linking multiple knots."""
-    knots = []
-    previous_end = None
-
-    for i in range(num_knots):
-        knot_type = np.random.choice(["trefoil", "figure_eight"])
-        offset = previous_end + np.random.uniform(-3.0, 3.0, size=3) if previous_end is not None else np.random.uniform(-5, 5, size=3)
-        scale = np.random.uniform(0.5, 1.0)  # Vary knot sizes
-        rotation = random_rotation_matrix()
-        
-        if knot_type == "trefoil":
-            knot = trefoil_knot(N=N_per_knot, scale=scale, offset=offset, rotation=rotation)
-        else:
-            knot = cinquefoil_knot(N=N_per_knot, scale=scale, offset=offset, rotation=rotation)
-        
-        if previous_end is not None:
-            linkage = smooth_linkage(previous_end, knot[0], N=50)  # Smooth connection
-            knots.append(linkage)
-
-        knots.append(knot)
-        previous_end = knot[-1]
-
-    return np.vstack(knots)
-
-def smooth_knot_spline(V, num_interp=100, closed=True):
-    """
-    Smoothly interpolates a 3D knot using a cubic spline.
-
-    Parameters:
-        V (numpy.ndarray): Nx3 array representing the 3D knot.
-        num_interp (int): Number of points in the interpolated knot.
-        closed (bool): Whether to enforce periodic boundary conditions for closed knots.
-
-    Returns:
-        numpy.ndarray: Smoothed Nx3 array of the interpolated knot.
-    """
-    if V.shape[1] != 3:
-        raise ValueError("Input array V must have shape (N, 3)")
-    
-    if len(V) < 4:
-        raise ValueError("At least 4 points are required for spline fitting.")
-
-    # Define the parameter t along the curve
-    t = np.linspace(0, 1, len(V))
-    
-    # Interpolation points
-    t_new = np.linspace(0, 1, num_interp)
-
-    # Fit cubic splines separately for each coordinate
-    cs_x = CubicSpline(t, V[:, 0], bc_type='periodic' if closed else 'not-a-knot')
-    cs_y = CubicSpline(t, V[:, 1], bc_type='periodic' if closed else 'not-a-knot')
-    cs_z = CubicSpline(t, V[:, 2], bc_type='periodic' if closed else 'not-a-knot')
-
-    # Evaluate the splines
-    x_new = cs_x(t_new)
-    y_new = cs_y(t_new)
-    z_new = cs_z(t_new)
-
-    return np.vstack((x_new, y_new, z_new)).T
-
-def link_number_ensemble(path,N_ens=1250,step=100):
-    nlinks = list()
-    Ms = np.load(path+'/other/Ms.npy')
-    Ns = np.load(path+'/other/Ns.npy')
-    for i in range(N_ens//step,N_ens,step):
-        V = uts.get_coordinates_cif(path+f'/ensemble/MDLE_{i+1}.cif')
-        ms, ns = Ms[:,i], Ns[:,i]
-        N_links, links = calculate_linking_number(V,ms,ns)
-        nlinks.append(N_links)
-    return nlinks
-
-def calculate_linking_number(V,ms,ns):
-    links = list()
-    for i in tqdm(range(len(ms))):
-        for j in range(i+1,len(ms)):
-            if (ns[i]-ms[i])>5 and (ns[j]-ms[j])>5 and (((ms[i]<ns[i]) and (ns[i]<ms[j])) or ((ms[j]<ns[j]) and (ns[j]<ms[i]))):
-                loop1 = V[ms[i]:ns[i]]
-                loop1 = np.vstack((loop1,loop1[0,:]))
-                loop1 = smooth_knot_spline(loop1,2*len(loop1))
-                l1 = [list(loop1[i]) for i in range(len(loop1))]
-                loop2 = V[ms[j]:ns[j]]
-                loop2 = np.vstack((loop2,loop2[0,:]))
-                loop2 = smooth_knot_spline(loop2,2*len(loop2))
-                l2 = [list(loop2[i]) for i in range(len(loop2))]
-                links.append(tp.gln(l1,l2))
-    links = np.array(links)
-    links = links[links>0.5]
-    N_links = len(links)
-    
-    return N_links, links