Description

Loader for experimental reflectometry CSV files that contain three columns with Q,R,E, namely Q = wavenumber, R = reflectivity, E = error of R.

Definition at line 29 of file QREDataLoader.h.

Inheritance diagram for QREDataLoader:

[legend]

Collaboration diagram for QREDataLoader:

[legend]

Classes
struct	ColumnDefinition

struct	ErrorDefinition
	Contains a line related error (stored in the import result). Used for showing line related errors in the import data table. More...

struct	ImportResult
	Result of the file import. Some of the contained data is only relevant for showing the results in the result table. The usage of vectors which cover also invalid or skipped lines has its reason also in this result showing (to improve presentation performance). More...

struct	ImportSettings
	Settings for importing the file. More...

Signals
void	contentsProcessed ()
	Emitted whenever contents have been processed. More...

void	importSettingsChanged ()
	Emitted whenever an import setting changed. More...

Public Member Functions
	QREDataLoader ()

void	applyImportSettings () override
	Read all values from the properties UI into the internal variables. More...

AbstractDataLoader *	clone () const override
	Create a complete clone, including all internal states. More...

AbstractDataLoaderResultModel *	createResultModel () const override
	Create a table model which contains the import information like original file content, raw content, processed content. The returned pointer will be owned by the caller. This base class' implementation does nothing (return nullptr). More...

virtual QByteArray	defaultImportSettings () const
	Return the default import settings. More...

void	deserialize (const QByteArray &data) override
	Initialize from serialization data. If any error occurred, then a DeserializationException has to be thrown. The complete state has to be restored. Therefore if e.g. errors occurred in the former serialization, but errors are not serialized, then they have to be regenerated/ recalculated in here. More...

QByteArray	fileContent () const override
	Returns the original file content. If not available any more (like for legacy project file import), then an empty array will be returned. More...

void	guessSettings () override
	Guess appropriate settings (for example the separator in a CSV file). Is called only once, directly after setting the file content. More...

void	initWithDefaultImportSettings () override
	Set import settings to defaults. More...

QStringList	lineUnrelatedErrors () const override
	Errors not related to a particular line. More...

QString	name () const override
	The name shown in the format selection combo. More...

int	numErrors () const override
	Number of errors found while processing the content. An error means that either a particular content (line) can't be used or may be suspicious (line related error), or that the whole content can't be used (e.g. only 1 line present). More...

int	numLineRelatedErrors () const override
	Number of errors related to a specific line. Such an error means that a particular content (line) can't be used or may be suspicious. More...

QString	persistentClassName () const override
	A name which can be used for save/load purposes (which will not change ever more) More...

void	populateImportSettingsWidget (QWidget *parent) override
	Fills the widget on the import dialog pane. The implementation here in the base class does nothing (meaning "no editable properties"). More...

void	processContents () override
	Process the file contents. Can be called more than once, e.g. if the import settings have changed. Any error has to be stored in the loader (see numErrors()). More...

RealDataItem *	realDataItem ()
	The real data item on which the import shall work. More...

const RealDataItem *	realDataItem () const
	The real data item on which the import shall work. More...

QByteArray	serialize () const override
	Returns every internal setting so it can be restored completely. More...

void	setFileContents (const QByteArray &fileContent) override
	Sets the file contents to be imported. If the file was a compressed file, then the decompressed content will be handed over already here. More...

void	setRealDataItem (RealDataItem *item)
	Define the real data item on which the import shall work. More...

Protected Attributes
RealDataItem *	m_item
	The real-data-item which owns this loader. Never delete this! More...

Private Types
enum class	DataType { Q , R , dR }

enum class	UnitInFile { none , perNanoMeter , perAngstrom , other }

Private Member Functions
void	calculateFromParseResult () const

void	datafieldFromParsingResult (RealDataItem *item) const

void	parseFileContent () const

Private Attributes
QByteArray	m_fileContent

ImportResult	m_importResult

struct QREDataLoader::ImportSettings	m_importSettings

QPointer< QREDataLoaderProperties >	m_propertiesWidget

Friends
QDataStream &	operator<< (QDataStream &stream, const QREDataLoader::ErrorDefinition &s)

QDataStream &	operator<< (QDataStream &stream, const QREDataLoader::ImportSettings &s)

QDataStream &	operator>> (QDataStream &stream, QREDataLoader::ErrorDefinition &s)

QDataStream &	operator>> (QDataStream &stream, QREDataLoader::ImportSettings &s)

class	QREDataLoaderResultModel

Member Enumeration Documentation

◆ DataType

enum QREDataLoader::DataType

strongprivate

Enumerator
Q
R
dR

Definition at line 66 of file QREDataLoader.h.

66 { Q, R, dR };

◆ UnitInFile

enum QREDataLoader::UnitInFile

strongprivate

Enumerator
none
perNanoMeter
perAngstrom
other

Definition at line 55 of file QREDataLoader.h.

55 { none, perNanoMeter, perAngstrom, other };

Unit::other

