DISI - Recent changes [en]

ZINC26

Frodo — Tue, 07 Jul 2026 19:30:32 GMT

asdf

← Older revision		Revision as of 19:30, 7 July 2026
Line 1:		Line 1:
	~~This~~ is ~~the main page~~ for ~~ZINC26, the new version that was started~~ in ~~spring of 2026~~.		== Introduction ==
			ZINC26 is a search tool for purchasable chemical space. It uses Smallworld and Arthor technology from NextMove Software to allow searching billions of molecules in seconds. There is a batch interface and an interactive one.

	The ~~new database is organized around a set~~ of ~~[[ZINC26:Principles \| principles]]~~.		== Batch interface ==
			ZINC26 batch allows you to search all purchasable molecules to find the most similar in a short transaction.
			The resulting zip file can be downloaded and opened with DataWarrior (openmolecules.org, free).
			An approach of how to use DataWarrior may be found below.

	ZINC26 ~~is organized into three main areas~~.		== Interactive interface ==
			ZINC26 has many catalogs of both purchasable and bioactive compounds, which allow many interesting questions to be answered almost instantly.

	== ~~1. Purch - purchasable molecules~~ ==		== Organization ==
			* (mostly non-covalent) Screening compounds
			* Bioactive compounds (ChEMBL, natural products, drugs, etc)
			* Building blocks
			* Covalent compounds.
			* maybe chemistry commons.

	~~Catalogs of purchasable molecules are organized as follows:~~		* Within screening compounds, we organize by vendor and heavy atom count (HAC).
	* ~~cc - chemistry commons. These can be made from commercially availabile building blocks~~		* Covalent are organized by warhead
	* ise - in stock economical (~~5 of these so far~~)		* building blocks are organized by warhead and by vendor
	* ~~iso - in stock other (192 of these)~~		* ChEMBL compounds are organized by target.
	* ~~ode - on demand economical (6 of these, working)~~		* Purchasable are organized by "Plus" (we have had a better experience) and regular.
	* ~~odo - on demand other (41 of these)~~
	* ~~oth - other catalogs~~ (~~5 of these~~)

	== ~~2. Bioact - bioactive molecules from public sources~~ ==		== Advantages of logging in ==
			If you request and use a login (free), you are entitled to additional access:
			* search for up to 10 molecules per transaction, not just 1 for anonymous search
			* access Arthor to search molecules that can not yet be indexed with Smallworld.
			* access the API

	~~There are three kinds~~ of ~~bioactives~~: ~~invitro, invivo and natural~~		The new database is organized around a set of [[ZINC26:Principles \| principles]].


	~~== 3. Purchbioact - purchasable bioactives and their close analogs ==~~

	* for example Purchbioact/invivo/approve/fda1/oth/DB00250.ambint.src.txt.anon.map.txt

	~~is FDA approved molecules, as located within the "other" catalog Ambint. Here, the molecule DB00250.~~


	~~== 4~~. ~~Covalent ==~~

	== ~~5. Building blocks~~ ==		== API ==
			* zinc26dev.docking.org/docs describes how to use. Here is a short tutorial to get you started.

			== Coming soon ==
			* 3d database builder
			* additional data

	~~There~~ are ~~also~~		== Tutorial in how to use datawarrior ==
	* ~~2D searching tools~~		* the columns in datawarrior are as follows.
	* ~~3D databases for docking in ready-to-download formats~~		* we are still working on adding a net_charge column.
			* we suggest you proceed as follows.



	[[Category:ZINC26]]		[[Category:ZINC26]]

Running ChemSTEP with SymDOCK

Kholland — Tue, 07 Jul 2026 17:20:38 GMT

