PyPI - pyLoopSage - Versions diffs - 1.0.22__tar.gz → 1.1.0__tar.gz - Mend

pyLoopSage 1.0.22tar.gz → 1.1.0tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

pyloopsage-1.1.0/MANIFEST.in ADDED Viewed

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

{pyloopsage-1.0.22/pyLoopSage.egg-info → pyloopsage-1.1.0}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyLoopSage
-Version: 1.0.22
+Version: 1.1.0
 Summary: An energy-based stochastic model of loop extrusion in chromatin.
 Home-page: https://github.com/SFGLab/pyLoopSage
 Author: Sebastian Korsak
@@ -31,6 +31,7 @@ Requires-Dist: statsmodels
 Requires-Dist: imageio
 Requires-Dist: imageio[ffmpeg]
 Requires-Dist: pillow
+Requires-Dist: pyBigWig
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -271,49 +272,73 @@ An example, illustrated with Chimera software, simulated trajectory of structure
 ### Long-table of LoopSage arguments
+#### General Settings
 | Argument Name          | Description                                                                                                     | Type        | Default Value       |
 |------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
 | PLATFORM              | Name of the platform. Available choices: CPU, CUDA, OpenCL                                                      | str        | CPU               |
 | DEVICE                | Device index for CUDA or OpenCL (count from 0)                                                                  | str        | None                  |
-| N_BEADS               | Number of Simulation Beads.                                                                                     | int        | None                  |
-| BEDPE_PATH            | A .bedpe file path with loops. It is required.                                                                  | str        | None                  |
 | OUT_PATH              | Output folder name.                                                                                             | str        | ../results       |
+| SAVE_MDT             | True to save metadata of the stochastic simulation.                                                            | bool       | True                |
+#### Input Data
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
+| BEDPE_PATH            | A .bedpe file path with loops. It is required.                                                                  | str        | None                  |
+| LEF_TRACK_FILE        | Path to a bw file of cohesin or condensin density. If it is provided, then simulation LEFs preferentially bind in enriched regions. | str | None |
+| BW_FILES              | List of paths to .bw files containing additional data for simulation. Enriched regions would act as barriers for cohesin.                | list       | None                  |
 | REGION_START          | Starting region coordinate.                                                                                     | int        | None                  |
 | REGION_END            | Ending region coordinate.                                                                                       | int        | None                  |
 | CHROM                 | Chromosome that corresponds to the modeling region of interest.                                                 | str        | None                  |
-| LEF_RW                | True if cohesins slide as a random walk instead of one direction.                                               | bool       | True                |
-| LEF_DRIFT             | True if LEFs are pushed back when they encounter other LEFs.                                                   | bool       | False               |
+#### Stochastic Simulation Parameters
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
+| N_BEADS               | Number of Simulation Beads.                                                                                     | int        | None                  |
 | N_STEPS               | Number of Monte Carlo steps.                                                                                    | int        | 40000               |
-| N_LEF                 | Number of loop extrusion factors.                                                                               | int        | None                  |
-| N_LEF2                | Number of second family loop extrusion factors.                                                                | int        | 0                   |
 | MC_STEP               | Monte Carlo frequency to avoid autocorrelated ensembles.                                                       | int        | 200                 |
 | BURNIN               | Burn-in period (steps before equilibrium).                                                                      | int        | 1000                |
 | T_INIT                | Initial Temperature of the Stochastic Model.                                                                   | float      | 2.0                 |
 | T_FINAL               | Final Temperature of the Stochastic Model.                                                                     | float      | 1.0                 |
 | METHOD                | Stochastic modeling method (Metropolis or Simulated Annealing).                                                | str        | 'Annealing'         |
+| LEF_RW                | True if cohesins slide as a random walk instead of one direction.                                               | bool       | True                |
+| LEF_DRIFT             | True if LEFs are pushed back when they encounter other LEFs.                                                   | bool       | False               |
+| N_LEF                 | Number of loop extrusion factors.                                                                               | int        | None                  |
+| N_LEF2                | Number of second family loop extrusion factors.                                                                | int        | 0                   |
+#### Energy Coefficients
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
 | FOLDING_COEFF         | Folding coefficient.                                                                                           | float      | 1.0                 |
 | FOLDING_COEFF2        | Folding coefficient for the second family of LEFs.                                                            | float      | 0.0                 |
 | CROSS_COEFF          | LEF crossing coefficient.                                                                                      | float      | 1.0                 |
 | CROSS_LOOP           | True if the penalty is applied when mi<mj<ni<nj. False if it applies only when mj=ni. When false it is better to enable LEF_DRIFT as well. | bool |True                |
 | BIND_COEFF           | CTCF binding coefficient.                                                                                      | float      | 1.0                 |
-| SAVE_PLOTS           | True to save diagnostic plots.                                                                                 | bool       | True                |
-| SAVE_MDT             | True to save metadata of the stochastic simulation.                                                            | bool       | True                |
-| INITIAL_STRUCTURE_TYPE | Choose from: rw, confined_rw, self_avoiding_rw, helix, circle, spiral, sphere.                                | str        | rw                |
+| BW_STRENGTHS          | List of strengths corresponding to each .bw file.                                                              | list       | None                  |
+#### Molecular Dynamics Simulation
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
 | SIMULATION_TYPE       | Either EM (energy minimizations) or MD (molecular dynamics).                                                  | str        | None                  |