@ other

The unit has no enum value defined in here (e.g. when defined as an explicit string)

Constructor & Destructor Documentation

◆ QREDataLoader()

QREDataLoader::QREDataLoader ( )

Definition at line 76 of file QREDataLoader.cpp.

     : m_propertiesWidget(nullptr)
 {
     initWithDefaultImportSettings();
 }

References initWithDefaultImportSettings().

Referenced by clone().

Here is the call graph for this function:

Member Function Documentation

◆ applyImportSettings()

void QREDataLoader::applyImportSettings ( )

overridevirtual

Read all values from the properties UI into the internal variables.

Reimplemented from AbstractDataLoader.

Definition at line 586 of file QREDataLoader.cpp.

 {
     if (!m_propertiesWidget)
         return;
  
     auto* const ui = m_propertiesWidget->m_ui;
  
     m_importSettings.separator = ui->separatorCombo->currentText();
     if (m_importSettings.separator == "<TAB>")
         m_importSettings.separator = "\t";
     if (m_importSettings.separator == "<SPACE>")
         m_importSettings.separator = " ";
  
     m_importSettings.headerPrefix = ui->headerPrefixEdit->text();
     m_importSettings.linesToSkip = ui->linesToSkipEdit->text();
  
     for (const auto dataType : m_importSettings.columnDefinitions.keys()) {
         auto& colDef = m_importSettings.columnDefinitions[dataType];
  
         colDef.column = m_propertiesWidget->columnSpinBox((int)dataType)->value() - 1;
         colDef.factor = m_propertiesWidget->factor((int)dataType);
     }
  
     m_importSettings.columnDefinitions[DataType::Q].unit =
         m_propertiesWidget->m_ui->qUnitCombo->currentIndex() == 0 ? UnitInFile::perNanoMeter
                                                                   : UnitInFile::perAngstrom;
  
     m_importSettings.columnDefinitions[DataType::dR].enabled =
         m_propertiesWidget->m_ui->enableErrorCheckBox->isChecked();
 }

References QREDataLoader::ImportSettings::columnDefinitions, dR, QREDataLoader::ImportSettings::headerPrefix, QREDataLoader::ImportSettings::linesToSkip, m_importSettings, m_propertiesWidget, perAngstrom, perNanoMeter, Q, and QREDataLoader::ImportSettings::separator.

Referenced by populateImportSettingsWidget().

◆ calculateFromParseResult()

void QREDataLoader::calculateFromParseResult ( ) const

private

Definition at line 441 of file QREDataLoader.cpp.

 {
     m_importResult.clearCalculatedValues();
     m_importResult.qValues.resize(m_importResult.lines.size());
     m_importResult.rValues.resize(m_importResult.lines.size());
     m_importResult.eValues.resize(m_importResult.lines.size());
  
     // -- calculate the Q/R/E values (take from specified column, use factor)
     const auto& c = m_importSettings.columnDefinitions; // easier access
     const bool errorColumnIsEnabled = c[DataType::dR].enabled;
     const double unitFac = (c[DataType::Q].unit == UnitInFile::perAngstrom) ? 10.0 : 1.0;
     const double qFactor = c[DataType::Q].factor * unitFac;
     const double rFactor = c[DataType::R].factor;
     const double eFactor = c[DataType::dR].factor;
  
     const int qCol = c[DataType::Q].column;
     const int rCol = c[DataType::R].column;
     const int eCol = c[DataType::dR].column;
  
     QSet<double> foundQValues;
  
     for (int lineNr = 0; lineNr < m_importResult.lines.size(); lineNr++) {
         const bool skipLine = m_importResult.lines[lineNr].first;
         if (skipLine)
             continue;
  
         const auto& rawValues = m_importResult.rawValues[lineNr];
  
         const bool qColIsValid = qCol >= 0 && qCol < rawValues.size();
         const bool rColIsValid = rCol >= 0 && rCol < rawValues.size();
         const bool eColIsValid = eCol >= 0 && eCol < rawValues.size();
  
         const double q =
             qColIsValid ? rawValues[qCol] * qFactor : std::numeric_limits<double>::quiet_NaN();
         const double r =
             rColIsValid ? rawValues[rCol] * rFactor : std::numeric_limits<double>::quiet_NaN();
         const double e =
             eColIsValid ? rawValues[eCol] * eFactor : std::numeric_limits<double>::quiet_NaN();
  
         if (std::isnan(q)) {
             m_importResult.addError(lineNr, ErrorDefinition::columnDoesNotContainValidNumber,
                                     qCol + 1);
             continue;
         }
  
         if (std::isnan(r)) {
             m_importResult.addError(lineNr, ErrorDefinition::columnDoesNotContainValidNumber,
                                     rCol + 1);
             continue;
         }
  
         if (std::isnan(e) && errorColumnIsEnabled) {
             m_importResult.addError(lineNr, ErrorDefinition::columnDoesNotContainValidNumber,
                                     eCol + 1);
             continue;
         }
  
         if (foundQValues.contains(q)) {
             m_importResult.addError(lineNr, ErrorDefinition::duplicateQ, q);
             continue;
         }
  
         if (r > 1.0 && !m_importSettings.allowValuesGreaterOne) {
             m_importResult.addError(lineNr, ErrorDefinition::RGreaterOne, r);
             continue;
         }
  
         if (r < 0.0) {
             m_importResult.addError(lineNr, ErrorDefinition::RLessZero, r);
             continue;
         }
  
         m_importResult.qValues[lineNr] = q;
         m_importResult.rValues[lineNr] = r;
         m_importResult.eValues[lineNr] = e;
         m_importResult.validCalculatedLines++;
         foundQValues << q;
     }
 }