Created page with "last update: july7 2026 katie. ChemSTEP (Chemical Space Traversal and Exploration Procedure) is an open-source, transparent acceleration algorithm for molecular docking capable of dealing with virtual libraries of several trillion compounds. This wiki page is a guide for BKS lab members to run ChemSTEP on Wynton HPC, using a subset of ZINC (22B or 72B) or 13.3B library from Enamine REAL. At a high-level, ChemSTEP is an iterative process that identifies molecules from..."

New page

last update: july7 2026 katie.

ChemSTEP (Chemical Space Traversal and Exploration Procedure) is an open-source, transparent acceleration algorithm for molecular docking capable of dealing with virtual libraries of several trillion compounds. This wiki page is a guide for BKS lab members to run ChemSTEP on Wynton HPC, using a subset of ZINC (22B or 72B) or 13.3B library from Enamine REAL.

At a high-level, ChemSTEP is an iterative process that identifies molecules from the larger virtual library to prioritize for docking. First, we identify a random sample of the total library (termed "seed set", round zero) and dock those molecules to the target of interest. From this seed set, we can calculate total-library pProp values (-log rank percentages) and the number of "virtual hits" in the total library (high-scoring molecules). ChemSTEP will identify a set of maximally diverse molecules that score above the desired pProp threshold ("beacons") from the seed set. These beacons guide prioritization, where molecules chosen and output by ChemSTEP are close in chemical space to the beacons. Prioritized molecules are then built, docked, and returned to ChemSTEP for a second round of prioritization. This process is iterated until you reach desired virtual hit recovery, or you are no longer recovering virtual hits.

= Running ChemSTEP (Auto DOCK and Build with SymDOCK) =

ChemSTEP is configured to run on Wynton with libraries of '''13B''', '''22B''' (HAC 17-26, cLogP <= 3.5), and '''72B''' (HAC4-49, cLogP <=4.0). This page covers the full workflow for running ChemSTEP with automatic submission of docking and building jobs.

__TOC__

== 1. Source Environment ==

<pre>
source /wynton/group/bks/work/shared/kholland/chemstep_auto_symdock/symdock/bin/activate
</pre>

== 2. Dock the Seed Set ==

Copy the <code>.sdi</code> file for the library you want to use into a directory called '''sdi''' at the same level as your dockfiles:

{| class="wikitable"
! Library !! Path
|-
| 13B || <code>/wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/libraries/13B/13M_seeds.wynton.sdi</code>
|-
| 22B || <code>/wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/libraries/22B/22M_seeds.sdi</code>
|-
| 72B || <code>/wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/libraries/72B/72M_seeds.sdi</code>
|}

DOCK the seed set:

<pre>
bash /wynton/group/bks/work/shared/kholland/chemstep_auto_symdock/subScripts/submit_symdock.sh
</pre>

== 3. Gather Scores for the Seed Set ==

Once docking is complete, run the following from the directory '''one level above''' your docking output (where dockfiles and sdi directories are).

'''22B/72B library:'''
<pre>
python /wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/get_scores.py 0
</pre>

'''13B library:'''
<pre>
python /wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/get_scores.py 0 MOL
</pre>

Note: You must specify the molecule ID prefix for the 13B library (<code>MOL</code>)

Verify that <code>scores_round_0.txt</code> was correctly written:
<pre>
wc -l scores_round_0.txt
</pre>

== 4. Convert Scores to .npy Files ==

Convert scores to ChemSTEP-readable <code>.npy</code> files:

<pre>
python /wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/convert_scores_to_npy.py 0 <mol_id_prefix>
</pre>

The <code>mol_id_prefix</code> should match the library:

{| class="wikitable"
! Library !! Prefix
|-
| 22B / 72B || <code>CSLB</code>
|-
| 13B || <code>MOL</code>
|}

== 5. Set Up the ChemSTEP Run Directory ==

Create and enter a ChemSTEP run directory, then copy in the necessary files (with the ChemSTEP SymDOCK environment sourced):

<pre>
mkdir chemstep_run
cd chemstep_run
chemstep-run-new
</pre>

