Przejdź do treści
Biblioteka skilli
Nauka i badania · Budowanie i kod

invrotzyme

/invrotzyme

Składa zestawy miejsc aktywnych enzymu wokół ligandu z pliku ograniczeń Rosetta w PyRosetta, jako zarodki do projektowania enzymów.

Licencja
MIT
Ostatnia zmiana repozytorium
05.06.2026

Ocena i bezpieczeństwo

87/ 100Klasa: dobry
Format20 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność17 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
8
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
6
Przestarzałość

Brak sygnałów. Repozytorium zmienione 05.06.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Składa zestawy miejsc aktywnych enzymu wokół ligandu z pliku ograniczeń Rosetta w PyRosetta, jako zarodki do projektowania enzymów.

Oryginalny opis (EN)

Build inverse-rotamer active-site assemblies from a Rosetta matcher/enzdes constraint (CST) file using PyRosetta. Use this skill when: (1) Constructing theozyme / active-site stubs (catalytic sidechains placed around a ligand) as starting points for de novo enzyme design, (2) Preparing inputs for **RFdiffusion All-Atom** (RFdiffusionAA) enzyme design pipelines — outputs include `REMARK 666` enzdes records so they drop straight into the published heme-binder-diffusion workflow, (3) Exhaustively enumerating clash-free combinations of catalytic rotamers + small idealized helix/strand backbone stu

Jak działa

  1. What this is
  2. When to use this vs alternatives
  3. Prerequisites
  4. Three-step quickstart
  5. CLI flags — full reference
  6. Per-CST argument convention
  7. Output layout
  8. CST file requirements
  9. How the pipeline runs (mental model)
  10. Hard rules / gotchas
Sekcje z nagłówków SKILL.md, w oryginale · 413 linii, 2 538 słów
Podgląd SKILL.md
---
name: invrotzyme
description: >
  Build inverse-rotamer active-site assemblies from a Rosetta matcher/enzdes
  constraint (CST) file using PyRosetta. Use this skill when:
  (1) Constructing theozyme / active-site stubs (catalytic sidechains placed
      around a ligand) as starting points for de novo enzyme design,
  (2) Preparing inputs for **RFdiffusion All-Atom** (RFdiffusionAA) enzyme
      design pipelines — outputs include `REMARK 666` enzdes records so
      they drop straight into the published heme-binder-diffusion workflow,
  (3) Exhaustively enumerating clash-free combinations of catalytic
      rotamers + small idealized helix/strand backbone stubs around a
      small-molecule substrate / cofactor,
  (4) Hosting one catalytic residue inside an externally-provided **motif
      PDB** (e.g. a CYS loop from a cytochrome P450) while still
      enumerating the other CST residues as inverse rotamers,
  (5) Filtering rotamers by Dunbrack cumulative probability (per-CST or
      global), per-CST secondary structure, and per-CST random subsampling
      to control combinatorial explosion,
  (6) Enabling Rosetta-style extra-χ sub-sampling (`-ex1`..`-ex4`-equivalent)
      per CST block to widen rotamer search at controlled cost,
  (7) Pinning a specific HIS tautomer (`HIS` vs `HIS_D`) per CST,
  (8) `--tip_atom` mode: skipping pairwise clash analysis and outputting
      assemblies based purely on unique geometric placement of catalytic
      tip atoms (much faster, looser).

  Covers the CST-file requirements, every CLI flag, the per-CST argument
  convention, the `--motif_for_cst` format, parallelization model
  (Python multiprocessing, SLURM-aware), output PDB structure (one
  `REMARK 666` line per catalytic residue), and the typical role of
  this tool inside a larger enzyme-design pipeline.

  Pairs with: `rfdiffusion` (specifically RFdiffusionAA — invrotzyme
  outputs are designed to be its inputs), `ligandmpnn` (sequence design
  on the resulting backbones), `chai` / `boltz` / `alphafold` (refold
  validation), `protein-qc` (QC thresholds), `bindcraft` (alternative
  end-to-end binder route — not enzyme-design).
license: MIT
category: protein-design
tags: [enzyme-design, theozyme, inverse-rotamer, rosetta, enzdes, matcher, rfdiffusion-aa, active-site, pyrosetta]
repo: https://github.com/ikalvet/invrotzyme
related_pipeline: https://github.com/ikalvet/heme_binder_diffusion
---

# InvrotZyme — Inverse-Rotamer Assemblies from Rosetta CST Files

