SiriusAdapterAlgorithm.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: Oliver Alka $
// $Authors: Oliver Alka, Lukas Zimmermann $
// --------------------------------------------------------------------------
 
#pragma once 
 
#include <OpenMS/ANALYSIS/MAPMATCHING/FeatureMapping.h>
 
#include <OpenMS/SYSTEM/File.h>
 
#include <unordered_map>
#include <QtCore/QString>
#include <QtCore/QStringList>
 
using namespace std;
 
namespace OpenMS
{
  class FeatureMap;
  class File;
  class KDTreeFeatureMaps;
 
  class OPENMS_DLLAPI SiriusAdapterAlgorithm : public DefaultParamHandler
    {
    public:
      SiriusAdapterAlgorithm();
 
      /*
       * Accessors for Preprocessing Parameters
       */
 
      bool isFeatureOnly() const { return preprocessing.getValue("feature_only").toBool(); }
      UInt getFilterByNumMassTraces() const { return preprocessing.getValue("filter_by_num_masstraces"); }
      double getPrecursorMzTolerance() const { return preprocessing.getValue("precursor_mz_tolerance"); }
      double getPrecursorRtTolerance() const { return preprocessing.getValue("precursor_rt_tolerance"); }
      bool precursorMzToleranceUnitIsPPM() const { return preprocessing.getValue("precursor_mz_tolerance_unit") == "ppm"; }
      bool isNoMasstraceInfoIsotopePattern() const { return preprocessing.getValue("no_masstrace_info_isotope_pattern").toBool(); }
      int getIsotopePatternIterations() const { return  preprocessing.getValue("isotope_pattern_iterations"); }
 
      int getNumberOfSiriusCandidates() const 
      {
        int number_of_candidates = sirius.getValue("candidates");
        // default for SiriusAdapter is -1 to not pass a value to command and use SIRIUS 5 default (10)
        // therefore 10 needs to be returned in this case
        if (number_of_candidates == -1)
        {
          return 10;
        }
        else
        {
          return number_of_candidates;
        }
      }
 
      void updateExistingParameter(const Param &param);
 
      bool hasFullNameParameter(const String &name) const;
 
      class OPENMS_DLLAPI SiriusTemporaryFileSystemObjects
      {
      public:
 
        SiriusTemporaryFileSystemObjects(int debug_level);
 
        ~SiriusTemporaryFileSystemObjects();
 
        const String& getTmpDir() const;
        const String& getTmpOutDir() const;
        const String& getTmpMsFile() const;
      
      private:
        int debug_level_;
 
        String tmp_dir_;
        String tmp_ms_file_;
        String tmp_out_dir_;
      };
 
      static String determineSiriusExecutable(String& executable);
 
      static void sortSiriusWorkspacePathsByScanIndex(std::vector<String>& subdirs);
 
 
      void preprocessingSirius(const String& featureinfo,
                               const MSExperiment& spectra,
                               FeatureMapping::FeatureMappingInfo& fm_info,
                               FeatureMapping::FeatureToMs2Indices& feature_mapping) const;
 
      void logFeatureSpectraNumber(const String& featureinfo,
                                   const FeatureMapping::FeatureToMs2Indices& feature_mapping,
                                   const MSExperiment& spectra) const;
 
      void logInSiriusAccount(String& executable, const String& email, const String& password) const;
 
      const vector<String> callSiriusQProcess(const String& tmp_ms_file,
                                              const String& tmp_out_dir,
                                              String& executable,
                                              const String& out_csifingerid,
                                              const bool decoy_generation) const;
 
    private:
    class ParameterModifier
    {
      const String openms_param_name;
      SiriusAdapterAlgorithm *enclose;
 
    public:
      explicit ParameterModifier(const String &param_name, SiriusAdapterAlgorithm *enclose) :
              openms_param_name(param_name), enclose(enclose) {}
 
      void withValidStrings(initializer_list<std::string> choices)
      {
        enclose->defaults_.setValidStrings(openms_param_name, choices);
      }
 
      void withMinInt(int value)
      {
        enclose->defaults_.setMinInt(openms_param_name, value);
      }
    };
 
    class ParameterSection
    {
      // Maps the OpenMS Parameter Names to the one for Sirius
      unordered_map<String, String> openms_to_sirius;
 
      String toFullParameter(const String &param_name) const
      {
        String result(param_name);
        result.substitute('-', '_');
        return sectionName() + ":" + result;
      }
 
    protected:
      ParameterModifier parameter(
              const String &parameter_name,
              const ParamValue &default_value,
              const String &parameter_description);
      void flag(
              const String &parameter_name,
              const String &parameter_description);
 
      explicit ParameterSection(SiriusAdapterAlgorithm* enclose): enclose(enclose) {}
 
      virtual void parameters() = 0;
      virtual String sectionName() const = 0;
 
      SiriusAdapterAlgorithm *enclose;
 
    public:
      virtual ~ParameterSection() = default;
 
      DataValue getValue(const String &param_name) const
      {
        return enclose->param_.getValue(toFullParameter(param_name));
      }
 
      QStringList getCommandLine() const
      {
        QStringList result;
        for (const auto &pair : openms_to_sirius)
        {
          DataValue value = enclose->param_.getValue(pair.first);
          DataValue default_value = enclose->defaults_.getValue(pair.first);
          if (!value.isEmpty() && value != default_value)
          {
           String string_value = value.toString(true);
           if (string_value == "true")
           {
             result.push_back(String("--" + pair.second).toQString());
           }
           else if (string_value != "false")
           {
             result.push_back(String("--" + pair.second + "=" + string_value).toQString());
           }
          };
        }
        return result;
      }
    };
 
    using SiriusSubtool = ParameterSection;
 
    class Preprocessing : public ParameterSection
    {
      String sectionName() const override { return "preprocessing"; }
    public:
      explicit Preprocessing(SiriusAdapterAlgorithm *enclose) : ParameterSection(enclose) {}
      void parameters() override;
    };
 
    class Project final : public SiriusSubtool
    {
      String sectionName() const override { return "project"; }
    public:
      explicit Project(SiriusAdapterAlgorithm *enclose) : ParameterSection(enclose) {}
      void parameters() override;
    };
 
    class Sirius final : public SiriusSubtool
    {
      String sectionName() const override { return "sirius"; }
    public:
      explicit Sirius(SiriusAdapterAlgorithm *enclose) : ParameterSection(enclose) {}
      void parameters() override;
    };
 
    class Fingerid final : public SiriusSubtool
    {
      String sectionName() const override { return "fingerid"; }
    public:
      explicit Fingerid(SiriusAdapterAlgorithm *enclose) : ParameterSection(enclose) {}
      void parameters() override;
    };
 
    class Passatutto final : public SiriusSubtool
    {
      String sectionName() const override { return "passatutto"; }
    public:
      explicit Passatutto(SiriusAdapterAlgorithm *enclose) : ParameterSection(enclose) {}
      void parameters() override;
     };
 
    Preprocessing preprocessing;
    Project project;
    Sirius sirius;
    Fingerid fingerid;
    Passatutto passatutto;
 
    };
} // namespace OpenMS