Struct SASAOptions 

pub struct SASAOptions<T> { /* private fields */ }

Options for configuring SASA (Solvent Accessible Surface Area) calculations.

This struct provides configuration options for SASA calculations at different levels of granularity (atom, residue, chain, or protein level). The type parameter T determines the output type and processing behavior.

Type Parameters

• T - The processing level, which must implement SASAProcessor. Available levels:
  • AtomLevel - Returns SASA values for individual atoms
  • ResidueLevel - Returns SASA values aggregated by residue
  • ChainLevel - Returns SASA values aggregated by chain
  • ProteinLevel - Returns SASA values aggregated for the entire protein

Fields

• probe_radius - Radius of the solvent probe sphere in Angstroms (default: 1.4)
• n_points - Number of points on the sphere surface for sampling (default: 100)
• parallel - Whether to use parallel processing (default: true)

Examples

use rust_sasa::options::{SASAOptions, ResidueLevel};
use pdbtbx::PDB;

// Create options with default settings
let options = SASAOptions::<ResidueLevel>::new();

// Customize the configuration
let custom_options = SASAOptions::<ResidueLevel>::new()
    .with_probe_radius(1.2)
    .with_n_points(200)
    .with_parallel(true);

// Process a PDB structure
let result = custom_options.process(&pdb)?;

Implementations

impl<T> SASAOptions<T>

pub fn new() -> SASAOptions<T>

Create a new SASAOptions with the specified level type

pub fn with_probe_radius(self, radius: f32) -> Self

Set the probe radius (default: 1.4 Angstroms)

pub fn with_n_points(self, points: usize) -> Self

Set the number of points on the sphere for sampling (default: 100)

pub fn with_parallel(self, parallel: bool) -> Self

Enable or disable parallel processing (default: true)

impl SASAOptions<AtomLevel>

pub fn atom_level() -> Self

impl SASAOptions<ResidueLevel>

pub fn residue_level() -> Self

impl SASAOptions<ChainLevel>

pub fn chain_level() -> Self

impl SASAOptions<ProteinLevel>

pub fn protein_level() -> Self

impl<T: SASAProcessor> SASAOptions<T>

pub fn process(&self, pdb: &PDB) -> Result<T::Output, SASACalcError>

This function calculates the SASA for a given protein. The output type is determined by the level type parameter. Probe radius and n_points can be customized, defaulting to 1.4 and 100 respectively. If you want more fine-grained control you may want to use calculate_sasa_internal instead.

Example

use pdbtbx::StrictnessLevel;
use rust_sasa::options::{SASAOptions, ResidueLevel};
let (mut pdb, _errors) = pdbtbx::open("./pdbs/example.cif").unwrap();
let result = SASAOptions::<ResidueLevel>::new().process(&pdb);

Trait Implementations

impl<T: Clone> Clone for SASAOptions<T>

fn clone(&self) -> SASAOptions<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for SASAOptions<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SASAOptions<ResidueLevel>

fn default() -> Self

Returns the “default value” for a type.