Struct OpairPSM 

#[non_exhaustive]
pub struct OpairPSM {

    pub raw_file: PathBuf,
    pub scan_number: usize,
    pub rt: Time,
    pub precursor_scan_number: usize,
    pub mz: MassOverCharge,
    pub z: Charge,
    pub mass: Mass,
    pub protein_location: Option<Range<u16>>,
    pub flanking_residues: (FlankingSequence, FlankingSequence),
    pub peptide: Peptidoform<SemiAmbiguous>,
    pub mod_number: u8,
    pub theoretical_mass: Mass,
    pub score: f64,
    pub rank: u32,
    pub matched_ion_series: Box<str>,
    pub matched_ion_mz_ratios: Box<str>,
    pub matched_ion_intensities: Box<str>,
    pub matched_ion_mass_error: Box<str>,
    pub matched_ion_ppm: Box<str>,
    pub matched_ion_counts: Box<str>,
    pub q_value: f64,
    pub pep: f64,
    pub pep_q_value: f64,
    pub localisation_score: f64,
    pub yion_score: f64,
    pub diagnostic_ion_score: f64,
    pub plausible_glycan_number: u8,
    pub total_glycosylation_sites: u8,
    pub glycan_mass: Mass,
    pub plausible_glycan_composition: Box<str>,
    pub n_glycan_motif: bool,
    pub r138_144: f64,
    pub plausible_glycan_structure: Box<str>,
    pub glycan_localisation_level: Box<str>,
    pub glycan_peptide_site_specificity: Box<str>,
    pub glycan_protein_site_specificity: Box<str>,
    pub all_potential_glycan_localisations: Box<str>,
    pub all_site_specific_localisation_probabilities: Box<str>,
    pub version: OpairVersion,
    pub accession: Arc<<OpairPSM as PSMMetaData>::Protein>,
    /* private fields */
}

The data for individual entries in Opair files.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

raw_file: PathBuf

scan_number: usize

rt: Time

precursor_scan_number: usize

mz: MassOverCharge

z: Charge

mass: Mass

protein_location: Option<Range<u16>>

flanking_residues: (FlankingSequence, FlankingSequence)

peptide: Peptidoform<SemiAmbiguous>

mod_number: u8

theoretical_mass: Mass

score: f64

rank: u32

matched_ion_series: Box<str>

matched_ion_mz_ratios: Box<str>

matched_ion_intensities: Box<str>

matched_ion_mass_error: Box<str>

matched_ion_ppm: Box<str>

matched_ion_counts: Box<str>

q_value: f64

pep: f64

pep_q_value: f64

localisation_score: f64

yion_score: f64

diagnostic_ion_score: f64

plausible_glycan_number: u8

total_glycosylation_sites: u8

glycan_mass: Mass

plausible_glycan_composition: Box<str>

n_glycan_motif: bool

r138_144: f64

plausible_glycan_structure: Box<str>

glycan_localisation_level: Box<str>

glycan_peptide_site_specificity: Box<str>

glycan_protein_site_specificity: Box<str>

all_potential_glycan_localisations: Box<str>

all_site_specific_localisation_probabilities: Box<str>

version: OpairVersion

The version used to read in the data

accession: Arc<<OpairPSM as PSMMetaData>::Protein>

Implementations

impl OpairPSM

pub fn full_csv_line(&self) -> Option<&[(Arc<String>, String)]>

Get all original columns from the CSV file, only available if the file was opened with the option keep_all_columns turned on.

Trait Implementations

impl Clone for OpairPSM

fn clone(&self) -> OpairPSM

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OpairPSM

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

Formats the value using the given formatter.

impl Default for OpairPSM

fn default() -> OpairPSM

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OpairPSM

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<OpairPSM> for PSM<SemiAmbiguous, PeptidoformPresent>

fn from(value: OpairPSM) -> Self

Converts to this type from the input type.

impl PSMMetaData for OpairPSM

type Protein = OpairProtein

The linked protein type

type SpectrumOutputMode = OutputMolecularFormula

What mode is the spectrum stored in

fn peptidoform_ion_set(&self) -> Option<Cow<'_, PeptidoformIonSet>>

Get the peptidoform ion set, if present

fn format(&self) -> KnownFileFormat

Get the format and version for this peptidoform

fn numerical_id(&self) -> Option<usize>

Get the numerical PSM identifier

fn id(&self) -> String

Get the PSM identifier

fn search_engine(&self) -> Option<Term>

Get the search engine that identified this PSM

fn confidence(&self) -> Option<f64>

Get the normalised confidence, a score between -1 and 1 describing the confidence in the entire PSM

fn local_confidence(&self) -> Option<Cow<'_, [f64]>>

Get the normalised local confidence, a score between -1 and 1 for each amino acid in the peptide

