pappso::PwizMsRunReader Class Reference

#include <pwizmsrunreader.h>

Inheritance diagram for pappso::PwizMsRunReader:

Public Member Functions
	PwizMsRunReader (MsRunIdCstSPtr &msrun_id_csp)
virtual	~PwizMsRunReader ()
virtual MassSpectrumSPtr	massSpectrumSPtr (std::size_t spectrum_index) override
	get a MassSpectrumSPtr class given its spectrum index More...
virtual MassSpectrumCstSPtr	massSpectrumCstSPtr (std::size_t spectrum_index) override
virtual QualifiedMassSpectrum	qualifiedMassSpectrum (std::size_t spectrum_index, bool want_binary_data=true) const override
	get a QualifiedMassSpectrum class given its scan number More...
virtual void	readSpectrumCollection (SpectrumCollectionHandlerInterface &handler) override
	function to visit an MsRunReader and get each Spectrum in a spectrum collection handler More...
virtual std::size_t	spectrumListSize () const override
	get the totat number of spectrum conained in the MSrun data file More...
virtual bool	hasScanNumbers () const override
	tells if spectra can be accessed using scan numbers by default, it returns false. Only overrided functions can check if scan numbers are available in the current file More...
Public Member Functions inherited from pappso::MsRunReader
	MsRunReader (MsRunIdCstSPtr &ms_run_id)
	MsRunReader (const MsRunReader &other)
virtual	~MsRunReader ()
const MsRunIdCstSPtr &	getMsRunId () const
virtual std::size_t	scanNumber2SpectrumIndex (std::size_t scan_number)
	if possible, converts a scan number into a spectrum index This is a convenient function to help transition from the old scan number (not implemented by all vendors) to more secure spectrum index (not vendor dependant). It is better to not rely on this function. More...

Protected Member Functions
virtual void	initialize () override
virtual bool	accept (const QString &file_name) const override
	tells if the reader is able to handle this file must be implemented by private MS run reader, specific of one or more file format More...
QualifiedMassSpectrum	qualifiedMassSpectrumFromPwizMSData (std::size_t spectrum_index, bool want_binary_data, bool &ok) const
QualifiedMassSpectrum	qualifiedMassSpectrumFromPwizSpectrumPtr (const MassSpectrumId &massSpectrumId, pwiz::msdata::Spectrum *spectrum_p, bool want_binary_data, bool &ok) const
pwiz::msdata::SpectrumPtr	getPwizSpectrumPtr (pwiz::msdata::SpectrumList *p_spectrum_list, std::size_t spectrum_index, bool want_binary_data) const

Protected Attributes
pwiz::msdata::MSDataPtr	msp_msData = nullptr
Protected Attributes inherited from pappso::MsRunReader
MsRunIdCstSPtr	mcsp_msRunId
MsRunReaderScanNumberMultiMap *	mpa_multiMapScanNumber = nullptr

Private Attributes
bool	m_hasScanNumbers = false

Friends
class	MsFileAccessor

Detailed Description

Definition at line 64 of file pwizmsrunreader.h.

Constructor & Destructor Documentation

PwizMsRunReader()

pappso::PwizMsRunReader::PwizMsRunReader

(

MsRunIdCstSPtr &

msrun_id_csp

)

Definition at line 72 of file pwizmsrunreader.cpp.

~PwizMsRunReader()

pappso::PwizMsRunReader::~PwizMsRunReader ( )

virtual

Definition at line 184 of file pwizmsrunreader.cpp.

Member Function Documentation

accept()

bool pappso::PwizMsRunReader::accept ( const QString &  file_name ) const

overrideprotectedvirtual

tells if the reader is able to handle this file must be implemented by private MS run reader, specific of one or more file format

Implements pappso::MsRunReader.

Definition at line 711 of file pwizmsrunreader.cpp.

{
  // qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__;
  return qualifiedMassSpectrum(spectrum_index, true).getMassSpectrumCstSPtr();
}
 
QualifiedMassSpectrum
PwizMsRunReader::qualifiedMassSpectrum(std::size_t spectrum_index,
                                       bool want_binary_data) const

getPwizSpectrumPtr()

pwiz::msdata::SpectrumPtr pappso::PwizMsRunReader::getPwizSpectrumPtr ( pwiz::msdata::SpectrumList *  p_spectrum_list, std::size_t  spectrum_index, bool  want_binary_data  ) const

