IsoSpecPy 2.2.3__tar.gz → 2.3.0.dev3__tar.gz

{isospecpy-2.2.3 → isospecpy-2.3.0.dev3}/.github/workflows/build_wheels.yml

@@ -15,7 +15,7 @@ jobs:
     strategy:
       matrix:
         #os: [ubuntu-20.04, windows-2019, macos-10.15]
-        os: [windows-latest, macos-13, macos-14, macos-15]
+        os: [ubuntu-22.04, windows-latest, macos-13, macos-14, macos-15]
 
     steps:
       - uses: actions/checkout@v4
@@ -31,7 +31,7 @@ jobs:
         # to supply options, put them in 'env', like:
         env:
           GITHUB_BUILDING_WHEELS: 1
-          CIBW_SKIP: pp*-*
+          CIBW_SKIP: pp*-* cp36-* cp37-*
 
 
       - uses: actions/upload-artifact@v4

{isospecpy-2.2.3 → isospecpy-2.3.0.dev3}/IsoSpec++/Makefile

@@ -1,6 +1,6 @@
 OPTFLAGS=-O3 -march=native -mtune=native
 DEBUGFLAGS=-O0 -g -Werror -DISOSPEC_DEBUG -DDEBUG -D_GLIBCXX_DEBUG
-CXXFLAGS=-std=c++11 -Wall -pedantic -Wextra -Wshadow -Wcast-align -Wcast-qual -Wctor-dtor-privacy -Wdisabled-optimization -Wformat=2 -Winit-self -Wmissing-include-dirs -Wno-old-style-cast -Woverloaded-virtual -Wredundant-decls -Wshadow -Wno-sign-conversion -Wsign-promo -Wswitch-default -Wundef
+CXXFLAGS=-std=c++17 -Wall -pedantic -Wextra -Wshadow -Wcast-align -Wcast-qual -Wctor-dtor-privacy -Wdisabled-optimization -Wformat=2 -Winit-self -Wmissing-include-dirs -Wno-old-style-cast -Woverloaded-virtual -Wredundant-decls -Wshadow -Wno-sign-conversion -Wsign-promo -Wswitch-default -Wundef
 SRCFILES=cwrapper.cpp allocator.cpp  dirtyAllocator.cpp  isoSpec++.cpp  isoMath.cpp  marginalTrek++.cpp  operators.cpp element_tables.cpp misc.cpp mman.cpp fixedEnvelopes.cpp fasta.cpp
 
 all: unitylib

{isospecpy-2.2.3 → isospecpy-2.3.0.dev3}/IsoSpec++/fasta.h

@@ -30,6 +30,11 @@ 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);
@@ -42,4 +47,21 @@ inline void parse_fasta(const char* fasta, int atomCounts[6])
     }
 }
 
+//! 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-2.2.3/IsoSpecR/src → isospecpy-2.3.0.dev3/IsoSpec++}/isoMath.cpp

@@ -146,9 +146,8 @@ double InverseLowerIncompleteGamma2(int a, double x)
     return s;
 }
 
-std::random_device random_dev;
-std::mt19937 random_gen(random_dev());
-std::uniform_real_distribution<double> stdunif(0.0, 1.0);
+thread_local std::mt19937 random_gen(std::random_device{}());
+thread_local std::uniform_real_distribution<double> stdunif(0.0, 1.0);
 
 size_t rdvariate_binom(size_t tries, double succ_prob, std::mt19937& rgen)
 {

{isospecpy-2.2.3/IsoSpecR/src → isospecpy-2.3.0.dev3/IsoSpec++}/isoMath.h

@@ -70,8 +70,8 @@ inline double InverseChiSquareCDF2(int k, double x)
     return InverseLowerIncompleteGamma2(k, x*tgamma(static_cast<double>(k)/2.0)) * 2.0;
 }
 
