ms_imputation.hpp

/*
##############################################################################
# file: ms_imputation.hpp
# 'msparser' toolkit
# 
##############################################################################
# COPYRIGHT NOTICE
# Copyright 1998-2024 Matrix Science Limited  All Rights Reserved.
#
##############################################################################
* @(#)$Source: parser/inc/ms_imputation.hpp $
* @(#)$Revision: bb42496f256d654703dbcb86842d07846b167b8b | MSPARSER_REL_3_0_0-2024-09-24-0-g93ebaeb4f4 $
* @(#)$Date: 2024-09-20 16:45:19 +0100 $
##############################################################################
 */
 
#if !defined(ms_imputation_INCLUDED_)
#define ms_imputation_INCLUDED_
#include <vector>
 
namespace matrix_science
{
    // Forward declarations
    class ms_imputation_method;
    class ms_imputation_fixed_value;
    class ms_imputation_average_value;
    class ms_imputation_knn;
    class ms_imputation_missforest;
 
    class MS_MASCOTRESFILE_API ms_imputation_missing_val { 
        
    public:
 
    ms_imputation_missing_val()
        : isMissing_(true)
        , val_(0.0)
        { }
 
    ms_imputation_missing_val(
        bool isMissing,
        double val)
        : isMissing_(isMissing)
        , val_(val) {}
 
    bool isMissing() const { return isMissing_; }
 
    void setMissing() { isMissing_ = true; val_ = 0.0; }
 
    double getVal() const { return val_; }
 
    void setVal(double val) { val_ = val; isMissing_ = false; }
        
    private:
 
    bool isMissing_ = true; 
    double val_ = 0.0; 
    };
 
    class MS_MASCOTRESFILE_API ms_imputation_peptide_data {
 
    public:
 
    ms_imputation_peptide_data(
        double retentionTime,
        int subproject)
        : retentionTime_(retentionTime)
        , subproject_(subproject) {}
 
 
    virtual ~ms_imputation_peptide_data() {}
 
    const double retentionTime() const { return retentionTime_; }
 
    const int subproject() const { return subproject_; }
 
    private:
 
    // Internal variables
    double retentionTime_;
    int subproject_;  // This is 1 based
    };
 
    class MS_MASCOTRESFILE_API ms_imputation : public ms_errors
    {
    public:
 
 
    enum IMPUTATION_VARIABLE { 
        IMPUTE_PROTEIN_RATIO,        
        IMPUTE_PEPTIDE_RATIO,        
        IMPUTE_RETENTION_TIME        
    };
 
    ms_imputation(const ms_ms1quantitation* ms1quantitation, ms_imputation_method& m, IMPUTATION_VARIABLE imputationVariableChoice);
 
    ms_imputation(const ms_ms2quantitation* ms2quantitation, ms_imputation_method& m, IMPUTATION_VARIABLE imputationVariableChoice);
 
    ms_imputation(std::vector<std::vector<ms_imputation_peptide_data>> imputationPeptides, ms_imputation_method& m);
 
    ~ms_imputation();
 
    const IMPUTATION_VARIABLE getImputationVariableChoice() const { return IMPUTATION_VARIABLE_; }
 
    void setImputationVariableChoice(const IMPUTATION_VARIABLE imputationVariableChoiceIn) { IMPUTATION_VARIABLE_ = imputationVariableChoiceIn; }
 
    bool getImputeMs1PeptideExcludedByFractionThr() { return (IMPUTATION_MS1_PEPTIDE_CHOICE_ & IMPUTATION_MS1_PEPTIDE_CHOICE::IMPUTE_IF_EXCLUDED_BY_FRACTION_THR) != 0; }
 
    void setImputeMs1PeptideExcludedByFractionThr(bool imputeMs1PeptideExcludedByFractionThr);
 
    bool getImputeMs1PeptideExcludedByCorrelationThr() { return (IMPUTATION_MS1_PEPTIDE_CHOICE_ & IMPUTATION_MS1_PEPTIDE_CHOICE::IMPUTE_IF_EXCLUDED_BY_CORRELATION_THR) != 0; }
 
    void setImputeMs1PeptideExcludedByCorrelationThr(bool imputeMs1PeptideExcludedByCorrelationThr);
 
