pyLoopSage 1.1.3__tar.gz → 1.1.5__tar.gz

pyloopsage-1.1.5/MANIFEST.in

@@ -0,0 +1 @@
+exclude Dockerfile

{pyloopsage-1.1.3/pyLoopSage.egg-info → pyloopsage-1.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyLoopSage
-Version: 1.1.3
+Version: 1.1.5
 Summary: An energy-based stochastic model of loop extrusion in chromatin.
 Home-page: https://github.com/SFGLab/pyLoopSage
 Author: Sebastian Korsak
@@ -32,6 +32,7 @@ Requires-Dist: imageio
 Requires-Dist: imageio[ffmpeg]
 Requires-Dist: pillow
 Requires-Dist: pyBigWig
+Requires-Dist: topoly
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -126,6 +127,51 @@ In general the user can run simulation in two different ways:
 
 Can be easily installed with `pip install pyLoopSage`. To have CUDA acceleration, it is needed to have cuda-toolkit installed in case that you use nvidia drivers (otherwise you can use OpenCL or parallelization across CPU cores).
 
+## 🐳 Running LoopSage with Docker
+
+To use LoopSage in a fully containerized and reproducible way, you can build and run it using Docker. This is a very efficient way when you want to use CUDA.
+
+### Step 1: Build the Docker Image
+
+Clone the repository and build the image:
+
+```bash
+docker build -t pyloopsage-cuda .
+```
+
+The `Dockerfile` can be found in the GitHub repo of pyLoopSage.
+
+### Step 2: Run the Simulation
+
+Use the following command to run your simulation:
+
+```bash
+docker run --rm -it --gpus all \
+  -v "$PWD/config.ini:/app/config.ini:ro" \
+  -v "$PWD/tmp:/app/output" \
+  -v "$HOME/Data:/home/blackpianocat/Data:ro" \
+  pyloopsage-cuda \
+  python -m loopsage.run -c /app/config.ini
+```
+
+**What this does:**
+
+* `--rm`: Automatically removes the container after it finishes.
+* `--gpus all`: It detects the gpus of the system.
+* `-it`: Runs with an interactive terminal.
+* `-v "$PWD/config.ini:/app/config.ini:ro"`: Mounts your local `config.ini` as read-only inside the container.
+* `-v "$PWD/tmp:/app/output"`: Maps the `tmp/` directory for outputs.
+* `-v "$HOME/Data:/home/blackpianocat/Data:ro"`: Mounts your full data directory so LoopSage can access input files.
+* The final command runs LoopSage with your config file.
+
+You do **not** need to manually stop or clean up anything—the container is temporary and self-destructs after it completes. The image (`pyloopsage-cuda`) remains available on your system and can be deleted anytime using:
+
+```bash
+docker rmi pyloopsage-cuda
+```
+
+**Note:** Install `nvidia-container-toolkit` in your system if you want to use the container with CUDA: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html
+
 ## How to use?
 
 ### Python Implementation

{pyloopsage-1.1.3 → pyloopsage-1.1.5}/README.md

@@ -80,6 +80,51 @@ In general the user can run simulation in two different ways:
 
 Can be easily installed with `pip install pyLoopSage`. To have CUDA acceleration, it is needed to have cuda-toolkit installed in case that you use nvidia drivers (otherwise you can use OpenCL or parallelization across CPU cores).
 
+## 🐳 Running LoopSage with Docker
+
+To use LoopSage in a fully containerized and reproducible way, you can build and run it using Docker. This is a very efficient way when you want to use CUDA.
+
+### Step 1: Build the Docker Image
+
+Clone the repository and build the image:
+
+```bash
+docker build -t pyloopsage-cuda .
+```
+
+The `Dockerfile` can be found in the GitHub repo of pyLoopSage.
+
+### Step 2: Run the Simulation
+
+Use the following command to run your simulation:
+
+```bash
+docker run --rm -it --gpus all \
+  -v "$PWD/config.ini:/app/config.ini:ro" \
+  -v "$PWD/tmp:/app/output" \
+  -v "$HOME/Data:/home/blackpianocat/Data:ro" \
+  pyloopsage-cuda \
+  python -m loopsage.run -c /app/config.ini
+```
+
+**What this does:**
+
+* `--rm`: Automatically removes the container after it finishes.
+* `--gpus all`: It detects the gpus of the system.
+* `-it`: Runs with an interactive terminal.
+* `-v "$PWD/config.ini:/app/config.ini:ro"`: Mounts your local `config.ini` as read-only inside the container.
+* `-v "$PWD/tmp:/app/output"`: Maps the `tmp/` directory for outputs.
+* `-v "$HOME/Data:/home/blackpianocat/Data:ro"`: Mounts your full data directory so LoopSage can access input files.
+* The final command runs LoopSage with your config file.
+
+You do **not** need to manually stop or clean up anything—the container is temporary and self-destructs after it completes. The image (`pyloopsage-cuda`) remains available on your system and can be deleted anytime using:
+
+```bash
+docker rmi pyloopsage-cuda
+```
+
+**Note:** Install `nvidia-container-toolkit` in your system if you want to use the container with CUDA: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html
+
 ## How to use?
 
 ### Python Implementation

{pyloopsage-1.1.3 → pyloopsage-1.1.5}/loopsage/__init__.py

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

{pyloopsage-1.1.3 → pyloopsage-1.1.5}/loopsage/args_definition.py

@@ -196,6 +196,7 @@ args = ListOfArgs([
     Arg('BIND_COEFF', help="CTCF binding coefficient.", type=float, default='1.0', val='1.0'),
     Arg('SAVE_PLOTS', help="It should be true in case that you would like to save diagnostic plots. In case that you use small MC_STEP or large N_STEPS is better to mark it as False.", type=bool, default='True', val='True'),
     Arg('SAVE_MDT', help="In case that you would liketo save metadata of the stochastic simulation.", type=bool, default='True', val='True'),
+    Arg('DETECT_KNOTS', help="In case that you would like to find out if there are knots in the structure.", type=bool, default='False', val='False'),
     
     # Molecular Dynamic Properties
     Arg('INITIAL_STRUCTURE_TYPE', help="you can choose between: rw, confined_rw, self_avoiding_rw, helix, circle, spiral, sphere.", type=str, default='rw', val='rw'),

pyloopsage-1.1.5/loopsage/knots.py

@@ -0,0 +1,210 @@
+from scipy.interpolate import CubicSpline, interp1d
+from scipy.spatial.distance import pdist, squareform
+from scipy.integrate import dblquad
+import topoly as tp
+import numpy as np
+from tqdm import tqdm
+from .utils import *
+import os
+
+################ Initial Knotted Structure Creation ######################
+
+def resample_curve(points, N):
+    deltas = np.diff(points, axis=0)
+    dists = np.linalg.norm(deltas, axis=1)
+    cumulative = np.insert(np.cumsum(dists), 0, 0)
+    uniform_samples = np.linspace(0, cumulative[-1], N)
+    interp = interp1d(cumulative, points, axis=0)
+    return interp(uniform_samples)
+
+def trefoil_knot(N=200, scale=0.5, offset=(0, 0, 0), rotation=None):
+    dense_N = 5000
+    t = np.linspace(0, 2 * np.pi, dense_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)
+    return resample_curve(V, N)
+
+def cinquefoil_knot(N=200, scale=0.5, offset=(0, 0, 0), rotation=None):
+    dense_N = 5000
+    t = np.linspace(0, 2 * np.pi, dense_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)
+    return resample_curve(V + np.array(offset), N)
+
+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 smooth_spline_linkage(start, start_dir, end, end_dir, N=100):
+    """Generate a smooth cubic spline from `start` to `end` with given directional derivatives."""
+    t = np.array([0, 1])
+    x = np.array([start[0], end[0]])
+    y = np.array([start[1], end[1]])
+    z = np.array([start[2], end[2]])
+
+    # Use directional derivative constraints
+    cs_x = CubicSpline(t, x, bc_type=((1, start_dir[0]), (1, end_dir[0])))
+    cs_y = CubicSpline(t, y, bc_type=((1, start_dir[1]), (1, end_dir[1])))
+    cs_z = CubicSpline(t, z, bc_type=((1, start_dir[2]), (1, end_dir[2])))
+
+    tt = np.linspace(0, 1, N)
+    return np.vstack((cs_x(tt), cs_y(tt), cs_z(tt))).T
+
+def random_unit_vector():
+    """Uniformly sample a unit vector on the 3D sphere."""
+    phi = np.random.uniform(0, 2*np.pi)
+    costheta = np.random.uniform(-0.1, 0.1)
+    sintheta = np.sqrt(1 - costheta**2)
+    return np.array([sintheta * np.cos(phi), sintheta * np.sin(phi), costheta])
+
+def generate_knotted_structure(N=1000, num_knots=5):
+    """Generate a structure with `num_knots` along a random walk, total `N` points."""
+    if num_knots >= N:
+        raise ValueError("N must be much larger than num_knots")
+
+    points_per_knot = N // num_knots
+    structure = []
+    position = np.zeros(3)
+    radius_buffer = 2.0  # Step size for knot placement
+
+    for _ in range(num_knots):
+        # Move to next knot position
+        direction = random_unit_vector()
+        position = position + direction * radius_buffer
+
+        # Random rotation and scale
+        rotation = random_rotation_matrix()
+        scale = np.random.uniform(0.6, 1.0)
+
+        # Generate knot
+        knot_type = np.random.choice(["trefoil", "figure_eight"])
+        if knot_type == "trefoil":
+            knot = trefoil_knot(N=points_per_knot, scale=scale, offset=position, rotation=rotation)
+        else:
+            knot = cinquefoil_knot(N=points_per_knot, scale=scale, offset=position, rotation=rotation)
+
+        structure.append(knot)
+
+    curve = np.vstack(structure)
+    return resample_curve(curve, N) if len(curve) != N else curve
+
+############## Identification of Knots and Links ######################
+
+def smooth_knot_spline(V, num_interp=200, 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 calculate_linking_number(V,ms,ns):
+    links = list()
+    for i in 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
+
+def link_number_ensemble(path, step=1, mode='MD', viz=False):
+    nlinks = list()
+    Ms = np.load(path+'/other/Ms.npy')
+    Ns = np.load(path+'/other/Ns.npy')
+    
+    # Automatically determine the number of ensembles
+    ensemble_files = [f for f in os.listdir(path+'/ensemble') if f.startswith('MDLE_') and f.endswith('.cif')]
+    max_index = max(int(f.split('_')[1].split('.')[0]) for f in ensemble_files)
+    
+    print('\nCalculating linking number of structures....')
+    for i in tqdm(range(step, max_index + 1, step)):
+        V = get_coordinates_cif(path+f'/ensemble/{mode}LE_{i}.cif')
+        ms, ns = Ms[:, i-1], Ns[:, i-1]
+        N_links, links = calculate_linking_number(V, ms, ns)
+        nlinks.append(N_links)
+    print('Done!')
+    
+    avg_link_number  = np.mean(nlinks)
+    std_link_number  = np.std(nlinks)
+    if viz:
+        plt.figure()
+        plt.plot(np.arange(0, len(nlinks)*step, step), nlinks)
+        plt.xlabel('Step')
+        plt.ylabel('Number of links')
+        plt.savefig(path+'/plots/links.png')
+        plt.close()
+
+        plt.figure()
+        plt.hist(nlinks, bins=20, alpha=0.75, color='blue', edgecolor='black')
+        plt.xlabel('Number of links')
+        plt.ylabel('Frequency')
+        plt.title('Histogram of Number of Links')
+        plt.savefig(path+'/plots/links_histogram.png')
+        plt.close()
+    np.save(path+'/other/links.npy', nlinks)
+    print(f'Average number of links: {avg_link_number:.2f} ± {std_link_number:.2f}')
+    return avg_link_number, std_link_number, nlinks

{pyloopsage-1.1.3 → pyloopsage-1.1.5}/loopsage/plots.py

@@ -101,60 +101,70 @@ def average_pooling(mat,dim_new):
     im_resized = np.array(im.resize(size))
     return im_resized
 
-def correlation_plot(given_heatmap,T_range,path):
-    pearsons, spearmans, kendals = np.zeros(len(T_range)), np.zeros(len(T_range)), np.zeros(len(T_range))
-    exp_heat_dim = len(given_heatmap)
-    for i, T in enumerate(T_range):
-        N_beads,N_coh,kappa,f,b = 500,30,20000,-2000,-2000
-        N_steps, MC_step, burnin = int(1e4), int(1e2), 20
-        L, R = binding_vectors_from_bedpe_with_peaks("/mnt/raid/data/Zofia_Trios/bedpe/hg00731_CTCF_pulled_2.bedpe",N_beads,[178421513,179491193],'chr1',False)
-        sim = LoopSage(N_beads,N_coh,kappa,f,b,L,R)
-        Es, Ms, Ns, Bs, Ks, Fs, ufs = sim.run_energy_minimization(N_steps,MC_step,burnin,T,mode='Metropolis',viz=True,vid=False)
-        md = MD_LE(Ms,Ns,N_beads,burnin,MC_step)
-        heat = md.run_pipeline(write_files=False,plots=False)
-        if N_beads>exp_heat_dim:
-            heat = average_pooling(heat,exp_heat_dim)
-            L = exp_heat_dim
-        else:
-            given_heatmap = average_pooling(given_heatmap,N_beads)
-            L = N_beads
-        a, b = np.reshape(heat, (L**2, )), np.reshape(given_heatmap, (L**2, ))
-        pearsons[i] = scipy.stats.pearsonr(a,b)[0]
-        spearmans[i] = scipy.stats.spearmanr(a, b).correlation
-        kendals[i] = scipy.stats.kendalltau(a, b).correlation
-        print(f'\nTemperature:{T}, Pearson Correlation coefficient:{pearsons[i]}, Spearman:{spearmans[i]}, Kendal:{kendals[i]}\n\n')
-
-    figure(figsize=(10, 8), dpi=600)
-    plt.plot(T_range,pearsons,'bo-')
-    plt.plot(T_range,spearmans,'ro-')
-    plt.plot(T_range,kendals,'go-')
-    # plt.plot(T_range,Cross,'go-')
-    plt.ylabel('Correlation with Experimental Heatmap', fontsize=16)
-    plt.xlabel('Temperature', fontsize=16)
-    # plt.yscale('symlog')
-    plt.legend(['Pearson','Spearman','Kendall Tau'])
-    plt.grid()
-    save_path = path+'/plots/pearson_plot.pdf' if path!=None else 'pearson_plot.pdf'
-    plt.savefig(save_path,dpi=600)
-    plt.close()
-
-def coh_traj_plot(ms,ns,N_beads,path):
+def coh_traj_plot(ms, ns, N_beads, path, jump_threshold=200, min_stable_time=10):
+    """
+    Plots the trajectories of cohesins as filled regions between their two ends over time.
+
+    Parameters:
+        ms (list of arrays): List where each element is an array of left-end positions of a cohesin over time.
+        ns (list of arrays): List where each element is an array of right-end positions of a cohesin over time.
+        N_beads (int): Total number of beads (simulation sites) in the system.
+        path (str): Directory path where the plots will be saved.
+        jump_threshold (int, optional): Maximum allowed jump (in bead units) between consecutive time points for both ends.
+            If the jump between two consecutive positions exceeds this threshold for either end, that segment is considered a jump and is masked out.
+            Lower values make the criterion for erasing (masking) trajectories more strict (more segments are erased), higher values make it less strict.
+        min_stable_time (int, optional): Minimum number of consecutive time points required for a region to be considered stable and shown.
+            Shorter stable regions (less than this value) are erased (masked out).
+            Higher values make the criterion more strict (only longer stable regions are shown), lower values make it less strict.
+
+    The function highlights only stable, non-jumping regions of cohesin trajectories.
+    """
+    print('\nPlotting trajectories of cohesins...')
     N_coh = len(ms)
-    figure(figsize=(18, 25))
-    color = ["#"+''.join([rd.choice('0123456789ABCDEF') for j in range(6)]) for i in range(N_coh)]
-    size = 0.01 if (N_beads > 500 or N_coh > 20) else 0.1
-    
-    ls = 'None'
-    for nn in range(N_coh):
-        tr_m, tr_n = ms[nn], ns[nn]
-        plt.fill_between(np.arange(len(tr_m)), tr_m, tr_n, color=color[nn], alpha=0.4, interpolate=False, linewidth=0)
-    plt.xlabel('Simulation Step', fontsize=24)
-    plt.ylabel('Position of Cohesin', fontsize=24)
+    figure(figsize=(10, 10), dpi=200)
+    cmap = plt.get_cmap('prism')
+    colors = [cmap(i / N_coh) for i in range(N_coh)]
+
+    for nn in tqdm(range(N_coh)):
+        tr_m, tr_n = np.array(ms[nn]), np.array(ns[nn])
+        steps = np.arange(len(tr_m))
+
+        # Calculate jump size for tr_m and tr_n independently
+        jumps_m = np.abs(np.diff(tr_m))
+        jumps_n = np.abs(np.diff(tr_n))
+
+        # Create mask: True = good point, False = jump
+        jump_mask = np.ones_like(tr_m, dtype=bool)
+        jump_mask[1:] = (jumps_m < jump_threshold) & (jumps_n < jump_threshold)  # both must be below threshold
+
+        # Now we want to detect stable regions
+        stable_mask = np.copy(jump_mask)
+
+        # Find connected regions
+        current_length = 0
+        for i in range(len(stable_mask)):
+            if jump_mask[i]:
+                current_length += 1
+            else:
+                if current_length < min_stable_time:
+                    stable_mask[i-current_length:i] = False
+                current_length = 0
+        # Handle last region
+        if current_length < min_stable_time:
+            stable_mask[len(stable_mask)-current_length:] = False
+
+        # Apply mask
+        tr_m_masked = np.ma.masked_array(tr_m, mask=~stable_mask)
+        tr_n_masked = np.ma.masked_array(tr_n, mask=~stable_mask)
+
+        plt.fill_between(steps, tr_m_masked, tr_n_masked,
+                         color=colors[nn], alpha=0.6, interpolate=False, linewidth=0)
+    plt.xlabel('MC Step', fontsize=16)
+    plt.ylabel('Simulation Beads', fontsize=16)
     plt.gca().invert_yaxis()
-    save_path = path+'/plots/coh_trajectories.png' if path!=None else 'coh_trajectories.png'
-    plt.savefig(save_path, format='png', dpi=200)
-    save_path = path+'/plots/coh_trajectories.svg' if path!=None else 'coh_trajectories.svg'
-    plt.savefig(save_path, format='svg', dpi=200)
+    plt.ylim((0, N_beads))
+    save_path = path + '/plots/LEFs.png'
+    plt.savefig(save_path, format='png',dpi=200)
     plt.close()
 
 def coh_probdist_plot(ms,ns,N_beads,path):

{pyloopsage-1.1.3 → pyloopsage-1.1.5}/loopsage/run.py

@@ -1,7 +1,6 @@
 from .stochastic_simulation import *
 from .args_definition import *
-import os
-import time
+from .knots import *
 import argparse
 import configparser
 from typing import List
@@ -95,5 +94,9 @@ def main():
     else:
         IndentationError('Uknown simulation type. It can be either MD or EM.')
 
+    # Knoting
+    if args.DETECT_KNOTS:
+        link_number_ensemble(path=args.OUT_PATH, viz=args.SAVE_PLOTS, mode=args.SIMULATION_TYPE)
+    
 if __name__=='__main__':
     main()

{pyloopsage-1.1.3 → pyloopsage-1.1.5}/loopsage/stochastic_simulation.py

@@ -198,7 +198,16 @@ def run_simulation(N_beads, N_steps, MC_step, burnin, T, T_min, fold_norm, fold_
     Es, Ks, Fs, Bs, ufs = np.zeros(N_steps // MC_step, dtype=np.float64), np.zeros(N_steps // MC_step, dtype=np.float64), np.zeros(N_steps // MC_step, dtype=np.float64), np.zeros(N_steps // MC_step, dtype=np.float64), np.zeros(N_steps // MC_step, dtype=np.float64)
     Ms, Ns = np.zeros((N_lef + N_lef2, N_steps // MC_step), dtype=np.int64), np.zeros((N_lef + N_lef2, N_steps // MC_step), dtype=np.int64)
 
+    last_percent = -1
+
     for i in range(N_steps):
+        # Print progress every 5%
+        percent = int(100 * i / N_steps)
+        if percent % 5 == 0 and percent != last_percent:
+            # Numba can't use print with flush, so just print
+            print(f"Progress: {percent} % completed.")
+            last_percent = percent
+        
         Ti = T - (T - T_min) * (i + 1) / N_steps if mode == 'Annealing' else T
         for j in range(N_lef + N_lef2):
             # Randomly choose a move (sliding or rebinding)
@@ -275,7 +284,7 @@ class StochasticSimulation:
         r = np.full(self.N_bws, -self.N_beads / 10) if not r and self.N_bws > 0 else (None if not r else r)
 
         # Run simulation
-        print('\nRunning simulation (with parallelization across CPU cores)...')
+        print('\nRunning simulation (with numba acceleration)...')
         start = time.time()
         self.burnin = burnin
         self.Ms, self.Ns, self.Es, self.Ks, self.Fs, self.Bs, self.ufs = run_simulation(self.N_beads, N_steps, MC_step, burnin, T, T_min, fold_norm, fold_norm2, bind_norm, k_norm, self.N_lef, self.N_lef2, self.L, self.R, mode, lef_rw, lef_drift, cross_loop, r, self.N_bws, self.BWs, self.lef_track, between_families_penalty)

{pyloopsage-1.1.3 → pyloopsage-1.1.5}/loopsage/utils.py

@@ -13,14 +13,23 @@ from scipy.stats.stats import pearsonr, spearmanr, kendalltau
 from tqdm import tqdm
 
 def make_folder(folder_name):
+    created = False
     if not os.path.exists(folder_name):
         os.mkdir(folder_name)
+        created = True
     elif os.path.isdir(folder_name):
-        print(f'Directory with name "{folder_name}" already exists! No problem lets continue!')
+        print(f'\033[94mDirectory with name "{folder_name}" already exists! No problem, let\'s continue!\033[0m')
     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)
+        subfolder_path = os.path.join(folder_name, subfolder)
+        if not os.path.exists(subfolder_path):
+            os.makedirs(subfolder_path, exist_ok=True)
+            created = True
+    
+    if created:
+        print(f'\033[92mAt least one directory was created!\033[0m')
     return folder_name
 
 ############# Creation of mmcif and psf files #############

{pyloopsage-1.1.3 → pyloopsage-1.1.5/pyLoopSage.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyLoopSage
-Version: 1.1.3
+Version: 1.1.5
 Summary: An energy-based stochastic model of loop extrusion in chromatin.
 Home-page: https://github.com/SFGLab/pyLoopSage
 Author: Sebastian Korsak
@@ -32,6 +32,7 @@ Requires-Dist: imageio
 Requires-Dist: imageio[ffmpeg]
 Requires-Dist: pillow
 Requires-Dist: pyBigWig
+Requires-Dist: topoly
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -126,6 +127,51 @@ In general the user can run simulation in two different ways:
 
 Can be easily installed with `pip install pyLoopSage`. To have CUDA acceleration, it is needed to have cuda-toolkit installed in case that you use nvidia drivers (otherwise you can use OpenCL or parallelization across CPU cores).
 
+## 🐳 Running LoopSage with Docker
+
+To use LoopSage in a fully containerized and reproducible way, you can build and run it using Docker. This is a very efficient way when you want to use CUDA.
+
+### Step 1: Build the Docker Image
+
+Clone the repository and build the image:
+
+```bash
+docker build -t pyloopsage-cuda .
+```
+
+The `Dockerfile` can be found in the GitHub repo of pyLoopSage.
+
+### Step 2: Run the Simulation
+
+Use the following command to run your simulation:
+
+```bash
+docker run --rm -it --gpus all \
+  -v "$PWD/config.ini:/app/config.ini:ro" \
+  -v "$PWD/tmp:/app/output" \
+  -v "$HOME/Data:/home/blackpianocat/Data:ro" \
+  pyloopsage-cuda \
+  python -m loopsage.run -c /app/config.ini
+```
+
+**What this does:**
+
+* `--rm`: Automatically removes the container after it finishes.
+* `--gpus all`: It detects the gpus of the system.
+* `-it`: Runs with an interactive terminal.
+* `-v "$PWD/config.ini:/app/config.ini:ro"`: Mounts your local `config.ini` as read-only inside the container.
+* `-v "$PWD/tmp:/app/output"`: Maps the `tmp/` directory for outputs.
+* `-v "$HOME/Data:/home/blackpianocat/Data:ro"`: Mounts your full data directory so LoopSage can access input files.
+* The final command runs LoopSage with your config file.
+
+You do **not** need to manually stop or clean up anything—the container is temporary and self-destructs after it completes. The image (`pyloopsage-cuda`) remains available on your system and can be deleted anytime using:
+
+```bash
+docker rmi pyloopsage-cuda
+```
+
+**Note:** Install `nvidia-container-toolkit` in your system if you want to use the container with CUDA: https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html
+
 ## How to use?
 
 ### Python Implementation

{pyloopsage-1.1.3 → pyloopsage-1.1.5}/pyLoopSage.egg-info/SOURCES.txt

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

@@ -18,3 +18,4 @@ imageio
 imageio[ffmpeg]
 pillow
 pyBigWig
+topoly

{pyloopsage-1.1.3 → pyloopsage-1.1.5}/setup.py

@@ -6,7 +6,7 @@ with open('README.md', 'r', encoding='utf-8') as f:
 
 setup(
     name='pyLoopSage',  # Package name
-    version='1.1.3',  # Version of the software
+    version='1.1.5',  # 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',
@@ -40,6 +40,7 @@ setup(
         'imageio[ffmpeg]',
         'pillow',
         'pyBigWig',
+        'topoly',
     ],
     entry_points={
         'console_scripts': [

pyloopsage-1.1.3/MANIFEST.in

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