+| INITIAL_STRUCTURE_TYPE | Choose from: rw, confined_rw, self_avoiding_rw, helix, circle, spiral, sphere.                                | str        | rw                |
 | INTEGRATOR_STEP       | Step of the integrator.                                                                                        | Quantity   | 100 femtosecond   |
 | FORCEFIELD_PATH       | Path to XML file with forcefield.                                                                             | str        | default_xml_path    |
 | 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                 |
 | 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                |
+#### Visualization
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
+| VIZ_HEATS            | True to visualize the output average heatmap.                                                                | bool       | True                |
+| SAVE_PLOTS           | True to save diagnostic plots.                                                                                 | bool       | True                |
 ## Citation
 Please cite the method and biological paper in case that you would like to use this model for your work,

{pyloopsage-1.0.22 → pyloopsage-1.1.0}/README.md RENAMED Viewed

@@ -226,49 +226,73 @@ An example, illustrated with Chimera software, simulated trajectory of structure
 ### Long-table of LoopSage arguments
+#### General Settings
 | Argument Name          | Description                                                                                                     | Type        | Default Value       |
 |------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
 | PLATFORM              | Name of the platform. Available choices: CPU, CUDA, OpenCL                                                      | str        | CPU               |
 | DEVICE                | Device index for CUDA or OpenCL (count from 0)                                                                  | str        | None                  |
-| N_BEADS               | Number of Simulation Beads.                                                                                     | int        | None                  |
-| BEDPE_PATH            | A .bedpe file path with loops. It is required.                                                                  | str        | None                  |
 | OUT_PATH              | Output folder name.                                                                                             | str        | ../results       |
+| SAVE_MDT             | True to save metadata of the stochastic simulation.                                                            | bool       | True                |
+#### Input Data
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
+| BEDPE_PATH            | A .bedpe file path with loops. It is required.                                                                  | str        | None                  |
+| LEF_TRACK_FILE        | Path to a bw file of cohesin or condensin density. If it is provided, then simulation LEFs preferentially bind in enriched regions. | str | None |
+| BW_FILES              | List of paths to .bw files containing additional data for simulation. Enriched regions would act as barriers for cohesin.                | list       | None                  |
 | REGION_START          | Starting region coordinate.                                                                                     | int        | None                  |
 | REGION_END            | Ending region coordinate.                                                                                       | int        | None                  |
 | CHROM                 | Chromosome that corresponds to the modeling region of interest.                                                 | str        | None                  |
-| LEF_RW                | True if cohesins slide as a random walk instead of one direction.                                               | bool       | True                |
-| LEF_DRIFT             | True if LEFs are pushed back when they encounter other LEFs.                                                   | bool       | False               |
+#### Stochastic Simulation Parameters
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
+| N_BEADS               | Number of Simulation Beads.                                                                                     | int        | None                  |
 | N_STEPS               | Number of Monte Carlo steps.                                                                                    | int        | 40000               |
-| N_LEF                 | Number of loop extrusion factors.                                                                               | int        | None                  |
-| N_LEF2                | Number of second family loop extrusion factors.                                                                | int        | 0                   |
 | MC_STEP               | Monte Carlo frequency to avoid autocorrelated ensembles.                                                       | int        | 200                 |
 | BURNIN               | Burn-in period (steps before equilibrium).                                                                      | int        | 1000                |
 | T_INIT                | Initial Temperature of the Stochastic Model.                                                                   | float      | 2.0                 |
 | T_FINAL               | Final Temperature of the Stochastic Model.                                                                     | float      | 1.0                 |
 | METHOD                | Stochastic modeling method (Metropolis or Simulated Annealing).                                                | str        | 'Annealing'         |
+| LEF_RW                | True if cohesins slide as a random walk instead of one direction.                                               | bool       | True                |
+| LEF_DRIFT             | True if LEFs are pushed back when they encounter other LEFs.                                                   | bool       | False               |
+| N_LEF                 | Number of loop extrusion factors.                                                                               | int        | None                  |
+| N_LEF2                | Number of second family loop extrusion factors.                                                                | int        | 0                   |
+#### Energy Coefficients
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
 | FOLDING_COEFF         | Folding coefficient.                                                                                           | float      | 1.0                 |
 | FOLDING_COEFF2        | Folding coefficient for the second family of LEFs.                                                            | float      | 0.0                 |
 | CROSS_COEFF          | LEF crossing coefficient.                                                                                      | float      | 1.0                 |
 | CROSS_LOOP           | True if the penalty is applied when mi<mj<ni<nj. False if it applies only when mj=ni. When false it is better to enable LEF_DRIFT as well. | bool |True                |
 | BIND_COEFF           | CTCF binding coefficient.                                                                                      | float      | 1.0                 |