This will populate the directory with <code>params.txt</code>, <code>run_chemstep.py</code>, and <code>launch_chemstep_as_job.sh</code>.

=== Optional: Integrated IFP ===

If running with integrated IFP for beacon selection, also run:

<pre>
chemstep-run-ifp
</pre>

This copies in the additional files <code>ifp_acceptance_criteria.txt</code> and <code>interactions.txt</code>.

== 6. Edit params.txt ==

Add the absolute paths to the ChemSTEP-readable score and indices <code>.npy</code> arrays generated in Step 4.

<pre>
seed_indices_file: /path/to/your/indices_round_0.npy
seed_scores_file: /path/to/your/scores_round_0.npy
hit_pprop: 5.5
n_docked_per_round: 2000000
bundle_size: 1000
max_beacons: 100
max_n_rounds: 250
</pre>

=== Parameter Reference ===

{| class="wikitable"
! Parameter !! Description
|-
| <code>hit_pprop</code> || Defines a "virtual hit." pProp = −log(rank%) within the total library score distribution. E.g., pProp 4 in 13B space ≈ top 0.01% (~1.3M molecules); pProp 5 ≈ 0.001% (~132K). The seed set should contain at least 10<sup>(pProp+2)</sup> molecules.
|-
| <code>n_docked_per_round</code> || Number of molecules prioritized per round. All must be built and docked between rounds. Too many slows throughput and may reduce diversity; too few slows virtual hit recovery. Recommended: 1-2 million
|-
| <code>max_beacons</code> || Diverse, well-scoring molecules used to guide prioritization. All molecules above the pProp threshold are candidates. Too many reduce inter-beacon diversity; too few hinder space exploration. Fewer beacons than specified may be assigned if an insufficient number of molecules clear the threshold. Recommended: 100
|-
| <code>bundle_size</code> || In auto docking mode, number of molecules submitted as a single build job.
|-
| <code>max_n_rounds</code> || No adjustment needed when running ChemSTEP prospectively as described here.
|}

== 7. Edit run_chemstep.py ==

'''Note:''' All paths must be '''absolute paths'''.

=== Required Settings ===

Set <code>lib_path</code> to the library pickle for your library:

{| class="wikitable"
! Library !! Path
|-
| 13B || <code>/wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/libraries/13B/boltz_fplib.pickle</code>
|-
| 22B || <code>/wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/libraries/22B/22B_fplib.pickle</code>
|-
| 72B || <code>/wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/libraries/72B/72B_fplib.pickle</code>
|}

<pre>
lib_path = '/full/path/to/library.pickle'
</pre>

Set <code>dockfiles_path</code>:

<pre>
dockfiles_path="/full/path/to/dockfiles"
</pre>

=== Optional: minTD Exclusion Zone ===

Molecules will not be prioritized from within a specified Tanimoto distance of beacons. Comment in the relevant lines and update the value. Consider also setting <code>enforce_n_docked_per_round = True</code> when using this option:

<pre>
min_td_search=0.5,
enforce_n_docked_per_round=True,
</pre>

=== Optional: Integrated IFP ===

Only selects beacons that satisfy user-defined interaction criteria. Comment in the following lines and update the paths to the necessary files (copied in Step 5 if you ran <code>chemstep-run-ifp</code>):

<pre>
use_IFP=True,
ifp_pdb_path='/full/path/to/rec.crg.pdb',
interactions_file='/full/path/to/interactions.txt',
ifp_acceptance_criteria_file='/full/path/to/ifp_acceptance_criteria.txt',
</pre>

'''<code>interactions.txt</code>''' — one interaction per line, comma-separated. Format: <code>interaction_type, residue_name_and_number</code>. Example:

<pre>
Hydrogen bond, GLY-19
Ionic, ASP-149
</pre>

Supported interaction types include: Proximal, Hydrogen bond, Ionic, Cation-pi, Hydrophobic, Halogen bond, and others. See LUNA and IFP documentation for the full list.

