pappso::MzIntegrationParams Class Reference

The MzIntegrationParams class provides the parameters definining how m/z ! More...

#include <mzintegrationparams.h>

Inheritance diagram for pappso::MzIntegrationParams:

Public Types
enum class	BinningType { NONE = 0 , DATA_BASED , ARBITRARY , LAST }
enum class	InitializationResult : uint32_t {   DEFAULT = 0x000 , BINNING_TYPE = 1 << 0 , BIN_SIZE_MODEL = 1 << 1 , BIN_SIZE_DIVISOR = 1 << 2 ,   DECIMAL_PLACES = 1 << 3 , BINNING_LOGIC_PARTIAL = (BINNING_TYPE | BIN_SIZE_MODEL) , BINNING_LOGIC_FULL = (BINNING_LOGIC_PARTIAL | BIN_SIZE_DIVISOR | DECIMAL_PLACES) , REMOVE_ZERO_DATA_POINTS = 1 << 4 ,   FULL = (REMOVE_ZERO_DATA_POINTS | BINNING_LOGIC_FULL) }

Signals
void	smallestMzChanged ()
void	greatestMzChanged ()
void	binningTypeChanged ()
void	decimalPlacesChanged ()
void	binSizeModelChanged ()
void	binSizeDivisorChanged ()
void	removeZeroValDataPointsChanged ()
void	wasReset ()

Public Member Functions
Q_INVOKABLE	MzIntegrationParams (QObject *parent=nullptr)
Q_INVOKABLE	MzIntegrationParams (const QString &text, QObject *parent=nullptr)
Q_INVOKABLE	MzIntegrationParams (double minMz, double maxMz, BinningType binningType, pappso::PrecisionPtr precisionPtr, int binSizeDivisor, int decimalPlaces, bool removeZeroValDataPoints, QObject *parent=nullptr)
virtual	~MzIntegrationParams ()
Q_INVOKABLE MzIntegrationParams *	clone (QObject *parent=nullptr) const
Q_INVOKABLE InitializationResult	initialize (const QString &text)
Q_INVOKABLE void	initialize (double minMz, double maxMz, BinningType binningType, pappso::PrecisionPtr precisionPtr, int binSizeDivisor, int decimalPlaces, bool removeZeroValDataPoints, QObject *parent=nullptr)
Q_INVOKABLE void	initialize (const MzIntegrationParams &other, QObject *parent=nullptr)
void	initialize (MzIntegrationParams &other, InitializationResult initialization_results)
void	setSmallestMz (double value)
Q_INVOKABLE void	updateSmallestMz (double value)
double	getSmallestMz () const
void	setGreatestMz (double value)
Q_INVOKABLE void	updateGreatestMz (double value)
double	getGreatestMz () const
Q_INVOKABLE void	setMzValues (double smallest, double greatest)
void	setBinningType (BinningType binningType)
BinningType	getBinningType () const
void	setBinSizeModel (pappso::PrecisionPtr bin_size_model_p)
pappso::PrecisionPtr	getBinSizeModel () const
void	setBinSizeDivisor (int divisor)
int	getBinSizeDivisor () const
void	setDecimalPlaces (int decimal_places)
int	getDecimalPlaces () const
void	setRemoveZeroValDataPoints (bool removeOrNot=true)
bool	isRemoveZeroValDataPoints () const
Q_INVOKABLE void	reset ()
	Reset the instance to default values.
Q_INVOKABLE bool	isValid () const
Q_INVOKABLE bool	hasValidMzRange () const
Q_INVOKABLE std::vector< double >	createBins ()
Q_INVOKABLE std::vector< double >	createBins (pappso::MassSpectrumCstSPtr mass_spectrum_csp)
Q_INVOKABLE QString	toString (int offset, const QString &spacer=" ") const
Q_INVOKABLE QString	toString () const

Static Public Member Functions
static void	registerJsConstructor (QJSEngine *engine)

Protected Member Functions
std::vector< double >	createArbitraryBins ()
std::vector< double >	createDataBasedBins (pappso::MassSpectrumCstSPtr massSpectrum)

Protected Attributes
double	m_smallestMz = std::numeric_limits<double>::max()
double	m_greatestMz = std::numeric_limits<double>::min()
BinningType	m_binningType = BinningType::ARBITRARY
pappso::PrecisionPtr	m_binSizeModel = pappso::PrecisionFactory::getResInstance(40000)
int	m_binSizeDivisor = 1
int	m_decimalPlaces = -1
bool	m_removeZeroValDataPoints = true

Properties
double	smallestMz
double	greatestMz
BinningType	binningType
int	decimalPlaces
pappso::PrecisionPtr	binSizeModel
int	binSizeDivisor
bool	removeZeroValDataPoints

Detailed Description

The MzIntegrationParams class provides the parameters definining how m/z !

Depending on the various mass spectrometer vendors, the mass spectrometry data files are structured in different ways and the software for mass data format conversion from raw files to mzML or mzXML produce mass data characterized by different behaviours.

The different characteristics of mass spectrometry data set are:

The size of the various mass spectra in the file is constant or variable;

The first m/z value of the various spectra is identical or not (that is, the spectra are root in a constant or variable root m/z value);

The m/z delta between two consecutive m/z values of a given spectrum are constant or variable;

The spectra contain or not 0-value m/z data points;

Definition at line 85 of file mzintegrationparams.h.

Member Enumeration Documentation

BinningType

enum class pappso::MzIntegrationParams::BinningType

strong

Enumerator
NONE	< no binning
DATA_BASED	binning based on mass spectral data
ARBITRARY	binning based on arbitrary bin size value
LAST

Definition at line 109 of file mzintegrationparams.h.

  {
    //! < no binning
    NONE = 0,
 
    //! binning based on mass spectral data
    DATA_BASED,
 
    //! binning based on arbitrary bin size value
    ARBITRARY,
 
    LAST,
  };