    bool getImputeMs1PeptideExcludedByStdErrThr() { return (IMPUTATION_MS1_PEPTIDE_CHOICE_ & IMPUTATION_MS1_PEPTIDE_CHOICE::IMPUTE_IF_EXCLUDED_BY_STDERR_THR) != 0; }
 
    void setImputeMs1PeptideExcludedByStdErrThr(bool imputeMs1PeptideExcludedByStdErrThr);
 
    bool getImputeMs1PeptideNegativeRatio() { return (IMPUTATION_MS1_PEPTIDE_CHOICE_ & IMPUTATION_MS1_PEPTIDE_CHOICE::IMPUTE_IF_NEGATIVE) != 0; }
 
    void setImputeMs1PeptideNegativeRatio(bool imputeMs1PeptideNegativeRatio);
 
    bool getImputeExcludedMs2PeptideRatios() { return imputation_ms2_peptide_choice_; }
 
    void setImputeExcludedMs2PeptideRatios(bool imputationMs2PeptideChoiceIn) { imputation_ms2_peptide_choice_ = imputationMs2PeptideChoiceIn; }
 
    std::vector<std::vector<double>> impute();
 
    private:
 
    ms_imputation(ms_imputation_method& m);
 
    void appendImputationPeptides();
 
    void appendObservation(ms_imputation_peptide_data);
 
 
    enum IMPUTATION_MS1_PEPTIDE_CHOICE {
        IMPUTE_ALL_EXCLUDED_RATIOS = 0,             
        IMPUTE_IF_EXCLUDED_BY_FRACTION_THR = 1,     
        IMPUTE_IF_EXCLUDED_BY_CORRELATION_THR = 2,  
        IMPUTE_IF_EXCLUDED_BY_STDERR_THR = 4,       
        IMPUTE_IF_NEGATIVE = 8,                     
        IMPUTE_NO_EXCLUDED_RATIOS = 16              
    };
 
    // Default excluded behaviour
    int IMPUTATION_MS1_PEPTIDE_CHOICE_ = 8; // i.e. IMPUTATION_PEPTIDE_CHOICE::IMPUTE_IF_NEGATIVE;
    bool imputation_ms2_peptide_choice_ = true; // Treat excluded ms2 peptide ratios as missing
    // Initialise member pointers to null
    const ms_peptidesummary* pepSum_ = nullptr;
    const ms_quant_method* quantMethod_ = nullptr;
    const ms_ms1quantitation* ms1_quant_ = nullptr;
    const ms_ms2quantitation* ms2_quant_ = nullptr;
    ms_imputation_fixed_value* fixed_value_imputation_ = nullptr;
    ms_imputation_average_value* average_value_imputation_ = nullptr;
    ms_imputation_knn* knn_imputation_ = nullptr;
    ms_imputation_missforest* missforest_imputation_ = nullptr;
    // Member variables
    ms_imputation_method& imputation_method_;
    std::vector<std::vector<ms_imputation_missing_val>> dataWithMissing_;
    std::vector<std::vector<ms_imputation_peptide_data>> imputationPeptides_;
    std::vector<ms_imputation_peptide_data> aObservationSet_;
    // Default ratio choice
    IMPUTATION_VARIABLE IMPUTATION_VARIABLE_ = IMPUTATION_VARIABLE::IMPUTE_PROTEIN_RATIO;
    // Methods
    void populateArraysForImputation();
    void extractProteinRatios();
    void extractPeptideRatios();
    std::vector<ms_ms1quant_match> getMatchesList(int hitNim, int memNum);
    void pullProteinsFrom(std::vector<matrix_science::ms_protein>& proteinsOut);
    void extractRetentionTimes();
    void extractMs1PeptideStatus(int ratioStatus, std::vector<bool>& boolStatus);
    };
 
    class MS_MASCOTRESFILE_API ms_imputation_method : public ms_errors
    {
    public:
 
    std::vector<std::vector<ms_imputation_missing_val>>& getDataWithMissing() { return dataWithMissing_; }
 
    // Overloaded method to execute the imputation calculation
    virtual std::vector<std::vector<double>> impute() = 0;
 
    friend class ms_imputation;
 
