Enum ForgeError 

pub enum ForgeError {
    ParameterParse(Error),
    RuleParse(String),
    AtomTyping(String),
    ChargeCalculation(String),
    MissingBioMetadata,
    HybridChargeAssignment {
        chain_id: String,
        residue_id: i32,
        residue_name: String,
        detail: String,
    },
    MissingParameter {
        atom_type: String,
        detail: String,
    },
    InvalidBond {
        i: usize,
        j: usize,
        detail: String,
    },
    EmptySystem,
    Conversion(String),
}

Errors that can occur during DREIDING parameterization.

This enum covers all failure modes when running the forge function, including configuration parsing, atom typing, charge calculation, and parameter lookup failures.

Variants

ParameterParse(Error)

Failed to parse force field parameters TOML.

RuleParse(String)

Failed to parse custom atom typing rules.

AtomTyping(String)

Atom typing assignment failed.

Occurs when the molecular graph cannot be typed due to unsupported elements, unusual bonding patterns, or rule matching failures.

ChargeCalculation(String)

Charge calculation failed.

Occurs when the QEq solver fails to converge or encounters invalid input data.

MissingBioMetadata

Hybrid charge method requires biological metadata.

Occurs when ChargeMethod::Hybrid is selected but the input system has no BioMetadata.

HybridChargeAssignment

Hybrid charge assignment failed for a specific residue.

Fields

chain_id: String

Chain identifier.

residue_id: i32

Residue sequence number.

residue_name: String

Residue name.

detail: String

Description of the problem.

MissingParameter

Required force field parameter not found.

Occurs when an atom type is assigned but no corresponding parameters exist in the force field parameter file.

Fields

atom_type: String

The atom type that is missing parameters.

detail: String

Description of which parameter is missing.

InvalidBond

Invalid bond definition in the input system.

Fields

i: usize

First atom index.

j: usize

Second atom index.

detail: String

Description of the problem.

EmptySystem

The input system contains no atoms.

Conversion(String)

Internal data conversion error.

Implementations

impl Error

pub fn hybrid_charge_assignment( chain_id: impl Into<String>, residue_id: i32, residue_name: &str, details: impl Into<String>, ) -> Self

Creates a HybridChargeAssignment error.

Arguments

• chain_id — Chain identifier
• residue_id — Residue sequence number
• residue_name — Residue name
• details — Description of the problem

Returns

A HybridChargeAssignment error variant.

pub fn missing_parameter(atom_type: &str, details: impl Into<String>) -> Self

Creates a MissingParameter error.

Arguments

• atom_type — The atom type that is missing parameters
• details — Description of which parameter is missing

Returns

A MissingParameter error variant.

pub fn invalid_bond(i: usize, j: usize, details: impl Into<String>) -> Self

Creates an InvalidBond error.

Arguments

• i — First atom index
• j — Second atom index
• details — Description of the bond problem

Returns

An InvalidBond error variant.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<CheqError> for Error

fn from(e: CheqError) -> Self

Converts to this type from the input type.

impl From<Error> for Error

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<TyperError> for Error

fn from(e: TyperError) -> Self

Converts to this type from the input type.