protected

Definition at line 190 of file pwizmsrunreader.cpp.

    {
      qDebug() << "getPwizSpectrumPtr error " << error.what()
               << typeid(error).name();
 
      throw ExceptionNotFound(
        QObject::tr("Pwiz spectrum index %1 not found in MS file :\n%2")
          .arg(spectrum_index)
          .arg(error.what()));
    }
 
  if(native_pwiz_spectrum_sp.get() == nullptr)
    {
      throw ExceptionNotFound(
        QObject::tr(
          "Pwiz spectrum index %1 not found in MS file : null pointer")
          .arg(spectrum_index));
    }
 
  return native_pwiz_spectrum_sp;
}
 
 
QualifiedMassSpectrum
PwizMsRunReader::qualifiedMassSpectrumFromPwizSpectrumPtr(
  const MassSpectrumId &massSpectrumId,
  pwiz::msdata::Spectrum *spectrum_p,
  bool want_binary_data,
  bool &ok) const
{
  // qDebug();
 
  std::string env;
  env = setlocale(LC_ALL, "");
  setlocale(LC_ALL, "C");
 
  QualifiedMassSpectrum qualified_mass_spectrum(massSpectrumId);
 
  try
    {

hasScanNumbers()

bool pappso::PwizMsRunReader::hasScanNumbers ( ) const

overridevirtual

tells if spectra can be accessed using scan numbers by default, it returns false. Only overrided functions can check if scan numbers are available in the current file

Reimplemented from pappso::MsRunReader.

Definition at line 899 of file pwizmsrunreader.cpp.

initialize()

void pappso::PwizMsRunReader::initialize ( )

overrideprotectedvirtual

Implements pappso::MsRunReader.

Definition at line 84 of file pwizmsrunreader.cpp.

    {
      defaultReaderList.read(file_name_std, msDataPtrVector);
    }
  catch(std::exception &error)
    {
      qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "()"
               << QString("Failed to read the data from file %1")
                    .arg(QString::fromStdString(file_name_std));
    }
 
  // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "()"
  //<< "The number of runs is:" << msDataPtrVector.size()
  //<< "The number of spectra in first run is:"
  //<< msDataPtrVector.at(0)->run.spectrumListPtr->size();
 
  // Single-run file handling here.
 
  // Specific case of the MGF data format: we do not have a run id for that kind
  // of data. In this case there must be a single run!
 
  if(mcsp_msRunId->getRunId().isEmpty())
    {
      if(msDataPtrVector.size() != 1)
        throw(
          ExceptionNotPossible("For the kind of file at hand there can only be "
                               "one run in the file."));
 
      // At this point we know the single msDataPtr is the one we are looking
      // for.
 
      msp_msData = msDataPtrVector.front();
    }
 
  else
    {
      // Multi-run file handling here.
      for(auto &msDataPtr : msDataPtrVector)
        {
          if(msDataPtr->run.id == mcsp_msRunId->getRunId().toStdString())
            {
              msp_msData = msDataPtr;
 
              // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "()"
              //<< "Found the right MSDataPtr for run id.";
 
              break;
            }
        }
    }
 
  if(msp_msData == nullptr)
    {
      throw(ExceptionNotPossible(
        "Could not find a MSDataPtr matching the requested run id."));
    }
 
 
  // check if this MS run can be used with scan numbers
  // MS:1000490 Agilent instrument model
  pwiz::cv::CVID native_id_format =
    pwiz::msdata::id::getDefaultNativeIDFormat(*msp_msData.get());
 
  // msp_msData.get()->getDefaultNativeIDFormat();
 
  if(native_id_format == pwiz::cv::CVID::MS_Thermo_nativeID_format)
    {
      m_hasScanNumbers = true;
    }
  else
    {
      m_hasScanNumbers = false;
    }
 
  if(mcsp_msRunId.get()->getMzFormat() == MzFormat::mzXML)
    {
      m_hasScanNumbers = true;
    }
}
 
 
PwizMsRunReader::~PwizMsRunReader()
{
}
 
 
pwiz::msdata::SpectrumPtr
PwizMsRunReader::getPwizSpectrumPtr(pwiz::msdata::SpectrumList *p_spectrum_list,
                                    std::size_t spectrum_index,
                                    bool want_binary_data) const
{
  pwiz::msdata::SpectrumPtr native_pwiz_spectrum_sp;
 
  try
    {
      native_pwiz_spectrum_sp =
        p_spectrum_list->spectrum(spectrum_index, want_binary_data);
    }

massSpectrumCstSPtr()

pappso::MassSpectrumCstSPtr pappso::PwizMsRunReader::massSpectrumCstSPtr ( std::size_t  spectrum_index )

overridevirtual

Implements pappso::MsRunReader.

Definition at line 733 of file pwizmsrunreader.cpp.

        {
          // spectrum = qualifiedMassSpectrumFromPwizMSData(scan_num - 1);
        }
    }

massSpectrumSPtr()

pappso::MassSpectrumSPtr pappso::PwizMsRunReader::massSpectrumSPtr ( std::size_t  spectrum_index )

overridevirtual

get a MassSpectrumSPtr class given its spectrum index

Implements pappso::MsRunReader.

Definition at line 726 of file pwizmsrunreader.cpp.

qualifiedMassSpectrum()

QualifiedMassSpectrum pappso::PwizMsRunReader::qualifiedMassSpectrum ( std::size_t  spectrum_index, bool  want_binary_data = true  ) const

overridevirtual

get a QualifiedMassSpectrum class given its scan number

Implements pappso::MsRunReader.

Definition at line 740 of file pwizmsrunreader.cpp.

{
 
  // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "()";
 
  // We want to iterate in the pwiz-spectrum-list and for each pwiz-spectrum
  // create a pappso-spectrum (QualifiedMassSpectrum). Once the pappso mass
  // spectrum has been fully qualified (that is, the member data have been
  // set), it is transferred to the handler passed as parameter to this
  // function for the consumer to do what it wants with it.
 
  // Does the handler consuming the mass spectra read from file want these
  // mass spectra to hold the binary data arrays (mz/i vectors)?
 
  const bool want_binary_data = handler.needPeakList();

qualifiedMassSpectrumFromPwizMSData()

QualifiedMassSpectrum pappso::PwizMsRunReader::qualifiedMassSpectrumFromPwizMSData ( std::size_t  spectrum_index, bool  want_binary_data, bool &  ok  ) const

protected

Definition at line 657 of file pwizmsrunreader.cpp.

    {
      setlocale(LC_ALL, env.c_str());
      throw ExceptionNotFound(
        QObject::tr("The spectrum index cannot be equal to the size of the "
                    "spectrum list."));
    }
 
  // At this point we know the spectrum index might be sane, so store it in
  // the mass spec id object.
  massSpectrumId.setSpectrumIndex(spectrum_index);
 
  pwiz::msdata::SpectrumPtr native_pwiz_spectrum_sp =
    getPwizSpectrumPtr(spectrum_list_p.get(), spectrum_index, want_binary_data);
 
  setlocale(LC_ALL, env.c_str());
 
  massSpectrumId.setNativeId(
    QString::fromStdString(native_pwiz_spectrum_sp->id));
 
  return qualifiedMassSpectrumFromPwizSpectrumPtr(
    massSpectrumId, native_pwiz_spectrum_sp.get(), want_binary_data, ok);
}
 
 
bool
PwizMsRunReader::accept(const QString &file_name) const
{
  // We want to know if we can handle the file_name.
  pwiz::msdata::ReaderList reader_list;
 
  std::string reader_type = reader_list.identify(file_name.toStdString());
 
  if(!reader_type.empty())
    return true;
 
  return false;
}
 
 
pappso::MassSpectrumSPtr
PwizMsRunReader::massSpectrumSPtr(std::size_t spectrum_index)

qualifiedMassSpectrumFromPwizSpectrumPtr()

QualifiedMassSpectrum pappso::PwizMsRunReader::qualifiedMassSpectrumFromPwizSpectrumPtr ( const MassSpectrumId &  massSpectrumId, pwiz::msdata::Spectrum *  spectrum_p, bool  want_binary_data, bool &  ok  ) const

protected

Definition at line 235 of file pwizmsrunreader.cpp.

        {
          // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "()"
          //<< "The spectrum has precursor(s).";
 
          // Sanity check
          if(msLevel <= 1)
            {
              qDebug() << "Going to throw.";
 
              throw(ExceptionNotPossible(
                "msLevel cannot be less than two for "
                "a spectrum that has items in its Precursor list."));
            }
 
          // See what is the first precursor in the list.
 
          // qDebug() << "Now tring to get the precursor.";
 
          pwiz::msdata::Precursor &precursor = spectrum_p->precursors.front();
 
          // Set this variable ready as we need that default value in certain
          // circumstances.
 
          std::size_t precursor_spectrum_index =
            std::numeric_limits<std::size_t>::max();
 
          // qDebug() << "First precursor:" << precursor.spectrumID.c_str();
 
          if(precursor.spectrumID.empty())
            {
              // qDebug() << "The precursor's spectrum ID is empty.";
 
              if(mcsp_msRunId.get()->getMzFormat() == MzFormat::MGF)
                {
                  // qDebug()
                  //<< "Format is MGF, precursor's spectrum ID can be empty.";
                }
              else
                {
                  // When performing Lumos Fusion fragmentation experiments in
                  // Tune mode and with recording, the first spectrum of the
                  // list is a fragmentation spectrum (ms level 2) that has no
                  // identity for the precursor spectrum because there is no
                  // full scan accquisition.
 
#if 0
                  // Let's try to understand if we are in this configuration.
 
                  if(!massSpectrumId.getSpectrumIndex())
                    {
                      qDebug() << "This MS2 sprectrum is at index 0."
                                  "This might indicate a fragmentation "
                                  "experiment performed in Tune mode.";
 
                      // The precursor spectrum index is initialized to max().
                      // So, it is not going to be changed in the present
                      // situation.
                    }
                  else
                    {
                      qDebug() << "This MS2 spectrum has no precursor's "
                                  "spectrum index.";
                    }
                  // else
                  //{
                  // throw(
                  // ExceptionNotPossible("Failed to get the id of the "
                  //"precursor ion's spectrum."));
                  //}
#endif
                }
            }
          else
            {
              // We could get a native precursor spectrum id, so convert that
              // native id to a spectrum index.
 
              qualified_mass_spectrum.setPrecursorNativeId(
                QString::fromStdString(precursor.spectrumID));
 
              if(qualified_mass_spectrum.getPrecursorNativeId().isEmpty())
                {
                  // qDebug()
                  //<< "The native id of the precursor spectrum is empty !!!";
                }
 
              //  Get the spectrum index of the spectrum that contained the
              //  precursor ion.
 
              precursor_spectrum_index =
                msp_msData->run.spectrumListPtr->find(precursor.spectrumID);
 
              // Note that the Mascot MGF format has a peculiar handling of the
              // precursor ion stuff so we cannot throw.
              if(precursor_spectrum_index ==
                 msp_msData->run.spectrumListPtr->size())
                {
                  if(mcsp_msRunId.get()->getMzFormat() != MzFormat::MGF)
                    {
                      throw(
                        ExceptionNotPossible("Failed to find the index of the "
                                             "precursor ion's spectrum."));
                    }
                }
 
              qualified_mass_spectrum.setPrecursorSpectrumIndex(
                precursor_spectrum_index);
 
              // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "()"
              //<< "Set the precursor spectrum index to:"
              //<< qualified_mass_spectrum.getPrecursorSpectrumIndex()
              //<< "for qualified mass spectrum:"
              //<< &qualified_mass_spectrum;
            }
 
          if(!precursor.selectedIons.size())
            {
              throw(
                ExceptionNotPossible("The spectrum has msLevel > 1 but the "
                                     "precursor ions's selected ions "
                                     "list is empty."));
            }
 
          pwiz::msdata::SelectedIon &ion = *(precursor.selectedIons.begin());
 
          // selected ion m/z
 
          pappso_double selected_ion_mz =
            QString(ion.cvParam(pwiz::cv::MS_selected_ion_m_z).value.c_str())
              .toDouble();
 
          qualified_mass_spectrum.setPrecursorMz(selected_ion_mz);
 
          // selected ion peak intensity
 
          pappso_double selected_ion_peak_intensity =
            QString(ion.cvParam(pwiz::cv::MS_peak_intensity).value.c_str())
              .toDouble();
 
          qualified_mass_spectrum.setPrecursorIntensity(
            selected_ion_peak_intensity);
 
          //  unsigned int test =
          //  QString(ion.cvParam(pwiz::cv::MS_1200_series_LC_MSD_SL).value.c_str()).toUInt();
          //  qDebug() << " test "<< test;
 
          // charge state
 
          unsigned int selected_ion_charge_state =
            QString(ion.cvParam(pwiz::cv::MS_charge_state).value.c_str())
              .toUInt();
 
          if(selected_ion_charge_state > 0)
            {
              qualified_mass_spectrum.setPrecursorCharge(
                selected_ion_charge_state);
            }
 
 
          // General sum-up
          // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "()"
          //<< "precursor_scan_number:"
          //<< "selected_ion_m_z:" << selected_ion_mz
          //<< "selected_ion_peak_intensity:"
          //<< selected_ion_peak_intensity << "selected_ion_charge_state"
          //<< selected_ion_charge_state;
        }
      // End of
      // if(spectrum_p->precursors.size() > 0)
      else
        {
          // Sanity check
          if(msLevel != 1)
            {
              throw(
                ExceptionNotPossible("msLevel cannot be different than 1 if "
                                     "there is not a single precursor ion."));
            }
        }
 
      //  We now have to set the retention time at which this mass spectrum was
      //  acquired. This is the scan start time.
 
      if(!spectrum_p->scanList.scans[0].hasCVParam(
           pwiz::msdata::MS_scan_start_time))
        {
          if(mcsp_msRunId.get()->getMzFormat() == MzFormat::MGF)
            { // MGF could not have scan start time
              qualified_mass_spectrum.setRtInSeconds(-1);
            }
          else
            {
              throw(ExceptionNotPossible(
                "The spectrum has no scan start time value set."));
            }
        }
      else
        {
          pwiz::data::CVParam retention_time_cv_param =
            spectrum_p->scanList.scans[0].cvParam(
              pwiz::msdata::MS_scan_start_time);
 
          // Try to get the units of the retention time value.
 
          std::string unit_name = retention_time_cv_param.unitsName();
          // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "()"
          //<< "Unit name for the retention time:"
          //<< QString::fromStdString(unit_name);
 
          if(unit_name == "second")
            {
              qualified_mass_spectrum.setRtInSeconds(
                retention_time_cv_param.valueAs<double>());
            }
          else if(unit_name == "minute")
            {
              qualified_mass_spectrum.setRtInSeconds(
                retention_time_cv_param.valueAs<double>() * 60);
            }
          else
            throw(ExceptionNotPossible(
              "Could not determine the unit for the scan start time value."));
        }
 
      // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "()"
      //<< "Retention time for spectrum is:"
      //<< qualified_mass_spectrum.getRtInSeconds();
 
      // Old version not checking unit (by default unit is minutes for RT,
      // not seconds)
      //
      // pappso_double retentionTime =
      // QString(spectrum_p->scanList.scans[0]
      //.cvParam(pwiz::msdata::MS_scan_start_time)
      //.value.c_str())
      //.toDouble();
      // qualified_mass_spectrum.setRtInSeconds(retentionTime);
 
      // Not all the acquisitions have ion mobility data. We need to test
      // that:
 
      if(spectrum_p->scanList.scans[0].hasCVParam(
           pwiz::msdata::MS_ion_mobility_drift_time))
        {
 
          // qDebug() << "as strings:"
          //<< QString::fromStdString(
          // spectrum_p->scanList.scans[0]
          //.cvParam(pwiz::msdata::MS_ion_mobility_drift_time)
          //.valueAs<std::string>());
 
          pappso_double driftTime =
            spectrum_p->scanList.scans[0]
              .cvParam(pwiz::msdata::MS_ion_mobility_drift_time)
              .valueAs<double>();
 
          // qDebug() << "driftTime:" << driftTime;
 
          // Old version requiring use of QString.
          // pappso_double driftTime =
          // QString(spectrum_p->scanList.scans[0]
          //.cvParam(pwiz::msdata::MS_ion_mobility_drift_time)
          //.value.c_str())
          //.toDouble();
 
          // Now make positively sure that the obtained value is correct.
          // Note that I suffered a lot with Waters Synapt data that
          // contained apparently correct drift time XML element that in
          // fact contained either NaN or inf. When such mass spectra were
          // encountered, the mz,i data were bogus and crashed the data loading
          // functions. We just want to skip this kind of bogus mass spectrum by
          // letting the caller  know that the drift time was bogus ("I" is
          // Filippo Rusconi).
 
          if(std::isnan(driftTime) || std::isinf(driftTime))
            {
              // qDebug() << "detected as nan or inf.";
 
              ok = false;
 
              return qualified_mass_spectrum;
            }
          else
            {
              // The mzML standard stipulates that drift times are in
              // milliseconds.
              qualified_mass_spectrum.setDtInMilliSeconds(driftTime);
            }
        }
      // End of
      // if(spectrum_p->scanList.scans[0].hasCVParam(
      // pwiz::msdata::MS_ion_mobility_drift_time))
      else
        {
          // Not a bogus mass spectrum but also not a drift spectrum, set -1 as
          // the drift time value.
          qualified_mass_spectrum.setDtInMilliSeconds(-1);
        }
 
      // for(pwiz::data::CVParam cv_param : ion.cvParams)
      //{
      // pwiz::msdata::CVID param_id = cv_param.cvid;
      // qDebug() << param_id;
      // qDebug() << cv_param.cvid.c_str();
      // qDebug() << cv_param.name().c_str();
      // qDebug() << cv_param.value.c_str();
      //}
 
      if(want_binary_data)
        {
 
          // Fill-in MZIntensityPair vector for convenient access to binary
          // data
 
          std::vector<pwiz::msdata::MZIntensityPair> pairs;
          spectrum_p->getMZIntensityPairs(pairs);
 
          MassSpectrum spectrum;
          double tic = 0;
          // std::size_t iterCount = 0;
 
          // Iterate through the m/z-intensity pairs
          for(std::vector<pwiz::msdata::MZIntensityPair>::const_iterator
                it  = pairs.begin(),
                end = pairs.end();
              it != end;
              ++it)
            {
              //++iterCount;
 
              // qDebug() << "it->mz " << it->mz << " it->intensity" <<
              // it->intensity;
              if(it->intensity)
                {
                  spectrum.push_back(DataPoint(it->mz, it->intensity));
                  tic += it->intensity;
                }
            }
 
          if(mcsp_msRunId.get()->getMzFormat() == MzFormat::MGF)
            {
              // Sort peaks by mz
              spectrum.sortMz();
            }
 
          // lc = localeconv ();
          // qDebug() << " env=" << localeconv () << " lc->decimal_point "
          // << lc->decimal_point;
          //  qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "() "<<
          //  spectrum.size();
          MassSpectrumSPtr spectrum_sp = spectrum.makeMassSpectrumSPtr();
          qualified_mass_spectrum.setMassSpectrumSPtr(spectrum_sp);
 
          // double sumY =
          // qualified_mass_spectrum.getMassSpectrumSPtr()->sumY(); qDebug()
          // <<
          // __FILE__ << "@" << __LINE__ << __FUNCTION__ << "()"
          //<< "iterCount:" << iterCount << "Spectrum size "
          //<< spectrum.size() << "with tic:" << tic
          //<< "and sumY:" << sumY;
        }
      else
        qualified_mass_spectrum.setMassSpectrumSPtr(nullptr);
    }
  catch(PappsoException &errorp)
    {
      qDebug() << "Going to throw";
 
      throw pappso::PappsoException(
        QObject::tr("Error reading data using the proteowizard library: %1")
          .arg(errorp.qwhat()));
    }
  catch(std::exception &error)
    {
      qDebug() << "Going to throw";
 
      throw pappso::PappsoException(
        QObject::tr("Error reading data using the proteowizard library: %1")
          .arg(error.what()));
    }
 
  // setlocale(LC_ALL, env.c_str());
 
  ok = true;
  return qualified_mass_spectrum;
}
 
 
QualifiedMassSpectrum
PwizMsRunReader::qualifiedMassSpectrumFromPwizMSData(std::size_t spectrum_index,
                                                     bool want_binary_data,
                                                     bool &ok) const
{
 
  std::string env;
  env = setlocale(LC_ALL, "");
  // struct lconv *lc = localeconv();
 
  // qDebug() << __FILE__ << " " << __FUNCTION__ << " " << __LINE__
  //<< "env=" << env.c_str()
  //<< "lc->decimal_point:" << lc->decimal_point;
 
  setlocale(LC_ALL, "C");
 
  MassSpectrumId massSpectrumId(mcsp_msRunId);

References pappso::MsRunReader::mcsp_msRunId, pappso::MGF, and msp_msData.

readSpectrumCollection()

void pappso::PwizMsRunReader::readSpectrumCollection ( SpectrumCollectionHandlerInterface &  handler )

overridevirtual

function to visit an MsRunReader and get each Spectrum in a spectrum collection handler

Implements pappso::MsRunReader.

Definition at line 766 of file pwizmsrunreader.cpp.

    {
 
      // If the user of this reader instance wants to stop reading the spectra,
      // then break this loop.
      if(handler.shouldStop())
        {
          qDebug() << "The operation was cancelled. Breaking the loop.";
          break;
        }
 
      // Get the native pwiz-spectrum from the spectrum list.
      // Note that this pointer is a shared pointer from pwiz.
 
      pwiz::msdata::SpectrumPtr native_pwiz_spectrum_sp =
        getPwizSpectrumPtr(spectrum_list_p.get(), iter, want_binary_data);
 
      /*
       * we want to load metadata of the spectrum even if it does not contain
       peaks
 
       * if(!native_pwiz_spectrum_sp->hasBinaryData())
              {
                // qDebug() << __FILE__ << "@" << __LINE__ << __FUNCTION__ << "
       ()"
                //<< "native pwiz spectrum is empty, continuing.";
                continue;
              }
              */
 
      // Instantiate the mass spectrum id that will hold critical information
      // like the the native id string and the spectrum index.
 
      MassSpectrumId massSpectrumId(mcsp_msRunId, iter /* spectrum index*/);
 
      // Get the spectrum native id as a QString to store it in the mass
      // spectrum id class. This is will allow later to refer to the same
      // spectrum starting back from the file.
 
      QString native_id = QString::fromStdString(native_pwiz_spectrum_sp->id);
      massSpectrumId.setNativeId(native_id);
 
      // Finally, instantiate the qualified mass spectrum with its id. This
      // function will continue performing pappso-spectrum detailed
      // qualification.
 
      bool ok = false;
 
      QualifiedMassSpectrum qualified_mass_spectrum =
        qualifiedMassSpectrumFromPwizSpectrumPtr(
          massSpectrumId, native_pwiz_spectrum_sp.get(), want_binary_data, ok);
 
      if(!ok)
        {
          // qDebug() << "Encountered a mass spectrum for which the returned "
          //"status is bad.";
          continue;
        }
 
      // Before handing the mass spectrum out to the handler, see if the native
      // mass spectrum was empty or not.
 
      // if(!native_pwiz_spectrum_sp->defaultArrayLength)
      // qDebug() << "The mass spectrum has not defaultArrayLength";
 
      qualified_mass_spectrum.setEmptyMassSpectrum(
        !native_pwiz_spectrum_sp->defaultArrayLength);
 
      // The handler will receive the index of the mass spectrum in the
      // current run via the mass spectrum id member datum.
      handler.setQualifiedMassSpectrum(qualified_mass_spectrum);
    }
 
  setlocale(LC_ALL, env.c_str());
  // End of
  // for(std::size_t iter = 0; iter < spectrum_list_size; iter++)
 
  // Now let the loading handler know that the loading of the data has ended.
  // The handler might need this "signal" to perform additional tasks or to
  // cleanup cruft.
 
  // qDebug() << "Loading ended";
  handler.loadingEnded();
}
 
 
std::size_t
PwizMsRunReader::spectrumListSize() const
{
  return msp_msData->run.spectrumListPtr.get()->size();
}
 
bool
PwizMsRunReader::hasScanNumbers() const
{
  return m_hasScanNumbers;
}
 
 
} // namespace pappso

spectrumListSize()

std::size_t pappso::PwizMsRunReader::spectrumListSize ( ) const

overridevirtual

get the totat number of spectrum conained in the MSrun data file

Implements pappso::MsRunReader.

Definition at line 893 of file pwizmsrunreader.cpp.

Friends And Related Function Documentation

MsFileAccessor

friend class MsFileAccessor

friend

Definition at line 86 of file pwizmsrunreader.h.

Member Data Documentation

m_hasScanNumbers

bool pappso::PwizMsRunReader::m_hasScanNumbers = false

private

Definition at line 129 of file pwizmsrunreader.h.

msp_msData

pwiz::msdata::MSDataPtr pappso::PwizMsRunReader::msp_msData = nullptr

protected

Definition at line 109 of file pwizmsrunreader.h.

Referenced by qualifiedMassSpectrumFromPwizSpectrumPtr().

---

The documentation for this class was generated from the following files:

• pappsomspp/msrun/private/pwizmsrunreader.h
• pappsomspp/msrun/private/pwizmsrunreader.cpp