# Spicoli TK

> Molecular surface generation and analysis toolkit for creating and manipulating triangulated surfaces from molecules and grids

## Links
- [Full Documentation](https://docs.eyesopen.com/toolkits/python/spicolitk/index.html)
- [Theory](https://docs.eyesopen.com/toolkits/python/spicolitk/theory.html)
- [API Reference](https://docs.eyesopen.com/toolkits/python/spicolitk/api.html)
- [Code Examples](https://docs.eyesopen.com/toolkits/python/spicolitk/selected_examples_python.html)

## Core API - Function Quick Reference

### Surface Generation

**OEMakeAccessibleSurface(surf: OESurface, mol: OEMolBase, probeRadius: float = 1.4) -> bool**
  Use for: Creating solvent-accessible surfaces (SAS) from molecules
  Example: `OEMakeAccessibleSurface(surf, mol, 1.4)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEMakeAccessibleSurface.html

**OEMakeMolecularSurface(surf: OESurface, mol: OEMolBase, probeRadius: float = 1.4) -> bool**
  Use for: Creating molecular surfaces (solvent-excluded surfaces/SES) from molecules
  Example: `OEMakeMolecularSurface(surf, mol, 1.4)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEMakeMolecularSurface.html

**OEMakeSurfaceFromGrid(surf: OESurface, grid: OEScalarGrid, isovalue: float) -> bool**
  Use for: Creating isosurface from grid data at specified contour level
  Example: `OEMakeSurfaceFromGrid(surf, grid, 0.5)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEMakeSurfaceFromGrid.html

**OEMakeCavitySurfaces(surfList: OESurfaceList, mol: OEMolBase, probeRadius: float = 1.4) -> bool**
  Use for: Detecting and generating surfaces for molecular cavities/pockets
  Example: `OEMakeCavitySurfaces(surfList, protein, 1.4)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEMakeCavitySurfaces.html

**OEMakeProteinRibbonSurface(surf: OESurface, mol: OEMolBase, ribbonType: unsigned int) -> bool**
  Use for: Creating protein ribbon/cartoon representations as surfaces
  Example: `OEMakeProteinRibbonSurface(surf, protein, OERibbonType_Cartoon)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEMakeProteinRibbonSurface.html

### Geometric Primitives

**OEMakeSphericalSurface(surf: OESurface, center: float*, radius: float, resolution: int = 2) -> bool**
  Use for: Creating spherical surfaces for visualization or analysis
  Example: `OEMakeSphericalSurface(surf, [0,0,0], 5.0, 3)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEMakeSphericalSurface.html

**OEMakeBoxSurface(surf: OESurface, minCorner: float*, maxCorner: float*) -> bool**
  Use for: Creating box surfaces for bounding regions
  Example: `OEMakeBoxSurface(surf, [-10,-10,-10], [10,10,10])`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEMakeBoxSurface.html

**OEMakeEllipsoidSurface(surf: OESurface, center: float*, radii: float*, resolution: int = 2) -> bool**
  Use for: Creating ellipsoidal surfaces with different radii per axis
  Example: `OEMakeEllipsoidSurface(surf, [0,0,0], [2,3,4], 2)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEMakeEllipsoidSurface.html

### Surface Analysis

**OESurfaceArea(surf: OESurface) -> float**
  Use for: Calculating total surface area of triangulated surface
  Example: `area = OESurfaceArea(surf)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OESurfaceArea.html

**OESurfaceVolume(surf: OESurface) -> float**
  Use for: Calculating enclosed volume of closed surface
  Example: `volume = OESurfaceVolume(surf)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OESurfaceVolume.html

**OECalculateSurfaceCurvature(surf: OESurface) -> bool**
  Use for: Computing mean and Gaussian curvature at each vertex
  Example: `OECalculateSurfaceCurvature(surf)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OECalculateSurfaceCurvature.html

**OESurfaceToMoleculeDistance(surf: OESurface, mol: OEMolBase) -> float**
  Use for: Finding minimum distance between surface and molecule atoms
  Example: `dist = OESurfaceToMoleculeDistance(surf, ligand)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OESurfaceToMoleculeDistance.html

### Surface Manipulation

**OESplitSurfaceByAtoms(surfList: OESurfaceList, surf: OESurface, mol: OEMolBase) -> bool**
  Use for: Splitting surface into per-atom patches based on closest atom
  Example: `OESplitSurfaceByAtoms(surfList, surf, mol)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OESplitSurfaceByAtoms.html

**OEMakeConnectedSurfaceCliques(surf: OESurface) -> unsigned int**
  Use for: Identifying disconnected surface components/islands
  Example: `numCliques = OEMakeConnectedSurfaceCliques(surf)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEMakeConnectedSurfaceCliques.html

**OEReduceSurface(surf: OESurface, reductionType: unsigned int, targetTriangles: unsigned int) -> bool**
  Use for: Simplifying surface by reducing triangle count
  Example: `OEReduceSurface(surf, OEEdgeReductionType_Default, 5000)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEReduceSurface.html

**OEAddSurfaces(destSurf: OESurface, srcSurf: OESurface) -> bool**
  Use for: Combining multiple surfaces into single surface object
  Example: `OEAddSurfaces(combinedSurf, surf1)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEAddSurfaces.html

### Surface Properties

**OECalculateNormals(surf: OESurface) -> bool**
  Use for: Computing vertex normal vectors for smooth shading
  Example: `OECalculateNormals(surf)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OECalculateNormals.html

**OECalculateSurfacePotentials(surf: OESurface, mol: OEMolBase) -> bool**
  Use for: Computing electrostatic potential at surface vertices
  Example: `OECalculateSurfacePotentials(surf, mol)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OECalculateSurfacePotentials.html

**OESetSurfaceColor(surf: OESurface, r: float, g: float, b: float, a: float = 1.0) -> bool**
  Use for: Setting uniform color for entire surface
  Example: `OESetSurfaceColor(surf, 1.0, 0.0, 0.0, 0.8)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OESetSurfaceColor.html

**OEColorSurfaceByPotential(surf: OESurface, minPot: float, maxPot: float) -> bool**
  Use for: Coloring surface by electrostatic potential values
  Example: `OEColorSurfaceByPotential(surf, -10.0, 10.0)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEColorSurfaceByPotential.html

### File I/O

**OEReadSurface(filename: str, surf: OESurface) -> bool**
  Use for: Loading surface from file (supports multiple formats)
  Example: `OEReadSurface("protein.oesrf", surf)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEReadSurface.html

**OEWriteSurface(filename: str, surf: OESurface) -> bool**
  Use for: Saving surface to file (format auto-detected from extension)
  Example: `OEWriteSurface("output.oesrf", surf)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEWriteSurface.html

**OEGetSurface(mol: OEMolBase, surf: OESurface) -> bool**
  Use for: Extracting surface stored in molecule's generic data
  Example: `OEGetSurface(mol, surf)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEGetSurface.html

**OESetSurface(mol: OEMolBase, surf: OESurface) -> bool**
  Use for: Attaching surface to molecule as generic data
  Example: `OESetSurface(mol, surf)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OESetSurface.html

### Grid Conversion

**OEMakeGridFromSurface(grid: OEScalarGrid, surf: OESurface, method: unsigned int) -> bool**
  Use for: Converting surface to grid representation (voxelization)
  Example: `OEMakeGridFromSurface(grid, surf, OEVoxelizeMethod_Default)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEMakeGridFromSurface.html

**OEMakeBitGridFromSurface(grid: OEBitGrid, surf: OESurface) -> bool**
  Use for: Creating binary grid marking interior/exterior regions
  Example: `OEMakeBitGridFromSurface(grid, surf)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OEMakeBitGridFromSurface.html

### Transformation

**OETranslateSurface(surf: OESurface, dx: float, dy: float, dz: float) -> bool**
  Use for: Moving surface by translation vector
  Example: `OETranslateSurface(surf, 5.0, 0.0, 0.0)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OETranslateSurface.html

**OERotateSurface(surf: OESurface, rotMatrix: float*) -> bool**
  Use for: Rotating surface using 3x3 rotation matrix
  Example: `OERotateSurface(surf, rotMatrix)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OERotateSurface.html

**OETransformSurface(surf: OESurface, transform: float*) -> bool**
  Use for: Applying 4x4 transformation matrix to surface
  Example: `OETransformSurface(surf, transformMatrix)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OETransformSurface.html

### Clique Operations

**OESurfaceCliqueArea(surf: OESurface, cliqueIdx: unsigned int) -> float**
  Use for: Calculating area of specific disconnected surface component
  Example: `area = OESurfaceCliqueArea(surf, 0)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OESurfaceCliqueArea.html

**OESurfaceCliqueVolume(surf: OESurface, cliqueIdx: unsigned int) -> float**
  Use for: Calculating volume of specific surface component
  Example: `volume = OESurfaceCliqueVolume(surf, 0)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OESurfaceCliqueVolume.html

**OESurfaceCliqueCentroid(surf: OESurface, cliqueIdx: unsigned int, centroid: float*) -> bool**
  Use for: Finding geometric center of surface component
  Example: `OESurfaceCliqueCentroid(surf, 0, centroid)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OESurfaceCliqueCentroid.html

**OESurfaceCropToClique(surf: OESurface, cliqueIdx: unsigned int) -> bool**
  Use for: Removing all surface components except specified one
  Example: `OESurfaceCropToClique(surf, 0)`
  See: https://docs.eyesopen.com/toolkits/python/spicolitk/OESpicoliFunctions/OESurfaceCropToClique.html

## Common Patterns - Complete Working Examples

### Pattern: Generate Molecular Surface from Protein

```python
from openeye import oechem, oespicoli

ifs = oechem.oemolistream("protein.pdb")
mol = oechem.OEGraphMol()
oechem.OEReadMolecule(ifs, mol)

surf = oespicoli.OESurface()
oespicoli.OEMakeMolecularSurface(surf, mol, 1.4)

ofs = oechem.oemolostreamstream("protein_surface.oesrf")
oespicoli.OEWriteSurface(ofs, surf)
```
Use when: You need to create a solvent-excluded surface (SES) for visualization or analysis of protein structure

### Pattern: Calculate Solvent Accessible Surface Area

```python
from openeye import oechem, oespicoli

mol = oechem.OEGraphMol()
oechem.OESmilesToMol(mol, "c1ccccc1")
oechem.OEAddExplicitHydrogens(mol)

surf = oespicoli.OESurface()
oespicoli.OEMakeAccessibleSurface(surf, mol, 1.4)

sasa = oespicoli.OESurfaceArea(surf)
print(f"SASA: {sasa:.2f} Ų")
```
Use when: You need to calculate solvent accessible surface area (SASA) for molecules, commonly used in protein-ligand binding analysis

### Pattern: Detect and Analyze Protein Cavities

```python
from openeye import oechem, oespicoli

protein = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("protein.pdb"), protein)

surfList = []
oespicoli.OEMakeCavitySurfaces(surfList, protein, 1.4)

for i, cavSurf in enumerate(surfList):
    volume = oespicoli.OESurfaceVolume(cavSurf)
    area = oespicoli.OESurfaceArea(cavSurf)
    print(f"Cavity {i}: Volume={volume:.1f} ų, Area={area:.1f} Ų")
```
Use when: You need to identify and characterize binding pockets or cavities in protein structures

### Pattern: Color Surface by Electrostatic Potential

```python
from openeye import oechem, oespicoli

mol = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("molecule.mol2"), mol)

surf = oespicoli.OESurface()
oespicoli.OEMakeMolecularSurface(surf, mol, 1.4)
oespicoli.OECalculateSurfacePotentials(surf, mol)
oespicoli.OEColorSurfaceByPotential(surf, -10.0, 10.0)

oespicoli.OEWriteSurface("colored_surface.oesrf", surf)
```
Use when: You want to visualize electrostatic properties on molecular surfaces for drug design or interaction analysis

### Pattern: Split Surface into Per-Atom Patches

```python
from openeye import oechem, oespicoli

mol = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("ligand.mol2"), mol)

surf = oespicoli.OESurface()
oespicoli.OEMakeAccessibleSurface(surf, mol, 1.4)

atomSurfs = []
oespicoli.OESplitSurfaceByAtoms(atomSurfs, surf, mol)

for atom, atomSurf in zip(mol.GetAtoms(), atomSurfs):
    area = oespicoli.OESurfaceArea(atomSurf)
    print(f"Atom {atom.GetIdx()}: {area:.2f} Ų")
```
Use when: You need to calculate per-atom surface areas or analyze surface contributions from individual atoms

### Pattern: Create Isosurface from Grid Data

```python
from openeye import oechem, oegrid, oespicoli

grid = oegrid.OEScalarGrid()
# ... populate grid with data ...

surf = oespicoli.OESurface()
isovalue = 0.5
oespicoli.OEMakeSurfaceFromGrid(surf, grid, isovalue)

oespicoli.OECalculateNormals(surf)
oespicoli.OEWriteSurface("isosurface.oesrf", surf)
```
Use when: You need to visualize 3D scalar field data (electron density, molecular orbitals, etc.) as contour surfaces

### Pattern: Reduce Surface Triangle Count

```python
from openeye import oechem, oespicoli

surf = oespicoli.OESurface()
oespicoli.OEReadSurface("high_res_surface.oesrf", surf)

originalTriangles = surf.NumTriangles()
targetTriangles = 5000

oespicoli.OEReduceSurface(surf, oespicoli.OEEdgeReductionType_Default, targetTriangles)

print(f"Reduced from {originalTriangles} to {surf.NumTriangles()} triangles")
oespicoli.OEWriteSurface("reduced_surface.oesrf", surf)
```
Use when: You need to simplify surfaces for faster rendering or reduced file sizes while maintaining shape

### Pattern: Combine Multiple Surfaces

```python
from openeye import oechem, oespicoli

protein = oechem.OEGraphMol()
ligand = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("protein.pdb"), protein)
oechem.OEReadMolecule(oechem.oemolistream("ligand.mol2"), ligand)