## What this is

InvrotZyme is a **single-script** PyRosetta tool that takes a
Rosetta matcher / enzdes constraint file (CST) and emits PDB files
containing all clash-free combinations of catalytic side-chain rotamers
placed around a ligand, each rotamer optionally embedded in a short
idealized α-helix or β-strand backbone stub.

Each output PDB contains:

- The catalytic ligand as `chain X`, residue `0` (when only one ligand).
- One short backbone stub per catalytic residue, each on its own chain.
- A `REMARK 666 MATCH TEMPLATE … MATCH MOTIF …` header line per
  catalytic residue — the **enzdes constraint header** that downstream
  Rosetta / RFdiffusionAA pipelines need to re-instate the constraint.

These PDBs are designed to be fed straight into the published
[heme_binder_diffusion](https://github.com/ikalvet/heme_binder_diffusion)
RFdiffusion-All-Atom enzyme-design pipeline, but they're also usable
as `match` outputs or Rosetta enzdes inputs.

The codebase is small (3 files: `invrotzyme.py`, `protocol.py`,
`utils.py`, plus a `utils/` subpackage with the Dunbrack-rotlib loader
and a Kabsch aligner) and depends only on **pyrosetta**, **numpy**,
**pandas**, **scipy**.

## When to use this vs alternatives

| You want… | Use |
|----------|-----|
| Clash-free **theozyme** / inverse-rotamer assemblies from a CST + params | **invrotzyme** |
| End-to-end binder against a *protein* target (no ligand) | `bindcraft`, `rfdiffusion`, `genie3` |
| Backbone generation around invrotzyme outputs (RFdiffusion **All-Atom**) | `rfdiffusion` (AA variant) — invrotzyme is its standard input |
| Sequence design on backbones that host a ligand | `ligandmpnn` |
| Joint sequence + structure co-design around a ligand (no CST file) | `disco`, `boltzgen` |
| Refold / validate the resulting enzyme designs | `chai`, `boltz`, `alphafold` |
| QC filtering of designed enzymes | `protein-qc` |

The headline use case is **stage 1** of an enzyme-design pipeline:
generate many small (~10 res) catalytic assemblies → RFdiffusionAA
scaffolds → LigandMPNN sequences → AF/Chai/Boltz refold → QC.

## Prerequisites

| Requirement | Notes |
|-------------|-------|
| **PyRosetta** | Must be installed and licensed. Provides the Dunbrack rotamer DB (`bbdep02.May.sortlib-correct.12.2010` is loaded from `<pyrosetta>/database/rotamer/`). |
| numpy, pandas, scipy | Standard scientific stack. |
| Rosetta `.params` for ligand | One `.params` file per non-canonical residue or small-molecule ligand referenced in the CST. |
| **CST file** | All six DOFs (distance, two angles, three torsions) defined per constraint block. See *CST file requirements* below. |
| CPU cores | The script is multiprocess and CPU-only (no GPU). Reads `SLURM_CPUS_ON_NODE` when running under SLURM, else defaults to `os.cpu_count()`. |

There is no GPU dependency and no model weights to download.

## Three-step quickstart

### 1) Clone (one-time)

```bash
git clone https://github.com/ikalvet/invrotzyme.git ~/Repos/invrotzyme
```

The script imports `protocol`, `utils`, `dunbrack_rotlib`, and
`align_pdbs` from its own directory — **run it from anywhere as long
as `invrotzyme.py` is invoked by its full or relative path** (it adds
its own directory and `utils/` to `sys.path`).

### 2) Prepare inputs

You need:

- A **`.cst` file** with one `CST::BEGIN … CST::END` block per catalytic
  interaction, each defining all six DOFs. Group alternative residues
  (e.g. SER/THR/TYR/ASN/GLN at the oxyanion hole) under
  `VARIABLE_CST::BEGIN … VARIABLE_CST::END`. See
  [references/cst-file.md](references/cst-file.md).
- A **`.params` file** for every non-canonical residue / ligand
  (e.g. `BIO.params` for benzisoxazole in the Kemp example).
- *(Optional)* a **motif PDB** if you want a specific catalytic
  residue to come from a pre-existing scaffold (e.g. P450 CYS loop)
  instead of an enumerated rotamer.

### 3) Run

Kemp eliminase (HIS-ED dyad + oxyanion hole, ~10s on 32 cores):

```bash
cd examples/Kemp_eliminase
python ../../invrotzyme.py \
  --cstfile inputs/BIO_His_ED_oxy_nosample.cst \
  --params  inputs/BIO.params \
  --dunbrack_prob 0.6 \
  --frac_random_rotamers_per_cst 0.5 0.5 0.5 0.5 \
  --secstruct_per_cst H H E \
  --prefix outputs/ \
  --suffix HHE
```

P450 with external motif holding the CYS:

```bash
cd examples/P450
python ../../invrotzyme.py \
  --cstfile inputs/HBA_CYS_P450_nosample.cst \
  --params  inputs/HBA_unique.params \
  --motif_for_cst 1:3:inputs/P450_motif.pdb \
  --frac_random_rotamers 0.1 \
  --prefix outputs/
```

Inspect any output PDB — it should start with one
`REMARK 666 MATCH TEMPLATE … MATCH MOTIF …` line per catalytic CST.

See [examples/](examples/) for full annotated invocations.

## CLI flags — full reference

The script is one positional-free `argparse` interface. All flags are
optional except `--cstfile`. Per-CST flags accept one value per CST
block (in CST order); the ligand-bearing CST 1 is **typically** included
in the per-CST list with a placeholder value (see *Per-CST argument
convention* below).

### Required

| Flag | Description |
|------|-------------|
| `--cstfile PATH` | Rosetta matcher/enzdes CST file. **All six DOFs must be defined per block.** |

### Inputs

| Flag | Description |
|------|-------------|
| `--params PATH [PATH ...]` | One or more `.params` files for non-canonical residues / ligands. Passed to PyRosetta as `-extra_res_fa`. |
| `--motif_for_cst CSTNO:RESNO_IN_MOTIF:FILEPATH [...]` | Use a residue from an external PDB instead of enumerating rotamers for that CST. **Currently only `CSTNO=1` is supported.** |

### Rotamer filtering

| Flag | Default | Description |
|------|---------|-------------|
| `--dunbrack_prob FLOAT` | `0.85` | Cumulative Dunbrack probability cutoff (same semantics as Rosetta `-packing:dunbrack_prob_…`). Lower = stricter (fewer rotamers). |
| `--dunbrack_prob_per_cst F [F ...]` | — | Per-CST override. One value per CST block (excluding the ligand). |
| `--keep_his_tautomer 'CST:HIS,CST:HIS_D,...'` | — | Pin a HIS tautomer per CST. Allowed values: `HIS`, `HIS_D`. |
| `--use_best_rotamer_cstids N [N ...]` | `[]` | For these CST IDs, only the single best rotamer per secondary-structure bin is kept (numbering starts at **1**). |

### Random subsampling (control combinatorial explosion)

These are the workhorses for keeping the run tractable on a CPU.

| Flag | Description |
|------|-------------|
| `--max_random_rotamers N` | Cap each residue's rotamer count to N (recommended < 20 for quick sampling). |
| `--max_random_rotamers_per_cst N0 N1 N2 ...` | Per-CST cap. **First value is for the ligand.** |
| `--frac_random_rotamers FLOAT` | Random fraction (0–1) of rotamers kept per residue. |
| `--frac_random_rotamers_per_cst F0 F1 F2 ...` | Per-CST fraction. **First value is for the ligand.** |
| `--prune_ligand_rotamers FLOAT` | RMSD cutoff (Å) for ligand-rotamer dedup. `0.0` disables. |

### Backbone stub generation

| Flag | Default | Description |
|------|---------|-------------|
| `--secstruct H\|E` | `H` | Idealized secondary structure of the stub built around each rotamer. |
| `--secstruct_per_cst S [S ...]` | — | Per-CST override (`E`, `H`, or `-`). |
| `--N_len N` | `4` | Number of residues added N-terminal of each catalytic residue. |
| `--C_len N` | `5` | Number of residues added C-terminal of each catalytic residue. |
| `--N_len_per_cst N [N ...]` | — | Per-CST override. |
| `--C_len_per_cst N [N ...]` | — | Per-CST override. |

### Extra χ sub-sampling

| Flag | Description |
|------|-------------|
| `--extra_chi 'chi:level,chi2:level2'` | Enable Rosetta-style χ sub-sampling for all CSTs. Format: `CHI:LEVEL` pairs comma-joined. |
| `--extra_chi_per_cst 'CSTNO-chi:level' [...]` | Per-CST extra-χ sub-sampling. |

Sampling levels (per the script's `calculate_samplings` docstring):

| Level | Samples |
|-------|---------|
| 0 | original only — equivalent to disabling |
| 1 | ± 1 σ — 3 samples |
| 2 | ± 0.5 σ — 3 samples |
| 3 | ± 1 σ, 2 σ — 5 samples |
| 4 | ± 0.5 σ, 1 σ — 5 samples |
| 5 | ± 0.5, 1, 1.5, 2 σ — 9 samples |
| 6 | ± 0.33, 0.67, 1 σ — 7 samples |
| 7 | ± 0.25, 0.5, 0.75, 1, 1.25, 1.5 σ — 13 samples |

### Output / runtime

| Flag | Default | Description |
|------|---------|-------------|
| `--prefix STR` | `""` | Prefix prepended to every output PDB filename (a path prefix works, e.g. `outputs/`). |
| `--suffix STR` | `""` | Suffix appended to every output PDB filename (before `.pdb`). |
| `--tip_atom` | off | Skip the full pairwise clash analysis; pre-select rotamers purely by *unique placement of catalytic tip atoms*. Much faster, much looser. |
| `--nproc N` | `os.cpu_count()` | CPU cores. Auto-overridden by `SLURM_CPUS_ON_NODE` if set. Forced to `1` under `--debug`. |
| `--max_outputs N` | — | Early-stop after N successful assemblies have been written. |
| `--debug` | off | Single-threaded, verbose. |

## Per-CST argument convention

Per-CST flags follow one of two conventions depending on the flag:

- **Rotamer-count flags** (`*_random_rotamers_per_cst`) take **one value per CST block plus one for the ligand**, ligand-first.
  *Example:* `--frac_random_rotamers_per_cst 0.5 0.5 0.5 0.5` for 3 CST blocks means
  `[0.5(ligand), 0.5(CST1), 0.5(CST2), 0.5(CST3)]`.
- **Geometry flags** (`secstruct_per_cst`, `N_len_per_cst`, `C_len_per_cst`, `dunbrack_prob_per_cst`)
  take **one value per CST block, ligand-excluded**.
  *Example:* `--secstruct_per_cst H H E` for 3 CST blocks.

Mixing these up will assert at startup — read the error message
carefully, it tells you the expected length.

## Output layout

Per successful rotamer combination, one PDB file is written:

```
<prefix><rotamer-letters>_<set>_<i><suffix>.pdb
```

Filename components are appended residue-by-residue:

- canonical AAs as their one-letter code (`H`, `E`, `S`, `Y`, …)
- ligands / non-canonicals as their three-letter `name3()`
- motif residues use the basename of the motif PDB (without `.pdb`)

`<set>` is the non-redundant rotamer-set index (1-based) and `<i>` is
the index within that set's `itertools.product` enumeration.

Inside each PDB:

- One `REMARK 666 MATCH TEMPLATE X <LIG> 0 MATCH MOTIF <chain> <RES> <resno> <cst#> <mcfi#>`
  line per catalytic residue (except the ligand itself).
- Each catalytic residue on its own chain (the result of building the
  idealized stub independently per residue and concatenating with
  `append_subpose_to_pose(new_chain=True)`).
- The ligand as the **last** chain (or `chain X residue 0` semantics in
  the REMARK when only one ligand is present).

A console line is emitted per successful build:

```
Found good rotamer: <prefix>H_E_S_<...>_<set>_<i><suffix>
```

For invalid rotamers, the rotamer ID is added to a per-CST
`bad_rotamers` list and skipped on subsequent combinations — this
cheap memoization is what keeps long enumerations tractable.

## CST file requirements

The CST file is the **standard Rosetta matcher / enzdes constraint
format**. Full reference:
<https://docs.rosettacommons.org/docs/latest/rosetta_basics/file_types/match-cstfile-format>.

InvrotZyme-specific requirements:

1. **All six DOFs must be defined** for every constraint block:
   `distanceAB`, `angle_A`, `angle_B`, `torsion_A`, `torsion_AB`,
   `torsion_B`. PyRosetta's `TheozymeInvrotTree.generate_targets_and_inverse_rotamers()`
   requires this to enumerate inverse rotamers.
2. **Keep in-CST conformational sampling minimal** — every additional
   sample multiplies the combinatorial space. Prefer to widen with
   `--extra_chi*` (deterministic, controllable) over CST-level samples.
3. **Variable CSTs** (`VARIABLE_CST::BEGIN … VARIABLE_CST::END`) work
   as expected — multiple alternative residue types share the same
   slot in the assembly.
4. **`SECONDARY_MATCH`** algorithm directives are respected. The
   `create_remark_lines` function walks `UPSTREAM_CST N` / `DOWNSTREAM`
   to pick the correct downstream residue when emitting `REMARK 666`.

See [references/cst-file.md](references/cst-file.md) for an annotated
walkthrough of the Kemp-eliminase CST.

## How the pipeline runs (mental model)

```
CST file ──► EnzConstraintIO ──► MCFI per block ──► restypes per block
                                                                │
            Dunbrack DB ─┐                                       ▼
                          ├──► find_good_rotamers(prob, secstruct)
                          │                                      │
                          ▼                                      ▼
             per-CST rotamer pool ◄── prune (proton-chi, ligand RMSD,
                                              extra-χ subsample)
                                                                │
                          itertools.product over per-CST pools ─┘
                                                                │
                          multiprocessing.Pool workers ─────────┤
                                                                ▼
                          per combination:
                            1) extend each rotamer into an SS stub
                            2) attach ligand and clash-check
                            3) assemble full pose; clash-check ignoring
                               (catalytic ↔ ligand) pairs
                            4) emit REMARK 666 lines per catalytic res
                            5) write PDB if all REMARKs computable
```

Workers share a `bad_rotamers` `manager.dict()` so each per-residue
clash-failure invalidates that rotamer for **all** future combinations.

## Hard rules / gotchas

1. **CST blocks must define all six DOFs.** The script will not run
   otherwise.
2. **Per-CST `*_random_rotamers_per_cst` lists are ligand-first** —
   the first entry is for the ligand pool, then one entry per CST.
   Geometry lists (`secstruct_per_cst`, `N_len_per_cst`, …) are
   ligand-excluded. Read the assertion errors carefully.
3. **`--motif_for_cst` only supports `CSTNO=1` right now.** The
   `parse_motif_input` function explicitly `sys.exit`s for any other
   CST. Format: `cst_no:resno_in_motif:filepath` (colons, no spaces).
4. **Combinatorial explosion is the #1 failure mode.** With 4 CSTs and
   100 rotamers each you have 10⁸ combinations. Use
   `--dunbrack_prob ≤ 0.6`, `--frac_random_rotamers_per_cst`, or
   `--use_best_rotamer_cstids` aggressively. The Kemp example uses
   `0.6` Dunbrack + `0.5` random fraction per CST.
5. **`--tip_atom` skips pairwise clash analysis.** Output volume goes
   up, but most assemblies will clash in any downstream step.
6. **Outputs include `REMARK 666` lines** — they are required by
   Rosetta enzdes downstream. If `create_remark_lines` cannot
   reconstruct all lines for an assembly, the PDB is **not** written.
7. **Files are overwritten silently** if the same `prefix`/`suffix`/
   indices match (the script tries an `a.pdb` suffix on collision, but
   the rename is buggy — `str.replace` returns a new string that is
   discarded; if duplicate names matter, vary `--suffix`).
8. **Bad rotamers are cached per-run**. A rotamer that fails the
   stub-extension clash check on its first appearance is blacklisted
   for the rest of the run. Re-running the script does **not** persist
   this cache.
9. **SLURM-aware nproc**: the script *unconditionally* overrides
   `--nproc` with `SLURM_CPUS_ON_NODE` if that env var is set. To
   pin a smaller value under SLURM, unset the env var first.
10. **PyRosetta init flags**: the script calls
    `pyrosetta.init("<-extra_res_fa> -run:preserve_header")` — if you
    need additional flags, edit `invrotzyme.py:269` (no CLI passthrough).
11. **External motif residue must be the right type.** The motif's
    `pose.residue(motif_resno).name3()` must appear in the CST's
    allowed restypes for that block, or the script asserts.
12. **Single-ligand REMARK shortcut.** When there is exactly one ligand,
    the `REMARK 666` line uses `chain X residue 0` for the ligand;
    multi-ligand cases use the in-pose chain/seqpos. Downstream parsers
    must handle both forms.

## Where outputs are used downstream

The intended downstream consumer is **RFdiffusion All-Atom**
(via the published [`heme_binder_diffusion`](https://github.com/ikalvet/heme_binder_diffusion)
pipeline). That pipeline:

1. Takes an invrotzyme PDB.
2. Diffuses a protein backbone that hosts all catalytic residues.
3. Sequence-designs the backbone (often **LigandMPNN** — see the
   `ligandmpnn` skill).
4. Refolds with AF2 / Chai / Boltz and filters by interface metrics
   and ligand-pocket geometry.

If you want to skip RFdiffusionAA and go straight to **Rosetta enzdes**
matching, the same `REMARK 666` PDBs are valid `match` outputs and can
be fed to `enzdes` design directly.

## Choosing the right reference doc

| You want to… | Read |
|--------------|------|
| Understand the CST file syntax + the Kemp example | [references/cst-file.md](references/cst-file.md) |
| See every CLI flag with worked examples | [references/cli.md](references/cli.md) |
| Tame combinatorial explosion (rotamer-filtering recipe) | [references/sampling.md](references/sampling.md) |
| Use a motif PDB instead of an enumerated rotamer | [references/motif.md](references/motif.md) |
| Parse / consume the output PDBs downstream | [references/outputs.md](references/outputs.md) |
| Plug invrotzyme into an RFdiffusionAA pipeline | [references/pipeline.md](references/pipeline.md) |
| See annotated example invocations | [examples/](examples/) |

## Quick decision tree

- **You have a CST file, just want clash-free assemblies fast** →
  `--dunbrack_prob 0.6 --frac_random_rotamers_per_cst <one_value_per_cst_+_ligand>`.
  Single-digit-minute on 32 cores.
- **You want exhaustive enumeration** → omit `--frac_random_rotamers*`
  and `--max_random_rotamers*`; raise `--dunbrack_prob` to `0.95`.
  Expect long runs.
- **You only care about geometric diversity of catalytic tips** →
  add `--tip_atom`. Skips most clash checks; produces *many* PDBs.
- **One catalytic residue lives on a fixed motif (e.g. P450 CYS)** →
  `--motif_for_cst 1:<resno>:motif.pdb`. Only CST 1 supported.
- **You hit combinatorial explosion** → bring `--dunbrack_prob` down
  to `0.5–0.6`, add `--use_best_rotamer_cstids 1 2 3` for the
  least-flexible residues, and `--max_outputs N` to early-stop.

## Installing this skill

```bash
# Symlink (recommended — picks up edits live)
mkdir -p ~/.claude/skills
ln -s "$(pwd)" ~/.claude/skills/invrotzyme

# Or copy:
cp -R . ~/.claude/skills/invrotzyme
```

After that, an agent invokes it via `Skill(skill="invrotzyme")`.

## Citation

InvrotZyme has no standalone publication. Cite the downstream
RFdiffusion-All-Atom enzyme-design paper when used in that pipeline,
and attribute the script to **I. Kalvet (Baker lab, UW)**.
Pliki w paczce (8)
  • SKILL.md 21 KB
  • examples/README.md 3 KB
  • references/cli.md 7 KB
  • references/cst-file.md 5 KB
  • references/motif.md 4 KB
  • references/outputs.md 6 KB
  • references/pipeline.md 9 KB
  • references/sampling.md 5 KB

Wersje

W bazie nie ma innych skilli o nazwie invrotzyme.

Migawka bazy z 13.11.2026 · wersja paczki a9ef3c132db5 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100pyrosetta-ligand
    Prowadzi przepływy PyRosetta dla ligandów: parametry, ustawianie pozycji i lokalne oraz globalne dokowanie.
  • 100tooluniverse-enzyme-design
    Projektuje enzymy de novo przez rusztowanie motywu katalitycznego: buduje motyw stanu przejściowego, generuje rusztowania w AlphaProtein Novo i filtruje projekty regułami mechanistycznymi.
  • 100ligandmpnn
    Projektuje sekwencje białek wokół małych cząsteczek, np. miejsc aktywnych enzymów, kieszeni wiążących i miejsc koordynacji metali.
  • 100alterlab-ligandmpnn
    Projektuje sekwencje białek wokół związanych ligandów, metali i kwasów nukleinowych modelem LigandMPNN, w tym kieszenie wiążące i miejsca aktywne enzymów.
  • 100complexa-design
    Prowadzi pełny potok projektowania Proteina-Complexa: binder białkowy, binder ligandu i rusztowania motywów enzymatycznych, od celu po wyniki.
  • 100ligandmpnn
    Projektuje sekwencje białek wokół ligandów: miejsca aktywne enzymów, kieszenie wiążące i miejsca koordynacji metali.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.