'''<code>ifp_acceptance_criteria.txt</code>''' — defines the number of unsatisfied donors/acceptors/specific interactions required for a molecule to pass IFP and be considered for beacon selection. Example:

<pre>
#_donors
#_acceptors
#_unstatisfied_donors == 0
#_unstatisfied_acceptors <= 4
Ionic/ASP-149 > 0
</pre>

=== Optional: SMARTS exclusion filter ===
Integrated SMARTS filer can exclude problematic chemotypes from being built, docked, or selected as beacons. Multiple SMARTS patterns are tolerated. Comment in the following line in run_chemstep.py:

<pre>
filter_smarts=['n1cncnc1', 'c1cccnc1[SH]']
</pre>

TRIAZINES: 'n1cncnc1'

=== Example: AmpC on 22B with minTD=0.50, No IFP ===

<pre>
lib_path = '/wynton/group/bks/work/shared/kholland/chemstep_auto_v04/scripts/libraries/22B/22B_fplib.pickle'
lib = load_library_from_pickle(lib_path)
algo = CSAlgo(lib, 'params.txt', 'output', 16, verbose=True,
scheduler='sge', smi_id_prefix='CSLB',
python_exec="/wynton/group/bks/work/shared/kholland/chemstep_auto_v04/bin/python",
dockfiles_path="/wynton/group/bks/work/kholland/chemstep_ampc_22B/seed_docking/dockfiles",
min_td_search=0.5,
enforce_n_docked_per_round=True,
#use_IFP=True,
#ifp_pdb_path='/path/to/your/reference/rec.crg.pdb',
#interactions_file='/path/to/your/interactions.txt',
#ifp_acceptance_criteria_file='/path/to/your/ifp_acceptance_criteria.txt',
docking_method="auto", track_beacon_orig=True)
</pre>

== 8. Launch the Job ==

Submit the main ChemSTEP job:

<pre>
qsub launch_chemstep_as_job.sh
</pre>

== 9. Monitor Job Status ==

Check job status with <code>qstat</code>. The main job will run for up to '''2 weeks''' given no errors. ChemSTEP will launch search, building, and docking jobs in successive rounds.

'''Note:''' If any building or docking subjobs hang, the main job will not proceed until those are canceled or finished. Monitor job statuses regularly and occasionally verify that docking output files (<code>scores_round_*.txt</code>) are being populated.

== 10. View Beacon SMILES and IDs ==

From the ChemSTEP running directory, run the following in a '''screen session on a dev node''':

<pre>
python /wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/get_beacon_ids_smiles.py output/complete_info/beacons.df /path/to/fp/library output.txt
</pre>

{| class="wikitable"
! Library !! Path
|-
| 13B || <code>/wynton/group/bks/work/omailhot/chunked_ampc_chemstep_lib</code>
|-
| 22B || <code>/wynton/group/bks/work/kholland/22B_fp_library</code>
|-
| 72B || <code>/wynton/group/bks/work/kholland/72B_fp_library</code>
|}

