pyLoopSage 1.0.18__tar.gz → 1.0.20__tar.gz

{pyloopsage-1.0.18/pyLoopSage.egg-info → pyloopsage-1.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyLoopSage
-Version: 1.0.18
+Version: 1.0.20
 Summary: An energy-based stochastic model of loop extrusion in chromatin.
 Home-page: https://github.com/SFGLab/pyLoopSage
 Author: Sebastian Korsak
@@ -12,7 +12,7 @@ Classifier: Operating System :: POSIX :: Linux
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy
+Requires-Dist: numpy==1.24.3
 Requires-Dist: numba
 Requires-Dist: scipy
 Requires-Dist: pandas
@@ -38,6 +38,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -178,7 +179,7 @@ You also need to download the reference genome from: ftp://ftp.1000genomes.ebi.a
 
 *Alternativelly, it is possible to import a .bedpe file without the last two columns (CTCF orientation). In this case, CTCF would act as an orientation independent barrier. This might affect slightly the results, but it is an easier option, if you do not want to run a CTCF motif finding script.*
 
-Then, we define the main parameters of the simulation `N_beads,N_coh,kappa,f,b` or we can choose the default ones (take care because it might be the case that they are not the appropriate ones and they need to be changed), the parameters of Monte Carlo `N_steps, MC_step, burnin, T`, and we initialize the class `LoopSage()`. The command `sim.run_energy_minimization()` corresponds to the stochastic Monte Carlo simulation, and it produces a set of cohesin constraints as a result (`Ms, Ns`). Note that the stochastic simulation has two modes: `Annealing` and `Metropolis`. We feed cohesin constraints to the molecular simulation part of and we run `MD_LE()` or `EM_LE()` simulation which produces a trajectory of 3d-structures, and the average heatmap. `MD_LE()` function can produce an actual trajectory and a `.dcd` video of how simulation changes over time. However, the implementation needs a high amount of memory since we need to define a bond for each time step, and it may not work for large systems. `EM_LE()` is suggested for large simulations, because it does not require so big amount of memory. *We would like to advise to our users that in case that they would like to use molecular dynamics (`MD`), it is better to choose small `MC_step`, because the trajectory of LEFs should be continuous.*
+Then, we define the main parameters of the simulation `N_beads,N_coh,kappa,f,b` or we can choose the default ones (take care because it might be the case that they are not the appropriate ones and they need to be changed), the parameters of Monte Carlo `N_steps, MC_step, burnin, T`, and we initialize the class `LoopSage()`. The command `sim.run_energy_minimization()` corresponds to the stochastic Monte Carlo simulation, and it produces a set of cohesin constraints as a result (`Ms, Ns`). Note that the stochastic simulation has two modes: `Annealing` and `Metropolis`. We feed cohesin constraints to the molecular simulation part of and we run `EM_LE()` or `EM_LE()` simulation which produces a trajectory of 3d-structures, and the average heatmap. `MD_LE()` function can produce an actual trajectory and a `.dcd` video of how simulation changes over time. However, the implementation needs a high amount of memory since we need to define a bond for each time step, and it may not work for large systems. `EM_LE()` is suggested for large simulations, because it does not require so big amount of memory.
 
 ### Running LoopSage from command-line
 To run LoopSage from command-line, you only need to type a command
@@ -307,8 +308,8 @@ An example, illustrated with Chimera software, simulated trajectory of structure
 | 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                 |
-| FRICTION             | Friction coefficient of the Langevin integrator.                                                              | float      | 0.1                 |
-| TOLERANCE            | Stopping condition for energy minimization.                                                                   | float      | 0.001               |
+| FRICTION             | Friction coefficient of the Langevin integrator.                                                              | float      | 0.1              |
+| TOLERANCE            | Stopping condition for energy minimization.     | float      | 0.001              |
 | VIZ_HEATS            | True to visualize the output average heatmap.                                                                | bool       | True                |
 | SIM_TEMP             | Temperature of the 3D simulation (EM or MD).                                                                  | Quantity   | 310 kelvin        |
 | SIM_STEP             | Amount of simulation steps for loop force adjustments.                                                        | int        | 1000                |

{pyloopsage-1.0.18 → pyloopsage-1.0.20}/README.md

@@ -134,7 +134,7 @@ You also need to download the reference genome from: ftp://ftp.1000genomes.ebi.a
 
 *Alternativelly, it is possible to import a .bedpe file without the last two columns (CTCF orientation). In this case, CTCF would act as an orientation independent barrier. This might affect slightly the results, but it is an easier option, if you do not want to run a CTCF motif finding script.*
 
-Then, we define the main parameters of the simulation `N_beads,N_coh,kappa,f,b` or we can choose the default ones (take care because it might be the case that they are not the appropriate ones and they need to be changed), the parameters of Monte Carlo `N_steps, MC_step, burnin, T`, and we initialize the class `LoopSage()`. The command `sim.run_energy_minimization()` corresponds to the stochastic Monte Carlo simulation, and it produces a set of cohesin constraints as a result (`Ms, Ns`). Note that the stochastic simulation has two modes: `Annealing` and `Metropolis`. We feed cohesin constraints to the molecular simulation part of and we run `MD_LE()` or `EM_LE()` simulation which produces a trajectory of 3d-structures, and the average heatmap. `MD_LE()` function can produce an actual trajectory and a `.dcd` video of how simulation changes over time. However, the implementation needs a high amount of memory since we need to define a bond for each time step, and it may not work for large systems. `EM_LE()` is suggested for large simulations, because it does not require so big amount of memory. *We would like to advise to our users that in case that they would like to use molecular dynamics (`MD`), it is better to choose small `MC_step`, because the trajectory of LEFs should be continuous.*
+Then, we define the main parameters of the simulation `N_beads,N_coh,kappa,f,b` or we can choose the default ones (take care because it might be the case that they are not the appropriate ones and they need to be changed), the parameters of Monte Carlo `N_steps, MC_step, burnin, T`, and we initialize the class `LoopSage()`. The command `sim.run_energy_minimization()` corresponds to the stochastic Monte Carlo simulation, and it produces a set of cohesin constraints as a result (`Ms, Ns`). Note that the stochastic simulation has two modes: `Annealing` and `Metropolis`. We feed cohesin constraints to the molecular simulation part of and we run `EM_LE()` or `EM_LE()` simulation which produces a trajectory of 3d-structures, and the average heatmap. `MD_LE()` function can produce an actual trajectory and a `.dcd` video of how simulation changes over time. However, the implementation needs a high amount of memory since we need to define a bond for each time step, and it may not work for large systems. `EM_LE()` is suggested for large simulations, because it does not require so big amount of memory.
 
 ### Running LoopSage from command-line
 To run LoopSage from command-line, you only need to type a command
@@ -263,8 +263,8 @@ An example, illustrated with Chimera software, simulated trajectory of structure
 | 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                 |
-| FRICTION             | Friction coefficient of the Langevin integrator.                                                              | float      | 0.1                 |
-| TOLERANCE            | Stopping condition for energy minimization.                                                                   | float      | 0.001               |
+| FRICTION             | Friction coefficient of the Langevin integrator.                                                              | float      | 0.1              |
+| TOLERANCE            | Stopping condition for energy minimization.     | float      | 0.001              |
 | VIZ_HEATS            | True to visualize the output average heatmap.                                                                | bool       | True                |
 | SIM_TEMP             | Temperature of the 3D simulation (EM or MD).                                                                  | Quantity   | 310 kelvin        |
 | SIM_STEP             | Amount of simulation steps for loop force adjustments.                                                        | int        | 1000                |

{pyloopsage-1.0.18 → pyloopsage-1.0.20}/loopsage/__init__.py

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

{pyloopsage-1.0.18 → pyloopsage-1.0.20}/loopsage/args_definition.py

@@ -178,4 +178,4 @@ args = ListOfArgs([
     Arg('VIZ_HEATS', help="Visualize the output average heatmap.", type=bool, default='True', val='True'),
     Arg('SIM_TEMP', help="The temperature of the 3D simulation (EM or MD).", type=Quantity, default='310 kelvin', val='310 kelvin'),
     Arg('SIM_STEP', help="This is the amount of simulation steps that are perform each time that we change the loop forces. If this number is too high, the simulation is slow, if is too low it may not have enough time to adapt the structure to the new constraints.", type=int, default='1000', val='1000'),
-])
+])