Referenced by processContents().

Here is the call graph for this function:

◆ clone()

AbstractDataLoader * QREDataLoader::clone ( ) const

overridevirtual

Create a complete clone, including all internal states.

Implements AbstractDataLoader.

Definition at line 212 of file QREDataLoader.cpp.

 {
     auto* loader = new QREDataLoader();
     loader->deserialize(serialize());
     return loader;
 }

References QREDataLoader(), and serialize().

Here is the call graph for this function:

◆ contentsProcessed

void AbstractDataLoader::contentsProcessed ( )

signalinherited

Emitted whenever contents have been processed.

Referenced by AutomaticDataLoader1D::processContents(), processContents(), and RealDataItem::setDataLoader().

◆ createResultModel()

AbstractDataLoaderResultModel * QREDataLoader::createResultModel ( ) const

overridevirtual

Create a table model which contains the import information like original file content, raw content, processed content. The returned pointer will be owned by the caller. This base class' implementation does nothing (return nullptr).

Reimplemented from AbstractDataLoader.

Definition at line 291 of file QREDataLoader.cpp.

 {
     return new QREDataLoaderResultModel(&m_importResult);
 }

References m_importResult, and QREDataLoaderResultModel.

◆ datafieldFromParsingResult()

void QREDataLoader::datafieldFromParsingResult ( RealDataItem * item ) const

private

Definition at line 521 of file QREDataLoader.cpp.

 {
     // create data sorted by ascending Q values.
     // For this, the line numbers are sorted by Q
     QVector<int> lineNumbers;
     for (int lineNr = 0; lineNr < m_importResult.lines.size(); lineNr++) {
         const bool skipLine = m_importResult.lines[lineNr].first;
         const bool lineHasError = m_importResult.calculationErrors.contains(lineNr);
         if (skipLine || lineHasError)
             continue;
  
         lineNumbers.push_back(lineNr);
     }
  
     std::sort(lineNumbers.begin(), lineNumbers.end(),
               [&](int a, int b) { return m_importResult.qValues[a] < m_importResult.qValues[b]; });
  
     // -- create Datafield
     std::vector<double> qVec;
     std::vector<double> rVec;
  
     for (auto lineNr : lineNumbers) {
         qVec.push_back(m_importResult.qValues[lineNr]);
         rVec.push_back(m_importResult.rValues[lineNr]);
     }
     auto* oData = new Datafield({new PointwiseAxis("qVector", qVec)}, rVec);
  
     // -- Replacement of item->setImportData(std::move(data));
     item->initNativeData();
  
     QString units_name = GUI::Util::CoordName::nameFromCoord(Coords::QSPACE);
  
     // -- Replacement of specularItem->reset(std::move(data));
     SpecularDataItem* specularItem = item->specularDataItem();
     ComboProperty combo = ComboProperty() << units_name;
  
     specularItem->setAxesUnits(combo);
  
     auto label_map = DataUtils::AxisNames::specAxis;
     const auto xAxisTitle = QString::fromStdString(label_map[Coords::QSPACE]);
     const auto* const yAxisTitle = "Signal [a.u.]"; // taken from ImportDataInfo::axisLabel
  
     specularItem->setXaxisTitle(xAxisTitle);
     specularItem->setYaxisTitle(yAxisTitle);
     specularItem->setDatafield(oData); // takes ownership of odata
     specularItem->setAxesRangeToData();
  
     item->setNativeDataUnits(units_name);
     item->setNativeDatafield(oData->clone()); // also takes ownership
 }

References QREDataLoader::ImportResult::calculationErrors, RealDataItem::initNativeData(), QREDataLoader::ImportResult::lines, m_importResult, GUI::Util::CoordName::nameFromCoord(), QREDataLoader::ImportResult::qValues, QREDataLoader::ImportResult::rValues, SpecularDataItem::setAxesRangeToData(), DataItem::setAxesUnits(), SpecularDataItem::setDatafield(), RealDataItem::setNativeDatafield(), RealDataItem::setNativeDataUnits(), SpecularDataItem::setXaxisTitle(), SpecularDataItem::setYaxisTitle(), and RealDataItem::specularDataItem().

Referenced by processContents().

Here is the call graph for this function:

◆ defaultImportSettings()

QByteArray AbstractDataLoader::defaultImportSettings ( ) const

