ExperimentalDesign.h

Go to the documentation of this file.

// --------------------------------------------------------------------------
//                   OpenMS -- Open-Source Mass Spectrometry
// --------------------------------------------------------------------------
// Copyright The OpenMS Team -- Eberhard Karls University Tuebingen,
// ETH Zurich, and Freie Universitaet Berlin 2002-2023.
//
// This software is released under a three-clause BSD license:
//  * Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//  * Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//  * Neither the name of any author or any participating institution
//    may be used to endorse or promote products derived from this software
//    without specific prior written permission.
// For a full list of authors, refer to the file AUTHORS.
// --------------------------------------------------------------------------
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL ANY OF THE AUTHORS OR THE CONTRIBUTING
// INSTITUTIONS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
// OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
// ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// --------------------------------------------------------------------------
// $Maintainer: Timo Sachsenberg $
// $Authors: Timo Sachsenberg $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/KERNEL/StandardTypes.h>
#include <OpenMS/DATASTRUCTURES/String.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;  
      String sample_name = "0"; 
    };
 
    class OPENMS_DLLAPI SampleSection
    {
    public:
 
      SampleSection() = default;
 
      SampleSection(
        const std::vector< std::vector < String > >& content,
        const std::map< String, Size >& sample_to_rowindex,
        const std::map< String, Size >& columnname_to_columnindex
      );
 
      // Get set of all samples that are present in the sample section
      std::set< String > getSamples() const;
 
      // Add a sample as the last row
      void addSample(const String& sample, const std::vector<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< String > getFactors() const;
 
      // Checks whether sample section has row for a sample number
      bool hasSample(const String& sample) const;
 
      // Checks whether Sample Section has a specific factor (i.e. column name)
      bool hasFactor(const String &factor) const;
 
      // Returns value of factor for given sample and factor name
      String getFactorValue(const String& sample_name, const String &factor) const;
 
      // Returns value of factor for given sample index and factor name
      String getFactorValue(unsigned sample_idx, const String &factor) const;
 
      // Returns column index of factor
      Size getFactorColIdx(const String &factor) const;
 
      // Returns the name/ID of the sample. Not necessarily the row index
      String getSampleName(unsigned sample_row) const;
 
      // Returns the row index in the sample section for a sample name/ID
      unsigned getSampleRow(const String& sample) const;
 
      Size getContentSize() const;
 
    private:
 
      // The entries of the Sample Section, filled while parsing
      // the Experimental Design File
      std::vector< std::vector < String > > content_;
 
      // Maps the Sample Entry name to the row where the sample
      // appears in the Sample section, its sample index
      std::map< String, Size > sample_to_rowindex_;
 
      // Maps the column name of the SampleSection to the
      // Index of the column
      std::map< 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<String>, std::set<String>> getUniqueSampleRowToSampleMapping() const;
 
    std::map<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<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<String, unsigned>>> getConditionToPathLabelVector() const;
 
    std::map<std::vector<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< String, unsigned >, unsigned> getPathLabelToPrefractionationMapping(bool use_basename_only) const;
 
    std::map< std::pair< String, unsigned >, unsigned> getPathLabelToConditionMapping(bool use_basename_only) const;
 
    std::map<String, unsigned> getSampleToConditionMapping() const;
 
    std::map< std::pair< String, unsigned >, unsigned> getPathLabelToSampleMapping(bool use_basename_only) const;
 
    std::map< std::pair< String, unsigned >, unsigned> getPathLabelToFractionMapping(bool use_basename_only) const;
 
    std::map< std::pair< 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<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< 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< 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 String &message);
 
    // basic consistency checks
    void isValid_();
 
    MSFileSection msfile_section_;
    SampleSection sample_section_;
  };
}