{pyloopsage-1.0.18 → pyloopsage-1.0.20}/loopsage/em.py

@@ -41,13 +41,13 @@ class EM_LE:
         self.ev_ff_power = ev_ff_power
         self.tolerance = tolerance
     
-    def run_pipeline(self,plots=False, friction=0.1, ff_path=default_xml_path, integrator_step = 100 * mm.unit.femtosecond, temperature = 310):
+    def run_pipeline(self,plots=False, friction=0.1, ff_path=default_xml_path, integrator_step = 100 * mm.unit.femtosecond, temperature = 310, init_struct='rw'):
         '''
         This is the basic function that runs the molecular simulation pipeline.
         '''
         # Define initial structure
         print('Building initial structure...')
-        points = compute_init_struct(self.N_beads,mode='rw')
+        points = compute_init_struct(self.N_beads,mode=init_struct)
         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')

pyloopsage-1.0.20/loopsage/knots.py

@@ -0,0 +1,193 @@
+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

{pyloopsage-1.0.18 → pyloopsage-1.0.20}/loopsage/md.py

@@ -36,7 +36,7 @@ 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',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):
         '''
         This is the basic function that runs the molecular simulation pipeline.
         '''
@@ -78,15 +78,14 @@ class MD_LE:
             print('Running molecular dynamics (wait for 100 steps)...')
             start = time.time()
             heats = list()