    virtual ~ms_imputation_method();
 
    protected:
 
    ms_imputation_method() = default;
    // Internal variables
    std::vector<std::vector<ms_imputation_missing_val>> dataWithMissing_;
    std::vector<std::vector<double>> completeObservations_;
    std::vector<double> averageValues_;
    // Methods
    void setDataWithMissing(const std::vector<std::vector<ms_imputation_missing_val>>& dataWithMissingIn);
    std::vector<double> changems_imputation_missing_valVecToDoubleVec(std::vector<ms_imputation_missing_val> missingObservation);
    std::vector<std::vector<double>> changems_imputation_missing_valArrayToDoubleArray(std::vector<std::vector<ms_imputation_missing_val>> dataProcess);
    std::vector<int> getMissingIndexes(std::vector<ms_imputation_missing_val>);
    std::vector<double> getKnownValues(std::vector<ms_imputation_missing_val>);
    std::vector<std::vector<int>> removeDuplicateIndexes(std::vector<std::vector<int>> duplicateIndexes);
    void averageFindAverage();
    };
 
    class MS_MASCOTRESFILE_API ms_imputation_fixed_value : public ms_imputation_method
    {
        using ms_imputation_method::ms_imputation_method;
 
    public:
 
    double getFixedValue() { return fixedValue_; }
 
    void setFixedValue(double fixedValueIn) { fixedValue_ = fixedValueIn; }
 
    std::vector<std::vector<double>> impute() override;
 
    friend class ms_imputation;
 
    ~ms_imputation_fixed_value();
 
    private:
 
    // Internal fixed value
    double fixedValue_ = 0;
    };
 
    class MS_MASCOTRESFILE_API ms_imputation_average_value : public ms_imputation_method
    {
        using ms_imputation_method::ms_imputation_method;
 
    public:
 
    std::vector<double> getAverageValues() { return averageValues_; }
 
    void setAverageValues(std::vector<double> averageValuesIn) { averageValues_ = averageValuesIn; }
 
    std::vector<std::vector<double>> impute() override;
 
    friend class ms_imputation;
 
    ~ms_imputation_average_value();
    };
 
    class MS_MASCOTRESFILE_API ms_imputation_knn : public ms_imputation_method
    {
        using ms_imputation_method::ms_imputation_method;
 
    public:
 
    int getKnnNumNeighbours() { return knnNumNeighbours_; }
 
    void setKnnNumNeighbours(int knnNumNeighboursIn) { knnNumNeighbours_ = knnNumNeighboursIn; }
 
    bool getKnnUseWeightedAverage() { return knnUseWeightedAverage_; }
 
    void setKnnUseWeightedAverage(bool knnUseWeightedAverageIn) { knnUseWeightedAverage_ = knnUseWeightedAverageIn; }
 
    std::vector<std::vector<double>> impute() override;
 
    friend class ms_imputation;
 
    ~ms_imputation_knn();
 
    private:
 
    // Internal knn parameters
    int knnNumNeighbours_ = 5;
    bool knnUseWeightedAverage_ = true;
    std::vector<std::vector<int>> missingCombinations_;
 
    // Internal methods
    void knnImpute();
    void knnProcess();
    void getCompleteObsAndMissingIndexes();
    };
 
    class MS_MASCOTRESFILE_API ms_imputation_missforest : public ms_imputation_method
    {
        using ms_imputation_method::ms_imputation_method;
 
    public:
 
    std::vector<std::vector<double>> impute() override;
 
    friend class ms_imputation;
 
    ~ms_imputation_missforest();
 
    private:
 
    // Internal methods
    void IdentifyMissing(std::vector<int>& missingCounts, std::vector<std::vector<int>>& missingRows);
    double GetDifferences(std::vector<std::vector<double>>& currData, std::vector<std::vector<double>>& prevData);
    double GetDoubleDifferences(std::vector<std::vector<double>>& currData, std::vector<std::vector<double>>& prevData);
    bool CompareDiffs(std::vector<double> iterationDifferences);
    };
 // end of tools_group
} // namespace matrix_science
 
#endif // !defined(ms_imputation_INCLUDED_)
 
/*------------------------------- End of File -------------------------------*/