-| SAVE_PLOTS           | True to save diagnostic plots.                                                                                 | bool       | True                |
-| SAVE_MDT             | True to save metadata of the stochastic simulation.                                                            | bool       | True                |
-| INITIAL_STRUCTURE_TYPE | Choose from: rw, confined_rw, self_avoiding_rw, helix, circle, spiral, sphere.                                | str        | rw                |
+| BW_STRENGTHS          | List of strengths corresponding to each .bw file.                                                              | list       | None                  |
+#### Molecular Dynamics Simulation
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
 | SIMULATION_TYPE       | Either EM (energy minimizations) or MD (molecular dynamics).                                                  | str        | None                  |
+| INITIAL_STRUCTURE_TYPE | Choose from: rw, confined_rw, self_avoiding_rw, helix, circle, spiral, sphere.                                | str        | rw                |
 | INTEGRATOR_STEP       | Step of the integrator.                                                                                        | Quantity   | 100 femtosecond   |
 | FORCEFIELD_PATH       | Path to XML file with forcefield.                                                                             | str        | default_xml_path    |
 | 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                 |
 | 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                |
+#### Visualization
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
+| VIZ_HEATS            | True to visualize the output average heatmap.                                                                | bool       | True                |
+| SAVE_PLOTS           | True to save diagnostic plots.                                                                                 | bool       | True                |
 ## Citation
 Please cite the method and biological paper in case that you would like to use this model for your work,

{pyloopsage-1.0.22 → pyloopsage-1.1.0}/loopsage/__init__.py RENAMED Viewed

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

{pyloopsage-1.0.22 → pyloopsage-1.1.0}/loopsage/args_definition.py RENAMED Viewed

@@ -23,6 +23,7 @@ class Arg(object):
     type: type
     default: Union[str, float, int, bool, Quantity, None]
     val: Union[str, float, int, bool, Quantity, None]
+    nargs: Union[str, None] = None  # Optional attribute for nargs
 # Define custom type to parse list from string
 def parse_list(s):
@@ -65,6 +66,18 @@ class ListOfArgs(list):
             raise ValueError(f"I Can't recognise unit {unit} in expression {val}. Example of valid quantity: 12.3 femtosecond.")
         return Quantity(value=float(value), unit=unit)
+    def parse_list_of_floats(self, s: str) -> list:
+        try:
+            return [float(x.strip()) for x in s.strip('[]').split(',')]
+        except ValueError:
+            raise argparse.ArgumentTypeError("Invalid list format. Must be a comma-separated list of floats.")
+    def parse_list_of_strings(self, s: str) -> list:
+        try:
+            return [x.strip() for x in s.strip('[]').split(',')]
+        except ValueError:
+            raise argparse.ArgumentTypeError("Invalid list format. Must be a comma-separated list of strings.")
     def to_python(self):
         """Casts string args to ints, floats, bool..."""
         for i in self:
@@ -78,6 +91,22 @@ class ListOfArgs(list):
                 i.val = int(i.val)
             elif i.type == float:
                 i.val = float(i.val)
+            elif i.type == list:
+                if i.name == "BW_FILES" or i.name == "STRING_LIST":  # Handle lists of strings
+                    if isinstance(i.val, str):
+                        i.val = self.parse_list_of_strings(i.val)
+                    elif not isinstance(i.val, list):
+                        raise ValueError(f"Can't convert {i.val} into list of strings.")
+                elif i.name == "BW_STRENGTHS" or i.name == "FLOAT_LIST":  # Handle lists of floats
+                    if isinstance(i.val, str):
+                        i.val = self.parse_list_of_floats(i.val)
+                    elif not isinstance(i.val, list):
+                        raise ValueError(f"Can't convert {i.val} into list of floats.")
+                else:  # Handle lists of integers
+                    if isinstance(i.val, str):
+                        i.val = parse_list(i.val)
+                    elif not isinstance(i.val, list):
+                        raise ValueError(f"Can't convert {i.val} into list of integers.")
             elif i.type == bool:
                 if i.val.lower() in ['true', '1', 'y', 'yes']:
                     i.val = True