-            for i in range(1,self.N_steps):
+            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)
-                # Change forcefield
                 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}.cif', 'w'))
+                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))
             end = time.time()
             elapsed = end - start

{pyloopsage-1.0.18 → pyloopsage-1.0.20}/loopsage/preproc.py

@@ -52,6 +52,8 @@ def binding_vectors_from_bedpe(bedpe_file,N_beads,region,chrom,normalization=Fal
             if df[7][i]>=0: R[x] += df[6][i]*df[7][i]
             if df[8][i]>=0: R[y] += df[6][i]*df[8][i]
         else:
+            if x>=N_beads: x=N_beads-1
+            if y>=N_beads: y=N_beads-1
             L[x] += df[6][i]
             L[y] += df[6][i]
             R[x] += df[6][i]

{pyloopsage-1.0.18 → pyloopsage-1.0.20}/loopsage/run.py

@@ -72,9 +72,9 @@ def main():
     sim = StochasticSimulation(region,chrom,bedpe_file,out_dir=output_name,N_beads=N_beads,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=args.SAVE_PLOTS,save=args.SAVE_MDT,lef_rw=args.LEF_RW,f=f,f2=f2,b=b,kappa=kappa,lef_drift=args.LEF_DRIFT,cross_loop=args.CROSS_LOOP)
     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.VIZ_HEATS,args.FORCEFIELD_PATH)
+        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.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)
     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.18 → pyloopsage-1.0.20}/loopsage/stochastic_simulation.py

@@ -136,7 +136,7 @@ def slide(m_old, n_old, ms, ns, N_beads, rw=True, drift=True):
         m_new =  m_old - r1 if m_old + r1>=0 else 0
     n_new = n_old + r2 if n_old + r2<N_beads else N_beads-1
     if np.any(ms==n_new) and drift and n_old-r2>m_old+1: 
-        n_new =  n_old - r2 if n_old + r2>=0 else 0
+        n_new =  n_old - r2 if n_old + r2<N_beads else N_beads-1
     return int(m_new), int(n_new)
 
 @njit
@@ -254,26 +254,25 @@ class StochasticSimulation:
 
         # Save simulation info
         if save:
-            f = open(self.path+'/other/info.txt', "w")
-            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 {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[burnin//MC_step:]):.2f}.\n')
-            f.close()
-
-            np.save(self.path+'/other/Ms.npy',self.Ms)
-            np.save(self.path+'/other/Ns.npy',self.Ns)
-            np.save(self.path+'/other/ufs.npy',self.ufs)
-            np.save(self.path+'/other/Es.npy',self.Es)
-            np.save(self.path+'/other/Bs.npy',self.Bs)
-            np.save(self.path+'/other/Fs.npy',self.Fs)
-            np.save(self.path+'/other/Ks.npy',self.Ks)
+            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')
+            np.save(save_dir + 'Ms.npy', self.Ms)
+            np.save(save_dir + 'Ns.npy', self.Ns)
+            np.save(save_dir + 'ufs.npy', self.ufs)
+            np.save(save_dir + 'Es.npy', self.Es)
+            np.save(save_dir + 'Bs.npy', self.Bs)
+            np.save(save_dir + 'Fs.npy', self.Fs)
+            np.save(save_dir + 'Ks.npy', self.Ks)
         
         # Some vizualizations
         if viz: coh_traj_plot(self.Ms,self.Ns,self.N_beads, self.path)
@@ -288,14 +287,14 @@ class StochasticSimulation:
         self.N_CTCF = np.max([np.count_nonzero(self.L),np.count_nonzero(self.R)])
         print('Number of CTCF:',self.N_CTCF)
 
-    def run_EM(self,platform='CPU',angle_ff_strength=200,le_distance=0.0,le_ff_strength=300000.0,ev_ff_strength=10.0,ev_ff_power=3.0,tolerance=0.001,friction=0.1,integrator_step=100*mm.unit.femtosecond,temperature=310,save_plots=True,ff_path=default_xml_path):
+    def run_EM(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',save_plots=True,ff_path=default_xml_path):
         em = EM_LE(self.Ms,self.Ns,self.N_beads,self.burnin,self.MC_step,self.path,platform,angle_ff_strength,le_distance,le_ff_strength,ev_ff_strength,ev_ff_power,tolerance)
-        sim_heat = em.run_pipeline(plots=save_plots,friction=friction,integrator_step=integrator_step,temperature=temperature,ff_path=ff_path)
+        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.0,le_ff_strength=300000.0,ev_ff_strength=10.0,ev_ff_power=3.0,tolerance=0.001,friction=0.1,integrator_step=100*mm.unit.femtosecond,temperature=310,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):
         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)
+        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)
         corr_exp_heat(sim_heat,self.bedpe_file,self.region,self.chrom,self.N_beads,self.path)
 
 def main():

{pyloopsage-1.0.18 → pyloopsage-1.0.20}/loopsage/utils.py

@@ -13,14 +13,14 @@ from scipy.stats.stats import pearsonr, spearmanr, kendalltau
 from tqdm import tqdm
 
 def make_folder(folder_name):
-    try:
+    if not os.path.exists(folder_name):
         os.mkdir(folder_name)
-        os.mkdir(folder_name+'/plots')
-        os.mkdir(folder_name+'/other')
-        os.mkdir(folder_name+'/ensemble')
-    except OSError as error:
-        a=1
-        # print(f'Directory with name "{folder_name}" already exists! No problem lets continue!')
+    elif os.path.isdir(folder_name):
+        print(f'Directory with name "{folder_name}" already exists! No problem lets continue!')
+    else:
+        raise IOError(f'File with name "{folder_name}" already exists! Please change the name of the folder!')        
+    for subfolder in ['plots', 'other', 'ensemble']:
+        os.makedirs(os.path.join(folder_name, subfolder), exist_ok=True)
     return folder_name
 
 ############# Creation of mmcif and psf files #############