virtualinherited

Return the default import settings.

Definition at line 31 of file AbstractDataLoader.cpp.

 {
     std::unique_ptr<AbstractDataLoader> cloned(clone());
     cloned->initWithDefaultImportSettings();
     return cloned->serialize();
 }

References AbstractDataLoader::clone().

Here is the call graph for this function:

◆ deserialize()

void QREDataLoader::deserialize ( const QByteArray & data )

overridevirtual

Initialize from serialization data. If any error occurred, then a DeserializationException has to be thrown. The complete state has to be restored. Therefore if e.g. errors occurred in the former serialization, but errors are not serialized, then they have to be regenerated/ recalculated in here.

Reimplemented from AbstractDataLoader.

Definition at line 177 of file QREDataLoader.cpp.

 {
     m_importSettings.columnDefinitions.clear(); // sufficient
     m_importResult.clear();
  
     QDataStream s(data);
     s.setVersion(QDataStream::Qt_5_12);
  
     quint8 version;
     s >> version;
  
     if (version < 4) // anything smaller 4 was internal developer version => no backwards
                      // compatibility necessary
         throw DeserializationException::tooOld();
  
     if (version == 4) {
         s >> m_fileContent;
         s >> m_importSettings;
         s >> m_importResult.lines;
         s >> m_importResult.rawValues;
         s >> m_importResult.qValues;
         s >> m_importResult.rValues;
         s >> m_importResult.eValues;
         s >> m_importResult.validCalculatedLines;
         s >> m_importResult.maxColumnCount;
         s >> m_importResult.calculationErrors;
         s >> m_importResult.error;
         s >> m_importResult.importSettings;
     } else
         throw DeserializationException::tooNew();
  
     if (s.status() != QDataStream::Ok)
         throw DeserializationException::streamError();
 }

Here is the call graph for this function:

◆ fileContent()

QByteArray QREDataLoader::fileContent ( ) const

overridevirtual

Returns the original file content. If not available any more (like for legacy project file import), then an empty array will be returned.

Reimplemented from AbstractDataLoader.

Definition at line 296 of file QREDataLoader.cpp.

 {
     return m_fileContent;
 }

References m_fileContent.

Referenced by setFileContents().

◆ guessSettings()

void QREDataLoader::guessSettings ( )

overridevirtual

Guess appropriate settings (for example the separator in a CSV file). Is called only once, directly after setting the file content.

Reimplemented from AbstractDataLoader.

Definition at line 301 of file QREDataLoader.cpp.

 {
     // #baimport - move to utils; create unit test
     // search for lines which start with a number, then try the separators
  
     const auto isFirstNumberChar = [](const QChar& c) {
         return c.isNumber() || c == '.' || c == '+' || c == '-';
     };
  
     const auto belongsToNumber = [](const QChar& c) {
         return c.isNumber() || c == '.' || c == 'e' || c == 'E' || c == '+' || c == '-';
     };
  
     QTextStream in(m_fileContent);
     int lineNr = 0;
     const int maxLinesToExamine = 100;
     while (!in.atEnd() && lineNr < maxLinesToExamine) {
         lineNr++;
         QString line = in.readLine().trimmed();
         if (line.isEmpty())
             continue;
         if (!isFirstNumberChar(line[0]))
             continue;
  
         // line starts with a number => search gap after it
         int startOfGap = 1;
         while (startOfGap < line.size() && belongsToNumber(line[startOfGap]))
             startOfGap++;
  
         if (startOfGap == line.size())
             continue;
  
         int endOfGap = startOfGap;
         while (endOfGap < line.size() && !belongsToNumber(line[endOfGap]))
             endOfGap++;
  
         QStringRef gapContent(&line, startOfGap, endOfGap - startOfGap);
         if (gapContent.isEmpty())
             continue;
  
         if (gapContent.contains("\t")) {
             m_importSettings.separator = "\t";
             return;
         }
  
         gapContent = gapContent.trimmed();
         if (gapContent.isEmpty()) {
             m_importSettings.separator = " ";
             return;
         }
  
         if (gapContent.contains(";")) {
             m_importSettings.separator = ";";
             return;
         }
  
         if (gapContent.contains(",")) {
             m_importSettings.separator = ",";
             return;
         }
     }
 }

References m_fileContent, m_importSettings, and QREDataLoader::ImportSettings::separator.

◆ importSettingsChanged

void AbstractDataLoader::importSettingsChanged ( )

signalinherited

Emitted whenever an import setting changed.

Referenced by UserDefinedDataLoader1D::UserDefinedDataLoader1D(), SpecularDataImportWidget::onFormatSelectionChanged(), populateImportSettingsWidget(), and SpecularDataImportWidget::setItem().

◆ initWithDefaultImportSettings()

void QREDataLoader::initWithDefaultImportSettings ( )

overridevirtual

Set import settings to defaults.

Reimplemented from AbstractDataLoader.