@@ -138,10 +167,14 @@ args = ListOfArgs([
     # Input data
     Arg('N_BEADS', help="Number of Simulation Beads.", type=int, default='', val=''),
     Arg('BEDPE_PATH', help="A .bedpe file path with loops. It is required.", type=str, default='', val=''),
+    Arg('LEF_TRACK_FILE', help="An optional track file for cohesin or condensin in bw format. If this file is specified LEF preferentially binds were the signal is enriched.", type=str, default='', val=''),
+    Arg('BW_FILES', help="List of bigWig file paths for feature extraction.", type=list, nargs='+', default=[], val=[]),
     Arg('OUT_PATH', help="Output folder name.", type=str, default='../results', val='../results'),
     Arg('REGION_START', help="Starting region coordinate.", type=int, default='', val=''),
     Arg('REGION_END', help="Ending region coordinate.", type=int, default='', val=''),
     Arg('CHROM', help="Chromosome that corresponds the the modelling region of interest (in case that you do not want to model the whole genome).", type=str, default='', val=''),
+    Arg('FLOAT_LIST', help="List of floating-point numbers.", type=list, nargs='+', default=[], val=[]),
+    Arg('STRING_LIST', help="List of strings.", type=list, nargs='+', default=[], val=[]),
     # Stochastic Simulation parameters
     Arg('LEF_RW', help="True in case that you would like to make cohesins slide as random walk, instead of sliding only in one direction.", type=bool, default='True', val='True'),
@@ -157,6 +190,7 @@ args = ListOfArgs([
     Arg('FOLDING_COEFF', help="Folding coefficient.", type=float, default='1.0', val='1.0'),
     Arg('FOLDING_COEFF2', help="Folding coefficient for the second family of LEFs.", type=float, default='0.0', val='0.0'),
     Arg('CROSS_COEFF', help="LEF crossing coefficient.", type=float, default='1.0', val='1.0'),
+    Arg('BW_STRENGTHS', help="List of strengths of the energy (floats) corresponding to each BW file. This equivalent to the `r` parameter in the LoopSage paper.", type=list, nargs='+', default=[], val=[]),
     Arg('CROSS_LOOP', help="It true if the penalty is applied for situations mi<mj<ni<nj and mi=nj, and false if it is applied only for mi=nj.", type=bool, default='True', val='True'),
     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'),
@@ -170,6 +204,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.1.0}/loopsage/md.py RENAMED Viewed

@@ -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.1.0}/loopsage/preproc.py RENAMED Viewed

@@ -2,7 +2,7 @@ import numpy as np
 import seaborn as sns
 import pandas as pd
 import matplotlib.pyplot as plt
-# import pyBigWig
+import pyBigWig
 from matplotlib.pyplot import figure
 def binding_vectors_from_bedpe(bedpe_file,N_beads,region,chrom,normalization=False,viz=False):
@@ -101,24 +101,24 @@ def get_rnap_energy(path,region,chrom,N_beads,normalization):
 def distance_point_line(x0,y0,a=1,b=-1,c=0):
     return np.abs(a*x0+b*y0+c)/np.sqrt(a**2+b**2)
-# def load_track(file,region,chrom,N_beads,viz=False,roll=False):
-#     bw = pyBigWig.open(file)
-#     weights = bw_to_array(bw, region, chrom, N_beads,viz,roll)
-#     return weights[:N_beads]
+def load_track(file,region,chrom,N_beads,viz=False,roll=False):
+    bw = pyBigWig.open(file)
+    weights = bw_to_array(bw, region, chrom, N_beads,viz,roll)
+    return weights[:N_beads]
-# def bw_to_array(bw, region, chrom, N_beads, viz=False, roll=False):
-#     step = (region[1]-region[0])//N_beads
-#     bw_array = bw.values(chrom, region[0], region[1])
-#     bw_array = np.nan_to_num(bw_array)
-#     bw_array_new = list()
-#     for i in range(step,len(bw_array)+1,step):
-#         bw_array_new.append(np.average(bw_array[(i-step):i]))
-#     weights = (np.roll(np.array(bw_array_new),3)+np.roll(np.array(bw_array_new),-3))/2 if roll else bw_array_new
-#     if viz:
-#         figure(figsize=(15, 5))
-#         plt.plot(weights)
-#         plt.grid()
-#         plt.title('ChIP-Seq signal',fontsize=20)
-#         plt.close()
+def bw_to_array(bw, region, chrom, N_beads, viz=False, roll=False):
+    step = (region[1]-region[0])//N_beads
+    bw_array = bw.values(chrom, region[0], region[1])
+    bw_array = np.nan_to_num(bw_array)
+    bw_array_new = list()
+    for i in range(step,len(bw_array)+1,step):
+        bw_array_new.append(np.average(bw_array[(i-step):i]))
+    weights = (np.roll(np.array(bw_array_new),3)+np.roll(np.array(bw_array_new),-3))/2 if roll else bw_array_new
+    if viz:
+        figure(figsize=(15, 5))
+        plt.plot(weights)
+        plt.grid()
+        plt.title('ChIP-Seq signal',fontsize=20)
+        plt.close()
-#     return weights
+    return weights

{pyloopsage-1.0.22 → pyloopsage-1.1.0}/loopsage/run.py RENAMED Viewed

@@ -69,9 +69,11 @@ def main():
     N_beads, N_lef, N_lef2 = args.N_BEADS, args.N_LEF, args.N_LEF2
     N_steps, MC_step, burnin, T, T_min = args.N_STEPS, args.MC_STEP, args.BURNIN, args.T_INIT, args.T_FINAL
     mode = args.METHOD
+    bw_paths = args.BW_FILES
     # Simulation Strengths
     f, f2, b, kappa = args.FOLDING_COEFF,  args.FOLDING_COEFF2, args.BIND_COEFF, args.CROSS_COEFF
+    r = args.BW_STRENGTHS
     # Definition of region
     region, chrom = [args.REGION_START,args.REGION_END], args.CHROM
@@ -81,12 +83,12 @@ def main():
     bedpe_file = args.BEDPE_PATH
     # Run Simulation
-    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)
+    sim = StochasticSimulation(region,chrom,bedpe_file,out_dir=output_name,N_beads=N_beads,N_lef=N_lef,N_lef2=N_lef2, bw_files=bw_paths, track_file=args.LEF_TRACK_FILE)
+    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,r=r)
     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_TOP)
     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.1.0}/loopsage/stochastic_simulation.py RENAMED Viewed

