DTAFile.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: Marc Sturm $
// --------------------------------------------------------------------------
 
#pragma once
 
#include <OpenMS/DATASTRUCTURES/StringUtils.h>
#include <OpenMS/CONCEPT/Constants.h>
#include <OpenMS/METADATA/Precursor.h>
#include <OpenMS/SYSTEM/File.h>
 
#include <fstream>
#include <vector>
 
namespace OpenMS
{
 
  class OPENMS_DLLAPI DTAFile
  {
 
public:
 
    DTAFile();
 
    virtual ~DTAFile();
 
    template <typename SpectrumType>
    void load(const std::string & filename, SpectrumType & spectrum)
    {
      std::ifstream is(filename.c_str());
      if (!is)
      {
        if (!File::exists(filename))
        {
          throw Exception::FileNotFound(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, filename);
        }
        else if (!File::readable(filename))
        {
          throw Exception::FileNotReadable(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, filename);
        }
        else
        {
          throw Exception::IOException(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, filename);
        }
      }
 
      // delete old spectrum
      spectrum.clear(true);
 
      // temporary variables
      std::string line;
      std::vector<std::string> strings(2);
      typename SpectrumType::PeakType p;
      char delimiter;
 
      // line number counter
      Size line_number = 1;
 
      // read first line and store precursor m/z and charge
      getline(is, line, '\n');
      StringUtils::trim(line);
 
      // test which delimiter is used in the line
      if (StringUtils::has(line, '\t'))
      {
        delimiter = '\t';
      }
      else
      {
        delimiter = ' ';
      }
 
      StringUtils::split(line, delimiter, strings);
      if (strings.size() != 2)
      {
        throw Exception::ParseError(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, std::string("Bad data line (" + StringUtils::toStr(line_number) + "): \"") + line + "\" (got  " + StringUtils::toStr(strings.size()) + ", expected 2 entries)", filename);
      }
      Precursor precursor;
      double mh_mass;
      Int charge;
      try
      {
        // by convention the first line holds: singly protonated peptide mass, charge state
        mh_mass = StringUtils::toDouble(strings[0]);
        charge = StringUtils::toInt32(strings[1]);
      }
      catch (...)
      {
        throw Exception::ParseError(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, std::string("Bad data line (" + StringUtils::toStr(line_number) + "): \"") + line + "\": not a float number.", filename);
      }
      if (charge != 0)
      {
        precursor.setMZ((mh_mass - Constants::PROTON_MASS_U) / charge + Constants::PROTON_MASS_U);
      }
      else
      {
        precursor.setMZ(mh_mass);
      }
      precursor.setCharge(charge);
      spectrum.getPrecursors().push_back(precursor);
      spectrum.setMSLevel(default_ms_level_);
 
      while (getline(is, line, '\n'))
      {
        ++line_number;
        StringUtils::trim(line);
        if (line.empty()) continue;
 
        //test which delimiter is used in the line
        if (StringUtils::has(line, '\t'))
        {
          delimiter = '\t';
        }
        else
        {
          delimiter = ' ';
        }
 
        StringUtils::split(line, delimiter, strings);
        if (strings.size() != 2)
        {
          throw Exception::ParseError(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, std::string("Bad data line (" + StringUtils::toStr(line_number) + "): \"") + line + "\" (got  " + StringUtils::toStr(strings.size()) + ", expected 2 entries)", filename);
        }
        try
        {
          //fill peak
          p.setPosition((typename SpectrumType::PeakType::PositionType)StringUtils::toDouble(strings[0]));
          p.setIntensity((typename SpectrumType::PeakType::IntensityType)StringUtils::toDouble(strings[1]));
        }
        catch (Exception::BaseException & /*e*/)
        {
          throw Exception::ParseError(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, std::string("Bad data line (" + StringUtils::toStr(line_number) + "): \"") + line + "\": not a float number.", filename);
        }
        spectrum.push_back(p);
      }
 
      spectrum.setName(File::basename(filename));
      is.close();
    }
 
    template <typename SpectrumType>
    void store(const std::string & filename, const SpectrumType & spectrum) const
    {
      std::ofstream os(filename.c_str());
      if (!os)
      {
        throw Exception::UnableToCreateFile(__FILE__, __LINE__, OPENMS_PRETTY_FUNCTION, filename);
      }
      os.precision(writtenDigits<double>(0.0));
 
      // write precursor information
      Precursor precursor;
      if (spectrum.getPrecursors().size() > 0)
      {
        precursor = spectrum.getPrecursors()[0];
      }
      if (spectrum.getPrecursors().size() > 1)
      {
        std::cerr << "Warning: The spectrum written to the DTA file '" << filename << "' has more than one precursor. The first precursor is used!" << "\n";
      }
      // unknown charge
      if (precursor.getCharge() == 0)
      {
        os << precursor.getMZ();
      }
      // known charge
      else
      {
        os << ((precursor.getMZ() - 1.0) * precursor.getCharge() + 1.0);
      }
      // charge
      os << " " << precursor.getCharge() << "\n";
 
      // iterate over all peaks of the spectrum and
      // write one line for each peak of the spectrum.
      typename SpectrumType::ConstIterator it(spectrum.begin());
      for (; it != spectrum.end(); ++it)
      {
        // write m/z and intensity
        os << it->getPosition() << " " << it->getIntensity() << "\n";
      }
 
      // done
      os.close();
    }
 
protected:
 
    UInt default_ms_level_;
 
  };
} // namespace OpenMS