-extern std::mt19937 random_gen;
-extern std::uniform_real_distribution<double> stdunif;
+extern thread_local std::mt19937 random_gen;
+extern thread_local std::uniform_real_distribution<double> stdunif;
 
 inline double rdvariate_beta_1_b(double b, std::mt19937& rgen = random_gen)
 {

{isospecpy-2.2.3/IsoSpecR/src → isospecpy-2.3.0.dev3/IsoSpec++}/isoSpec++.cpp

@@ -650,22 +650,22 @@ IsoThresholdGenerator::~IsoThresholdGenerator()
  * ------------------------------------------------------------------------------------------------------------------------
  */
 
-
-IsoLayeredGenerator::IsoLayeredGenerator(Iso&& iso, int tabSize, int hashSize, bool reorder_marginals, double t_prob_hint)
+template <typename MarginalType>
+IsoLayeredGeneratorTemplate<MarginalType>::IsoLayeredGeneratorTemplate(Iso&& iso, int tabSize, int hashSize, bool reorder_marginals, double t_prob_hint)
 : IsoGenerator(std::move(iso))
 {
     counter = new int[dimNumber];
     maxConfsLPSum = new double[dimNumber-1];
     currentLThreshold = nextafter(mode_lprob, -std::numeric_limits<double>::infinity());
     lastLThreshold = (std::numeric_limits<double>::min)();
-    marginalResultsUnsorted = new LayeredMarginal*[dimNumber];
+    marginalResultsUnsorted = new MarginalType*[dimNumber];
     resetPositions = new const double*[dimNumber];
     marginalsNeedSorting = doMarginalsNeedSorting();
 
     memset(counter, 0, sizeof(int)*dimNumber);
 
     for(int ii = 0; ii < dimNumber; ii++)
-        marginalResultsUnsorted[ii] = new LayeredMarginal(std::move(*(marginals[ii])), tabSize, hashSize);
+        marginalResultsUnsorted[ii] = new MarginalType(std::move(*(marginals[ii])), tabSize, hashSize);
 
     if(reorder_marginals && dimNumber > 1)
     {
@@ -681,7 +681,7 @@ IsoLayeredGenerator::IsoLayeredGenerator(Iso&& iso, int tabSize, int hashSize, b
         TableOrder<double> TO(marginal_priorities);
 
         std::sort(tmpMarginalOrder, tmpMarginalOrder + dimNumber, TO);
-        marginalResults = new LayeredMarginal*[dimNumber];
+        marginalResults = new MarginalType*[dimNumber];
 
         for(int ii = 0; ii < dimNumber; ii++)
             marginalResults[ii] = marginalResultsUnsorted[tmpMarginalOrder[ii]];
@@ -715,10 +715,11 @@ IsoLayeredGenerator::IsoLayeredGenerator(Iso&& iso, int tabSize, int hashSize, b
     counter[0]--;
     lProbs_ptr--;
     lastLThreshold = 10.0;
-    IsoLayeredGenerator::nextLayer(-0.00001);
+    IsoLayeredGeneratorTemplate<MarginalType>::nextLayer(-0.00001);
 }
 
-bool IsoLayeredGenerator::nextLayer(double offset)
+template <typename MarginalType>
+bool IsoLayeredGeneratorTemplate<MarginalType>::nextLayer(double offset)
 {
     size_t first_mrg_size = marginalResults[0]->get_no_confs();
 
@@ -746,7 +747,8 @@ bool IsoLayeredGenerator::nextLayer(double offset)
     return true;
 }
 
-bool IsoLayeredGenerator::carry()
+template <typename MarginalType>
+bool IsoLayeredGeneratorTemplate<MarginalType>::carry()
 {
     // If we reached this point, a carry is needed
 
@@ -781,8 +783,8 @@ bool IsoLayeredGenerator::carry()
     return false;
 }
 
-
-void IsoLayeredGenerator::terminate_search()
+template<typename MarginalType>
+void IsoLayeredGeneratorTemplate<MarginalType>::terminate_search()
 {
     for(int ii = 0; ii < dimNumber; ii++)
     {
@@ -793,7 +795,8 @@ void IsoLayeredGenerator::terminate_search()
     lProbs_ptr = lProbs_ptr_start + marginalResults[0]->get_no_confs()-1;
 }
 
-IsoLayeredGenerator::~IsoLayeredGenerator()
+template<typename MarginalType>
+IsoLayeredGeneratorTemplate<MarginalType>::~IsoLayeredGeneratorTemplate()
 {
     delete[] counter;
     delete[] maxConfsLPSum;
@@ -805,33 +808,35 @@ IsoLayeredGenerator::~IsoLayeredGenerator()
       delete[] marginalOrder;
 }
 
+template class IsoLayeredGeneratorTemplate<LayeredMarginal>;
+//template class IsoLayeredGeneratorTemplate<PrecalculatedMarginal>;
+//template class IsoLayeredGeneratorTemplate<MarginalTrek>;
+template class IsoLayeredGeneratorTemplate<SingleAtomMarginal<true>>;
 
 /*
  * ------------------------------------------------------------------------------------------------------------------------
  */
 
-
-IsoOrderedGenerator::IsoOrderedGenerator(Iso&& iso, int _tabSize, int _hashSize) :
+template<typename MarginalType>
+IsoOrderedGeneratorTemplate<MarginalType>::IsoOrderedGeneratorTemplate(Iso&& iso, int _tabSize, int _hashSize) :
 IsoGenerator(std::move(iso), false), allocator(dimNumber, _tabSize)
 {
     partialLProbs = &currentLProb;
     partialMasses = &currentMass;
     partialProbs = &currentProb;
 
-    marginalResults = new MarginalTrek*[dimNumber];
+    marginalResults = new MarginalType*[dimNumber];
 
     for(int i = 0; i < dimNumber; i++)
-        marginalResults[i] = new MarginalTrek(std::move(*(marginals[i])), _tabSize, _hashSize);
+        marginalResults[i] = new MarginalType(std::move(*(marginals[i])), _tabSize, _hashSize);
 
     logProbs        = new const pod_vector<double>*[dimNumber];
     masses          = new const pod_vector<double>*[dimNumber];
-    marginalConfs   = new const pod_vector<int*>*[dimNumber];
 
     for(int i = 0; i < dimNumber; i++)
     {
         masses[i] = &marginalResults[i]->conf_masses();
         logProbs[i] = &marginalResults[i]->conf_lprobs();
-        marginalConfs[i] = &marginalResults[i]->confs();
     }
 
     topConf = allocator.newConf();
@@ -851,20 +856,19 @@ IsoGenerator(std::move(iso), false), allocator(dimNumber, _tabSize)
     pq.push(topConf);
 }
 
-
-IsoOrderedGenerator::~IsoOrderedGenerator()
+template<typename MarginalType>
+IsoOrderedGeneratorTemplate<MarginalType>::~IsoOrderedGeneratorTemplate()
 {
-    dealloc_table<MarginalTrek*>(marginalResults, dimNumber);
+    dealloc_table<MarginalType*>(marginalResults, dimNumber);
     delete[] logProbs;
     delete[] masses;
-    delete[] marginalConfs;
     partialLProbs = nullptr;
     partialMasses = nullptr;
     partialProbs = nullptr;
 }
 
-
-bool IsoOrderedGenerator::advanceToNextConfiguration()
+template<typename MarginalType>
+bool IsoOrderedGeneratorTemplate<MarginalType>::advanceToNextConfiguration()
 {
     if(pq.size() < 1)
         return false;
@@ -914,22 +918,32 @@ bool IsoOrderedGenerator::advanceToNextConfiguration()
     return true;
 }
 
+template class IsoOrderedGeneratorTemplate<MarginalTrek>;
+template class IsoOrderedGeneratorTemplate<SingleAtomMarginal<false>>;
+
 
 /*
  * ---------------------------------------------------------------------------------------------------
  */
 
-
-IsoStochasticGenerator::IsoStochasticGenerator(Iso&& iso, size_t no_molecules, double _precision, double _beta_bias) :
+template<typename IsoType>
+IsoStochasticGeneratorTemplate<IsoType>::IsoStochasticGeneratorTemplate(Iso&& iso, size_t no_molecules, double _precision, double _beta_bias, std::mt19937& _rng) :
 IsoGenerator(std::move(iso)),
 ILG(std::move(*this)),
 to_sample_left(no_molecules),
 precision(_precision),
 beta_bias(_beta_bias),
 confs_prob(0.0),
-chasing_prob(0.0)
+chasing_prob(0.0),
+rdvariate_gen(_rng)
 {}
 
+template class IsoStochasticGeneratorTemplate<IsoLayeredGeneratorTemplate<LayeredMarginal>>;
+template class IsoStochasticGeneratorTemplate<IsoLayeredGeneratorTemplate<SingleAtomMarginal<true>>>;
+template class IsoStochasticGeneratorTemplate<IsoOrderedGeneratorTemplate<MarginalTrek>>;
+template class IsoStochasticGeneratorTemplate<IsoOrderedGeneratorTemplate<SingleAtomMarginal<false>>>;
+//template class IsoStochasticGeneratorTemplate<IsoThresholdGenerator>;
+
 /*
  * ---------------------------------------------------------------------------------------------------
  */

{isospecpy-2.2.3/IsoSpecR/src → isospecpy-2.3.0.dev3/IsoSpec++}/isoSpec++.h

@@ -21,6 +21,7 @@
 #include <limits>
 #include <string>
 #include <vector>
+#include <algorithm>
 #include "platform.h"
 #include "dirtyAllocator.h"
 #include "summator.h"
@@ -233,24 +234,24 @@ class ISOSPEC_EXPORT_SYMBOL IsoGenerator : public Iso
     This algorithm take O(N*log(N)) to compute the N isotopologues because of using the Priority Queue data structure.
     Obtaining the N isotopologues can be achieved in O(N) if they are not required to be spit out in the descending order.
 */
-class ISOSPEC_EXPORT_SYMBOL IsoOrderedGenerator: public IsoGenerator
+template<typename MarginalType>
+class ISOSPEC_EXPORT_SYMBOL IsoOrderedGeneratorTemplate: public IsoGenerator
 {
  private:
-    MarginalTrek**              marginalResults;                    /*!< Table of pointers to marginal distributions of subisotopologues. */
+    MarginalType**              marginalResults;                    /*!< Table of pointers to marginal distributions of subisotopologues. */
     std::priority_queue<void*, pod_vector<void*>, ConfOrder> pq;   /*!< The priority queue used to generate isotopologues ordered by descending probability. */
     void*                       topConf;                            /*!< Most probable configuration. */
     DirtyAllocator              allocator;                          /*!< Structure used for alocating memory for isotopologues. */
     const pod_vector<double>**  logProbs;                           /*!< Obtained log-probabilities. */
     const pod_vector<double>**  masses;                             /*!< Obtained masses. */
-    const pod_vector<Conf>**    marginalConfs;                      /*!< Obtained counts of isotopes. */
     double                      currentLProb;                       /*!< The log-probability of the current isotopologue. */
     double                      currentMass;                        /*!< The mass of the current isotopologue. */
     double                      currentProb;                        /*!< The probability of the current isotopologue. */
     int                         ccount;
 
  public:
-    IsoOrderedGenerator(const IsoOrderedGenerator& other) = delete;
-    IsoOrderedGenerator& operator=(const IsoOrderedGenerator& other) = delete;
+    IsoOrderedGeneratorTemplate(const IsoOrderedGeneratorTemplate& other) = delete;
+    IsoOrderedGeneratorTemplate& operator=(const IsoOrderedGeneratorTemplate& other) = delete;
 
     bool advanceToNextConfiguration() override final;
 
@@ -261,29 +262,49 @@ class ISOSPEC_EXPORT_SYMBOL IsoOrderedGenerator: public IsoGenerator
     */
     inline void get_conf_signature(int* space) const override final
     {
-        int* c = getConf(topConf);
+        if constexpr (std::is_same<MarginalType, MarginalTrek>::value)
+        {
+            int* c = getConf(topConf);
 
-        if (ccount >= 0)
-            c[ccount]--;
+            if (ccount >= 0)
+                c[ccount]--;
 
-        for(int ii = 0; ii < dimNumber; ii++)
-        {
-            memcpy(space, marginalResults[ii]->confs()[c[ii]], isotopeNumbers[ii]*sizeof(int));
-            space += isotopeNumbers[ii];
-        }
+            for(int ii = 0; ii < dimNumber; ii++)
+            {
+                memcpy(space, marginalResults[ii]->confs()[c[ii]], isotopeNumbers[ii]*sizeof(int));
+                space += isotopeNumbers[ii];
+            }
 
-        if (ccount >= 0)
-            c[ccount]++;
+            if (ccount >= 0)
+                c[ccount]++;
+        }
+        else
+            throw std::runtime_error("IsoOrderedGeneratorTemplate::get_conf_signature() called on a non-MarginalTrek generator. This is not supported yet.");
     };
 
     //! The move-contstructor.
-    IsoOrderedGenerator(Iso&& iso, int _tabSize  = 1000, int _hashSize = 1000);  // NOLINT(runtime/explicit) - constructor deliberately left to be used as a conversion
+    IsoOrderedGeneratorTemplate(Iso&& iso, int _tabSize  = 1000, int _hashSize = 1000);  // NOLINT(runtime/explicit) - constructor deliberately left to be used as a conversion
 
     //! Destructor.
-    virtual ~IsoOrderedGenerator();
-};
+    virtual ~IsoOrderedGeneratorTemplate();
 
+    inline void get_conf_by_indexes(int* space)
+    {
+        if constexpr (std::is_same<MarginalType, SingleAtomMarginal<false>>::value)
+        {
+            if(dimNumber == 0)
+                return;
 
+            int* c = getConf(topConf);
+            space[0] = std::max(c[0]-1, 0);
+
+            for(int ii = 1; ii < dimNumber; ii++)
+                space[ii] = c[ii];
+        }
+    }
+};
+
+using IsoOrderedGenerator = IsoOrderedGeneratorTemplate<MarginalTrek>;
 
 
 //! The generator of isotopologues above a given threshold value.
@@ -435,15 +456,15 @@ class ISOSPEC_EXPORT_SYMBOL IsoThresholdGenerator: public IsoGenerator
 
 
 
-
-class ISOSPEC_EXPORT_SYMBOL IsoLayeredGenerator : public IsoGenerator
+template<typename MarginalType>
+class ISOSPEC_EXPORT_SYMBOL IsoLayeredGeneratorTemplate : public IsoGenerator
 {
  private:
     int*                    counter;            /*!< An array storing the position of an isotopologue in terms of the subisotopologues ordered by decreasing probability. */
     double*                 maxConfsLPSum;
     double currentLThreshold, lastLThreshold;
-    LayeredMarginal** marginalResults;
-    LayeredMarginal** marginalResultsUnsorted;
+    MarginalType** marginalResults;
+    MarginalType** marginalResultsUnsorted;
     int* marginalOrder;
 
     const double* lProbs_ptr;
@@ -455,8 +476,8 @@ class ISOSPEC_EXPORT_SYMBOL IsoLayeredGenerator : public IsoGenerator
 
 
  public:
-    IsoLayeredGenerator(const IsoLayeredGenerator& other) = delete;
-    IsoLayeredGenerator& operator=(const IsoLayeredGenerator& other) = delete;
+    IsoLayeredGeneratorTemplate(const IsoLayeredGeneratorTemplate& other) = delete;
+    IsoLayeredGeneratorTemplate& operator=(const IsoLayeredGeneratorTemplate& other) = delete;
 
     inline void get_conf_signature(int* space) const override final
     {
@@ -482,9 +503,9 @@ class ISOSPEC_EXPORT_SYMBOL IsoLayeredGenerator : public IsoGenerator
 
     inline double get_currentLThreshold() const { return currentLThreshold; }
 
-    IsoLayeredGenerator(Iso&& iso, int _tabSize = 1000, int _hashSize = 1000, bool reorder_marginals = true, double t_prob_hint = 0.99);  // NOLINT(runtime/explicit) - constructor deliberately left to be used as a conversion
+    IsoLayeredGeneratorTemplate(Iso&& iso, int _tabSize = 1000, int _hashSize = 1000, bool reorder_marginals = true, double t_prob_hint = 0.99);  // NOLINT(runtime/explicit) - constructor deliberately left to be used as a conversion
 
-    ~IsoLayeredGenerator();
+    ~IsoLayeredGeneratorTemplate();
 
     ISOSPEC_FORCE_INLINE bool advanceToNextConfiguration() override final
     {
@@ -492,7 +513,7 @@ class ISOSPEC_EXPORT_SYMBOL IsoLayeredGenerator : public IsoGenerator
         {
             if(advanceToNextConfigurationWithinLayer())
                 return true;
-        } while(IsoLayeredGenerator::nextLayer(-2.0));
+        } while(IsoLayeredGeneratorTemplate<MarginalType>::nextLayer(-2.0));
         return false;
     }
 
@@ -533,24 +554,48 @@ class ISOSPEC_EXPORT_SYMBOL IsoLayeredGenerator : public IsoGenerator
 
     bool nextLayer(double offset);
 
+    void get_conf_by_indexes(int* space) const
+    {
+        if constexpr (std::is_same<MarginalType, SingleAtomMarginal<true>>::value)
+        {
+            counter[0] = lProbs_ptr - lProbs_ptr_start;
+            if(marginalOrder != nullptr)
+            {
+                for(int ii = 0; ii < dimNumber; ii++)
+                {
+                    int jj = marginalOrder[ii];
+                    space[ii] = marginalResultsUnsorted[ii]->get_original_position(counter[jj]);
+                }
+            }
+            else
+            {
+                for(int ii = 0; ii < dimNumber; ii++)
+                    space[ii] = marginalResultsUnsorted[ii]->get_original_position(counter[ii]);
+            }
+        }
+        else
+            throw std::runtime_error("IsoLayeredGeneratorTemplate::get_conf_by_indexes() called on a non-SingleAtomMarginal generator. This is not supported yet.");
+    }
+
  private:
     bool carry();
 };
+using IsoLayeredGenerator = IsoLayeredGeneratorTemplate<LayeredMarginal>;
 
-
-
-class IsoStochasticGenerator : public IsoGenerator
+template<typename IsoType>
+class IsoStochasticGeneratorTemplate : public IsoGenerator
 {
-    IsoLayeredGenerator ILG;
+    IsoType ILG;
     size_t to_sample_left;
     const double precision;
     const double beta_bias;
     double confs_prob;
     double chasing_prob;
     size_t current_count;
+    std::mt19937& rdvariate_gen;  /*!< The random number generator used to generate random numbers. */
 
  public:
-    IsoStochasticGenerator(Iso&& iso, size_t no_molecules, double precision = 0.9999, double beta_bias = 5.0);
+    IsoStochasticGeneratorTemplate(Iso&& iso, size_t no_molecules, double precision = 0.9999, double beta_bias = 5.0, std::mt19937& rdvariate_gen = random_gen);
 
     ISOSPEC_FORCE_INLINE size_t count() const { return current_count; }
 
@@ -636,7 +681,13 @@ class IsoStochasticGenerator : public IsoGenerator
             }
         };
     }
+
+    ISOSPEC_FORCE_INLINE void get_indexes(int* space)
+    {
+        ILG.get_conf_by_indexes(space);
+    }
 };
 
+using IsoStochasticGenerator = IsoStochasticGeneratorTemplate<IsoLayeredGenerator>;
 
 }  // namespace IsoSpec