@@ -66,12 +66,23 @@ def E_fold(ms, ns, fold_norm):
     return fold_norm * folding
 @njit
-def get_E(L, R, bind_norm, fold_norm, fold_norm2, k_norm, ms, ns, N_lef, N_lef2, cross_loop):
+def E_bw(N_bws, r, BWs, ms, ns):
+    '''
+    Calculation of the RNApII binding energy. Needs cohesins positions as input.
+    '''
+    E_bw = 0
+    for i in range(N_bws):
+        E_bw += r[i] * np.sum(BWs[i, ms] + BWs[i, ns]) / np.sum(BWs[i])
+    return E_bw
+@njit
+def get_E(L, R, bind_norm, fold_norm, fold_norm2, k_norm, ms, ns, N_lef, N_lef2, cross_loop, r=None, N_bws=0, BWs=None):
     ''''
     The total energy.
     '''
     energy = E_bind(L, R, ms, ns, bind_norm) + E_cross(ms, ns, k_norm, cross_loop) + E_fold(ms, ns, fold_norm)
     if fold_norm2!=0: energy += E_fold(ms[N_lef:N_lef+N_lef2],ns[N_lef:N_lef+N_lef2], fold_norm2)
+    if r is not None and BWs is not None: energy += E_bw(N_bws, r, BWs, ms, ns)
     return energy
 @njit
@@ -88,6 +99,13 @@ def get_dE_fold(fold_norm,ms,ns,m_new,n_new,idx):
     '''
     return fold_norm*(np.log(n_new-m_new)-np.log(ns[idx]-ms[idx]))
+@njit
+def get_dE_bw(N_bws, r, BWs, ms, ns, m_new, n_new, idx):
+    dE_bw = 0
+    for i in range(N_bws):
+        dE_bw += r[i] * (BWs[i, m_new] + BWs[i, n_new] - BWs[i, ms[idx]] - BWs[i, ns[idx]]) / np.sum(BWs[i])
+    return dE_bw
 @njit
 def get_dE_cross(ms, ns, m_new, n_new, idx, k_norm, cross_loop):
     '''
@@ -101,7 +119,7 @@ def get_dE_cross(ms, ns, m_new, n_new, idx, k_norm, cross_loop):
     return k_norm * (K2 - K1)
 @njit
-def get_dE(L, R, bind_norm, fold_norm, fold_norm2, k_norm, ms, ns, m_new, n_new, idx, N_lef, N_lef2, cross_loop):
+def get_dE(L, R, bind_norm, fold_norm, fold_norm2, k_norm, ms, ns, m_new, n_new, idx, N_lef, N_lef2, cross_loop, r=None, N_bws=0, BWs=None):
     '''
     Total energy difference.
     '''
@@ -112,14 +130,19 @@ def get_dE(L, R, bind_norm, fold_norm, fold_norm2, k_norm, ms, ns, m_new, n_new,
         dE += get_dE_fold(fold_norm2,ms[N_lef:N_lef+N_lef2],ns[N_lef:N_lef+N_lef2],m_new,n_new,idx-N_lef)
     dE += get_dE_bind(L, R, bind_norm, ms, ns, m_new, n_new, idx)
     dE += get_dE_cross(ms, ns, m_new, n_new, idx, k_norm, cross_loop)
+    if r is not None and BWs is not None: dE += get_dE_bw(N_bws, r, BWs, ms, ns, m_new, n_new, idx)
     return dE
 @njit
-def unbind_bind(N_beads):
+def unbind_bind(N_beads, track=None):
     '''
     Rebinding Monte-Carlo step.
     '''
-    m_new = rd.randint(0, N_beads - 3)
+    if track is not None:
+        weights = track / np.sum(track)
+        m_new = np.searchsorted(np.cumsum(weights), np.random.rand())
+    else:
+        m_new = np.random.randint(0, N_beads - 3)
     n_new = m_new + 2
     return int(m_new), int(n_new)
@@ -152,58 +175,58 @@ def unfolding_metric(ms,ns,N_beads):
     return unfold
 @njit
-def initialize(N_beads,N_lef):
+def initialize(N_beads, N_lef, track=None):
     '''
     Random initialization of polymer DNA fiber with some cohesin positions.
     '''
     ms, ns = np.zeros(N_lef,dtype=np.int64), np.zeros(N_lef,dtype=np.int64)
     for i in range(N_lef):
-        ms[i], ns[i] = unbind_bind(N_beads)
+        ms[i], ns[i] = unbind_bind(N_beads, track)
     return ms, ns
 @njit
-def run_simulation(N_beads,N_steps,MC_step,burnin,T,T_min,fold_norm,fold_norm2,bind_norm,k_norm,N_lef,N_lef2,L,R,mode,lef_rw=True,lef_drift=True,cross_loop=True):
+def run_simulation(N_beads, N_steps, MC_step, burnin, T, T_min, fold_norm, fold_norm2, bind_norm, k_norm, N_lef, N_lef2, L, R, mode, lef_rw=True, lef_drift=True, cross_loop=True, r=None, N_bws=0, BWs=None, track=None):
     '''
     Runs the Monte Carlo simulation.
     '''
     Ti = T
-    bi = burnin//MC_step
-    ms, ns = initialize(N_beads,N_lef+N_lef2)
-    E = get_E(L, R, bind_norm, fold_norm, fold_norm2, k_norm,  ms, ns, N_lef, N_lef2, cross_loop)
-    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)
+    bi = burnin // MC_step
+    ms, ns = initialize(N_beads, N_lef + N_lef2, track)
+    E = get_E(L, R, bind_norm, fold_norm, fold_norm2, k_norm, ms, ns, N_lef, N_lef2, cross_loop, r, N_bws, BWs)
+    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)
     for i in range(N_steps):