protSurf = oespicoli.OESurface()
ligSurf = oespicoli.OESurface()
oespicoli.OEMakeMolecularSurface(protSurf, protein, 1.4)
oespicoli.OEMakeMolecularSurface(ligSurf, ligand, 1.4)

combinedSurf = oespicoli.OESurface(protSurf)
oespicoli.OEAddSurfaces(combinedSurf, ligSurf)
oespicoli.OEWriteSurface("complex_surface.oesrf", combinedSurf)
```
Use when: You need to create a single surface representation of a multi-component system (protein-ligand complex)

### Pattern: Analyze Disconnected Surface Components

```python
from openeye import oechem, oespicoli

surf = oespicoli.OESurface()
oespicoli.OEReadSurface("surface.oesrf", surf)

numCliques = oespicoli.OEMakeConnectedSurfaceCliques(surf)
print(f"Found {numCliques} disconnected components")

for i in range(numCliques):
    area = oespicoli.OESurfaceCliqueArea(surf, i)
    volume = oespicoli.OESurfaceCliqueVolume(surf, i)
    print(f"Component {i}: Area={area:.1f}, Volume={volume:.1f}")
```
Use when: You need to identify and analyze separate surface regions (e.g., multiple binding sites or surface islands)

### Pattern: Store Surface with Molecule

```python
from openeye import oechem, oespicoli