{pyloopsage-1.0.18 → pyloopsage-1.0.20/pyLoopSage.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: pyLoopSage
-Version: 1.0.18
+Version: 1.0.20
 Summary: An energy-based stochastic model of loop extrusion in chromatin.
 Home-page: https://github.com/SFGLab/pyLoopSage
 Author: Sebastian Korsak
@@ -12,7 +12,7 @@ Classifier: Operating System :: POSIX :: Linux
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy
+Requires-Dist: numpy==1.24.3
 Requires-Dist: numba
 Requires-Dist: scipy
 Requires-Dist: pandas
@@ -38,6 +38,7 @@ Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
 Dynamic: license
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
@@ -178,7 +179,7 @@ You also need to download the reference genome from: ftp://ftp.1000genomes.ebi.a
 
 *Alternativelly, it is possible to import a .bedpe file without the last two columns (CTCF orientation). In this case, CTCF would act as an orientation independent barrier. This might affect slightly the results, but it is an easier option, if you do not want to run a CTCF motif finding script.*
 
-Then, we define the main parameters of the simulation `N_beads,N_coh,kappa,f,b` or we can choose the default ones (take care because it might be the case that they are not the appropriate ones and they need to be changed), the parameters of Monte Carlo `N_steps, MC_step, burnin, T`, and we initialize the class `LoopSage()`. The command `sim.run_energy_minimization()` corresponds to the stochastic Monte Carlo simulation, and it produces a set of cohesin constraints as a result (`Ms, Ns`). Note that the stochastic simulation has two modes: `Annealing` and `Metropolis`. We feed cohesin constraints to the molecular simulation part of and we run `MD_LE()` or `EM_LE()` simulation which produces a trajectory of 3d-structures, and the average heatmap. `MD_LE()` function can produce an actual trajectory and a `.dcd` video of how simulation changes over time. However, the implementation needs a high amount of memory since we need to define a bond for each time step, and it may not work for large systems. `EM_LE()` is suggested for large simulations, because it does not require so big amount of memory. *We would like to advise to our users that in case that they would like to use molecular dynamics (`MD`), it is better to choose small `MC_step`, because the trajectory of LEFs should be continuous.*
+Then, we define the main parameters of the simulation `N_beads,N_coh,kappa,f,b` or we can choose the default ones (take care because it might be the case that they are not the appropriate ones and they need to be changed), the parameters of Monte Carlo `N_steps, MC_step, burnin, T`, and we initialize the class `LoopSage()`. The command `sim.run_energy_minimization()` corresponds to the stochastic Monte Carlo simulation, and it produces a set of cohesin constraints as a result (`Ms, Ns`). Note that the stochastic simulation has two modes: `Annealing` and `Metropolis`. We feed cohesin constraints to the molecular simulation part of and we run `EM_LE()` or `EM_LE()` simulation which produces a trajectory of 3d-structures, and the average heatmap. `MD_LE()` function can produce an actual trajectory and a `.dcd` video of how simulation changes over time. However, the implementation needs a high amount of memory since we need to define a bond for each time step, and it may not work for large systems. `EM_LE()` is suggested for large simulations, because it does not require so big amount of memory.
 
 ### Running LoopSage from command-line
 To run LoopSage from command-line, you only need to type a command
@@ -307,8 +308,8 @@ An example, illustrated with Chimera software, simulated trajectory of structure
 | 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                 |
-| FRICTION             | Friction coefficient of the Langevin integrator.                                                              | float      | 0.1                 |
-| TOLERANCE            | Stopping condition for energy minimization.                                                                   | float      | 0.001               |
+| FRICTION             | Friction coefficient of the Langevin integrator.                                                              | float      | 0.1              |
+| TOLERANCE            | Stopping condition for energy minimization.     | float      | 0.001              |
 | VIZ_HEATS            | True to visualize the output average heatmap.                                                                | bool       | True                |
 | SIM_TEMP             | Temperature of the 3D simulation (EM or MD).                                                                  | Quantity   | 310 kelvin        |
 | SIM_STEP             | Amount of simulation steps for loop force adjustments.                                                        | int        | 1000                |

{pyloopsage-1.0.18 → pyloopsage-1.0.20}/pyLoopSage.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ 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.18 → pyloopsage-1.0.20}/pyLoopSage.egg-info/requires.txt

@@ -1,4 +1,4 @@
-numpy
+numpy==1.24.3
 numba
 scipy
 pandas

{pyloopsage-1.0.18 → pyloopsage-1.0.20}/setup.py

@@ -6,7 +6,7 @@ with open('README.md', 'r', encoding='utf-8') as f:
 
 setup(
     name='pyLoopSage',  # Package name
-    version='1.0.18',  # Version of the software
+    version='1.0.20',  # 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',
@@ -20,7 +20,7 @@ setup(
     'loopsage': ['forcefields/*'],
     },
     install_requires=[  # List your package dependencies here
-        'numpy',
+        'numpy==1.24.3',
         'numba',
         'scipy',
         'pandas',