InitializationResult

enum class pappso::MzIntegrationParams::InitializationResult : uint32_t

strong

Enumerator
DEFAULT
BINNING_TYPE
BIN_SIZE_MODEL
BIN_SIZE_DIVISOR
DECIMAL_PLACES
BINNING_LOGIC_PARTIAL
BINNING_LOGIC_FULL
REMOVE_ZERO_DATA_POINTS
FULL

Definition at line 124 of file mzintegrationparams.h.

  {
    // The order is important.
    // See end of class declaration for overload of bitwise operators
    DEFAULT             = 0x000,
    BINNING_TYPE            = 1 << 0,
    BIN_SIZE_MODEL          = 1 << 1,
    BIN_SIZE_DIVISOR        = 1 << 2,
    DECIMAL_PLACES          = 1 << 3,
    BINNING_LOGIC_PARTIAL   = (BINNING_TYPE | BIN_SIZE_MODEL),
    BINNING_LOGIC_FULL      = (BINNING_LOGIC_PARTIAL | BIN_SIZE_DIVISOR | DECIMAL_PLACES),
    REMOVE_ZERO_DATA_POINTS = 1 << 4,
    FULL                    = (REMOVE_ZERO_DATA_POINTS | BINNING_LOGIC_FULL),
  };

Constructor & Destructor Documentation

MzIntegrationParams() [1/3]

pappso::MzIntegrationParams::MzIntegrationParams ( QObject * parent = nullptr )

explicit

Definition at line 90 of file mzintegrationparams.cpp.

                                                        : QObject(parent)
{
}

Referenced by clone(), initialize(), and initialize().

MzIntegrationParams() [2/3]

pappso::MzIntegrationParams::MzIntegrationParams ( const QString & text, QObject * parent = nullptr )

explicit

Definition at line 94 of file mzintegrationparams.cpp.

                                                                             : QObject(parent)
{
  initialize(text);
}

References initialize().

MzIntegrationParams() [3/3]

pappso::MzIntegrationParams::MzIntegrationParams ( double minMz, double maxMz, MzIntegrationParams::BinningType binning_type, pappso::PrecisionPtr precisionPtr, int binSizeDivisor, int decimalPlaces, bool removeZeroValDataPoints, QObject * parent = nullptr )

explicit

Definition at line 99 of file mzintegrationparams.cpp.

  : QObject(parent),
    m_smallestMz(min_mz),
    m_greatestMz(max_mz),
    m_binningType(binning_type),
    m_binSizeModel(bin_size_model),
    m_binSizeDivisor(bin_size_divisor),
    m_decimalPlaces(decimal_places),
    m_removeZeroValDataPoints(remove_zero_val_data_points)
{
  if(m_binSizeModel == nullptr)
    m_binSizeModel = pappso::PrecisionFactory::getPpmInstance(20);
 
  // qDebug() << "MetaObject?" << this->metaObject()->className();
}

References pappso::PrecisionFactory::getPpmInstance(), m_binningType, m_binSizeDivisor, m_binSizeModel, m_decimalPlaces, m_greatestMz, m_removeZeroValDataPoints, and m_smallestMz.

~MzIntegrationParams()

pappso::MzIntegrationParams::~MzIntegrationParams ( )

virtual

Definition at line 122 of file mzintegrationparams.cpp.

{
}

Member Function Documentation

binningTypeChanged

void pappso::MzIntegrationParams::binningTypeChanged ( )

signal

Referenced by setBinningType().

binSizeDivisorChanged

void pappso::MzIntegrationParams::binSizeDivisorChanged ( )

signal

Referenced by setBinSizeDivisor().

binSizeModelChanged

void pappso::MzIntegrationParams::binSizeModelChanged ( )

signal

clone()

MzIntegrationParams * pappso::MzIntegrationParams::clone

(

QObject *

parent = nullptr

)

const

Definition at line 127 of file mzintegrationparams.cpp.

{
  MzIntegrationParams *mz_integration_params_p = new MzIntegrationParams(m_smallestMz,
                                                                         m_greatestMz,
                                                                         m_binningType,
                                                                         m_binSizeModel,
                                                                         m_binSizeDivisor,
                                                                         m_decimalPlaces,
                                                                         m_removeZeroValDataPoints,
                                                                         parent);
 
  return mz_integration_params_p;
}

References MzIntegrationParams(), m_binningType, m_binSizeDivisor, m_binSizeModel, m_decimalPlaces, m_greatestMz, m_removeZeroValDataPoints, and m_smallestMz.

createArbitraryBins()

std::vector< double > pappso::MzIntegrationParams::createArbitraryBins ( )

protected

Definition at line 543 of file mzintegrationparams.cpp.

