ExperimentalDesign.h

Go to the documentation of this file.

// Copyright (c) 2002-present, OpenMS Inc. -- 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/METADATA/ProteinIdentification.h>
 
#include <vector>
#include <map>
#include <set>
 
namespace OpenMS
{
  class ConsensusMap;
  class FeatureMap;
 
  class OPENMS_DLLAPI ExperimentalDesign
  {
 
  public:
    class OPENMS_DLLAPI MSFileSectionEntry
    {
    public:
      MSFileSectionEntry() = default;
      unsigned fraction_group = 1; 
      unsigned fraction = 1; 
      std::string path = "UNKNOWN_FILE"; 
      unsigned label = 1;  
      unsigned sample = 0;  
      std::string sample_name = "0"; 
    };
 
    class OPENMS_DLLAPI SampleSection
    {
    public:
 
      SampleSection() = default;
 
      SampleSection(
        const std::vector< std::vector < std::string > >& content,
        const std::map< std::string, Size >& sample_to_rowindex,
        const std::map< std::string, Size >& columnname_to_columnindex
      );
 
      // Get set of all samples that are present in the sample section
      std::set< std::string > getSamples() const;
 
      // Add a sample as the last row
      void addSample(const std::string& sample, const std::vector<std::string>& content = {});
 
      // TODO should it include the Sample ID column or not??
      // Get set of all factors (column names) that were defined for the sample section
      std::set< std::string > getFactors() const;
 
      // Checks whether sample section has row for a sample number
      bool hasSample(const std::string& sample) const;
 
      // Checks whether Sample Section has a specific factor (i.e. column name)
      bool hasFactor(const std::string &factor) const;
 
      // Returns value of factor for given sample and factor name
      std::string getFactorValue(const std::string& sample_name, const std::string &factor) const;
 
      // Returns value of factor for given sample index and factor name
      std::string getFactorValue(unsigned sample_idx, const std::string &factor) const;
 
      // Returns column index of factor
      Size getFactorColIdx(const std::string &factor) const;
 
      // Returns the name/ID of the sample. Not necessarily the row index
      std::string getSampleName(unsigned sample_row) const;
 
      // Returns the row index in the sample section for a sample name/ID
      unsigned getSampleRow(const std::string& sample) const;
 
      Size getContentSize() const;
 
    private:
 
      // The entries of the Sample Section, filled while parsing
      // the Experimental Design File
      std::vector< std::vector < std::string > > content_;
 
      // Maps the Sample Entry name to the row where the sample
      // appears in the Sample section, its sample index
      std::map< std::string, Size > sample_to_rowindex_;
 
      // Maps the column name of the SampleSection to the
      // Index of the column
      std::map< std::string, Size > columnname_to_columnindex_;
    };
 
    using MSFileSection = std::vector<MSFileSectionEntry>;
 
    // Experimental Design c'tors
    ExperimentalDesign() = default;
 
    ExperimentalDesign(const MSFileSection& msfile_section, const SampleSection& sample_section);
 
    const MSFileSection& getMSFileSection() const;
 
    void setMSFileSection(const MSFileSection& msfile_section);
 
    // Returns the Sample Section of the experimental design file
    const ExperimentalDesign::SampleSection& getSampleSection() const;
 
    void setSampleSection(const SampleSection& sample_section);
 
    std::map<std::vector<std::string>, std::set<std::string>> getUniqueSampleRowToSampleMapping() const;
 
    std::map<std::string, unsigned> getSampleToPrefractionationMapping() const;
 
    //TODO this probably needs a basename parameter to be fully compatible with the other mappings!! Implicit full path.
    std::map<unsigned int, std::vector<std::string> > getFractionToMSFilesMapping() const;
 
    //TODO this probably needs a basename parameter to be fully compatible with the other mappings!! Implicit full path.
    std::vector<std::vector<std::pair<std::string, unsigned>>> getConditionToPathLabelVector() const;
 
    std::map<std::vector<std::string>, std::set<unsigned>> getConditionToSampleMapping() const;
 
   /*
    *   The (Path, Label) tuples in the experimental design have to be unique, so we can map them
    *   uniquely to the sample number, fraction number, and fraction_group number
    */
 
    std::map< std::pair< std::string, unsigned >, unsigned> getPathLabelToPrefractionationMapping(bool use_basename_only) const;
 
    std::map< std::pair< std::string, unsigned >, unsigned> getPathLabelToConditionMapping(bool use_basename_only) const;
 
    std::map<std::string, unsigned> getSampleToConditionMapping() const;
 
    std::map< std::pair< std::string, unsigned >, unsigned> getPathLabelToSampleMapping(bool use_basename_only) const;
 
    std::map< std::pair< std::string, unsigned >, unsigned> getPathLabelToFractionMapping(bool use_basename_only) const;
 
    std::map< std::pair< std::string, unsigned >, unsigned> getPathLabelToFractionGroupMapping(bool use_basename_only) const;
 
    // @return the number of samples measured (= highest sample index)
    unsigned getNumberOfSamples() const;
 
    // @return the number of fractions (= highest fraction index)
    unsigned getNumberOfFractions() const;
 
    // @return the number of labels per file
    unsigned getNumberOfLabels() const;
 
    // @return the number of MS files (= fractions * fraction groups)
    unsigned getNumberOfMSFiles() const;
 
    // @return the number of fraction_groups
    // Allows to group fraction ids and source files
    unsigned getNumberOfFractionGroups() const;
 
    // @return sample index (depends on fraction_group and label)
    unsigned getSample(unsigned fraction_group, unsigned label = 1);
 
    // This is the case if we have at least one fraction group with >= 2 fractions
    bool isFractionated() const;
 
    Size filterByBasenames(const std::set<std::string>& bns);
 
    bool sameNrOfMSFilesPerFraction() const;
 
    static ExperimentalDesign fromConsensusMap(const ConsensusMap& c);
 
    static ExperimentalDesign fromFeatureMap(const FeatureMap& f);
 
    static ExperimentalDesign fromIdentifications(const std::vector<ProteinIdentification>& proteins);
    //TODO create another overload here, that takes two enums outerVec and innerVec with entries Replicate, Fraction, Sample
 
    private:
    // MS filename column, optionally trims to basename
    std::vector< std::string > getFileNames_(bool basename) const;
 
    // returns label column
    std::vector<unsigned> getLabels_() const;
 
    // returns fraction column
    std::vector<unsigned> getFractions_() const;
 
    std::map< std::pair< std::string, unsigned >, unsigned> pathLabelMapper_(
        bool,
        unsigned (*f)(const ExperimentalDesign::MSFileSectionEntry&)) const;
 
    // sort to obtain the default order
    void sort_();
 
    template<typename T>
    static void errorIfAlreadyExists(std::set<T> &container, T &item, const std::string &message);
 
    // basic consistency checks
    void isValid_();
 
    MSFileSection msfile_section_;
    SampleSection sample_section_;
  };
}