Definition at line 134 of file QREDataLoader.cpp.

 {
     m_importSettings.separator = ";";
     m_importSettings.headerPrefix = "#,//";
     m_importSettings.linesToSkip = "";
  
     for (const auto dataType : {DataType::Q, DataType::R, DataType::dR}) {
         m_importSettings.columnDefinitions[dataType].enabled = true;
         m_importSettings.columnDefinitions[dataType].column = (int)dataType;
         m_importSettings.columnDefinitions[dataType].unit = UnitInFile::none;
         m_importSettings.columnDefinitions[dataType].factor = 1.0;
     }
  
     m_importSettings.columnDefinitions[DataType::Q].unit = UnitInFile::perNanoMeter;
 }

References QREDataLoader::ImportSettings::columnDefinitions, dR, QREDataLoader::ImportSettings::headerPrefix, QREDataLoader::ImportSettings::linesToSkip, m_importSettings, none, perNanoMeter, Q, R, and QREDataLoader::ImportSettings::separator.

Referenced by QREDataLoader().

◆ lineUnrelatedErrors()

QStringList QREDataLoader::lineUnrelatedErrors ( ) const

overridevirtual

Errors not related to a particular line.

Reimplemented from AbstractDataLoader.

Definition at line 283 of file QREDataLoader.cpp.

 {
     if (!m_importResult.error.isEmpty())
         return {m_importResult.error};
  
     return {};
 }

References QREDataLoader::ImportResult::error, and m_importResult.

◆ name()

QString QREDataLoader::name ( ) const

overridevirtual

The name shown in the format selection combo.

Implements AbstractDataLoader.

Definition at line 82 of file QREDataLoader.cpp.

 {
     return "CSV file (Reflectometry - Q/R/sigma_R)";
 }

◆ numErrors()

int QREDataLoader::numErrors ( ) const

overridevirtual

Number of errors found while processing the content. An error means that either a particular content (line) can't be used or may be suspicious (line related error), or that the whole content can't be used (e.g. only 1 line present).

Reimplemented from AbstractDataLoader.

Definition at line 273 of file QREDataLoader.cpp.

 {
     return (m_importResult.error.isEmpty() ? 0 : 1) + m_importResult.calculationErrors.size();
 }

References QREDataLoader::ImportResult::calculationErrors, QREDataLoader::ImportResult::error, and m_importResult.

◆ numLineRelatedErrors()

int QREDataLoader::numLineRelatedErrors ( ) const

overridevirtual

Number of errors related to a specific line. Such an error means that a particular content (line) can't be used or may be suspicious.

Reimplemented from AbstractDataLoader.

Definition at line 278 of file QREDataLoader.cpp.

 {
     return m_importResult.calculationErrors.size();
 }

References QREDataLoader::ImportResult::calculationErrors, and m_importResult.

◆ parseFileContent()

void QREDataLoader::parseFileContent ( ) const

private

Definition at line 369 of file QREDataLoader.cpp.

 {
     m_importResult.clear();
  
     const QStringList headerPrefixes = (m_importSettings.headerPrefix.trimmed().isEmpty())
                                            ? QStringList()
                                            : m_importSettings.headerPrefix.split(",");
  
     const auto lineIsHeader = [headerPrefixes](const QString& line) {
         for (const auto& prefix : headerPrefixes) {
             if (line.startsWith(prefix.trimmed()))
                 return true;
         }
  
         return false;
     };
  
     const auto skippedLines = expandLineNumberPattern(m_importSettings.linesToSkip);
     const auto lineShouldBeSkipped = [skippedLines](int lineNr) {
         for (const auto& pair : skippedLines) {
             if (lineNr >= pair.first && lineNr <= pair.second)
                 return true;
         }
         return false;
     };
  
     QTextStream in(m_fileContent);
     int lineNr = 0;
     // if separator is SPACE: e.g. three consecutive SPACEs do not represent 3 columns => delete
     // empty parts
     QString::SplitBehavior splitBehavior =
         m_importSettings.separator == " " ? QString::SkipEmptyParts : QString::KeepEmptyParts;
  
     while (!in.atEnd()) {
         lineNr++;
  
         QString line = in.readLine();
  
         const bool skip =
             lineIsHeader(line) || lineShouldBeSkipped(lineNr) || line.trimmed().isEmpty();
  
         m_importResult.lines << qMakePair(skip, line);
     }
  
     m_importResult.rawValues.resize(m_importResult.lines.size());
  
     for (int lineNr = 0; lineNr < m_importResult.lines.size(); lineNr++) {
         const bool skip = m_importResult.lines[lineNr].first;
         if (skip)
             continue;
  
         const QStringList lineEntries =
             m_importResult.lines[lineNr].second.split(m_importSettings.separator, splitBehavior);
  
         m_importResult.maxColumnCount =
             std::max(m_importResult.maxColumnCount, lineEntries.count());
  
         QVector<double> rowEntriesAsDouble;
  
         for (int col = 0; col < lineEntries.count(); col++) {
             bool ok = false;
             double val = lineEntries[col].toDouble(&ok);
             if (!ok)
                 val = std::numeric_limits<double>::quiet_NaN();
  
             rowEntriesAsDouble << val;
         }
  
         m_importResult.rawValues[lineNr] = rowEntriesAsDouble;
     }
 }

