qcborspectrum.cpp

Go to the documentation of this file.

/**
 * \file pappsomspp/core/processing/cbor/mzcbor/copyreplace/qcborspectrum.cpp
 * \date 2/10/2026
 * \author Olivier Langella
 * \brief Low level CBOR map to store an mzCBOR Spectrum object
 */
 
/*******************************************************************************
 * Copyright (c) 2026 Olivier Langella <Olivier.Langella@cnrs.fr>.
 *
 * This file is part of PAPPSOms-tools.
 *
 *     PAPPSOms-tools is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation, either version 3 of the License, or
 *     (at your option) any later version.
 *
 *     PAPPSOms-tools is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with PAPPSOms-tools.  If not, see <http://www.gnu.org/licenses/>.
 *
 ******************************************************************************/
 
#include "qcborspectrum.h"
#include <cstddef>
#include <QCborMap>
#include <QCborValue>
#include <QCborArray>
#include <QDebug>
#include <qcborarray.h>
#include <qcbormap.h>
#include <qcborvalue.h>
#include <qlogging.h>
#include "pappsomspp/core/pappsoexception.h"
#include "pappsomspp/core/exception/exceptionnotfound.h"
#include "pappsomspp/core/processing/cbor/mzcbor/copyreplace/qcborspectrumprecursor.h"
#include "pappsomspp/core/processing/cbor/mzcbor/binarydataarray.h"
#include "pappsomspp/core/processing/cbor/mzcbor/scan.h"
 
