IsoSpecPy 2.5.0__py3-none-win_amd64.whl

IsoSpecPy/IsoSpec++/dirtyAllocator.h

@@ -0,0 +1,58 @@
+/*
+ *   Copyright (C) 2015-2020 Mateusz Łącki and Michał Startek.
+ *
+ *   This file is part of IsoSpec.
+ *
+ *   IsoSpec is free software: you can redistribute it and/or modify
+ *   it under the terms of the Simplified ("2-clause") BSD licence.
+ *
+ *   IsoSpec is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *   You should have received a copy of the Simplified BSD Licence
+ *   along with IsoSpec.  If not, see <https://opensource.org/licenses/BSD-2-Clause>.
+ */
+
+#pragma once
+
+#include <cstring>
+#include "pod_vector.h"
+
+namespace IsoSpec
+{
+
+class DirtyAllocator
+{
+ private:
+    void*   currentTab;
+    void*   currentConf;
+    void*   endOfTablePtr;
+    const int       tabSize;
+    int     cellSize;
+    pod_vector<void*>  prevTabs;
+
+ public:
+    explicit DirtyAllocator(const int dim, const int tabSize = 10000);
+    ~DirtyAllocator();
+
+    DirtyAllocator(const DirtyAllocator& other) = delete;
+    DirtyAllocator& operator=(const DirtyAllocator& other) = delete;
+
+    void shiftTables();
+
+    inline void* newConf()
+    {
+        if (currentConf >= endOfTablePtr)
+        {
+            shiftTables();
+        }
+
+        void*  ret = currentConf;
+        currentConf = reinterpret_cast<char*>(currentConf) + cellSize;
+
+        return ret;
+    }
+};
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/element_lookup.h

@@ -0,0 +1,36 @@
+/*
+ *   Copyright (C) 2015-2026 Mateusz Łącki and Michał Startek.
+ *
+ *   This file is part of IsoSpec.
+ *
+ *   IsoSpec is free software: you can redistribute it and/or modify
+ *   it under the terms of the Simplified ("2-clause") BSD licence.
+ *
+ *   IsoSpec is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *   You should have received a copy of the Simplified BSD Licence
+ *   along with IsoSpec.  If not, see <https://opensource.org/licenses/BSD-2-Clause>.
+ */
+
+#pragma once
+
+#include <cstddef>
+
+namespace IsoSpec {
+
+//! Row index of `symbol`'s first isotope in element_tables.h's flat
+//! elem_table_* arrays (grouped by element, contiguous), or -1 if `symbol`
+//! isn't a known element. `len` must be 1 or 2 -- IsoSpec's own
+//! element_tables.cpp never uses longer symbols. A direct-indexed
+//! [26][27] table (first letter x optional second letter), built once,
+//! backs this -- no scan, no map.
+int find_element_table_first_index(const char* symbol, size_t len);
+
+//! How many contiguous isotope rows starting at `first_index` belong to
+//! that element (elem_table_ID stays constant over that run). Returns 0 for
+//! a negative `first_index`.
+int element_isotope_count(int first_index);
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/element_tables.h

@@ -0,0 +1,50 @@
+/*
+ *   Copyright (C) 2015-2020 Mateusz Łącki and Michał Startek.
+ *
+ *   This file is part of IsoSpec.
+ *
+ *   IsoSpec is free software: you can redistribute it and/or modify
+ *   it under the terms of the Simplified ("2-clause") BSD licence.
+ *
+ *   IsoSpec is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *   You should have received a copy of the Simplified BSD Licence
+ *   along with IsoSpec.  If not, see <https://opensource.org/licenses/BSD-2-Clause>.
+ */
+
+#pragma once
+
+#include <stddef.h>
+
+#include "platform.h"
+
+namespace IsoSpec
+{
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES 293
+ISOSPEC_C_API extern const size_t isospec_number_of_isotopic_entries;
+
+ISOSPEC_C_API extern const int elem_table_ID[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const int elem_table_atomicNo[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const double elem_table_probability[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const double elem_table_mass[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const double elem_table_massNo[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const int elem_table_extraNeutrons[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const char* elem_table_element[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const char* elem_table_symbol[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const bool elem_table_Radioactive[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+ISOSPEC_C_API extern const double elem_table_log_probability[ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES];
+
+
+#ifdef __cplusplus
+}
+#endif
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/fasta.h

@@ -0,0 +1,70 @@
+/*
+ *   Copyright (C) 2015-2020 Mateusz Łącki and Michał Startek.
+ *
+ *   This file is part of IsoSpec.
+ *
+ *   IsoSpec is free software: you can redistribute it and/or modify
+ *   it under the terms of the Simplified ("2-clause") BSD licence.
+ *
+ *   IsoSpec is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *   You should have received a copy of the Simplified BSD Licence
+ *   along with IsoSpec.  If not, see <https://opensource.org/licenses/BSD-2-Clause>.
+ */
+
+
+#pragma once
+
+#include <cstddef>
+#include <cstring>
+
+namespace IsoSpec{
+
+// We will work with C H N O S Se tuples */
+extern const int aa_isotope_numbers[6];
+
+extern const double aa_elem_masses[19];
+
+extern const double aa_elem_nominal_masses[19];
+
+extern const double aa_elem_probabilities[19];
+
+extern const int aa_symbol_to_elem_counts[256*6];
+
+//! Count elemental composition of an unmodificed sequence of amino acids, resulting in CHNOSSe counts.
+/*!
+    WARNING!!! This function does not add the terminating H and OH groups, resulting in a residue backbone skeleton formula.
+    If you don't know what that means, you should probably be using parse_fasta_full function.
+*/
+inline void parse_fasta(const char* fasta, int atomCounts[6])
+{
+    memset(atomCounts, 0, sizeof(decltype(atomCounts[0]))*6);
+
+    for(size_t idx = 0; fasta[idx] != '\0'; ++idx)
+    {
+        const int* counts = &aa_symbol_to_elem_counts[static_cast<unsigned char>(fasta[idx])*6];
+        for(int ii = 0; ii < 6; ++ii)
+            atomCounts[ii] += counts[ii];
+    }
+}
+
+//! Turn an input FASTA aminoacid sequence into atom counts, in CHNOSSe order.
+/*!
+    Unlike parse_fasta, this function includes the H and OH groups at the N- and C- termini of the skeleton, resulting in a formula of a full (inert) molecule.
+*/
+inline void parse_fasta_full(const char* fasta, int atomCounts[6])
+{
+    parse_fasta(fasta, atomCounts);
+    // Add terminal water (H2O) for either precursor or fragment.
+    const int H_INDEX = 1;  // Indexing: 0=C, 1=H, 2=N, 3=O, 4=S, 5=Se
+    const int O_INDEX = 3;
+
+    atomCounts[H_INDEX] += 2;
+    atomCounts[O_INDEX] += 1;
+}
+
+
+
+}  // namespace IsoSpec

IsoSpecPy/IsoSpec++/fasta_mods.h

@@ -0,0 +1,70 @@
+/*
+ *   Copyright (C) 2015-2026 Mateusz Łącki and Michał Startek.
+ *
+ *   This file is part of IsoSpec.
+ *
+ *   IsoSpec is free software: you can redistribute it and/or modify
+ *   it under the terms of the Simplified ("2-clause") BSD licence.
+ *
+ *   IsoSpec is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *   You should have received a copy of the Simplified BSD Licence
+ *   along with IsoSpec.  If not, see <https://opensource.org/licenses/BSD-2-Clause>.
+ */
+
+#pragma once
+
+#include <vector>
+
+#include "composition.h"
+#include "isoSpec++.h"
+#include "unimod.h"
+
+namespace IsoSpec {
+
+//! Parses `sequence` for [UNIMOD:<id>] modification brackets in exactly the
+//! notation this monorepo's SAGE fork writes (crates/sage/src/peptide.rs):
+//! `[UNIMOD:<id>]-SEQUENCE` for an N-terminal mod, `X[UNIMOD:<id>]` for an
+//! internal one (immediately after the modified residue), `SEQUENCE-
+//! [UNIMOD:<id>]` for a C-terminal one. Parsing needs no position-awareness
+//! to get this right: a `[UNIMOD:<id>]` bracket has the same effect (add
+//! that modification's composition delta) wherever it appears, and the
+//! surrounding '-' either side of a terminal bracket is just an ordinary
+//! ignored character, exactly as it always was in a plain sequence (see
+//! parse_fasta's "unrecognized characters are silently ignored" contract,
+//! which this function preserves for everything except '[' itself -- a
+//! literal '[' or a digit outside a bracket was never valid input before
+//! either way).
+//!
+//! Base residue composition comes from fasta.h's existing
+//! aa_symbol_to_elem_counts (CHNOSSe); each recognized mod's resolved
+//! composition (from `mods`) is added on top, so the result can include
+//! elements no plain amino-acid sequence ever needs (P, Br, Ca, Fe, ...).
+//!
+//! Throws std::invalid_argument on a malformed bracket (missing "UNIMOD:"
+//! prefix, missing/non-numeric id, missing closing ']') or an id not present
+//! in `mods` -- covers both a genuinely-unknown id and one of the ids
+//! data/unimod.csv deliberately excludes (isotope-labeled, glycan/
+//! derivatization "brick" entries) alike, same error, no special-casing.
+ElementComposition parse_fasta_with_mods(const char* sequence, const UnimodTable& mods = embedded_unimod_table());
+
+//! As above, plus terminal H2O -- mirrors parse_fasta_full's role for the
+//! mods-unaware path.
+ElementComposition parse_fasta_with_mods_full(const char* sequence, const UnimodTable& mods = embedded_unimod_table());
+
+//! Same as parse_fasta_with_mods, but fills a caller-owned `out` in place
+//! (cleared first) instead of returning a fresh ElementComposition -- the
+//! allocation-free form for a hot loop over many sequences (a single `out`
+//! reused across the whole loop reallocates at most a handful of times, not
+//! once per call). parse_fasta_with_mods/_full are thin convenience wrappers
+//! around this pair for one-off callers.
+void parse_fasta_with_mods_into(const char* sequence, ElementComposition& out,
+                                 const UnimodTable& mods = embedded_unimod_table());
+
+//! As above, plus terminal H2O.
+void parse_fasta_with_mods_full_into(const char* sequence, ElementComposition& out,
+                                      const UnimodTable& mods = embedded_unimod_table());
+
+}  // namespace IsoSpec