NuXLModificationsGenerator.h

Go to the documentation of this file.

// Copyright (c) 2002-present, The OpenMS Team -- EKU Tuebingen, ETH Zurich, and FU Berlin
// SPDX-License-Identifier: BSD-3-Clause
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Timo Sachsenberg $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/KERNEL/StandardTypes.h>
#include <OpenMS/DATASTRUCTURES/StringUtils.h>
#include <OpenMS/DATASTRUCTURES/TypeAliases.h>
#include <OpenMS/CHEMISTRY/EmpiricalFormula.h>
#include <vector>
#include <map>
#include <set>
#include <iostream>
#include <iterator>
 
namespace OpenMS
{
  class AASequence;
  class Residue;
  class ResidueModification;
 
  struct NuXLModificationMassesResult
  {
    struct MyStringLengthCompare
    {
      bool operator () (const std::string & p_lhs, const std::string & p_rhs) const
      {
        const size_t lhsLength = p_lhs.length() ;
        const size_t rhsLength = p_rhs.length() ;
        if(lhsLength == rhsLength)
        {
            return (p_lhs < p_rhs) ; // when two strings have the same
                                     // length, defaults to the normal
                                     // string comparison
        }
        return (lhsLength < rhsLength) ; // compares with the length
      }
    };
    std::map<std::string, double> formula2mass; 
 
    using NucleotideFormulas = std::set<std::string, MyStringLengthCompare>;
    using MapSumFormulaToNucleotideFormulas = std::map<std::string, NucleotideFormulas>;
    MapSumFormulaToNucleotideFormulas mod_combinations; 
 
    struct PrecursorAdduct
    {
      const std::string* sum_formula = nullptr; 
      const std::string* adduct = nullptr; 
    };
 
    PrecursorAdduct findPrecursorAdduct(Size NA_mod_index, Size NA_adduct_amb_index) const
    {
      if (NA_mod_index >= mod_combinations.size()) { return {}; }
      auto mod_combinations_it = std::next(mod_combinations.cbegin(), NA_mod_index);
      if (NA_adduct_amb_index >= mod_combinations_it->second.size()) { return {}; }
      return {&mod_combinations_it->first, &*std::next(mod_combinations_it->second.cbegin(), NA_adduct_amb_index)};
    }
  };
 
  class NuXLModificationsGenerator
  {
    public:
      static NuXLModificationMassesResult initModificationMassesNA(const StringList& target_nucleotides,
                                                                     const StringList& nt_groups,
                                                                     const std::set<char>& can_xl,
                                                                     const StringList& mappings,
                                                                     const StringList& modifications,
                                                                     std::string sequence_restriction = "",
                                                                     bool cysteine_adduct = false,
                                                                     Int max_length = 4,
                                                                     const std::set<char>& standalone = {});
 
      static const ResidueModification* registerPrecursorAdduct(const std::string& nucleotide_composition,
                                                                const EmpiricalFormula& adduct_formula,
                                                                const Residue& residue);
    private:
      static bool notInSeq(const std::string& res_seq, const std::string& query);
 
      static void generateTargetSequences(const std::string& res_seq, Size param_pos, const std::map<char, std::vector<char> >& map_source2target, StringList& target_sequences);
    };
}