namespace pappso
{
namespace cbor
{
namespace mzcbor
{
QcborSpectrum::QcborSpectrum() : QCborMap()
{
}
QcborSpectrum::QcborSpectrum(const QcborSpectrum &other) : QCborMap(other)
{
}
std::vector<QcborSpectrumPrecursor>
QcborSpectrum::getPrecursorList() const
{
  std::vector<QcborSpectrumPrecursor> precursor_list;
  qDebug();
  auto itout = constFind(QCborValue("precursorList"));
  if(itout != end())
    {
      auto it = itout.value().toMap().constFind(QCborValue("precursor"));
      if(it != end())
        {
          for(auto it_cv = it->toArray().cbegin(); it_cv != it->toArray().cend(); it_cv++)
            {
              qDebug();
              QcborSpectrumPrecursor precursor(it_cv->toMap());
              precursor_list.push_back(precursor);
            }
          return precursor_list;
        }
      else
        {
          throw pappso::PappsoException(QObject::tr("ERROR: no precursor array in QcborSpectrum"));
        }
    }
  else
    {
      throw pappso::PappsoException(QObject::tr("ERROR: no precursorList in QcborSpectrum"));
    }
}
 
double
QcborSpectrum::getRetentionTimeInSeconds() const
{
  auto itout = constFind(QCborValue("scanList"));
  if(itout != end())
    {
      auto it = itout.value().toMap().constFind(QCborValue("scan"));
      if(it != end())
        {
          for(auto it_cv = it->toArray().cbegin(); it_cv != it->toArray().cend(); it_cv++)
            {
              qDebug();
              Scan scan;
              scan.fromQCborMap(it_cv->toMap());
              return scan.getRtInSeconds();
            }
        }
      else
        {
          throw pappso::PappsoException(QObject::tr("ERROR: no scan array in QcborSpectrum"));
        }
    }
  else
    {
      throw pappso::PappsoException(QObject::tr("ERROR: no scanList in QcborSpectrum"));
    }
  return 0.0;
}
void
QcborSpectrum::setPrecursorList(std::vector<QcborSpectrumPrecursor> &precursor_list)
{
  QCborMap cbor_precursor_list;
  // auto itout = find(QCborValue("precursorList"));
  // qDebug();
  // if(itout != end())
  //   {
  qDebug();
  cbor_precursor_list.insert(QCborValue("count"), (qint64)precursor_list.size());
  qDebug();
 
  QCborArray cbor_arr;
  for(auto &it_prec : precursor_list)
    {
      cbor_arr.push_back(it_prec);
    }
  cbor_precursor_list.insert(QCborValue("precursor"), cbor_arr);
 
  insert(QCborValue("precursorList"), cbor_precursor_list);
  // auto it2 = itout.value().toMap().find(QCborValue("precursor"));
  // if(it2 != end())
  //   {
  //     QCborArray cbor_arr;
  //     for(auto &it_prec : precursor_list)
  //       {
  //         cbor_arr.push_back(it_prec);
  //       }
  //     qDebug() << cbor_arr.size();
  //     // it2. = QCborValue(cbor_arr);
  //     itout.value().toMap().insert(QCborValue("precursor"), cbor_arr);
  //   }
  // else
  //   {
  //     throw pappso::PappsoException(
  //       QObject::tr("ERROR: no precursor in precursorList QcborSpectrum"));
  //   }
  //     qDebug();
  //   }
  // else
  //   {
  //     throw pappso::PappsoException(QObject::tr("ERROR: no precursorList in QcborSpectrum"));
  //   }
}
QString
QcborSpectrum::getId() const
{
  // <spectrum
  //           id="controllerType=0 controllerNumber=1 scan=1"
  //           index="0"
  //           defaultArrayLength="1552"
  //       >
  QCborValue id("id");
  auto it = constFind(id);
  if(it != end())
    {
      qDebug() << *it;
      return it.value().toString();
    }
  else
    {
      throw pappso::PappsoException(QObject::tr("ERROR: no id in QcborSpectrum"));
    }
}
std::size_t
QcborSpectrum::getDefaultArrayLength() const
{
  QCborValue id("defaultArrayLength");
  auto it = constFind(id);
  if(it != end())
    {
      qDebug() << *it;
      return it.value().toInteger();
    }
  else
    {
      throw pappso::PappsoException(
        QObject::tr("ERROR: no defaultArrayLength in QcborSpectrum %1").arg(getId()));
    }
}
void
QcborSpectrum::setId(const QString &id)
{
  // <spectrum
  //           id="controllerType=0 controllerNumber=1 scan=1"
  //           index="0"
  //           defaultArrayLength="1552"
  //       >
  QCborValue native_id("id");
  auto it = find(native_id);
  if(it != end())
    {
      qDebug() << *it;
      it.value() = QCborValue(id);
    }
  else
    {
      throw pappso::PappsoException(QObject::tr("ERROR: no id in QcborSpectrum"));
    }
}
std::size_t
QcborSpectrum::getIndex() const
{
  QCborValue id("index");
  auto it = constFind(id);
  if(it != end())
    {
      qDebug() << *it;
      return (std::size_t)it.value().toInteger();
    }
  else
    {
      throw pappso::PappsoException(QObject::tr("ERROR: no index in QcborSpectrum"));
    }
}
void
QcborSpectrum::setIndex(std::size_t index)
{
  // <spectrum
  //           id="controllerType=0 controllerNumber=1 scan=1"
  //           index="0"
  //           defaultArrayLength="1552"
  //       >
  QCborValue id("index");
  auto it = find(id);
  if(it != end())
    {
      qDebug() << *it;
      it.value() = QCborValue((qint64)index);
    }
  else
    {
      throw pappso::PappsoException(QObject::tr("ERROR: no index in QcborSpectrum"));
    }
}
 
int
QcborSpectrum::getMsLevel() const
{
  //"cvParam":[{"cvRef":"MS","accession":"MS:1000511","name":"ms level","value":1}
 
  QCborValue cv_param("cvParam");
  auto it = constFind(cv_param);
  if(it != end())
    {
      for(auto it_cv = it->toArray().cbegin(); it_cv != it->toArray().cend(); it_cv++)
        {
          auto it_accession = it_cv->toMap().constFind(QCborValue("accession"));
          if(it_accession->toString() == "MS:1000511")
            {
              auto it_value = it_cv->toMap().find(QCborValue("value"));
              return (it_value.value().toInteger());
            }
        }
 
      throw pappso::ExceptionNotFound(
        QObject::tr("ERROR: MS level not found in QcborSpectrum %1").arg(getId()));
    }
  else
    {
      throw pappso::PappsoException(
        QObject::tr("ERROR: no cvparam in QcborSpectrum %1").arg(getId()));
    }
}
 
void
QcborSpectrum::decodeTrace(pappso::Trace &trace) const
{
  qDebug();
  std::vector<pappso_double> xVector;
  std::vector<pappso_double> yVector;
  std::size_t length = getDefaultArrayLength();
 
 
  auto it = constFind(QCborValue("binaryDataArray"));
  if(it != end())
    {
      for(auto it_binarr = it->toArray().cbegin(); it_binarr != it->toArray().cend(); it_binarr++)
        {
          BinaryDataArray binary_array;
          binary_array.fromQCborMap(it_binarr->toMap());
          qDebug();
          if(binary_array.isIntensity())
            {
              qDebug();
              binary_array.decodeVector(length, yVector);
            }
          else if(binary_array.isMz())
            {
              qDebug();
              binary_array.decodeVector(length, xVector);
            }
          else
            {
 
              throw pappso::ExceptionNotFound(
                QObject::tr("error in QcborSpectrum::decodeTrace binary vector "
                            "type not found"));
            }
          qDebug();
        }
    }
  else
    {
      throw pappso::PappsoException(
        QObject::tr("ERROR: no binaryDataArray in QcborSpectrum %1").arg(getId()));
    }
  qDebug();
  trace.initialize(xVector, yVector);
  qDebug();
}
} // namespace mzcbor
} // namespace cbor
} // namespace pappso