mol = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("molecule.mol2"), mol)

surf = oespicoli.OESurface()
oespicoli.OEMakeMolecularSurface(surf, mol, 1.4)

oespicoli.OESetSurface(mol, surf)
oechem.OEWriteMolecule(oechem.oemolostreamstream("mol_with_surf.oeb"), mol)

# Later retrieve surface
retrievedSurf = oespicoli.OESurface()
oespicoli.OEGetSurface(mol, retrievedSurf)
```
Use when: You want to bundle surface data with molecule for convenient storage and retrieval in OEB format

### Pattern: Convert Surface to Grid Representation

```python
from openeye import oechem, oegrid, oespicoli

surf = oespicoli.OESurface()
oespicoli.OEReadSurface("surface.oesrf", surf)

grid = oegrid.OEScalarGrid()
spacing = 0.5
oespicoli.OEMakeGridFromSurface(grid, surf, oespicoli.OEVoxelizeMethod_Default)

# Grid now contains voxelized representation
print(f"Grid dimensions: {grid.GetXDim()} x {grid.GetYDim()} x {grid.GetZDim()}")
```
Use when: You need to convert surface to volumetric grid for further analysis or different algorithms

### Pattern: Calculate Surface Curvature

```python
from openeye import oechem, oespicoli

mol = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("protein.pdb"), mol)