{isospecpy-2.2.3 → isospecpy-2.3.0.dev3}/IsoSpec++/marginalTrek++.cpp

@@ -695,4 +695,46 @@ double LayeredMarginal::get_max_mass() const
     return ret;
 }
 
+/* ===============================================================   */
+
+template<bool add_guards>
+SingleAtomMarginal<add_guards>::SingleAtomMarginal(Marginal&& m, int, int)
+: Marginal(std::move(m)), current_threshold(1.0), extended_to_idx(0)
+{
+    original_indexes.resize(isotopeNo);
+    for(size_t ii = 0; ii < isotopeNo; ++ii)
+        original_indexes[ii] = ii;
+
+    std::sort(original_indexes.begin(), original_indexes.end(), [&](int a, int b) {
+        return atom_lProbs[a] > atom_lProbs[b];
+    });
+
+
+    masses.reserve(isotopeNo);
+    probs.reserve(isotopeNo);
+
+    if constexpr (add_guards)
+    {
+        lProbs.reserve(isotopeNo+2);
+        lProbs.push_back(std::numeric_limits<double>::infinity());
+    }
+    else
+        lProbs.reserve(isotopeNo);
+
+    for(size_t idx : original_indexes)
+    {
+        lProbs.push_back(atom_lProbs[idx]);
+        probs.push_back(exp(lProbs.back()));
+        masses.push_back(atom_masses[idx]);
+    }
+
+    if constexpr (add_guards)
+   {
+        lProbs.push_back(-std::numeric_limits<double>::infinity());
+        guarded_lProbs = lProbs.data()+1;
+    }
+    else
+        guarded_lProbs = lProbs.data();
+}
+
 }  // namespace IsoSpec