References QREDataLoader::ImportResult::clear(), QREDataLoader::ImportSettings::headerPrefix, QREDataLoader::ImportResult::lines, QREDataLoader::ImportSettings::linesToSkip, m_fileContent, m_importResult, m_importSettings, QREDataLoader::ImportResult::maxColumnCount, QREDataLoader::ImportResult::rawValues, and QREDataLoader::ImportSettings::separator.

Referenced by processContents().

Here is the call graph for this function:

◆ persistentClassName()

QString QREDataLoader::persistentClassName ( ) const

overridevirtual

A name which can be used for save/load purposes (which will not change ever more)

Implements AbstractDataLoader.

Definition at line 87 of file QREDataLoader.cpp.

 {
     return "QREDataLoader";
 }

◆ populateImportSettingsWidget()

void QREDataLoader::populateImportSettingsWidget ( QWidget * parent )

overridevirtual

Fills the widget on the import dialog pane. The implementation here in the base class does nothing (meaning "no editable properties").

Reimplemented from AbstractDataLoader.

Definition at line 92 of file QREDataLoader.cpp.

 {
     if (m_propertiesWidget == nullptr)
         m_propertiesWidget = new QREDataLoaderProperties;
  
     auto* l = new QHBoxLayout(parent);
     l->setContentsMargins(0, 0, 0, 0);
     parent->setLayout(l);
     l->addWidget(m_propertiesWidget);
  
     if (m_importSettings.separator == " ")
         m_propertiesWidget->m_ui->separatorCombo->setCurrentText("<SPACE>");
     else if (m_importSettings.separator == "\t")
         m_propertiesWidget->m_ui->separatorCombo->setCurrentText("<TAB>");
     else
         m_propertiesWidget->m_ui->separatorCombo->setCurrentText(m_importSettings.separator);
  
     m_propertiesWidget->m_ui->headerPrefixEdit->setText(m_importSettings.headerPrefix);
     m_propertiesWidget->m_ui->linesToSkipEdit->setText(m_importSettings.linesToSkip);
  
     for (const auto dataType : {DataType::Q, DataType::R, DataType::dR}) {
         m_propertiesWidget->columnSpinBox((int)dataType)
             ->setValue(m_importSettings.columnDefinitions[dataType].column + 1); // view is 1-based
  
         m_propertiesWidget->factorSpinBox((int)dataType)
             ->setValue(m_importSettings.columnDefinitions[dataType].factor);
     }
  
     m_propertiesWidget->m_ui->enableErrorCheckBox->setChecked(
         m_importSettings.columnDefinitions[DataType::dR].enabled);
  
     if (m_importSettings.columnDefinitions[DataType::Q].unit == UnitInFile::perAngstrom)
         m_propertiesWidget->m_ui->qUnitCombo->setCurrentIndex(1);
     else
         m_propertiesWidget->m_ui->qUnitCombo->setCurrentIndex(0); // 1/nm
  
     QObject::connect(m_propertiesWidget, &QREDataLoaderProperties::propertiesChanged, [this]() {
         applyImportSettings();
         emit importSettingsChanged();
     });
 }

References applyImportSettings(), QREDataLoader::ImportSettings::columnDefinitions, dR, QREDataLoader::ImportSettings::headerPrefix, AbstractDataLoader::importSettingsChanged(), QREDataLoader::ImportSettings::linesToSkip, m_importSettings, m_propertiesWidget, perAngstrom, QREDataLoaderProperties::propertiesChanged(), Q, R, and QREDataLoader::ImportSettings::separator.

Here is the call graph for this function:

◆ processContents()

void QREDataLoader::processContents ( )

overridevirtual

Process the file contents. Can be called more than once, e.g. if the import settings have changed. Any error has to be stored in the loader (see numErrors()).

Implements AbstractDataLoader.