surf = oespicoli.OESurface()
oespicoli.OEMakeMolecularSurface(surf, mol, 1.4)

oespicoli.OECalculateSurfaceCurvature(surf)

# Curvature values now stored at vertices
# Can be used for coloring or analysis
for vertex in surf.GetVertices():
    meanCurv = vertex.GetMeanCurvature()
    gaussCurv = vertex.GetGaussianCurvature()
```
Use when: You need to analyze surface shape characteristics for identifying binding sites or surface features

### Pattern: Create Protein Ribbon Surface

```python
from openeye import oechem, oespicoli

protein = oechem.OEGraphMol()
oechem.OEReadMolecule(oechem.oemolistream("protein.pdb"), protein)

ribbonSurf = oespicoli.OESurface()
oespicoli.OEMakeProteinRibbonSurface(ribbonSurf, protein, oespicoli.OERibbonType_Cartoon)

oespicoli.OECalculateNormals(ribbonSurf)
oespicoli.OEWriteSurface("ribbon.oesrf", ribbonSurf)
```
Use when: You want to create cartoon/ribbon representations of protein secondary structure as surfaces

### Pattern: Transform Surface Coordinates

```python
from openeye import oechem, oespicoli
import math

surf = oespicoli.OESurface()
oespicoli.OEReadSurface("surface.oesrf", surf)