Use the library pickle path from [[#7. Edit run_chemstep.py|Step 7]].

== 11. Plot Hit Recovery ==

In your ChemSTEP directory containing <code>chemstep_algo.log</code> and score files,
<pre>
bash /wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/submit_hit_recovery.sh
</pre>

== 12. Get Poses After Docking ==

Make a list of <code>test.mol2.gz.0</code> files from docking:

<pre>
find round_*_docking/bundle_paths -maxdepth 2 -name "test.mol2.gz.0" > docked_poses.txt
</pre>

Then extract top poses:

<pre>
python /wynton/group/bks/work/bwhall61/for_beau/top_poses.py -t <pProp_energy_threshold> -s <num_poses_per_file> docked_poses.txt
</pre>

Get poses for Beacons:
<pre> python /wynton/group/bks/work/shared/kholland/chemstep_auto_v04/v04/scripts/get_beacon_poses.py output/complete_info/beacons.df /path/to/fp/library/ docked_poses.txt -o beacon_poses -j 8
</pre>

ADMET Builder

Bromero — Tue, 07 Jul 2026 00:23:52 GMT

← Older revision		Revision as of 00:23, 7 July 2026
Line 2:		Line 2:

	== Introduction ==		== Introduction ==
			[[File:ADMET builder webpage.png\|thumb]]

	As of 7/6/26, '''ADMET Builder''' is an internal Irwin Lab web tool for submitting one or more compounds in SMILES format and receiving OpenADMET prediction results.		As of 7/6/26, '''ADMET Builder''' is an internal Irwin Lab web tool for submitting one or more compounds in SMILES format and receiving OpenADMET prediction results.
Line 18:		Line 19:
	* Human plasma protein binding		* Human plasma protein binding
	* Downloadable CSV output		* Downloadable CSV output

			[[File:Results.png\|thumb]]

	Created by Benjamin "Ben" Romero (Undergrad Northwestern University '29), Summer 2026.<br>		Created by Benjamin "Ben" Romero (Undergrad Northwestern University '29), Summer 2026.<br>

File:Results.png

Bromero — Tue, 07 Jul 2026 00:23:43 GMT

Bromero uploaded File:Results.png

New page

Results

File:ADMET builder webpage.png

Bromero — Tue, 07 Jul 2026 00:22:09 GMT

Bromero uploaded File:ADMET builder webpage.png

New page

interface

ADMET Builder

Bromero — Tue, 07 Jul 2026 00:18:27 GMT

Show changes

ADMET Builder

Bromero — Tue, 07 Jul 2026 00:13:48 GMT

ADMET Builder is a lightweight very modular web interface for running OpenADMET predictions from typed SMILES strings. It was created to make ADMET prediction easier to use for chemists, students, and researchers who may not want to run command-line tools directly.

New page

# ADMET Builder

ADMET Builder is a lightweight web interface for running OpenADMET predictions from typed SMILES strings. It was created to make ADMET prediction easier to use for chemists, students, and researchers who may not want to run command-line tools directly.

---

## What It Does

ADMET Builder lets a user paste one or more SMILES strings into a web interface and run ADMET predictions.

The app returns:

- A clean results table in the browser
- A downloadable CSV file
- Molecular formulas calculated from SMILES
- RDKit-generated 2D structure images
- Click-to-enlarge structure viewing

The current OpenADMET model predicts:

- logD
- Caco-2 A to B permeability
- Caco-2 B to A permeability
- Mouse plasma protein binding
- Human plasma protein binding

---

## How It Works

ADMET Builder has three main parts:

| Layer | Technology | Purpose |
|---|---|---|
| Frontend | HTML, CSS, JavaScript | User interface, SMILES input, results table, structure display |
| Backend API | Flask | Receives SMILES, runs predictions, returns results |
| Prediction Engine | OpenADMET | Generates ADMET predictions from molecular input |

The browser sends SMILES strings to the backend using:

```text
POST /predict-smiles
```

The Flask backend then:

1. Receives the SMILES strings.
2. Converts them into a temporary CSV file.
3. Runs the OpenADMET command-line prediction tool.
4. Reads the prediction output.
5. Generates molecular formulas and structure images using RDKit.
6. Sends results back to the web interface as JSON.
7. Provides the same results as a downloadable CSV file.

---

## Why It Is Modular

ADMET Builder is intentionally modular. The frontend, backend, and prediction engine are separated so each part can be changed or reused.

This means:

- The frontend can be redesigned without changing the model logic.
- The Flask backend can support new endpoints.
- Additional OpenADMET models can be added later.
- Other chemistry tools can be wrapped using the same backend pattern.
- The results table can be adapted for different prediction outputs.
- The SMILES-to-structure display can be reused in other cheminformatics apps.
- The app can serve as a template for future scientific web interfaces.

Because of this structure, ADMET Builder can be used not only as a lab tool, but also as a starting point for other modular research software.

---

## Getting The Code

Clone the repository using HTTPS:

```bash
git clone https://gitlab.docking.org/bromero/admet-builder.git
cd admet-builder
```

Or clone using SSH:

```bash
git clone git@gitlab.docking.org:bromero/admet-builder.git
cd admet-builder
```

---

## Requirements

ADMET Builder expects OpenADMET to already be installed in a working conda environment.

The C7 setup uses:

```bash
module load anaconda3/2025.06.0
source "$(conda info --base)/etc/profile.d/conda.sh"
conda activate openadmet-models
```

Python dependencies include:

- Flask
- pandas
- RDKit
- OpenADMET models package

The app also expects the OpenADMET model directory to be available at:

```text
~/openadmet/permeability-logd-ppb-chemeleon-baseline/anvil_training
```

---

## Running The App

From the repository folder:

```bash
cd ~/openadmet/admet-builder
module load anaconda3/2025.06.0
source "$(conda info --base)/etc/profile.d/conda.sh"
conda activate openadmet-models
python app.py
```

The app runs on:

```text
http://169.230.26.173:8501
```

---

## Running In Screen

For persistent use on C7, run ADMET Builder inside `screen`.

Start a screen session:

```bash
screen -S admet-builder
```

Inside screen, run:

```bash
module load anaconda3/2025.06.0
source "$(conda info --base)/etc/profile.d/conda.sh"
conda activate openadmet-models
cd ~/openadmet/admet-builder
python app.py
```

Detach from screen while keeping the app running:

```text
Ctrl+A
D
```

Reconnect later:

```bash
screen -r admet-builder
```

List running screen sessions:

```bash
screen -ls
```

Stop the app from inside screen:

```text
Ctrl+C
```

---

## Using The Website

1. Open ADMET Builder in the browser.
2. Paste one SMILES string per line.
3. Click `RUN ADMET`.
4. View the results in the table.
5. A CSV file downloads automatically.
6. Click a molecular structure image to enlarge it.

Example input:

```text
CCO
c1ccccc1
CC(=O)Oc1ccccc1C(=O)O
```

---

## Output

The output table includes:

| Column | Meaning |
|---|---|
| Molecule | Molecular formula calculated from the SMILES string |
| SMILES | Input molecule string |
| Structure Image | RDKit-generated 2D molecular structure |
| logD | Predicted distribution coefficient |
| Caco-2 A to B | Predicted apical-to-basolateral permeability |
| Caco-2 B to A | Predicted basolateral-to-apical permeability |
| Mouse PPB | Predicted mouse plasma protein binding |
| Human PPB | Predicted human plasma protein binding |

The CSV download contains the same prediction values in a machine-readable format.

---

## Access Through SwitchyOmega

If using SwitchyOmega, the proxy should be:

```text
SOCKS5
localhost
1074
```

The website itself is opened at:

```text
http://169.230.26.173:8501
```

The ports mean different things:

| Port | Purpose |
|---|---|
| 1074 | Local SOCKS5 proxy used by SwitchyOmega |
| 8501 | ADMET Builder web app running on C7 |

If the SOCKS proxy is not running, start it from a Mac terminal:

```bash
ssh -f -N -D 1074 bromero@epsilon.compbio.ucsf.edu
```

---

## Repository Structure

```text
admet-builder/
├── app.py
├── static/
│ ├── index.html
│ ├── styles.css
│ └── app.js
└── .gitignore
```

### `app.py`

The Flask backend. It receives SMILES input, runs OpenADMET, generates formulas and structure images, and returns results.

### `static/index.html`

The main web page structure.

### `static/styles.css`

The UCSF-style visual design and table layout.

### `static/app.js`

The browser-side logic. It sends SMILES to the backend, renders the results table, downloads CSV output, and handles structure image enlargement.

---

## Current API Endpoint

```text
POST /predict-smiles
```

Example JSON request:

```json
{
"smiles": [
"CCO",
"c1ccccc1",
"CC(=O)Oc1ccccc1C(=O)O"
]
}
```

Example response includes:

```json
{
"csv": "...",
"rows": [],
"columns": []
}
```

The frontend uses this response to display results and download the CSV.

---

## Notes

ADMET Builder is a research tool. Its predictions are intended for screening, comparison, prioritization, and exploration.

Results should not be treated as experimental measurements.

---

## Attribution

Created by Benjamin "Ben" Romero (Undergrad Northwestern University '29), Summer 2026.
Developed in the Irwin Lab at UCSF.
Released as part of an open-source UCSF research tool; please credit the creator and lab when using or adapting this work.

ZINC26:Help

Frodo — Thu, 02 Jul 2026 18:16:40 GMT

asfd

← Older revision		Revision as of 18:16, 2 July 2026
Line 1:		Line 1:
	ZINC26 provides interfaces to search purchasable chemical space and biologically active chemical space.		ZINC26 provides interfaces to search purchasable chemical space and biologically active chemical space.

	~~The interface at zinc26.docking.org features both an~~ interactive ~~batch method to search. The interative approach allows near-instant~~ (~10s) ~~searches of individual databases of up to 5 billion molecules in each transaction. This allows "what~~ if~~" type searches of parts of chemical space, and based on individual vendors~~.		There are two separate interfaces, interactive (10s turnaround time) and batch (3 mins turnaround time if there is no queue).

	~~== Interactive ==~~		The interactive interface searches specific databases subsets you select, from a few to a few billion molecules each. The batch interface searches _all_ purchasable or _all_ bioactive databases in a single transaction.

	~~== Batch ==~~		Anonymous users can search for one molecule at a time in the batch interface, while logged in users may search for up to 10 molecules in a single transaction.

			We throttle usage in other (so far undisclosed) ways that allow us to offer a free public service without overloading.

			Collectively, ZINC26 allows "what if" type searches of purchasable and biologically precedented chemical space. It allows the following questions.

			* what are the most similar molecules I can purchase?
			* what the most most similar molecules I can purchase from a particular vendor (within a particular HAC range)?
			* Does vendor X sell compounds that look like my compound?
			* what is the nearest drug to my compound?
			* what is the nearest chembl bioactive 1uM or better to my compound?
			* what is the nearest ligand for some gene product, say DRD4, 1uM or better, to my compound?
			* what is the nearest natural product to my compound?
			* what is the nearest metabolite to my compound?

	~~== Searching Bioactive chemical space ==~~

	== Updates / Status ==		== Updates / Status ==
			* As of July 2, 2026, zinc26 is in production at zinc26.docking.org and zinc26dev.docking.org. If you cannot get in, write us at jjiteam at googlegroups dot com for access.
			* we have indexed most of the commercially available libraries that are distributed as enumerated libraries. Synthon based libraries will enumerated, but it takes time (ask the vendor to enumerate up to HAC29 and send it to us, and we will index it)
			* We are aiming to offer "all purchasable to HAC29" and "all bioactives" as one-click interactive databases. So far, we are not quiet there, but we are close. Use the batch interface until that is ready. It may turn out that we need to offer
			* all-purchasable-to-HAC25, and then one by one by HAC after that, in order to provide good interactive service. But we are trying to do it to HAC29.

	== how to report suggestions / problems ==		== how to report suggestions / problems ==
			Please use our usual form for reporting problems: https://forms.gle/LZV1FCmLWxUWznVi9

			* Please send us catalogs that you do not see indexed.

SEA26

Frodo — Thu, 02 Jul 2026 17:08:16 GMT

asdf

New page

This is the documentation for the new version of SEA by Yujin Wu and Khanh Tang.

== explanation of all the columns ==

== explanation of all the colors ==

== narration of one or two examples to show how to use it ==

== explanation of all menu items ==

== explanation of how to use compounds vs targets ==

== FAQ ==

== Data sources ==

== Software is open source ==
(link to github?)

[[Category:SEA]]

Group Meeting

Yvonne Munchua — Thu, 02 Jul 2026 16:58:02 GMT

MEETING SCHEDULE

← Older revision		Revision as of 16:58, 2 July 2026
(One intermediate revision by the same user not shown)
Line 25:		Line 25:

	= '''MEETING SCHEDULE =		= '''MEETING SCHEDULE =

	*6/5/26: Katie Holland
	*6/12/26: Brian Dick
	*6/19/26: NO lab mtg (UC Holiday - Juneteenth)
	*6/26/26: Weixiu Xu


Line 53:		Line 48:
	*Xinyu Xu		*Xinyu Xu
	*Joe Pepe		*Joe Pepe
			*Maya Druch (Start Date: 6/22/26 - Will present Oct 2)
	*Andrii Kyrylchuk		*Andrii Kyrylchuk
	*Katie Holland		*Katie Holland
	*Weixiu Xu (Start Date: 2/2/26)		*Weixiu Xu
			*Chris Flores (Start Date: 7/1/26 - Will present Nov 6)
	*Jongbin Kim		*Jongbin Kim
	*Zoey Dingman		*Zoey Dingman

Category:ZINC26

Frodo — Wed, 01 Jul 2026 15:47:05 GMT

asdf

New page

Link all ZINC26 related articles together.

ZINC26:API

Frodo — Wed, 01 Jul 2026 15:46:41 GMT

asdf

New page

Here is how to use the ZINC26 API.

Documentation is at zinc26dev.docking.org/docs/

Examples of how to use it. This may change as it develops, and may change as login/authentication is incorporated.

[[Category:JJI]]
[[Category:ZINC26]]

Looping solution

Frodo — Tue, 30 Jun 2026 22:48:19 GMT

asdf

New page

= Looping Solution =

Here is our approach to running jobs at scale on coreHPC.

* 1. on cluster 7 there is a directory with job control language
* 2. there is a cronjob that runs on corehpc.
* 3. once an hour, it iterates over all jobs in the system, and moves them forward.
* 4. the job status of each job is below.
* 5. the supported job control language is below.

== job status ==
* 0 new job request
* 1 job data has started copying to fac
* 2 job data copy to fac has completed successfully
* 12 job data copy to fac failed (and requires attention)
* 3 job has been submitted on coreHPC
* 4 job is running on coreHPC
* 5 job has completed on coreHPC
* 15 job has failed in coreHPC (and requires attention)
* 6 scp of job results to C7 has started
* 7 scp of job results to C7 has completed normally
* 17 scp of job results to C7 has failed (and requires attention)

== supported job control language (JCL) ==

* Each job has a file. The command syntax is as follows
type: docking, chemstep, other
dockfiles: /nfs/exe/work/jji/projects/target1/dockfiles (includes INDOCK)
tranches: /nfs/exe/work/jji/projects/target1/tranches (one file per jobs, circa 1 TB each)

[[Category:JJI]]

Cluster 8

Frodo — Tue, 30 Jun 2026 22:39:30 GMT

asdf

← Older revision		Revision as of 22:39, 30 June 2026
Line 41:		Line 41:
	https://it.ucsf.edu/how-to/fac-drive-mapping-instructions?check_logged_in=1#linux		https://it.ucsf.edu/how-to/fac-drive-mapping-instructions?check_logged_in=1#linux


			smb://capstorage.fac.ucsf.edu/CX900007_DS1. lab storage
			/mnt/fac/CX900007_DS1 fac

	[[Category:Cluster]]		[[Category:Cluster]]