-        Ti = T-(T-T_min)*(i+1)/N_steps if mode=='Annealing' else T
-        for j in range(N_lef+N_lef2):
+        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)
-            r = np.random.choice(np.array([0, 1]))
-            if r==0:
-                m_new, n_new = unbind_bind(N_beads)
+            r_move = np.random.choice(np.array([0, 1]))
+            if r_move == 0:
+                m_new, n_new = unbind_bind(N_beads, track)
             else:
-                m_new, n_new = slide(ms[j],ns[j],ms,ns,N_beads,lef_rw,lef_drift)
+                m_new, n_new = slide(ms[j], ns[j], ms, ns, N_beads, lef_rw, lef_drift)
             # Compute energy difference
-            dE = get_dE(L, R, bind_norm, fold_norm, fold_norm2, k_norm, ms, ns, m_new, n_new, j, N_lef, N_lef2, cross_loop)
+            dE = get_dE(L, R, bind_norm, fold_norm, fold_norm2, k_norm, ms, ns, m_new, n_new, j, N_lef, N_lef2, cross_loop, r, N_bws, BWs)
-            if dE <= 0 or np.exp(-dE/Ti) > np.random.rand():
+            if dE <= 0 or np.exp(-dE / Ti) > np.random.rand():
                 ms[j], ns[j] = m_new, n_new
                 E += dE
             # Compute Metrics