fn original_confidence(&self) -> Option<(f64, Term)>

Get the original confidence and the term identifying the type of original confidence

fn original_local_confidence(&self) -> Option<&[f64]>

Get the original local confidence, a score for each amino acid in the peptide

fn charge(&self) -> Option<Charge>

The charge of the precursor/PSM, if known

fn mode(&self) -> Option<Cow<'_, str>>

Which fragmentation mode was used, if known

fn retention_time(&self) -> Option<Time>

The retention time, if known

fn scans(&self) -> SpectrumIds

The scans per rawfile that are at the basis for this PSM

fn experimental_mz(&self) -> Option<MassOverCharge>

Get the mz as experimentally determined

fn experimental_mass(&self) -> Option<Mass>

Get the mass as experimentally determined

fn proteins(&self) -> Cow<'_, [Self::Protein]>

Get the linked protein

fn protein_location(&self) -> Option<Range<u16>>

Get the protein location if this was database matched data

fn flanking_sequences(&self) -> (&FlankingSequence, &FlankingSequence)

Get the flanking sequences on the N and C terminal side. The reported sequences are both in N to C direction.

fn database(&self) -> Option<(&str, Option<&str>)>

The database that was used for matching optionally with the version of the database

fn unique(&self) -> Option<bool>

Get if this PSM is marked as a unique match for its database match, note that this might not be true anymore if multiple streams of data are merged

fn reliability(&self) -> Option<Reliability>

Get the reliability of this PSM

fn uri(&self) -> Option<String>

Get the URI for this PSM

fn fragmentation_model(&self) -> Option<BuiltInFragmentationModel>

Which built-in fragmentation model this fragmentation mode matches to. The default implementation matches on the textual output of [MetaData::mode]. If needed a custom implementation can be made.

fn ppm_error(&self) -> Option<Ratio>

Get the absolute ppm error between the experimental and theoretical precursor mass, if there are multiple masses possible returns the smallest ppm

fn mass_error(&self) -> Option<Mass>

Get the absolute mass error between the experimental and theoretical precursor mass, if there are multiple masses possible returns the smallest difference

fn annotated_spectrum( &self, ) -> Option<Cow<'_, AnnotatedSpectrum<Self::SpectrumOutputMode>>>

Get the annotated spectrum if this is encoded in the format

fn has_annotated_spectrum(&self) -> bool

Check if this spectrum has an annotated spectrum available. This can be overwritten to built a faster implementation if creating the spectrum needs to happen at runtime.

impl PSMSource for OpairPSM

const VERSIONS: &[&Self::Format]

The list of possible versions

type Source = CsvLine

The source data where the peptides are parsed form

type Format = OpairFormat

The format type

type Complexity = SemiAmbiguous

The complexity marker type

type PeptidoformAvailability = PeptidoformPresent

The peptidoform availability marker type

type Version = OpairVersion

The version type

fn parse( source: &Self::Source, ontologies: &Ontologies, keep_all_columns: bool, proteins: &mut HashMap<String, Arc<<OpairPSM as PSMMetaData>::Protein>>, ) -> Result<(Self, &'static Self::Format), BoxedError<'static, BasicKind>>

Parse a single PSM from its source and return the detected format

fn parse_file( path: impl AsRef<Path>, ontologies: &Ontologies, keep_all_columns: bool, version: Option<Self::Version>, ) -> Result<BoxedIdentifiedPeptideIter<'_, Self>, BoxedError<'static, BasicKind>>

Parse a file with PSMs.

fn parse_reader<'a>( reader: impl Read + 'a, ontologies: &'a Ontologies, keep_all_columns: bool, version: Option<Self::Version>, ) -> Result<BoxedIdentifiedPeptideIter<'a, Self>, BoxedError<'static, BasicKind>>

Parse a reader with PSMs.

fn parse_specific( source: &Self::Source, format: &OpairFormat, ontologies: &Ontologies, keep_all_columns: bool, proteins: &mut HashMap<String, Arc<<OpairPSM as PSMMetaData>::Protein>>, ) -> Result<Self, BoxedError<'static, BasicKind>>

Parse a single PSM with the given format

fn post_process( _source: &CsvLine, parsed: Self, _ontologies: &Ontologies, ) -> Result<Self, BoxedError<'static, BasicKind>>

Allow post processing of the peptide

fn parse_many<I: Iterator<Item = Result<Self::Source, BoxedError<'static, BasicKind>>>>( iter: I, ontologies: &Ontologies, keep_all_columns: bool, format: Option<Self::Format>, ) -> PSMIter<'_, Self, I>

Parse a source of multiple peptides using the given format or automatically determining the format to use by the first item

impl PartialEq for OpairPSM

fn eq(&self, other: &OpairPSM) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for OpairPSM

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for OpairPSM