SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2212.02714 · 2022

Systematic Analysis of Biomolecular Conformational Ensembles with PENSA

arXiv · PDF · Open in the Atlas

Code that ran

11 of 12 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 11 have no contract verdict; 0 failures of our instrument; 1 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2212.02714.json · badge: /api/ran/2212.02714.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
drorlab/pensa canonical (classifier label)
classifier basis not recorded on the link
11 ran · 1 no recorded run
FunctionStatusWhere it lives
calculate_pca Ran
ran on a synthesized input
drorlab/pensa/pensa/dimensionality/pca.py
code served (permissive licence) · get_code("603b5774c3863f43")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned PCA. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
from sklearn.decomposition import PCA

# Create small trajectory data: [frames, frame_data]
# Using distinct dimensions: 2 frames, 4 features per frame
data = np.random.randn(2, 4).astype(np.float32)

# Define arguments dictionary
ARGS = {
    "data": data,
    "dim": None,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PCA — a PCA output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a PCA output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
feature_correlation Ran
ran on a synthesized input
drorlab/pensa/pensa/comparison/statistics.py
code served (permissive licence) · get_code("bbb10ad602da2935")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Create trajectory data with distinct dimensions
# data_a: 5 frames, 3 features
data_a = np.random.randn(5, 3).astype(np.float32)

# data_b: 5 frames, 4 features (distinct from data_a's feature count)
data_b = np.random.randn(5, 4).astype(np.float32)

ARGS = {
    "data_a": data_a,
    "data_b": data_b,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (3, 4) — shape (3, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
kolmogorov_smirnov_analysis Ran
ran on a synthesized input
drorlab/pensa/pensa/comparison/statistics.py
code served (permissive licence) · get_code("c3a73a27e09438d0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import scipy as sp

# Set random seed for reproducibility
np.random.seed(0)

# Create feature names for both ensembles
features_a = ['feature_1', 'feature_2', 'feature_3', 'feature_4']
features_b = ['feature_1', 'feature_2', 'feature_3', 'feature_4']

# Create sample trajectory data
# Format: [frames, frame_data]
# all_data_a and all_data_b will be transposed in the function to [features, frames]
n_frames = 100
n_features = 4

# Generate random trajectory data for ensemble A
all_data_a = np.random.randn(n_frames, n_features).astype(np.float32)

# Generate random trajectory data for ensemble B
all_data_b = np.random.randn(n_frames, n_features).astype(np.float32)

ARGS = {
    'features_a': features_a,
    'features_b': features_b,
    'all_data_a': all_data_a,
    'all_data_b': all_data_b,
    'verbose': True,
    'override_name_check': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
mean_difference_analysis Ran
ran on a synthesized input
drorlab/pensa/pensa/comparison/statistics.py
code served (permissive licence) · get_code("70d68f4c31c51cad")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create small sample data
# features_a and features_b: lists of feature names
features_a = ['feature_0', 'feature_1', 'feature_2']
features_b = ['feature_0', 'feature_1', 'feature_2']

# all_data_a and all_data_b: trajectory data with shape [frames, frame_data]
# Let's create data with 5 frames and 3 features
np.random.seed(0)
all_data_a = np.random.randn(5, 3).astype(np.float32)
all_data_b = np.random.randn(5, 3).astype(np.float32)

# Set up the ARGS dictionary with all parameters
ARGS = {
    'features_a': features_a,
    'features_b': features_b,
    'all_data_a': all_data_a,
    'all_data_b': all_data_b,
    'verbose': True,
    'override_name_check': False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
pair_features_heatmap Ran
ran on a synthesized input
drorlab/pensa/pensa/comparison/visualization.py
code served (permissive licence) · get_code("d861400b58e997b2")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (5, 5) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import tempfile
import os

# Create temporary directory for plot output
temp_dir = tempfile.gettempdir()
plot_filename = os.path.join(temp_dir, "test_heatmap.png")

# Create sample feature names with PyEMMA nomenclature
# Format: "ResidueID_type - ResidueID_type"
feat_names = np.array([
    "CA 1 - CA 2",
    "CA 1 - CA 3",
    "CA 2 - CA 3",
    "CB 1 - CB 2",
])

# Create corresponding feature difference values
feat_diff = np.array([0.5, 0.3, 0.8, 0.2])

ARGS = {
    'feat_names': feat_names,
    'feat_diff': feat_diff,
    'plot_filename': plot_filename,
    'separator': ' - ',
    'num_drop_char': 0,
    'sort_by_pos': 1,
    'numerical_sort': True,
    'vmin': 0.0,
    'vmax': 1.0,
    'symmetric': True,
    'cbar_label': 'Feature Difference'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (5, 5) — shape (5, 5) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
pca_eigenvalues_plot Ran
ran on a synthesized input
drorlab/pensa/pensa/dimensionality/pca.py
code served (permissive licence) · get_code("d2f6fdbed4b2fc19")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
from sklearn.decomposition import PCA

# Create a small dataset
np.random.seed(0)
X = np.random.randn(10, 5)  # 10 samples, 5 features

# Fit PCA
pca = PCA(n_components=5)
pca.fit(X)

# Ensure explained_variance_ has at least 12 values (or use what we have)
# The function will use the first `num` eigenvalues
# Since we only have 5 components, let's create more
X_larger = np.random.randn(20, 15)  # More features to get more components
pca = PCA(n_components=15)
pca.fit(X_larger)

ARGS = {
    'pca': pca,
    'num': 12,
    'plot_file': None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy, sklearn — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
relative_entropy_analysis Ran
ran on a synthesized input
drorlab/pensa/pensa/comparison/relative_entropy.py
code served (permissive licence) · get_code("0757cc46884494ce")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import scipy as sp
import scipy.spatial.distance

# Set random seed for reproducibility
np.random.seed(0)

# Create small sample data
# Format: [frames, frame_data] - will be transposed to [frame_data, frames] inside function
num_frames = 50
num_features = 4

# Generate sample trajectory data for ensemble A
all_data_a = np.random.randn(num_frames, num_features).astype(np.float32)

# Generate sample trajectory data for ensemble B (slightly different distribution)
all_data_b = np.random.randn(num_frames, num_features).astype(np.float32) + 0.5

# Create feature names
features_list = [f"feature_{i}" for i in range(num_features)]

# Define all arguments
ARGS = {
    "features_a": features_list,
    "features_b": features_list,
    "all_data_a": all_data_a,
    "all_data_b": all_data_b,
    "bin_width": None,
    "bin_num": 10,
    "verbose": True,
    "override_name_check": False,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
resnum_heatmap Ran
ran on a synthesized input
drorlab/pensa/pensa/comparison/visualization.py
code served (permissive licence) · get_code("ee64bca4342a3444")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (7, 7) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import tempfile
import os

# Create temporary directory for plot output
temp_dir = tempfile.gettempdir()
plot_filename = os.path.join(temp_dir, "test_heatmap.png")

# Construct feature names in PyEMMA nomenclature
# Format: "word1 word2 word3 resid1 word5 word6 resid2 ..."
# With res1_pos=2 and res2_pos=6
feat_names = [
    "CA CA 1 CA CA CA 5 CA",
    "CA CA 2 CA CA CA 6 CA",
    "CA CA 3 CA CA CA 7 CA",
    "CA CA 1 CA CA CA 6 CA",
    "CA CA 2 CA CA CA 7 CA",
]

# Create corresponding difference values
feat_diff = np.array([0.5, -0.3, 0.2, 0.1, -0.4], dtype=float)

ARGS = {
    "feat_names": feat_names,
    "feat_diff": feat_diff,
    "plot_filename": plot_filename,
    "res1_pos": 2,
    "res2_pos": 6,
    "vmin": -0.5,
    "vmax": 0.5,
    "symmetric": True,
    "verbose": False,
    "cbar_label": "Difference",
    "tick_step": 1,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (7, 7) — shape (7, 7) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
ssi_sem_analysis Ran
ran on a synthesized input
drorlab/pensa/pensa/comparison/uncertainty_analysis.py
code served (permissive licence) · get_code("926fb0df5c224883")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import scipy.stats
import scipy.spatial.distance
import matplotlib.pyplot as plt
import os
from scipy.optimize import curve_fit

# Create minimal valid arguments for ssi_sem_analysis

# ssi_namelist: list of strings representing SSI names
# The function extracts first 3 characters as residue names
ssi_namelist = ['ALA_1', 'ALA_2', 'GLY_1', 'GLY_2', 'VAL_1', 'VAL_2']

# ssi_blocks: list of lists, where each inner list contains SSI values for a block
# The function processes these and removes -1 values
# Creating a list of numpy arrays with varying block data
ssi_blocks = [
    np.array([0.5, 0.6, 0.7, -1]),
    np.array([0.55, 0.65, 0.75, 0.8]),
    np.array([0.4, 0.5, 0.6, -1]),
    np.array([0.45, 0.55, 0.65, 0.7]),
    np.array([0.6, 0.7, 0.8, 0.85]),
    np.array([0.5, 0.6, 0.7, -1]),
]

ARGS = {
    'ssi_namelist': ssi_namelist,
    'ssi_blocks': ssi_blocks,
    'write_plot': False,
    'expfit': False,
    'plot_dir': './SEM_plots',
    'plot_prefix': '_test'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
tica_eigenvalues_plot Ran
ran on a synthesized input
drorlab/pensa/pensa/dimensionality/tica.py
code served (permissive licence) · get_code("adff94d4501f2fe0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import matplotlib.pyplot as plt

class TICAStandIn:
    """Minimal TICA object with required attributes."""
    def __init__(self):
        # The function accesses tica.singular_values[:num]
        # num defaults to 12, so we need at least 12 singular values
        self.singular_values = np.array([0.95, 0.87, 0.76, 0.68, 0.58, 0.49, 
                                         0.41, 0.34, 0.28, 0.22, 0.16, 0.11,
                                         0.08, 0.05, 0.02])

tica_obj = TICAStandIn()

ARGS = {
    "tica": tica_obj,
    "num": 12,
    "plot_file": None
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 2, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
tica_feature_correlation Ran
ran on a synthesized input
drorlab/pensa/pensa/comparison/projections.py
code served (permissive licence) · get_code("a9148ce57a03835c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 1, dtype family float, shape (7,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import matplotlib.pyplot as plt

# Create a mock TICA object with the required attributes
class MockTICA:
    def __init__(self, num_features, num_components):
        # feature_component_correlation should be shape (num_features, num_components)
        # Initialize with some correlations between -1 and 1
        self.feature_component_correlation = np.random.uniform(-1, 1, (num_features, num_components))

# Define the arguments
num_features = 7
num_components = 3

features = ['feature_0', 'feature_1', 'feature_2', 'feature_3', 'feature_4', 'feature_5', 'feature_6']
data = np.random.randn(10, num_features)  # Small dummy data
num = 3
tica = MockTICA(num_features, num_components)
threshold = 0.1
plot_file = None  # No file I/O
add_labels = False

ARGS = {
    'features': features,
    'data': data,
    'num': num,
    'tica': tica,
    'threshold': threshold,
    'plot_file': plot_file,
    'add_labels': add_labels
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
matplotlib, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 1, dtype family float, shape (7,) — shape (7,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
project_on_pc Not yet run
unverified (harvested, no recorded run)
drorlab/pensa/pensa/dimensionality/pca.py
code served (permissive licence) · get_code("f2655f2476b7ad0f")
How it ran

no invocation recorded.

Also present in other papers' code

Of 12 samples lifted from this paper's linked repositories, 12 carry a function identity and 0 do not. Of the 12 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 12 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Atomic-level simulations are widely used to study biomolecules and their dynamics. A common goal in such studies is to compare simulations of a molecular system under several conditions -- for example, with various mutations or bound ligands -- in order to identify differences between the molecular conformations adopted under these conditions. However, the large amount of data produced by simulations of ever larger and more complex systems often renders it difficult to identify the structural features that are relevant for a particular biochemical phenomenon. We present a flexible software package named PENSA that enables a comprehensive and thorough investigation into biomolecular conformational ensembles. It provides featurizations and feature transformations that allow for a complete representation of biomolecules like proteins and nucleic acids, including water and ion binding sites, thus avoiding bias that would come with manual feature selection. PENSA implements methods to systematically compare the distributions of molecular features across ensembles to find the significant differences between them and identify regions of interest. It also includes a novel approach to quantify the state-specific information between two regions of a biomolecule, which allows, e.g., tracing information flow to identify allosteric pathways. PENSA also comes with convenient tools for loading data and visualizing results, making them quick to process and easy to interpret. PENSA is an open-source Python library maintained at https://github.com/drorlab/pensa along with an example workflow and a tutorial. We demonstrate its usefulness in real-world examples by showing how it helps to determine molecular mechanisms efficiently.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2212.02714")
get_code_for_paper("2212.02714")
have("2212.02714")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2212.02714.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2212.02714.svg)](https://syntology.ai/paper/2212.02714)

Connect an agent — have() is free.