-            if i%MC_step==0:
-                Ms[j,i//MC_step], Ns[j,i//MC_step] = ms[j], ns[j]
+            if i % MC_step == 0:
+                Ms[j, i // MC_step], Ns[j, i // MC_step] = ms[j], ns[j]
         # Compute Metrics
-        if i%MC_step==0:
-            ufs[i//MC_step] = unfolding_metric(ms,ns,N_beads)
-            Es[i//MC_step] = E
-            Ks[i//MC_step] = E_cross(ms,ns,k_norm,cross_loop)
-            Fs[i//MC_step] = E_fold(ms,ns,fold_norm)
-            Bs[i//MC_step] = E_bind(L,R,ms,ns,bind_norm)
+        if i % MC_step == 0:
+            ufs[i // MC_step] = unfolding_metric(ms, ns, N_beads)
+            Es[i // MC_step] = E
+            Ks[i // MC_step] = E_cross(ms, ns, k_norm, cross_loop)
+            Fs[i // MC_step] = E_fold(ms, ns, fold_norm)
+            Bs[i // MC_step] = E_bind(L, R, ms, ns, bind_norm)
     return Ms, Ns, Es, Ks, Fs, Bs, ufs
 class StochasticSimulation:
-    def __init__(self,region,chrom,bedpe_file,N_beads=None,N_lef=None,N_lef2=0,out_dir=None):
+    def __init__(self,region,chrom,bedpe_file,N_beads=None,N_lef=None,N_lef2=0,out_dir=None, bw_files=None, track_file=None):
         '''
         Definition of simulation parameters and input files.
@@ -218,16 +241,17 @@ class StochasticSimulation:
         r (list): strength of each ChIP-Seq experinment.
         '''
         self.N_beads = N_beads if N_beads!=None else int(np.round((region[1]-region[0])/2000))
+        self.N_bws = len(bw_files) if bw_files else 0
         print('Number of beads:',self.N_beads)
         self.chrom, self.region = chrom, region
-        self.bedpe_file = bedpe_file
+        self.bedpe_file, self.bw_files, self.track_file = bedpe_file, bw_files, track_file
         self.preprocessing()
         self.N_lef = 2*self.N_CTCF if N_lef==None else N_lef
         self.N_lef2 = N_lef2
         print('Number of LEFs:',self.N_lef+self.N_lef2)
         self.path = make_folder(out_dir)
-    def run_energy_minimization(self,N_steps,MC_step,burnin,T=1,T_min=0,mode='Metropolis',viz=False,save=False, f=1.0, f2=0.0, b=1.0, kappa=1.0, lef_rw=True, lef_drift=True, cross_loop=True):
+    def run_energy_minimization(self, N_steps, MC_step, burnin, T=1, T_min=0, mode='Metropolis', viz=False, save=False, f=1.0, f2=0.0, b=1.0, kappa=1.0, lef_rw=True, lef_drift=True, cross_loop=True, r=None):
         '''
         Implementation of the stochastic Monte Carlo simulation.
@@ -238,34 +262,40 @@ class StochasticSimulation:
         T (float): simulation (initial) temperature.
         mode (str): it can be either 'Metropolis' or 'Annealing'.
         viz (bool): True in case that user wants to see plots.
+        r (list): strength of each ChIP-Seq experiment.
+        N_bws (int): number of binding weight matrices.
+        BWs (np.ndarray): binding weight matrices.
         '''
         # Define normalization constants
         fold_norm, fold_norm2, bind_norm, k_norm = -self.N_beads*f/((self.N_lef+self.N_lef2)*np.log(self.N_beads/(self.N_lef+self.N_lef2))), -self.N_beads*f2/((self.N_lef+self.N_lef2)*np.log(self.N_beads/(self.N_lef+self.N_lef2))), -self.N_beads*b/(np.sum(self.L)+np.sum(self.R)), kappa*1e4
         self.N_steps, self.MC_step = N_steps, MC_step
+        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)...')
         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)
+        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)
         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.')
+        print(f'Computation finished successfully 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')
+                if r is not None and self.BWs is not None:
+                    file.write(f'RNApII binding energy included with {N_bws} binding weight matrices.\n')
+                file.write(f'Energy at equilibrium: {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)
@@ -274,16 +304,27 @@ class StochasticSimulation:
             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)
+        # Some visualizations
+        if viz: coh_traj_plot(self.Ms, self.Ns, self.N_beads, self.path)
         if viz: make_timeplots(self.Es, self.Bs, self.Ks, self.Fs, burnin//MC_step, mode, self.path)
-        if viz: coh_probdist_plot(self.Ms,self.Ns,self.N_beads,self.path)
-        if viz and self.N_beads<=2000: stochastic_heatmap(self.Ms,self.Ns,MC_step,self.N_beads,self.path)
+        if viz: coh_probdist_plot(self.Ms, self.Ns, self.N_beads, self.path)
+        if viz and self.N_beads <= 2000: stochastic_heatmap(self.Ms, self.Ns, MC_step, self.N_beads, self.path)
         return self.Es, self.Ms, self.Ns, self.Bs, self.Ks, self.Fs, self.ufs
     def preprocessing(self):
         self.L, self.R, self.dists = binding_vectors_from_bedpe(self.bedpe_file,self.N_beads,self.region,self.chrom,False,False)
+        if not self.bw_files:
+            self.BWs = None
+            self.N_bws = 0
+        else:
+            if isinstance(self.bw_files, str):
+                self.bw_files = [self.bw_files]
+                self.N_bws = 1
+            self.BWs = np.zeros((self.N_bws, self.N_beads))
+            for i, f in enumerate(self.bw_files):
+                self.BWs[i, :] = load_track(file=f, region=self.region, chrom=self.chrom, N_beads=self.N_beads, viz=False)
+        self.lef_track = load_track(self.track_file,self.region,self.chrom,self.N_beads,False,True) if self.track_file else None
         self.N_CTCF = np.max([np.count_nonzero(self.L),np.count_nonzero(self.R)])
         print('Number of CTCF:',self.N_CTCF)
@@ -292,9 +333,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 +352,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.01)
 if __name__=='__main__':
-    main()
+    main()

{pyloopsage-1.0.22 → pyloopsage-1.1.0/pyLoopSage.egg-info}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyLoopSage
-Version: 1.0.22
+Version: 1.1.0
 Summary: An energy-based stochastic model of loop extrusion in chromatin.
 Home-page: https://github.com/SFGLab/pyLoopSage
 Author: Sebastian Korsak
@@ -31,6 +31,7 @@ Requires-Dist: statsmodels
 Requires-Dist: imageio
 Requires-Dist: imageio[ffmpeg]
 Requires-Dist: pillow
+Requires-Dist: pyBigWig
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier
@@ -271,49 +272,73 @@ An example, illustrated with Chimera software, simulated trajectory of structure
 ### Long-table of LoopSage arguments
+#### General Settings
 | Argument Name          | Description                                                                                                     | Type        | Default Value       |
 |------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
 | PLATFORM              | Name of the platform. Available choices: CPU, CUDA, OpenCL                                                      | str        | CPU               |
 | DEVICE                | Device index for CUDA or OpenCL (count from 0)                                                                  | str        | None                  |
-| N_BEADS               | Number of Simulation Beads.                                                                                     | int        | None                  |
-| BEDPE_PATH            | A .bedpe file path with loops. It is required.                                                                  | str        | None                  |
 | OUT_PATH              | Output folder name.                                                                                             | str        | ../results       |
+| SAVE_MDT             | True to save metadata of the stochastic simulation.                                                            | bool       | True                |
+#### Input Data
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
+| BEDPE_PATH            | A .bedpe file path with loops. It is required.                                                                  | str        | None                  |
+| LEF_TRACK_FILE        | Path to a bw file of cohesin or condensin density. If it is provided, then simulation LEFs preferentially bind in enriched regions. | str | None |
+| BW_FILES              | List of paths to .bw files containing additional data for simulation. Enriched regions would act as barriers for cohesin.                | list       | None                  |
 | REGION_START          | Starting region coordinate.                                                                                     | int        | None                  |
 | REGION_END            | Ending region coordinate.                                                                                       | int        | None                  |
 | CHROM                 | Chromosome that corresponds to the modeling region of interest.                                                 | str        | None                  |
-| LEF_RW                | True if cohesins slide as a random walk instead of one direction.                                               | bool       | True                |
-| LEF_DRIFT             | True if LEFs are pushed back when they encounter other LEFs.                                                   | bool       | False               |
+#### Stochastic Simulation Parameters
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
+| N_BEADS               | Number of Simulation Beads.                                                                                     | int        | None                  |
 | N_STEPS               | Number of Monte Carlo steps.                                                                                    | int        | 40000               |
-| N_LEF                 | Number of loop extrusion factors.                                                                               | int        | None                  |
-| N_LEF2                | Number of second family loop extrusion factors.                                                                | int        | 0                   |
 | MC_STEP               | Monte Carlo frequency to avoid autocorrelated ensembles.                                                       | int        | 200                 |
 | BURNIN               | Burn-in period (steps before equilibrium).                                                                      | int        | 1000                |
 | T_INIT                | Initial Temperature of the Stochastic Model.                                                                   | float      | 2.0                 |
 | T_FINAL               | Final Temperature of the Stochastic Model.                                                                     | float      | 1.0                 |
 | METHOD                | Stochastic modeling method (Metropolis or Simulated Annealing).                                                | str        | 'Annealing'         |
+| LEF_RW                | True if cohesins slide as a random walk instead of one direction.                                               | bool       | True                |
+| LEF_DRIFT             | True if LEFs are pushed back when they encounter other LEFs.                                                   | bool       | False               |
+| N_LEF                 | Number of loop extrusion factors.                                                                               | int        | None                  |
+| N_LEF2                | Number of second family loop extrusion factors.                                                                | int        | 0                   |
+#### Energy Coefficients
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
 | FOLDING_COEFF         | Folding coefficient.                                                                                           | float      | 1.0                 |
 | FOLDING_COEFF2        | Folding coefficient for the second family of LEFs.                                                            | float      | 0.0                 |
 | CROSS_COEFF          | LEF crossing coefficient.                                                                                      | float      | 1.0                 |
 | CROSS_LOOP           | True if the penalty is applied when mi<mj<ni<nj. False if it applies only when mj=ni. When false it is better to enable LEF_DRIFT as well. | bool |True                |
 | BIND_COEFF           | CTCF binding coefficient.                                                                                      | float      | 1.0                 |
-| SAVE_PLOTS           | True to save diagnostic plots.                                                                                 | bool       | True                |
-| SAVE_MDT             | True to save metadata of the stochastic simulation.                                                            | bool       | True                |
-| INITIAL_STRUCTURE_TYPE | Choose from: rw, confined_rw, self_avoiding_rw, helix, circle, spiral, sphere.                                | str        | rw                |
+| BW_STRENGTHS          | List of strengths corresponding to each .bw file.                                                              | list       | None                  |
+#### Molecular Dynamics Simulation
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
 | SIMULATION_TYPE       | Either EM (energy minimizations) or MD (molecular dynamics).                                                  | str        | None                  |
+| INITIAL_STRUCTURE_TYPE | Choose from: rw, confined_rw, self_avoiding_rw, helix, circle, spiral, sphere.                                | str        | rw                |
 | INTEGRATOR_STEP       | Step of the integrator.                                                                                        | Quantity   | 100 femtosecond   |
 | FORCEFIELD_PATH       | Path to XML file with forcefield.                                                                             | str        | default_xml_path    |
 | 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                 |
 | 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                |
+#### Visualization
+| Argument Name          | Description                                                                                                     | Type        | Default Value       |
+|------------------------|-----------------------------------------------------------------------------------------------------------------|------------|---------------------|
+| VIZ_HEATS            | True to visualize the output average heatmap.                                                                | bool       | True                |
+| SAVE_PLOTS           | True to save diagnostic plots.                                                                                 | bool       | True                |
 ## Citation
 Please cite the method and biological paper in case that you would like to use this model for your work,

{pyloopsage-1.0.22 → pyloopsage-1.1.0}/pyLoopSage.egg-info/SOURCES.txt RENAMED Viewed

@@ -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.1.0}/pyLoopSage.egg-info/requires.txt RENAMED Viewed

@@ -17,3 +17,4 @@ statsmodels
 imageio
 imageio[ffmpeg]
 pillow
+pyBigWig

{pyloopsage-1.0.22 → pyloopsage-1.1.0}/setup.py RENAMED Viewed

@@ -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.1.0',  # 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',
@@ -39,6 +39,7 @@ setup(
         'imageio',
         'imageio[ffmpeg]',
         'pillow',
+        'pyBigWig',
     ],
     entry_points={
         'console_scripts': [

pyloopsage-1.0.22/loopsage/knots.py DELETED Viewed

@@ -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