Definition at line 219 of file QREDataLoader.cpp.

 {
     AutoEmit emitter([this] { contentsProcessed(); }); // automatic signal calling in any return
  
     // Important: If the current options match the ones in m_parsingResult, then nothing should be
     // performed. Otherwise e.g. a linked instrument may have to be re-linked
  
     m_importResult.error.clear();
  
     ASSERT(m_item != nullptr);
     ASSERT(m_item->isSpecularData());
  
     const auto invalidateItemData = [this]() {
         m_item->removeNativeData();
         m_item->specularDataItem()->setDatafield(nullptr);
     };
  
     const bool parsingSettingsChanged =
         m_importResult.importSettings.headerPrefix != m_importSettings.headerPrefix
         || m_importResult.importSettings.linesToSkip != m_importSettings.linesToSkip
         || m_importResult.importSettings.separator != m_importSettings.separator;
     const bool calculationSettingsChanged =
         m_importResult.importSettings.columnDefinitions != m_importSettings.columnDefinitions;
     const bool calculationIsNecessary = (parsingSettingsChanged || calculationSettingsChanged);
     const bool creationOfDatafieldIsNecessary = calculationIsNecessary;
  
     if (parsingSettingsChanged)
         // everything has to be re-parsed
         parseFileContent();
  
     if (calculationIsNecessary)
         calculateFromParseResult();
  
     m_importResult.importSettings = m_importSettings;
  
     // -- make a few checks (mainly for fulfilling PointwiseAxis::sanityCheck())
     if (m_importResult.validCalculatedLines < 2)
         m_importResult.error = "At least two full rows must exist";
  
     if (!m_importResult.error.isEmpty()) {
         invalidateItemData();
         return;
     }
  
     if (creationOfDatafieldIsNecessary) {
         try {
             datafieldFromParsingResult(m_item);
         } catch (...) {
             m_importResult.error = "Import not successful - caught an exception.";
             invalidateItemData();
         }
     }
 }

References calculateFromParseResult(), QREDataLoader::ImportSettings::columnDefinitions, AbstractDataLoader::contentsProcessed(), datafieldFromParsingResult(), QREDataLoader::ImportResult::error, QREDataLoader::ImportSettings::headerPrefix, QREDataLoader::ImportResult::importSettings, RealDataItem::isSpecularData(), QREDataLoader::ImportSettings::linesToSkip, m_importResult, m_importSettings, AbstractDataLoader::m_item, parseFileContent(), RealDataItem::removeNativeData(), QREDataLoader::ImportSettings::separator, SpecularDataItem::setDatafield(), RealDataItem::specularDataItem(), and QREDataLoader::ImportResult::validCalculatedLines.

Here is the call graph for this function:

◆ realDataItem() [1/2]

RealDataItem * AbstractDataLoader::realDataItem ( )

inherited

The real data item on which the import shall work.

Definition at line 70 of file AbstractDataLoader.cpp.

 {
     return m_item;
 }

References AbstractDataLoader::m_item.

◆ realDataItem() [2/2]

const RealDataItem * AbstractDataLoader::realDataItem ( ) const

inherited

The real data item on which the import shall work.

Definition at line 75 of file AbstractDataLoader.cpp.

 {
     return m_item;
 }

References AbstractDataLoader::m_item.

◆ serialize()

QByteArray QREDataLoader::serialize ( ) const

overridevirtual

Returns every internal setting so it can be restored completely.

Reimplemented from AbstractDataLoader.

Definition at line 150 of file QREDataLoader.cpp.

 {
     // changed in version 2: no file hash anymore (1 was only a developer version)
     // changed in version 3: refactored lists/vectors (2 was only a developer version)
     // changed in version 4: refactored lists/vectors (3 was only a developer version)
  
     QByteArray a;
     QDataStream s(&a, QIODevice::WriteOnly);
     s.setVersion(QDataStream::Qt_5_12);
  
     s << (quint8)4; // version
     s << m_fileContent;
     s << m_importSettings;
     s << m_importResult.lines;
     s << m_importResult.rawValues;
     s << m_importResult.qValues;
     s << m_importResult.rValues;
     s << m_importResult.eValues;
     s << m_importResult.validCalculatedLines;
     s << m_importResult.maxColumnCount;
     s << m_importResult.calculationErrors;
     s << m_importResult.error;
     s << m_importResult.importSettings;
  
     return a;
 }

References QREDataLoader::ImportResult::calculationErrors, QREDataLoader::ImportResult::error, QREDataLoader::ImportResult::eValues, QREDataLoader::ImportResult::importSettings, QREDataLoader::ImportResult::lines, m_fileContent, m_importResult, m_importSettings, QREDataLoader::ImportResult::maxColumnCount, QREDataLoader::ImportResult::qValues, QREDataLoader::ImportResult::rawValues, QREDataLoader::ImportResult::rValues, and QREDataLoader::ImportResult::validCalculatedLines.

Referenced by clone(), and QREDataLoader::ImportSettings::operator!=().

◆ setFileContents()

void QREDataLoader::setFileContents ( const QByteArray & fileContent )

overridevirtual

Sets the file contents to be imported. If the file was a compressed file, then the decompressed content will be handed over already here.

Implements AbstractDataLoader.

Definition at line 364 of file QREDataLoader.cpp.

 {
     m_fileContent = fileContent;
 }

References fileContent(), and m_fileContent.

Here is the call graph for this function:

◆ setRealDataItem()

void AbstractDataLoader::setRealDataItem ( RealDataItem * item )

inherited

Define the real data item on which the import shall work.

Definition at line 65 of file AbstractDataLoader.cpp.

 {
     m_item = item;
 }

References AbstractDataLoader::m_item.

Referenced by GUI::View::ImportDataUtils::Import1dData(), and SpecularDataImportWidget::onFormatSelectionChanged().

Friends And Related Function Documentation

◆ operator<< [1/2]