{
  // Now starts the tricky stuff. Depending on the binning size model, we need to take diverse
  // actions.
 
  if(!isValid())
    qFatal() << "Programming error. The MzIntegrationParams::BinningLogic is not valid, cannot "
                "create bins.";
 
  qDebug() << "Binning logic:" << toString();
 
  double min_mz = m_smallestMz;
  double max_mz = m_greatestMz;
 
  qDebug() << "m_smallestMz:" << m_smallestMz << "m_greatestMz:" << m_greatestMz;
 
  double bin_size;
 
  if(m_binSizeModel->unit() == Enums::PrecisionUnit::res)
    {
      double resolution_based_bin_size = m_binSizeModel->delta(min_mz);
      bin_size                         = resolution_based_bin_size / m_binSizeDivisor;
 
      // qDebug() << "With res-based bin size, the uncorrected bin size:"
      //<< resolution_based_bin_size
      //<< "and the final binSize:" << binSize;
    }
  else
    bin_size = m_binSizeModel->delta(min_mz);
 
  // qDebug() << QString::asprintf(
  //"binSize is the precision delta for min_mz: %.6f\n", binSize);
 
  // Only compute the decimal places if they were not configured already.
  if(m_decimalPlaces == -1)
    {
      // qDebug() << "Now checking how many decimal places are needed.";
 
      // We want as many decimal places as there are 0s between the integral
      // part of the double and the first non-0 cipher.  For example, if
      // binSize is 0.004, zero decimals is 2 and m_decimalPlaces is set to 3,
      // because we want decimals up to 4 included.
 
      m_decimalPlaces = pappso::Utils::zeroDecimalsInValue(bin_size) + 1;
 
      // qDebug() << "With binSize" << binSize
      //<< " m_decimalPlaces was computed to be:" << m_decimalPlaces;
    }
  // else
  // qDebug() << "m_decimalPlaces: " << m_decimalPlaces;
 
  // Now that we have defined the value of m_decimalPlaces, let's use that
  // value.
 
  double first_mz =
    ceil((min_mz * std::pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
  double last_mz = ceil((max_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
  // qDebug() << "After having accounted for the decimals, new min/max values:"
  //<< QString::asprintf("Very first data point: %.6f\n", first_mz)
  //<< QString::asprintf("Very last data point to reach: %.6f\n",
  // last_mz);
 
  // Instanciate the vector of mz double_s that we'll feed with the bins.
 
  std::vector<double> bins;
 
  // Store that very first value for later use in the loop.
  // The bins are notking more than:
  //
  // 1. The first mz (that is the smallest mz value found in all the spectra
  // 2. A sequence of mz values corresponding to that first mz value
  // incremented by the bin size.
 
  // Seed the root of the bin vector with the first mz value rounded above as
  // requested.
  double previous_mz_bin = first_mz;
 
  bins.push_back(previous_mz_bin);
 
  // Now continue adding mz values until we have reached the end of the
  // spectrum, that is the max_mz value, as converted using the decimals to
  // last_mz.
 
  // debugCount value used below for debugging purposes.
  // int debugCount = 0;
 
  while(previous_mz_bin <= last_mz)
    {
 
      // qDebug() << "Now starting the bin creation loop.";
 
      // Calculate dynamically the precision delta according to the current mz
      // value.
 
      // double precision_delta = mp_precision->delta(previous_mz_bin);
      // qDebug() << "precision_delta: " << precision_delta;
 
      // In certain circumstances, the bin size is not enough to properly render
      // hyper-high resolution data (like the theoretical isotopic cluster data
      // generated in silico). In that case, the bin size, computed using the
      // precision object, is divided by the m_binSizeDivisor, which normally is
      // set to 1 as the default, that is, it has no effect.
 
      double current_mz;
 
      if(m_binSizeModel->unit() == Enums::PrecisionUnit::res)
        {
          current_mz =
            previous_mz_bin + (m_binSizeModel->delta(previous_mz_bin) / m_binSizeDivisor);
        }
      else
        {
          current_mz = previous_mz_bin + m_binSizeModel->delta(previous_mz_bin);
        }
 
      // qDebug() << QString::asprintf(
      //"previous_mzBin: %.6f and current_mz: %.6f\n",
      // previous_mz_bin,
      // current_mz);
 
      // Now apply on the obtained mz value the decimals that were either set
      // or computed earlier.
 
      double current_rounded_mz =
        ceil((current_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
      // qDebug() << QString::asprintf(
      //"current_mz: %.6f and current_rounded_mz: %.6f and previous_mzBin "
      //": % .6f\n ",
      // current_mz,
      // current_rounded_mz,
      // previous_mz_bin);
 
      // If rounding makes the new value identical to the previous one, then
      // that means that we need to decrease roughness.
 
      if(current_rounded_mz == previous_mz_bin)
        {
          ++m_decimalPlaces;
 
          current_rounded_mz =
            ceil((current_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
          // qDebug().noquote()
          //<< "Had to increment decimal places by one while creating the bins "
          //"in MzIntegrationParams::BinningType::ARBITRARY mode..";
        }
 
      bins.push_back(current_rounded_mz);
 
      // Use the local_mz value for the storage of the previous mz bin.
      previous_mz_bin = current_rounded_mz;
    }
 
 
#if 0
 
  QString fileName = "/tmp/massSpecArbitraryBins.txt-at-" +
                     QDateTime::currentDateTime().toString("yyyyMMdd-HH-mm-ss");
 
  qDebug() << "Writing the list of bins setup in the "
              "mass spectrum in file "
           << fileName;
 
  QFile file(fileName);
  file.open(QIODevice::WriteOnly);
 
  QTextStream fileStream(&file);
 
  for(auto &&bin : bins)
    fileStream << QString("%1\n").arg(bin, 0, 'f', 10);
 
  fileStream.flush();
  file.close();
 
#endif
 
  // qDebug() << "Prepared bins with " << bins.size() << "elements."
  //<< "starting with mz" << bins.front() << "ending with mz"
  //<< bins.back();
 
  return bins;
}

References isValid(), m_binSizeDivisor, m_binSizeModel, m_decimalPlaces, m_greatestMz, m_smallestMz, pappso::Enums::res, toString(), and pappso::Utils::zeroDecimalsInValue().

Referenced by createBins(), and createBins().

createBins() [1/2]

std::vector< double > pappso::MzIntegrationParams::createBins

(

)

Definition at line 483 of file mzintegrationparams.cpp.

{
 
  // qDebug() << "mp_precision:" << mp_precision->toString();
 
  std::vector<double> bins;
 
  if(m_binningType == MzIntegrationParams::BinningType::NONE)
    {
      // If no binning is to be performed, fine.
      return bins;
    }
  else if(m_binningType == MzIntegrationParams::BinningType::ARBITRARY)
    {
      // Use only data in the MzIntegrationParams member data.
      return createArbitraryBins();
    }
  else if(m_binningType == MzIntegrationParams::BinningType::DATA_BASED)
    {
      // qDebug();
 
      qFatal("Programming error. This kind of binning is not supported.");
    }
 
  return bins;
}

References ARBITRARY, createArbitraryBins(), DATA_BASED, m_binningType, and NONE.

createBins() [2/2]

std::vector< double > pappso::MzIntegrationParams::createBins

(

pappso::MassSpectrumCstSPtr

mass_spectrum_csp

)

Definition at line 512 of file mzintegrationparams.cpp.

{
 
  // qDebug();
 
  std::vector<double> bins;
 
  if(m_binningType == MzIntegrationParams::BinningType::NONE)
    {
      // If no binning is to be performed, fine.
      return bins;
    }
  else if(m_binningType == MzIntegrationParams::BinningType::ARBITRARY)
    {
      // Use only data in the MzIntegrationParams member data.
      return createArbitraryBins();
    }
  else if(m_binningType == MzIntegrationParams::BinningType::DATA_BASED)
    {
      // qDebug();
 
      // Use the first spectrum to perform the data-based bins
 
      return createDataBasedBins(mass_spectrum_csp);
    }
 
  return bins;
}

References ARBITRARY, createArbitraryBins(), createDataBasedBins(), DATA_BASED, m_binningType, and NONE.

createDataBasedBins()

std::vector< double > pappso::MzIntegrationParams::createDataBasedBins ( pappso::MassSpectrumCstSPtr massSpectrum )

protected

Definition at line 730 of file mzintegrationparams.cpp.

{
  // qDebug();
 
  // The bins in *this mass spectrum must be calculated starting from the
  // data in the mass_spectrum_csp parameter.
 
  // Instanciate the vector of mz double_s that we'll feed with the bins.
 
  std::vector<double> bins;
 
  if(mass_spectrum_csp->size() < 2)
    return bins;
 
  // Make sure the spectrum is sorted, as this functions takes for granted
  // that the DataPoint instances are sorted in ascending x (== mz) value
  // order.
  pappso::MassSpectrum local_mass_spectrum = *mass_spectrum_csp;
  local_mass_spectrum.sortMz();
 
  double min_mz = m_smallestMz;
 
  // qDebug() << "The min_mz:" << min_mz;
 
  if(m_decimalPlaces != -1)
    min_mz = ceil((min_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
 
  // Two values for the definition of a MassSpectrumBin.
 
  // The first value of the mz range that defines the bin. This value is part
  // of the bin.
  double start_mz_in = min_mz;
 
  // The second value of the mz range that defines the bin. This value is
  // *not* part of the bin.
  double end_mz_out;
 
  std::vector<pappso::DataPoint>::const_iterator it = local_mass_spectrum.begin();
 
  double prev_mz = it->x;
 
  if(m_decimalPlaces != -1)
    prev_mz = ceil((prev_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
  ++it;
 
  while(it != local_mass_spectrum.end())
    {
      double next_mz = it->x;
 
      if(m_decimalPlaces != -1)
        next_mz = ceil((next_mz * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
      double step = next_mz - prev_mz;
      end_mz_out  = start_mz_in + step;
 
      if(m_decimalPlaces != -1)
        end_mz_out =
          ceil((end_mz_out * pow(10, m_decimalPlaces)) - 0.49) / pow(10, m_decimalPlaces);
 
      // The data point that is crafted has a 0 y-value. The binning must
      // indeed not create artificial intensity data.
 
      // qDebug() << "Pushing back bin:" << start_mz_in << end_mz_out;
 
      bins.push_back(start_mz_in);
 
      // Prepare next bin
      start_mz_in = end_mz_out;
 
      // Update prev_mz to be the current one for next iteration.
      prev_mz = next_mz;
 
      // Now got the next DataPoint instance.
      ++it;
    }
 
#if 0
 
  QString fileName = "/tmp/massSpecDataBasedBins.txt";
 
  qDebug() << "Writing the list of bins setup in the "
              "mass spectrum in file "
           << fileName;
 
  QFile file(fileName);
  file.open(QIODevice::WriteOnly);
 
  QTextStream fileStream(&file);
 
  for(auto &&bin : m_bins)
    fileStream << QString("[%1-%2]\n")
                    .arg(bin.startMzIn, 0, 'f', 10)
                    .arg(bin.endMzOut, 0, 'f', 10);
 
  fileStream.flush();
  file.close();
 
  qDebug() << "elements."
           << "starting with mz" << m_bins.front().startMzIn << "ending with mz"
           << m_bins.back().endMzOut;
 
#endif
 
  return bins;
}

References m_decimalPlaces, m_smallestMz, and pappso::MassSpectrum::sortMz().

Referenced by createBins().

decimalPlacesChanged

void pappso::MzIntegrationParams::decimalPlacesChanged ( )

signal

Referenced by setDecimalPlaces().

getBinningType()

MzIntegrationParams::BinningType pappso::MzIntegrationParams::getBinningType

(

)

const

Definition at line 355 of file mzintegrationparams.cpp.

{
  return m_binningType;
}

References m_binningType.

getBinSizeDivisor()

int pappso::MzIntegrationParams::getBinSizeDivisor

(

)

const

Definition at line 396 of file mzintegrationparams.cpp.

{
  return m_binSizeDivisor;
}

References m_binSizeDivisor.

getBinSizeModel()

pappso::PrecisionPtr pappso::MzIntegrationParams::getBinSizeModel

(

)

const

Definition at line 380 of file mzintegrationparams.cpp.

{
  return m_binSizeModel;
}

References m_binSizeModel.

getDecimalPlaces()

int pappso::MzIntegrationParams::getDecimalPlaces

(

)

const

Definition at line 362 of file mzintegrationparams.cpp.

{
  return m_decimalPlaces;
}

References m_decimalPlaces.

getGreatestMz()

double pappso::MzIntegrationParams::getGreatestMz

(

)

const

Definition at line 331 of file mzintegrationparams.cpp.

{
  return m_greatestMz;
}

References m_greatestMz.

getSmallestMz()

double pappso::MzIntegrationParams::getSmallestMz

(

)

const

Definition at line 302 of file mzintegrationparams.cpp.

{
  return m_smallestMz;
}

References m_smallestMz.

greatestMzChanged

void pappso::MzIntegrationParams::greatestMzChanged ( )

signal

Referenced by setGreatestMz(), and updateGreatestMz().

hasValidMzRange()

bool pappso::MzIntegrationParams::hasValidMzRange

(

)

const

Definition at line 475 of file mzintegrationparams.cpp.

{
  return (m_smallestMz < std::numeric_limits<double>::max()) &&
         (m_greatestMz >= std::numeric_limits<double>::min());
}

References m_greatestMz, and m_smallestMz.

initialize() [1/4]

void pappso::MzIntegrationParams::initialize	(	const MzIntegrationParams &	other,
		QObject *	parent = nullptr )

Definition at line 244 of file mzintegrationparams.cpp.

{
  m_smallestMz              = other.m_smallestMz;
  m_greatestMz              = other.m_greatestMz;
  m_binningType             = other.m_binningType;
  m_binSizeModel            = other.m_binSizeModel;
  m_binSizeDivisor          = other.m_binSizeDivisor;
  m_decimalPlaces           = other.m_decimalPlaces;
  m_removeZeroValDataPoints = other.m_removeZeroValDataPoints;
 
  setParent(parent);
}

References MzIntegrationParams(), m_binningType, m_binSizeDivisor, m_binSizeModel, m_decimalPlaces, m_greatestMz, m_removeZeroValDataPoints, and m_smallestMz.

initialize() [2/4]

MzIntegrationParams::InitializationResult pappso::MzIntegrationParams::initialize

(

const QString &

text

)

Definition at line 142 of file mzintegrationparams.cpp.

{
  // qDebug() << "Initializing MzIntegrationParams using text:" << text;
 
  InitializationResult initialization_result = InitializationResult::DEFAULT;
 
  reset();
 
  m_removeZeroValDataPoints = true;
 
  if(text.isEmpty())
    return initialization_result;
 
  // Expected text: "Smallest (first) m/z:294.725158\nGreatest (last) m/z:2055.002453\nDecimal
  // places:-1\nBinning type:2\nBin size model:0.05 dalton\nBin size divisor:1\nRemove 0-val data
  // points:1\n"
 
  // In order to consider that the parameters were correctly read, we need
  // some of the members to effectively be set from the settings values.
 
  bool binning_type_set            = false;
  bool decimal_places_set          = false;
  bool bin_size_model_set          = false;
  bool bin_size_divisor_set        = false;
  bool remove_zero_data_points_set = false;
 
  QStringList string_list = text.split("\n");
 
  for(int iter = 0; iter < string_list.size(); ++iter)
    {
      QString iter_string = string_list.at(iter);
 
      // qDebug() << "Iterating in string:" << iter_string;
 
      if(iter_string.contains("Binning type:"))
        {
          m_binningType    = getBinningTypeFromString(iter_string.split(':').last());
          binning_type_set = true;
        }
      else if(iter_string.contains("Bin size model:"))
        {
          m_binSizeModel     = PrecisionFactory::fromString(iter_string.split(':').last());
          bin_size_model_set = true;
        }
      else if(iter_string.contains("Bin size divisor:"))
        {
          m_binSizeDivisor     = iter_string.split(':').last().toInt();
          bin_size_divisor_set = true;
        }
      else if(iter_string.contains("Decimal places:"))
        {
          m_decimalPlaces    = iter_string.split(':').last().toInt();
          decimal_places_set = true;
        }
      else if(iter_string.contains("Remove 0-val data points:"))
        {
          remove_zero_data_points_set = true;
          m_removeZeroValDataPoints   = iter_string.split(':').last().toInt();
        }
    }
 
  // qDebug() << "At this point the initialization is done and this"
  //             " MzIntegrationParams instance is: "
  //          << toString();
 
  if(binning_type_set)
    initialization_result |= InitializationResult::BINNING_TYPE;
  if(bin_size_model_set)
    initialization_result |= InitializationResult::BIN_SIZE_MODEL;
  if(bin_size_divisor_set)
    initialization_result |= InitializationResult::BIN_SIZE_DIVISOR;
  if(decimal_places_set)
    initialization_result |= InitializationResult::DECIMAL_PLACES;
 
  if(remove_zero_data_points_set)
    initialization_result |= InitializationResult::REMOVE_ZERO_DATA_POINTS;
 
  return initialization_result;
}

References BIN_SIZE_DIVISOR, BIN_SIZE_MODEL, BINNING_TYPE, DECIMAL_PLACES, DEFAULT, pappso::PrecisionFactory::fromString(), pappso::getBinningTypeFromString(), m_binningType, m_binSizeDivisor, m_binSizeModel, m_decimalPlaces, m_removeZeroValDataPoints, REMOVE_ZERO_DATA_POINTS, and reset().

Referenced by MzIntegrationParams().

initialize() [3/4]

void pappso::MzIntegrationParams::initialize	(	double	minMz,
		double	maxMz,
		MzIntegrationParams::BinningType	binning_type,
		pappso::PrecisionPtr	precisionPtr,
		int	binSizeDivisor,
		int	decimalPlaces,
		bool	removeZeroValDataPoints,
		QObject *	parent = nullptr )

Definition at line 223 of file mzintegrationparams.cpp.

{
  m_smallestMz              = min_mz;
  m_greatestMz              = max_mz;
  m_binningType             = binning_type;
  m_binSizeModel            = bin_size_model;
  m_binSizeDivisor          = bin_size_divisor;
  m_decimalPlaces           = decimal_places;
  m_removeZeroValDataPoints = remove_zero_val_data_points;
 
  setParent(parent);
}

References m_binningType, m_binSizeDivisor, m_binSizeModel, m_decimalPlaces, m_greatestMz, m_removeZeroValDataPoints, and m_smallestMz.

initialize() [4/4]

void pappso::MzIntegrationParams::initialize	(	MzIntegrationParams &	other,
		InitializationResult	initialization_results )

Definition at line 260 of file mzintegrationparams.cpp.

{
  if(static_cast<bool>(initialization_results &
                       pappso::MzIntegrationParams::InitializationResult::BINNING_TYPE))
    m_binningType = other.m_binningType;
 
  if(static_cast<bool>(initialization_results &
                       pappso::MzIntegrationParams::InitializationResult::BIN_SIZE_MODEL))
    m_binSizeModel = other.m_binSizeModel;
 
  if(static_cast<bool>(initialization_results &
                       pappso::MzIntegrationParams::InitializationResult::BIN_SIZE_DIVISOR))
    m_binSizeDivisor = other.m_binSizeDivisor;
 
  if(static_cast<bool>(initialization_results &
                       pappso::MzIntegrationParams::InitializationResult::DECIMAL_PLACES))
    m_decimalPlaces = other.m_decimalPlaces;
}

References MzIntegrationParams(), BIN_SIZE_DIVISOR, BIN_SIZE_MODEL, BINNING_TYPE, DECIMAL_PLACES, m_binningType, m_binSizeDivisor, m_binSizeModel, and m_decimalPlaces.

isRemoveZeroValDataPoints()

bool pappso::MzIntegrationParams::isRemoveZeroValDataPoints

(

)

const

Definition at line 423 of file mzintegrationparams.cpp.

{
  return m_removeZeroValDataPoints;
}

References m_removeZeroValDataPoints.

isValid()

bool pappso::MzIntegrationParams::isValid

(

)

const

Definition at line 448 of file mzintegrationparams.cpp.

{
  int errors = 0;
 
  if(m_binningType != MzIntegrationParams::BinningType::NONE)
    {
      // qDebug() << "m_smallestMz:" << m_smallestMz;
      // qDebug() << "smallest is max:" << (m_smallestMz ==
      // std::numeric_limits<double>::max());
      errors += (m_smallestMz == std::numeric_limits<double>::max() ? 1 : 0);
 
      // qDebug() << "m_greatestMz:" << m_greatestMz;
      // qDebug() << "greatest is min:" << (m_greatestMz ==
      // std::numeric_limits<double>::min());
      errors += (m_greatestMz == std::numeric_limits<double>::min() ? 1 : 0);
    }
 
  if(errors)
    {
      qCritical() << "The m/z integration parameters are invalid.";
    }
 
  return !errors;
}

References m_binningType, m_greatestMz, m_smallestMz, and NONE.

Referenced by createArbitraryBins().

registerJsConstructor()

void pappso::MzIntegrationParams::registerJsConstructor ( QJSEngine * engine )

static

Definition at line 907 of file mzintegrationparams.cpp.

{
  qDebug() << "registerJsConstructor for MzIntegrationParams to QJSEngine.";
 
  if(!engine)
    {
      qWarning() << "Cannot register class: engine is null";
      return;
    }
 
  QJSValue enumObject;
 
  enumObject = engine->newObject();
  enumObject.setProperty("none", static_cast<int>(pappso::MzIntegrationParams::BinningType::NONE));
  enumObject.setProperty("dataBased",
                         static_cast<int>(pappso::MzIntegrationParams::BinningType::DATA_BASED));
  enumObject.setProperty("arbitrary",
                         static_cast<int>(pappso::MzIntegrationParams::BinningType::ARBITRARY));
  engine->globalObject().setProperty("BinningType", enumObject);
 
  enumObject = engine->newObject();
  enumObject.setProperty(
    "default", static_cast<int>(pappso::MzIntegrationParams::InitializationResult::DEFAULT));
  enumObject.setProperty(
    "fromSettingsBinSizeModelPartial",
    static_cast<int>(pappso::MzIntegrationParams::InitializationResult::BINNING_LOGIC_PARTIAL));
  enumObject.setProperty(
    "fromSettingsBinSizeModelFull",
    static_cast<int>(pappso::MzIntegrationParams::InitializationResult::BINNING_LOGIC_FULL));
  enumObject.setProperty("fromSettingsFull",
                         static_cast<int>(pappso::MzIntegrationParams::InitializationResult::FULL));
  engine->globalObject().setProperty("InitializationResult", enumObject);
 
  // Register the meta object as a constructor
  QJSValue jsMetaObject = engine->newQMetaObject(&MzIntegrationParams::staticMetaObject);
  engine->globalObject().setProperty("MzIntegrationParams", jsMetaObject);
}

References ARBITRARY, BINNING_LOGIC_FULL, BINNING_LOGIC_PARTIAL, DATA_BASED, DEFAULT, FULL, and NONE.

removeZeroValDataPointsChanged

void pappso::MzIntegrationParams::removeZeroValDataPointsChanged ( )

signal

Referenced by setRemoveZeroValDataPoints().

reset()

void pappso::MzIntegrationParams::reset

(

)

Reset the instance to default values.

Definition at line 431 of file mzintegrationparams.cpp.

{
  m_smallestMz = std::numeric_limits<double>::max();
  m_greatestMz = std::numeric_limits<double>::min();
 
  m_binningType    = BinningType::ARBITRARY;
  m_binSizeModel   = pappso::PrecisionFactory::getResInstance(40000);
  m_binSizeDivisor = 1;
  m_decimalPlaces  = -1;
 
  m_removeZeroValDataPoints = true;
 
  emit wasReset();
}

References ARBITRARY, pappso::PrecisionFactory::getResInstance(), m_binningType, m_binSizeDivisor, m_binSizeModel, m_decimalPlaces, m_greatestMz, m_removeZeroValDataPoints, m_smallestMz, and wasReset().

Referenced by initialize().

setBinningType()

void pappso::MzIntegrationParams::setBinningType

(

MzIntegrationParams::BinningType

binning_type

)

Definition at line 344 of file mzintegrationparams.cpp.

{
  if(m_binningType == binning_type)
    return;
 
  m_binningType = binning_type;
  return binningTypeChanged();
}

References binningTypeChanged(), and m_binningType.

setBinSizeDivisor()

void pappso::MzIntegrationParams::setBinSizeDivisor

(

int

divisor

)

Definition at line 386 of file mzintegrationparams.cpp.

{
  if(m_binSizeDivisor == divisor)
    return;
 
  m_binSizeDivisor = divisor;
  emit binSizeDivisorChanged();
}

References binSizeDivisorChanged(), and m_binSizeDivisor.

setBinSizeModel()

void pappso::MzIntegrationParams::setBinSizeModel

(

pappso::PrecisionPtr

bin_size_model_p

)

Definition at line 368 of file mzintegrationparams.cpp.

{
  if(m_binSizeModel == bin_size_model_p)
    return;
 
  m_binSizeModel = bin_size_model_p;
 
  if(m_binSizeModel == nullptr)
    m_binSizeModel = pappso::PrecisionFactory::getResInstance(40000);
}

References pappso::PrecisionFactory::getResInstance(), and m_binSizeModel.

setDecimalPlaces()

void pappso::MzIntegrationParams::setDecimalPlaces

(

int

decimal_places

)

Definition at line 402 of file mzintegrationparams.cpp.

{
  if(m_decimalPlaces == decimal_places)
    return;
 
  m_decimalPlaces = decimal_places;
  emit decimalPlacesChanged();
}

References decimalPlacesChanged(), and m_decimalPlaces.

setGreatestMz()

void pappso::MzIntegrationParams::setGreatestMz

(

double

value

)

Definition at line 309 of file mzintegrationparams.cpp.

{
  if(m_greatestMz == value)
    return;
 
  m_greatestMz = value;
  emit greatestMzChanged();
}

References greatestMzChanged(), and m_greatestMz.

Referenced by setMzValues().

setMzValues()

void pappso::MzIntegrationParams::setMzValues	(	double	smallest,
		double	greatest )

Definition at line 337 of file mzintegrationparams.cpp.

{
  setSmallestMz(smallest);
  setGreatestMz(greatest);
}

References setGreatestMz(), and setSmallestMz().

setRemoveZeroValDataPoints()

void pappso::MzIntegrationParams::setRemoveZeroValDataPoints

(

bool

removeOrNot = true

)

Definition at line 412 of file mzintegrationparams.cpp.

{
  if(m_removeZeroValDataPoints == removeOrNot)
    return;
 
  m_removeZeroValDataPoints = removeOrNot;
  emit removeZeroValDataPointsChanged();
}

References m_removeZeroValDataPoints, and removeZeroValDataPointsChanged().

setSmallestMz()

void pappso::MzIntegrationParams::setSmallestMz

(

double

value

)

Definition at line 281 of file mzintegrationparams.cpp.

{
  if(m_smallestMz != value)
    m_smallestMz = value;
 
  emit smallestMzChanged();
}

References m_smallestMz, and smallestMzChanged().

Referenced by setMzValues().

smallestMzChanged

void pappso::MzIntegrationParams::smallestMzChanged ( )

signal

Referenced by setSmallestMz(), and updateSmallestMz().

toString() [1/2]

QString pappso::MzIntegrationParams::toString

(

)

const

Definition at line 889 of file mzintegrationparams.cpp.

{
  QString text;
 
  // In the string for saving settings, we do not ouput the m/z values.
  text.append(QString("Binning type:%1\n").arg(::pappso::binningTypeMap[m_binningType]));
  text.append(QString("Bin size model: %1\n").arg(m_binSizeModel->toString()));
  text.append(QString("Bin size divisor: %2\n").arg(m_binSizeDivisor));
  text.append(QString("Decimal places:%1\n").arg(m_decimalPlaces));
  text.append(QString("Remove 0-val data points:%1\n").arg(m_removeZeroValDataPoints));
 
  // qDebug().noquote() << "Returning text:\n" << text;
 
  return text;
}

References pappso::binningTypeMap, m_binningType, m_binSizeDivisor, m_binSizeModel, m_decimalPlaces, and m_removeZeroValDataPoints.

Referenced by createArbitraryBins().

toString() [2/2]

QString pappso::MzIntegrationParams::toString	(	int	offset,
		const QString &	spacer = " " ) const

Definition at line 841 of file mzintegrationparams.cpp.

{
  // The space-containing string that reflects the offset at which
  // new text lines should be added to start with.
  QString offset_lead;
 
  for(int iter = 0; iter < offset; ++iter)
    offset_lead += spacer;
 
  QString text = offset_lead;
  text += "m/z integration parameters:\n";
 
  QString new_lead = QString("%1%2").arg(offset_lead).arg(spacer);
 
  text += new_lead;
  if(m_smallestMz != std::numeric_limits<double>::max())
    text.append(QString::asprintf("Smallest (first) m/z: %.6f\n", m_smallestMz));
 
  text += new_lead;
  if(m_greatestMz != std::numeric_limits<double>::min())
    text.append(QString::asprintf("Greatest (last) m/z: %.6f\n", m_greatestMz));
 
  text += new_lead;
  text +=
    QString("Remove 0-val data points: %1\n").arg(m_removeZeroValDataPoints ? "true" : "false");
 
  text += new_lead;
  text.append("Binning logic:\n");
 
  new_lead += spacer;
 
  text += new_lead;
  text.append(QString("Binning type:%1\n").arg(::pappso::binningTypeMap[m_binningType]));
 
  text += new_lead;
  text.append(QString("Bin size model: %1\n").arg(m_binSizeModel->toString()));
 
  text += new_lead;
  text.append(QString("Bin size divisor: %2\n").arg(m_binSizeDivisor));
 
  text += new_lead;
  text.append(QString("Decimal places: %1\n").arg(m_decimalPlaces));
 
  return text;
}

References pappso::binningTypeMap, m_binningType, m_binSizeDivisor, m_binSizeModel, m_decimalPlaces, m_greatestMz, m_removeZeroValDataPoints, and m_smallestMz.

updateGreatestMz()

void pappso::MzIntegrationParams::updateGreatestMz

(

double

value

)

Definition at line 320 of file mzintegrationparams.cpp.

{
  if(value > m_greatestMz)
    {
      m_greatestMz = value;
      emit greatestMzChanged();
    }
}

References greatestMzChanged(), and m_greatestMz.

updateSmallestMz()

void pappso::MzIntegrationParams::updateSmallestMz

(

double

value

)

Definition at line 291 of file mzintegrationparams.cpp.

{
  if(value == m_smallestMz)
    return;
 
  m_smallestMz = value;
  emit smallestMzChanged();
}

References m_smallestMz, and smallestMzChanged().

wasReset

void pappso::MzIntegrationParams::wasReset ( )

signal

Referenced by reset().

Member Data Documentation

m_binningType

BinningType pappso::MzIntegrationParams::m_binningType = BinningType::ARBITRARY

protected

Definition at line 232 of file mzintegrationparams.h.

Referenced by MzIntegrationParams(), clone(), createBins(), createBins(), getBinningType(), initialize(), initialize(), initialize(), initialize(), isValid(), reset(), setBinningType(), toString(), and toString().

m_binSizeDivisor

int pappso::MzIntegrationParams::m_binSizeDivisor = 1

protected

Definition at line 234 of file mzintegrationparams.h.

Referenced by MzIntegrationParams(), clone(), createArbitraryBins(), getBinSizeDivisor(), initialize(), initialize(), initialize(), initialize(), reset(), setBinSizeDivisor(), toString(), and toString().

m_binSizeModel

pappso::PrecisionPtr pappso::MzIntegrationParams::m_binSizeModel = pappso::PrecisionFactory::getResInstance(40000)

protected

Definition at line 233 of file mzintegrationparams.h.

Referenced by MzIntegrationParams(), clone(), createArbitraryBins(), getBinSizeModel(), initialize(), initialize(), initialize(), initialize(), reset(), setBinSizeModel(), toString(), and toString().

m_decimalPlaces

int pappso::MzIntegrationParams::m_decimalPlaces = -1

protected

Definition at line 237 of file mzintegrationparams.h.

Referenced by MzIntegrationParams(), clone(), createArbitraryBins(), createDataBasedBins(), getDecimalPlaces(), initialize(), initialize(), initialize(), initialize(), reset(), setDecimalPlaces(), toString(), and toString().

m_greatestMz

double pappso::MzIntegrationParams::m_greatestMz = std::numeric_limits<double>::min()

protected

Definition at line 227 of file mzintegrationparams.h.

Referenced by MzIntegrationParams(), clone(), createArbitraryBins(), getGreatestMz(), hasValidMzRange(), initialize(), initialize(), isValid(), reset(), setGreatestMz(), toString(), and updateGreatestMz().

m_removeZeroValDataPoints

bool pappso::MzIntegrationParams::m_removeZeroValDataPoints = true

protected

Definition at line 242 of file mzintegrationparams.h.

Referenced by MzIntegrationParams(), clone(), initialize(), initialize(), initialize(), isRemoveZeroValDataPoints(), reset(), setRemoveZeroValDataPoints(), toString(), and toString().

m_smallestMz

double pappso::MzIntegrationParams::m_smallestMz = std::numeric_limits<double>::max()

protected

Definition at line 223 of file mzintegrationparams.h.

Referenced by MzIntegrationParams(), clone(), createArbitraryBins(), createDataBasedBins(), getSmallestMz(), hasValidMzRange(), initialize(), initialize(), isValid(), reset(), setSmallestMz(), toString(), and updateSmallestMz().

Property Documentation

binningType

BinningType pappso::MzIntegrationParams::binningType

readwrite

Definition at line 95 of file mzintegrationparams.h.

binSizeDivisor

int pappso::MzIntegrationParams::binSizeDivisor

readwrite

Definition at line 101 of file mzintegrationparams.h.

binSizeModel

pappso::PrecisionPtr pappso::MzIntegrationParams::binSizeModel

readwrite

Definition at line 99 of file mzintegrationparams.h.

decimalPlaces

int pappso::MzIntegrationParams::decimalPlaces

readwrite

Definition at line 97 of file mzintegrationparams.h.

greatestMz

double pappso::MzIntegrationParams::greatestMz

readwrite

Definition at line 94 of file mzintegrationparams.h.

removeZeroValDataPoints

bool pappso::MzIntegrationParams::removeZeroValDataPoints

read

Definition at line 103 of file mzintegrationparams.h.

smallestMz

double pappso::MzIntegrationParams::smallestMz

readwrite

Definition at line 91 of file mzintegrationparams.h.

---

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

• pappsomspp/core/processing/combiners/mzintegrationparams.h
• pappsomspp/core/processing/combiners/mzintegrationparams.cpp