# Translate surface
oespicoli.OETranslateSurface(surf, 10.0, 0.0, 0.0)

# Rotate 90 degrees around Z-axis
angle = math.pi / 2
rotMatrix = [math.cos(angle), -math.sin(angle), 0,
             math.sin(angle), math.cos(angle), 0,
             0, 0, 1]
oespicoli.OERotateSurface(surf, rotMatrix)

oespicoli.OEWriteSurface("transformed.oesrf", surf)
```
Use when: You need to align or reposition surfaces for comparison or visualization

## API Decision Guide

### Surface Type Selection
- For **solvent accessible surface (SAS)**: use `OEMakeAccessibleSurface` (probe rolls on van der Waals surface)
- For **molecular surface (SES)**: use `OEMakeMolecularSurface` (solvent-excluded, more detailed)
- For **cavity detection**: use `OEMakeCavitySurfaces` (automatically finds pockets)
- For **grid isosurfaces**: use `OEMakeSurfaceFromGrid` (contour surfaces from 3D data)
- For **protein visualization**: use `OEMakeProteinRibbonSurface` (cartoon/ribbon representations)

### Surface Analysis Tasks
- For **total surface area**: use `OESurfaceArea` (single value for entire surface)
- For **per-atom areas**: use `OESplitSurfaceByAtoms` then `OESurfaceArea` on each patch
- For **enclosed volume**: use `OESurfaceVolume` (requires closed surface)
- For **shape analysis**: use `OECalculateSurfaceCurvature` (mean and Gaussian curvature)
- For **distance calculations**: use `OESurfaceToMoleculeDistance` (closest approach)

### Surface Modification
- For **simplification**: use `OEReduceSurface` (reduce triangle count while preserving shape)
- For **combining surfaces**: use `OEAddSurfaces` (merge multiple surfaces into one)
- For **extracting components**: use `OEMakeConnectedSurfaceCliques` then `OESurfaceCropToClique`
- For **smooth appearance**: use `OECalculateNormals` (compute vertex normals for shading)

### Coloring and Properties
- For **uniform color**: use `OESetSurfaceColor` (single RGBA color)
- For **electrostatic coloring**: use `OECalculateSurfacePotentials` then `OEColorSurfaceByPotential`
- For **custom properties**: use `OESetSurfacePotentials` (arbitrary per-vertex values)

### File I/O
- For **reading surfaces**: use `OEReadSurface` (auto-detects format: .oesrf, .stl, .obj, .ply)
- For **writing surfaces**: use `OEWriteSurface` (format from extension)
- For **bundling with molecules**: use `OESetSurface`/`OEGetSurface` (store in OEB format)
- For **format checking**: use `OEGetSurfaceFileType` (identify file format)

### Grid Conversion
- For **surface to grid**: use `OEMakeGridFromSurface` (voxelization)
- For **binary occupancy**: use `OEMakeBitGridFromSurface` (inside/outside only)
- For **grid to surface**: use `OEMakeSurfaceFromGrid` (isosurface extraction)

### Probe Radius Selection
- For **standard SASA**: use 1.4 Å (water probe radius)
- For **larger cavities**: use 2.0-3.0 Å (detect bigger pockets)
- For **tight crevices**: use 1.0 Å or less (find small gaps)

## Common Parameters & Types

**OESurface**: Core surface object containing triangulated mesh
  - Create with: `surf = oespicoli.OESurface()` (empty) or `oespicoli.OESurface(otherSurf)` (copy)
  - Common in: All surface generation and manipulation functions
  - Access data: `surf.GetVertices()`, `surf.GetTriangles()`, `surf.NumVertices()`, `surf.NumTriangles()`
  - Gotcha: Surfaces must be closed (no holes) for volume calculations to be meaningful

**probeRadius (float)**: Radius of spherical probe for surface generation
  - Typical values: 1.4 Å (water), 1.0 Å (small probe), 2.0-3.0 Å (large cavities)
  - Common in: `OEMakeAccessibleSurface`, `OEMakeMolecularSurface`, `OEMakeCavitySurfaces`
  - Effect: Larger probes smooth surfaces and miss small crevices; smaller probes capture more detail
  - Gotcha: Probe radius affects both surface area and volume significantly

**OEMolBase**: Molecule object from OEChem containing atoms and coordinates
  - Create with: `mol = oechem.OEGraphMol()` then read from file or build
  - Common in: All molecular