QDataStream& operator<<	(	QDataStream &	stream,
		const QREDataLoader::ErrorDefinition &	s
	)

friend

Definition at line 760 of file QREDataLoader.cpp.

 {
     stream << (quint8)s.type;
     if (std::holds_alternative<int>(s.data)) {
         stream << true;
         stream << quint32(std::get<int>(s.data));
     } else {
         stream << false;
         stream << qreal(std::get<double>(s.data));
     }
  
     return stream;
 }

◆ operator<< [2/2]

QDataStream& operator<<	(	QDataStream &	stream,
		const QREDataLoader::ImportSettings &	s
	)

friend

Definition at line 572 of file QREDataLoader.cpp.

 {
     stream << s.serialize();
     return stream;
 }

◆ operator>> [1/2]

QDataStream& operator>>	(	QDataStream &	stream,
		QREDataLoader::ErrorDefinition &	s
	)

friend

Definition at line 774 of file QREDataLoader.cpp.

 {
     quint8 t;
     stream >> t;
     s.type = QREDataLoader::ErrorDefinition::Type(t);
     bool isInt = false;
     stream >> isInt;
     if (isInt) {
         quint32 d;
         stream >> d;
         s.data = int(d);
     } else {
         qreal d;
         stream >> d;
         s.data = double(d);
     }
  
     return stream;
 }

◆ operator>> [2/2]

QDataStream& operator>>	(	QDataStream &	stream,
		QREDataLoader::ImportSettings &	s
	)

friend

Definition at line 578 of file QREDataLoader.cpp.

 {
     QByteArray b;
     stream >> b;
     s.deserialize(b);
     return stream;
 }

◆ QREDataLoaderResultModel

friend class QREDataLoaderResultModel

friend

Definition at line 137 of file QREDataLoader.h.

Referenced by createResultModel().

Member Data Documentation

◆ m_fileContent

QByteArray QREDataLoader::m_fileContent

private

Definition at line 129 of file QREDataLoader.h.

Referenced by deserialize(), fileContent(), guessSettings(), parseFileContent(), serialize(), and setFileContents().

◆ m_importResult

ImportResult QREDataLoader::m_importResult

mutableprivate

Definition at line 128 of file QREDataLoader.h.

Referenced by calculateFromParseResult(), createResultModel(), datafieldFromParsingResult(), deserialize(), lineUnrelatedErrors(), numErrors(), numLineRelatedErrors(), parseFileContent(), processContents(), and serialize().

◆ m_importSettings

struct QREDataLoader::ImportSettings QREDataLoader::m_importSettings

private

Referenced by applyImportSettings(), calculateFromParseResult(), deserialize(), guessSettings(), initWithDefaultImportSettings(), parseFileContent(), populateImportSettingsWidget(), processContents(), and serialize().

◆ m_item

RealDataItem* AbstractDataLoader::m_item

protectedinherited

The real-data-item which owns this loader. Never delete this!

Definition at line 124 of file AbstractDataLoader.h.

Referenced by AutomaticDataLoader1D::createResultModel(), AutomaticDataLoader1D::processContents(), processContents(), AbstractDataLoader::realDataItem(), and AbstractDataLoader::setRealDataItem().

◆ m_propertiesWidget

QPointer<QREDataLoaderProperties> QREDataLoader::m_propertiesWidget

private

Definition at line 131 of file QREDataLoader.h.

Referenced by applyImportSettings(), and populateImportSettingsWidget().

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

/home/build/builds/o5h8MZZm/0/mlz/bornagain/GUI/View/Loaders/QREDataLoader.h
/home/build/builds/o5h8MZZm/0/mlz/bornagain/GUI/View/Loaders/QREDataLoader.cpp

Description

Classes

Signals

Public Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Member Enumeration Documentation

◆ DataType

◆ UnitInFile

Constructor & Destructor Documentation

◆ QREDataLoader()

Member Function Documentation

◆ applyImportSettings()

◆ calculateFromParseResult()

◆ clone()

◆ contentsProcessed

◆ createResultModel()

◆ datafieldFromParsingResult()

◆ defaultImportSettings()

◆ deserialize()

◆ fileContent()

◆ guessSettings()

◆ importSettingsChanged

◆ initWithDefaultImportSettings()

◆ lineUnrelatedErrors()

◆ name()

◆ numErrors()

◆ numLineRelatedErrors()

◆ parseFileContent()

◆ persistentClassName()

◆ populateImportSettingsWidget()

◆ processContents()

◆ realDataItem() [1/2]

◆ realDataItem() [2/2]

◆ serialize()

◆ setFileContents()

◆ setRealDataItem()

Friends And Related Function Documentation

◆ operator<< [1/2]

◆ operator<< [2/2]

◆ operator>> [1/2]

◆ operator>> [2/2]

◆ QREDataLoaderResultModel

Member Data Documentation

◆ m_fileContent

◆ m_importResult

◆ m_importSettings

◆ m_item

◆ m_propertiesWidget