10. PLACER

PLACER (paper, code) stands for Protein-Ligand Atomistic Conformational Ensemble Resolver. It’s a graph neural network that operates entirely at the atomic level to generate conformational ensembles of protein-ligand complexes.

Why Use PLACER?

Ensemble predictions: Generates multiple conformations to capture binding uncertainty
All-atom accuracy: Operates at atomic level for precise interactions
Side chain flexibility: Predicts side chain conformations alongside ligand poses
Confidence scores: Multiple metrics for ranking and validating predictions

Related Tools: For protein-protein docking, see DiffDock-PP. For structure prediction of complexes, see Chai-1 or Boltz-2.

Resource Requirements

Resource	Minimum	Recommended	Notes
GPU RAM	8 GB	16 GB	1-3 sec/model on GPU
CPU RAM	16 GB	32 GB	~1 min/model on 8 cores
Disk Space	2 GB	5 GB	Model weights included
Python	3.9+	3.10	Required

Performance:

GPU: 1-3 seconds per model
CPU (8 cores): ~1 minute per model
Ligands with many symmetric groups take longer

Preparation

Mark as complete

Prerequisites:

Completed HPC Setup guide
Conda/Mamba installed
GPU recommended for reasonable throughput

Installation

Mark as complete

Clone the repository:

git clone https://github.com/baker-laboratory/PLACER.git
cd PLACER

The repository includes model weights - no separate download needed.

Create the conda environment from the provided file:

mamba env create -f envs/placer_env.yml

Activate the environment:

mamba activate placer_env

Testing the Installation

Mark as complete

Run a simple heme docking prediction:

python run_PLACER.py \
    --ifile examples/inputs/dnHEM1.pdb \
    --odir test_output \
    --rerank prmsd \
    -n 10 \
    --ligand_file HEM:examples/ligands/HEM.mol2

Success indicators:

Command completes without errors
test_output/ directory is created
Contains ranked PDB files of docked complexes

Expected runtime: 30-60 seconds on GPU, 10-15 minutes on CPU.

HPC Job Script

#!/bin/bash
#SBATCH --job-name=placer
#SBATCH --partition=gpu
#SBATCH --gpus=1
#SBATCH --cpus-per-task=8
#SBATCH --mem=32G
#SBATCH --time=04:00:00
#SBATCH --output=%x_%j.out

module load cuda/12.1

# source ~/.bashrc
mamba activate placer_env

cd /path/to/PLACER

# Predict ligand binding with 100 samples
python run_PLACER.py \
    --ifile my_complex.pdb \
    --odir results/ \
    --predict_ligand LIG-501 \
    --rerank prmsd \
    -n 100 \
    --ligand_file LIG:ligand.sdf

Usage Examples

Basic ligand docking:

python run_PLACER.py \
    -f INPUT.pdb \
    -o OUTPUT_DIR \
    -n 50

Ligand docking with cofactor fixed:

python run_PLACER.py \
    --ifile 4dtz.cif \
    --odir output/ \
    --predict_ligand D-LDP-501 \
    --fixed_ligand C-HEM-500 \
    -n 100 \
    --rerank prmsd

Side chain prediction (apo mode, no ligand):

python run_PLACER.py \
    --ifile protein.pdb \
    --odir output/ \
    --target_res A-149 \
    -n 50 \
    --no-use_sm

Multiple ligands simultaneously:

python run_PLACER.py \
    --ifile complex.pdb \
    --odir output/ \
    --predict_multi \
    --predict_ligand LIG1 LIG2 \
    -n 100

Key Parameters

Parameter	Description
`-f` or `--ifile`	Input PDB/mmCIF file
`-o` or `--odir`	Output directory
`-n` or `--nsamples`	Number of ensemble samples (50-100 recommended)
`--rerank`	Rank by confidence: `prmsd`, `plddt`, or `plddt_pde`
`--predict_ligand`	Specify which ligand(s) to predict
`--fixed_ligand`	Keep certain ligands fixed in place
`--ligand_file`	Provide SDF/MOL2 for correct atom typing
`--target_res`	Specific residue(s) for side chain prediction
`--no-use_sm`	Apo mode - predict without small molecules

Understanding Confidence Scores

PLACER provides multiple confidence metrics:

Metric	Description	Good Values
prmsd	Predicted RMSD to true pose	<2.0 Å (excellent), <4.0 Å (acceptable)
plddt	Per-residue confidence (1D track)	>0.8
plddt_pde	Per-residue confidence (2D track)	>0.8
fape	All-atom FAPE loss	Lower is better
rmsd	Actual RMSD to reference (if available)	<2.0 Å
kabsch	Superimposed RMSD	Measures conformation accuracy

Recommendation: Use --rerank prmsd for docking tasks.

Python API

PLACER can be imported as a Python module:

import sys
sys.path.append("/path/to/PLACER")
import PLACER

# Load model
placer = PLACER.PLACER()

# Set up input
pl_input = PLACER.PLACERinput()
pl_input.pdb("complex.pdb")
pl_input.name("my_prediction")
pl_input.ligand_reference({"HEM": "heme.mol2"})

# Run 50 predictions
outputs = placer.run(pl_input, 50)

# Access results
for out in outputs:
    print(f"pRMSD: {out.prmsd:.2f}, pLDDT: {out.plddt:.2f}")

Understanding the Output

Output directory structure:

output/
├── ranked_0.pdb          # Best pose by confidence
├── ranked_1.pdb          # Second best
├── ranked_2.pdb          # ...
├── scores.csv            # All confidence metrics
└── ensemble/             # All generated samples

Interpreting ensemble results:

Multiple similar poses = high confidence
Diverse poses = uncertain binding mode
Compare top-ranked poses to assess convergence

Input Format Requirements

Ligand must be in input structure:

PLACER requires the ligand to be present in the PDB
SMILES-only input is not supported
Use --ligand_file to provide correct bonding information

Ligand file formats:

SDF files: Best for drug-like molecules
MOL2 files: Good for cofactors
Helps with: aromatic rings, stereochemistry, bond orders

Troubleshooting

Common Issues

Non-planar aromatic rings:

Provide SDF/MOL2 file with --ligand_file
This ensures correct bonding information

Missing ligands in PDB:

Ligands must be in the input structure
SMILES-only input is not currently supported

Custom/non-canonical residues:

python run_PLACER.py \
    --ifile input.pdb \
    --residue_json custom_residues.json \
    --odir output/

Slow predictions:

Symmetric ligands (many equivalent atoms) are slower
Use GPU for production runs
Reduce -n for initial testing

Out of memory:

PLACER is generally memory-efficient
If issues persist, try reducing ensemble size
Or use CPU with multiple cores