// Part of BNC, a utility for retrieving decoding and // converting GNSS data streams from NTRIP broadcasters. // // Copyright (C) 2007 // German Federal Agency for Cartography and Geodesy (BKG) // http://www.bkg.bund.de // Czech Technical University Prague, Department of Geodesy // http://www.fsv.cvut.cz // // Email: euref-ip@bkg.bund.de // // This program 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, version 2. // // This program 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 this program; if not, write to the Free Software // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. /* ------------------------------------------------------------------------- * BKG NTRIP Client * ------------------------------------------------------------------------- * * Class: t_reqcAnalyze * * Purpose: Analyze RINEX Files * * Author: L. Mervart * * Created: 11-Apr-2012 * * Changes: * * -----------------------------------------------------------------------*/ #include #include #include #include "reqcanalyze.h" #include "bnccore.h" #include "bncsettings.h" #include "reqcedit.h" #include "bncutils.h" #include "graphwin.h" #include "polarplot.h" #include "availplot.h" #include "eleplot.h" #include "dopplot.h" #include "bncephuser.h" using namespace std; // Constructor //////////////////////////////////////////////////////////////////////////// t_reqcAnalyze::t_reqcAnalyze(QObject* parent) : QThread(parent) { bncSettings settings; _logFileName = settings.value("reqcOutLogFile").toString(); expandEnvVar(_logFileName); _logFile = 0; _log = 0; _currEpo = 0; _obsFileNames = settings.value("reqcObsFile").toString().split(",", QString::SkipEmptyParts); _navFileNames = settings.value("reqcNavFile").toString().split(",", QString::SkipEmptyParts); _reqcPlotSignals = settings.value("reqcSkyPlotSignals").toString(); _defaultSignalTypes << "G:1&2" << "R:1&2" << "J:1&2" << "E:1&5" << "S:1&5" << "C:2&7"; if (_reqcPlotSignals.isEmpty()) { _reqcPlotSignals = _defaultSignalTypes.join(" "); } analyzePlotSignals(_signalTypes); connect(this, SIGNAL(dspSkyPlot(const QString&, const QString&, QVector*, const QString&, QVector*, const QByteArray&, double)), this, SLOT(slotDspSkyPlot(const QString&, const QString&, QVector*, const QString&, QVector*, const QByteArray&, double))); connect(this, SIGNAL(dspAvailPlot(const QString&, const QByteArray&)), this, SLOT(slotDspAvailPlot(const QString&, const QByteArray&))); } // Destructor //////////////////////////////////////////////////////////////////////////// t_reqcAnalyze::~t_reqcAnalyze() { for (int ii = 0; ii < _rnxObsFiles.size(); ii++) { delete _rnxObsFiles[ii]; } for (int ii = 0; ii < _ephs.size(); ii++) { delete _ephs[ii]; } delete _log; _log = 0; delete _logFile; _logFile = 0; if (BNC_CORE->mode() != t_bncCore::interactive) { qApp->exit(0); } } // //////////////////////////////////////////////////////////////////////////// void t_reqcAnalyze::run() { static const double QC_FORMAT_VERSION = 1.0; // Open Log File // ------------- if (!_logFileName.isEmpty()) { _logFile = new QFile(_logFileName); if (_logFile->open(QIODevice::WriteOnly | QIODevice::Text)) { _log = new QTextStream(); _log->setDevice(_logFile); } } if (_log) { *_log << "QC Format Version : " << QString("%1").arg(QC_FORMAT_VERSION,3,'f',1) << endl << endl; } // Check Ephemerides // ----------------- checkEphemerides(); // Initialize RINEX Observation Files // ---------------------------------- t_reqcEdit::initRnxObsFiles(_obsFileNames, _rnxObsFiles, _log); // Read Ephemerides // ---------------- t_reqcEdit::readEphemerides(_navFileNames, _ephs); // Loop over all RINEX Files // ------------------------- for (int ii = 0; ii < _rnxObsFiles.size(); ii++) { analyzeFile(_rnxObsFiles[ii]); } // Exit // ---- emit finished(); deleteLater(); } // //////////////////////////////////////////////////////////////////////////// void t_reqcAnalyze::analyzePlotSignals(QMap >& signalTypes) { QStringList signalsOpt = _reqcPlotSignals.split(" ", QString::SkipEmptyParts); for (int ii = 0; ii < signalsOpt.size(); ii++) { QStringList input = signalsOpt.at(ii).split(QRegExp("[:&]"), QString::SkipEmptyParts); if (input.size() > 1 && input[0].length() == 1) { char system = input[0].toAscii().constData()[0]; QStringList sysValid = _defaultSignalTypes.filter(QString(system)); QStringList defaultSignals = sysValid.at(0).split(QRegExp("[:&]")); if (sysValid.isEmpty()) {continue;} if (input[1][0].isDigit()) { signalTypes[system].append(input[1]); } else { signalTypes[system].append(defaultSignals[1]); } if (input.size() > 2) { if (input[2][0].isDigit()) { signalTypes[system].append(input[2]); } else { signalTypes[system].append(defaultSignals[2]); } } else { signalTypes[system].append(defaultSignals[2]); if (signalTypes[system][0] == signalTypes[system][1]) { signalTypes[system][0] = defaultSignals[1]; } } } } } // //////////////////////////////////////////////////////////////////////////// void t_reqcAnalyze::analyzeFile(t_rnxObsFile* obsFile) { _qcFile.clear(); // A priori Coordinates // -------------------- ColumnVector xyzSta = obsFile->xyz(); // Loop over all Epochs // -------------------- try { QMap lastObsTime; bool firstEpo = true; while ( (_currEpo = obsFile->nextEpoch()) != 0) { if (firstEpo) { firstEpo = false; _qcFile._startTime = _currEpo->tt; _qcFile._antennaName = obsFile->antennaName(); _qcFile._markerName = obsFile->markerName(); _qcFile._receiverType = obsFile->receiverType(); _qcFile._interval = obsFile->interval(); } _qcFile._endTime = _currEpo->tt; t_qcEpo qcEpo; qcEpo._epoTime = _currEpo->tt; qcEpo._PDOP = cmpDOP(xyzSta); // Loop over all satellites // ------------------------ for (unsigned iObs = 0; iObs < _currEpo->rnxSat.size(); iObs++) { const t_rnxObsFile::t_rnxSat& rnxSat = _currEpo->rnxSat[iObs]; if (_signalTypes.find(rnxSat.prn.system()) == _signalTypes.end()) { continue; } t_satObs satObs; t_rnxObsFile::setObsFromRnx(obsFile, _currEpo, rnxSat, satObs); t_qcSat& qcSat = qcEpo._qcSat[satObs._prn]; setQcObs(qcEpo._epoTime, xyzSta, satObs, lastObsTime, qcSat); updateQcSat(qcSat, _qcFile._qcSatSum[satObs._prn]); } _qcFile._qcEpo.push_back(qcEpo); } analyzeMultipath(); preparePlotData(obsFile); printReport(obsFile); } catch (QString str) { if (_log) { *_log << "Exception " << str << endl; } else { qDebug() << str; } } } // Compute Dilution of Precision //////////////////////////////////////////////////////////////////////////// double t_reqcAnalyze::cmpDOP(const ColumnVector& xyzSta) const { if ( xyzSta.size() != 3 || (xyzSta[0] == 0.0 && xyzSta[1] == 0.0 && xyzSta[2] == 0.0) ) { return 0.0; } unsigned nSat = _currEpo->rnxSat.size(); if (nSat < 4) { return 0.0; } Matrix AA(nSat, 4); unsigned nSatUsed = 0; for (unsigned iSat = 0; iSat < nSat; iSat++) { const t_rnxObsFile::t_rnxSat& rnxSat = _currEpo->rnxSat[iSat]; const t_prn& prn = rnxSat.prn; if (_signalTypes.find(prn.system()) == _signalTypes.end()) { continue; } t_eph* eph = 0; for (int ie = 0; ie < _ephs.size(); ie++) { if (_ephs[ie]->prn() == prn) { eph = _ephs[ie]; break; } } if (eph) { ColumnVector xSat(4); ColumnVector vv(3); if (eph->getCrd(_currEpo->tt, xSat, vv, false) == success) { ++nSatUsed; ColumnVector dx = xSat.Rows(1,3) - xyzSta; double rho = dx.norm_Frobenius(); AA(nSatUsed,1) = dx(1) / rho; AA(nSatUsed,2) = dx(2) / rho; AA(nSatUsed,3) = dx(3) / rho; AA(nSatUsed,4) = 1.0; } } } if (nSatUsed < 4) { return 0.0; } AA = AA.Rows(1, nSatUsed); SymmetricMatrix QQ; QQ << AA.t() * AA; QQ = QQ.i(); return sqrt(QQ.trace()); } // //////////////////////////////////////////////////////////////////////////// void t_reqcAnalyze::updateQcSat(const t_qcSat& qcSat, t_qcSatSum& qcSatSum) { for (int ii = 0; ii < qcSat._qcFrq.size(); ii++) { const t_qcFrq& qcFrq = qcSat._qcFrq[ii]; t_qcFrqSum& qcFrqSum = qcSatSum._qcFrqSum[qcFrq._rnxType2ch]; qcFrqSum._numObs += 1; if (qcFrq._slip) { qcFrqSum._numSlipsFlagged += 1; } if (qcFrq._gap) { qcFrqSum._numGaps += 1; } if (qcFrq._SNR > 0.0) { qcFrqSum._numSNR += 1; qcFrqSum._sumSNR += qcFrq._SNR; } } } // //////////////////////////////////////////////////////////////////////////// void t_reqcAnalyze::setQcObs(const bncTime& epoTime, const ColumnVector& xyzSta, const t_satObs& satObs, QMap& lastObsTime, t_qcSat& qcSat) { t_eph* eph = 0; for (int ie = 0; ie < _ephs.size(); ie++) { if (_ephs[ie]->prn().system() == satObs._prn.system() && _ephs[ie]->prn().number() == satObs._prn.number()) { eph = _ephs[ie]; break; } } if (eph) { ColumnVector xc(4); ColumnVector vv(3); if ( xyzSta.size() == 3 && (xyzSta[0] != 0.0 || xyzSta[1] != 0.0 || xyzSta[2] != 0.0) && eph->getCrd(epoTime, xc, vv, false) == success) { double rho, eleSat, azSat; topos(xyzSta(1), xyzSta(2), xyzSta(3), xc(1), xc(2), xc(3), rho, eleSat, azSat); qcSat._eleSet = true; qcSat._azDeg = azSat * 180.0/M_PI; qcSat._eleDeg = eleSat * 180.0/M_PI; } if (satObs._prn.system() == 'R') { qcSat._slotSet = true; qcSat._slotNum = eph->slotNum(); } } // Availability and Slip Flags // --------------------------- for (unsigned ii = 0; ii < satObs._obs.size(); ii++) { const t_frqObs* frqObs = satObs._obs[ii]; qcSat._qcFrq.push_back(t_qcFrq()); t_qcFrq& qcFrq = qcSat._qcFrq.back(); qcFrq._rnxType2ch = QString(frqObs->_rnxType2ch.c_str()); qcFrq._SNR = frqObs->_snr; qcFrq._slip = frqObs->_slip; qcFrq._phaseValid = frqObs->_phaseValid; qcFrq._codeValid = frqObs->_codeValid; // Check Gaps // ---------- QString key = QString(satObs._prn.toString().c_str()) + qcFrq._rnxType2ch; if (lastObsTime[key].valid()) { double dt = epoTime - lastObsTime[key]; if (dt > 1.5 * _qcFile._interval) { qcFrq._gap = true; } } lastObsTime[key] = epoTime; // Compute the Multipath Linear Combination // ---------------------------------------- if (frqObs->_codeValid) { t_frequency::type fA = t_frequency::dummy; t_frequency::type fB = t_frequency::dummy; char sys = satObs._prn.system(); std::string frqType1, frqType2; if (_signalTypes.find(sys) != _signalTypes.end()) { frqType1.push_back(sys); frqType1.push_back(_signalTypes[sys][0][0].toAscii()); frqType2.push_back(sys); frqType2.push_back(_signalTypes[sys][1][0].toAscii()); if (frqObs->_rnxType2ch[0] == frqType1[1]) { fA = t_frequency::toInt(frqType1); fB = t_frequency::toInt(frqType2); } else if (frqObs->_rnxType2ch[0] == frqType2[1]) { fA = t_frequency::toInt(frqType2); fB = t_frequency::toInt(frqType1); } } if (fA != t_frequency::dummy && fB != t_frequency::dummy) { double f_a = t_CST::freq(fA, qcSat._slotNum); double f_b = t_CST::freq(fB, qcSat._slotNum); double C_a = frqObs->_code; bool foundA = false; double L_a = 0.0; bool foundB = false; double L_b = 0.0; for (unsigned jj = 0; jj < satObs._obs.size(); jj++) { const t_frqObs* frqObsHlp = satObs._obs[jj]; if (frqObsHlp->_rnxType2ch[0] == t_frequency::toString(fA)[1] && frqObsHlp->_phaseValid) { foundA = true; L_a = frqObsHlp->_phase * t_CST::c / f_a; } else if (frqObsHlp->_rnxType2ch[0] == t_frequency::toString(fB)[1] && frqObsHlp->_phaseValid) { foundB = true; L_b = frqObsHlp->_phase * t_CST::c / f_b; } } if (foundA && foundB) { qcFrq._setMP = true; qcFrq._rawMP = C_a - L_a - 2.0*f_b*f_b/(f_a*f_a-f_b*f_b) * (L_a - L_b); } } } } // satObs loop } // //////////////////////////////////////////////////////////////////////////// void t_reqcAnalyze::analyzeMultipath() { const double SLIPTRESH = 10.0; // cycle-slip threshold (meters) const double chunkStep = 600.0; // 10 minutes // Loop over all satellites available // ---------------------------------- QMutableMapIterator itSat(_qcFile._qcSatSum); while (itSat.hasNext()) { itSat.next(); const t_prn& prn = itSat.key(); t_qcSatSum& qcSatSum = itSat.value(); // Loop over all frequencies available // ----------------------------------- QMutableMapIterator itFrq(qcSatSum._qcFrqSum); while (itFrq.hasNext()) { itFrq.next(); const QString& frqType = itFrq.key(); t_qcFrqSum& qcFrqSum = itFrq.value(); // Loop over all Chunks of Data // ---------------------------- for (bncTime chunkStart = _qcFile._startTime; chunkStart < _qcFile._endTime; chunkStart += chunkStep) { bncTime chunkEnd = chunkStart + chunkStep; QVector frqVec; QVector MP; // Loop over all Epochs within one Chunk of Data // --------------------------------------------- for (int iEpo = 0; iEpo < _qcFile._qcEpo.size(); iEpo++) { t_qcEpo& qcEpo = _qcFile._qcEpo[iEpo]; if (chunkStart <= qcEpo._epoTime && qcEpo._epoTime < chunkEnd) { if (qcEpo._qcSat.contains(prn)) { t_qcSat& qcSat = qcEpo._qcSat[prn]; for (int iFrq = 0; iFrq < qcSat._qcFrq.size(); iFrq++) { t_qcFrq& qcFrq = qcSat._qcFrq[iFrq]; if (qcFrq._rnxType2ch == frqType) { frqVec << &qcFrq; if (qcFrq._setMP) { MP << qcFrq._rawMP; } } } } } } // Compute the multipath mean and standard deviation // ------------------------------------------------- if (MP.size() > 1) { double meanMP = 0.0; for (int ii = 0; ii < MP.size(); ii++) { meanMP += MP[ii]; } meanMP /= MP.size(); bool slipMP = false; double stdMP = 0.0; for (int ii = 0; ii < MP.size(); ii++) { double diff = MP[ii] - meanMP; if (fabs(diff) > SLIPTRESH) { slipMP = true; break; } stdMP += diff * diff; } if (slipMP) { stdMP = 0.0; stdMP = 0.0; qcFrqSum._numSlipsFound += 1; } else { stdMP = sqrt(stdMP / (MP.size()-1)); qcFrqSum._numMP += 1; qcFrqSum._sumMP += stdMP; } for (int ii = 0; ii < frqVec.size(); ii++) { t_qcFrq* qcFrq = frqVec[ii]; if (slipMP) { qcFrq->_slip = true; } else { qcFrq->_stdMP = stdMP; } } } } // chunk loop } // frq loop } // sat loop } // //////////////////////////////////////////////////////////////////////////// void t_reqcAnalyze::preparePlotData(const t_rnxObsFile* obsFile) { QString mp1Title = "Multipath\n"; QString mp2Title = "Multipath\n"; QString sn1Title = "Signal-to-Noise Ratio\n"; QString sn2Title = "Signal-to-Noise Ratio\n"; for(QMap >::iterator it = _signalTypes.begin(); it != _signalTypes.end(); it++) { mp1Title += QString(it.key()) + ":" + it.value()[0] + " "; sn1Title += QString(it.key()) + ":" + it.value()[0] + " "; mp2Title += QString(it.key()) + ":" + it.value()[1] + " "; sn2Title += QString(it.key()) + ":" + it.value()[1] + " "; } QVector* dataMP1 = new QVector; QVector* dataMP2 = new QVector; QVector* dataSNR1 = new QVector; QVector* dataSNR2 = new QVector; // Loop over all observations // -------------------------- for (int iEpo = 0; iEpo < _qcFile._qcEpo.size(); iEpo++) { t_qcEpo& qcEpo = _qcFile._qcEpo[iEpo]; QMapIterator it(qcEpo._qcSat); while (it.hasNext()) { it.next(); const t_prn& prn = it.key(); const t_qcSat& qcSat = it.value(); if (qcSat._eleSet) { QString frqType[2]; for (int iFrq = 0; iFrq < qcSat._qcFrq.size(); iFrq++) { const t_qcFrq& qcFrq = qcSat._qcFrq[iFrq]; for (int ii = 0; ii < 2; ii++) { if (frqType[ii].isEmpty()) { QMapIterator > it(_signalTypes); while (it.hasNext()) { it.next(); if (it.key() == prn.system()) { if (it.value()[ii] == qcFrq._rnxType2ch || it.value()[ii] == qcFrq._rnxType2ch.left(1)) { frqType[ii] = qcFrq._rnxType2ch; break; } } } } } if (qcFrq._rnxType2ch == frqType[0]) { (*dataSNR1) << (new t_polarPoint(qcSat._azDeg, 90.0 - qcSat._eleDeg, qcFrq._SNR)); (*dataMP1) << (new t_polarPoint(qcSat._azDeg, 90.0 - qcSat._eleDeg, qcFrq._stdMP)); } else if (qcFrq._rnxType2ch == frqType[1]) { (*dataSNR2) << (new t_polarPoint(qcSat._azDeg, 90.0 - qcSat._eleDeg, qcFrq._SNR)); (*dataMP2) << (new t_polarPoint(qcSat._azDeg, 90.0 - qcSat._eleDeg, qcFrq._stdMP)); } } } } } // Show the plots // -------------- if (BNC_CORE->GUIenabled()) { QFileInfo fileInfo(obsFile->fileName()); QByteArray title = fileInfo.fileName().toAscii(); emit dspSkyPlot(obsFile->fileName(), mp1Title, dataMP1, mp2Title, dataMP2, "Meters", 2.0); emit dspSkyPlot(obsFile->fileName(), sn1Title, dataSNR1, sn2Title, dataSNR2, "dbHz", 54.0); emit dspAvailPlot(obsFile->fileName(), title); } else { for (int ii = 0; ii < dataMP1->size(); ii++) { delete dataMP1->at(ii); } delete dataMP1; for (int ii = 0; ii < dataMP2->size(); ii++) { delete dataMP2->at(ii); } delete dataMP2; for (int ii = 0; ii < dataSNR1->size(); ii++) { delete dataSNR1->at(ii); } delete dataSNR1; for (int ii = 0; ii < dataSNR2->size(); ii++) { delete dataSNR2->at(ii); } delete dataSNR2; } } // //////////////////////////////////////////////////////////////////////////// void t_reqcAnalyze::slotDspSkyPlot(const QString& fileName, const QString& title1, QVector* data1, const QString& title2, QVector* data2, const QByteArray& scaleTitle, double maxValue) { if (BNC_CORE->GUIenabled()) { if (maxValue == 0.0) { if (data1) { for (int ii = 0; ii < data1->size(); ii++) { double val = data1->at(ii)->_value; if (maxValue < val) { maxValue = val; } } } if (data2) { for (int ii = 0; ii < data2->size(); ii++) { double val = data2->at(ii)->_value; if (maxValue < val) { maxValue = val; } } } } QwtInterval scaleInterval(0.0, maxValue); QVector plots; if (data1) { QwtText title(title1); QFont font = title.font(); font.setPointSize(font.pointSize()-1); title.setFont(font); t_polarPlot* plot1 = new t_polarPlot(title, scaleInterval, BNC_CORE->mainWindow()); plot1->addCurve(data1); plots << plot1; } if (data2) { QwtText title(title2); QFont font = title.font(); font.setPointSize(font.pointSize()-1); title.setFont(font); t_polarPlot* plot2 = new t_polarPlot(title, scaleInterval, BNC_CORE->mainWindow()); plot2->addCurve(data2); plots << plot2; } t_graphWin* graphWin = new t_graphWin(0, fileName, plots, &scaleTitle, &scaleInterval); graphWin->show(); bncSettings settings; QString dirName = settings.value("reqcPlotDir").toString(); if (!dirName.isEmpty()) { QByteArray ext = (scaleTitle == "Meters") ? "_M.png" : "_S.png"; graphWin->savePNG(dirName, ext); } } } // //////////////////////////////////////////////////////////////////////////// void t_reqcAnalyze::slotDspAvailPlot(const QString& fileName, const QByteArray& title) { t_plotData plotData; QMap plotDataMap; for (int ii = 0; ii < _qcFile._qcEpo.size(); ii++) { const t_qcEpo& qcEpo = _qcFile._qcEpo[ii]; double mjdX24 = qcEpo._epoTime.mjddec() * 24.0; plotData._mjdX24 << mjdX24; plotData._PDOP << qcEpo._PDOP; plotData._numSat << qcEpo._qcSat.size(); QMapIterator it(qcEpo._qcSat); while (it.hasNext()) { it.next(); const t_prn& prn = it.key(); const t_qcSat& qcSat = it.value(); t_plotData& data = plotDataMap[prn]; if (qcSat._eleSet) { data._mjdX24 << mjdX24; data._eleDeg << qcSat._eleDeg; } char frqChar1 = _signalTypes[prn.system()][0][0].toAscii(); char frqChar2 = _signalTypes[prn.system()][1][0].toAscii(); QString frqType1; QString frqType2; for (int iFrq = 0; iFrq < qcSat._qcFrq.size(); iFrq++) { const t_qcFrq& qcFrq = qcSat._qcFrq[iFrq]; if (qcFrq._rnxType2ch[0] == frqChar1 && frqType1.isEmpty()) { frqType1 = qcFrq._rnxType2ch; } if (qcFrq._rnxType2ch[0] == frqChar2 && frqType2.isEmpty()) { frqType2 = qcFrq._rnxType2ch; } if (qcFrq._rnxType2ch == frqType1) { if (qcFrq._slip) { data._L1slip << mjdX24; } else if (qcFrq._gap) { data._L1gap << mjdX24; } else { data._L1ok << mjdX24; } } else if (qcFrq._rnxType2ch == frqType2) { if (qcFrq._slip) { data._L2slip << mjdX24; } else if (qcFrq._gap) { data._L2gap << mjdX24; } else { data._L2ok << mjdX24; } } } } } if (BNC_CORE->GUIenabled()) { t_availPlot* plotA = new t_availPlot(0, plotDataMap); plotA->setTitle(title); t_elePlot* plotZ = new t_elePlot(0, plotDataMap); t_dopPlot* plotD = new t_dopPlot(0, plotData); QVector plots; plots << plotA << plotZ << plotD; t_graphWin* graphWin = new t_graphWin(0, fileName, plots, 0, 0); int ww = QFontMetrics(graphWin->font()).width('w'); graphWin->setMinimumSize(120*ww, 40*ww); graphWin->show(); bncSettings settings; QString dirName = settings.value("reqcPlotDir").toString(); if (!dirName.isEmpty()) { QByteArray ext = "_A.png"; graphWin->savePNG(dirName, ext); } } } // Finish the report //////////////////////////////////////////////////////////////////////////// void t_reqcAnalyze::printReport(const t_rnxObsFile* obsFile) { if (!_log) { return; } QFileInfo obsFi(obsFile->fileName()); QString obsFileName = obsFi.fileName(); // Summary // ------- *_log << "Observation File : " << obsFileName << endl << "RINEX Version : " << QString("%1").arg(obsFile->version(),4,'f',2) << endl << "Marker Name : " << _qcFile._markerName << endl << "Marker Number : " << obsFile->markerNumber() << endl << "Receiver : " << _qcFile._receiverType << endl << "Antenna : " << _qcFile._antennaName << endl << "Position XYZ : " << QString("%1 %2 %3").arg(obsFile->xyz()(1), 14, 'f', 4) .arg(obsFile->xyz()(2), 14, 'f', 4) .arg(obsFile->xyz()(3), 14, 'f', 4) << endl << "Antenna dH/dE/dN : " << QString("%1 %2 %3").arg(obsFile->antNEU()(3), 8, 'f', 4) .arg(obsFile->antNEU()(2), 8, 'f', 4) .arg(obsFile->antNEU()(1), 8, 'f', 4) << endl << "Start Time : " << _qcFile._startTime.datestr().c_str() << ' ' << _qcFile._startTime.timestr(1,'.').c_str() << endl << "End Time : " << _qcFile._endTime.datestr().c_str() << ' ' << _qcFile._endTime.timestr(1,'.').c_str() << endl << "Interval : " << _qcFile._interval << endl; int numPossibleObs = int((_qcFile._endTime - _qcFile._startTime + _qcFile._interval)/_qcFile._interval); // Number of systems // ----------------- QMap > systemMap; QMapIterator itSat(_qcFile._qcSatSum); while (itSat.hasNext()) { itSat.next(); const t_prn& prn = itSat.key(); const t_qcSatSum& qcSatSum = itSat.value(); systemMap[prn.system()].push_back(&qcSatSum); } *_log << "Navigation Systems : " << systemMap.size() << " "; QMapIterator > itSys(systemMap); while (itSys.hasNext()) { itSys.next(); *_log << ' ' << itSys.key(); } *_log << endl; // Observation types per system // ----------------------------- for (int iSys = 0; iSys < obsFile->numSys(); iSys++) { char sys = obsFile->system(iSys); if (sys != ' ') { *_log << "Observation Types " << sys << ":"; for (int iType = 0; iType < obsFile->nTypes(sys); iType++) { QString type = obsFile->obsType(sys, iType); *_log << " " << type; } *_log << endl; } } itSys.toFront(); while (itSys.hasNext()) { itSys.next(); const QChar& sys = itSys.key(); const QVector& qcSatVec = itSys.value(); QString prefixSys = QString(" ") + sys + QString(": "); QMap > frqMap; for (int ii = 0; ii < qcSatVec.size(); ii++) { const t_qcSatSum* qcSatSum = qcSatVec[ii]; QMapIterator itFrq(qcSatSum->_qcFrqSum); while (itFrq.hasNext()) { itFrq.next(); QString frqType = itFrq.key(); if (frqType.length() < 2) frqType += '?'; const t_qcFrqSum& qcFrqSum = itFrq.value(); frqMap[frqType].push_back(&qcFrqSum); } } *_log << endl << prefixSys << "Satellites: " << qcSatVec.size() << endl << prefixSys << "Signals : " << frqMap.size() << " "; QMapIterator > itFrq(frqMap); while (itFrq.hasNext()) { itFrq.next(); QString frqType = itFrq.key(); if (frqType.length() < 2) frqType += '?'; *_log << ' ' << frqType; } *_log << endl; QString prefixSys2 = " " + prefixSys; itFrq.toFront(); while (itFrq.hasNext()) { itFrq.next(); QString frqType = itFrq.key(); if (frqType.length() < 2) frqType += '?'; const QVector qcFrqVec = itFrq.value(); QString prefixFrq = QString(" ") + frqType + QString(": "); int numObs = 0; int numSlipsFlagged = 0; int numSlipsFound = 0; int numGaps = 0; int numSNR = 0; int numMP = 0; double sumSNR = 0.0; double sumMP = 0.0; for (int ii = 0; ii < qcFrqVec.size(); ii++) { const t_qcFrqSum* qcFrqSum = qcFrqVec[ii]; numObs += qcFrqSum->_numObs ; numSlipsFlagged += qcFrqSum->_numSlipsFlagged; numSlipsFound += qcFrqSum->_numSlipsFound ; numGaps += qcFrqSum->_numGaps ; numSNR += qcFrqSum->_numSNR; numMP += qcFrqSum->_numMP; sumSNR += qcFrqSum->_sumSNR; sumMP += qcFrqSum->_sumMP; } if (numSNR > 0) { sumSNR /= numSNR; } if (numMP > 0) { sumMP /= numMP; } double ratio = double(numObs) / ((double(numPossibleObs) * double(qcSatVec.size()))); *_log << endl << prefixSys2 << prefixFrq << "Observations : " << QString("%1 (%2) %3 \%\n").arg(numObs, 6).arg(numPossibleObs*qcSatVec.size(), 8).arg(ratio*100.0, 8, 'f', 2) << prefixSys2 << prefixFrq << "Slips (file+found): " << QString("%1 +").arg(numSlipsFlagged, 8) << QString("%1\n").arg(numSlipsFound, 8) << prefixSys2 << prefixFrq << "Gaps : " << QString("%1\n").arg(numGaps, 8) << prefixSys2 << prefixFrq << "Mean SNR : " << QString("%1\n").arg(sumSNR, 8, 'f', 1) << prefixSys2 << prefixFrq << "Mean Multipath : " << QString("%1\n").arg(sumMP, 8, 'f', 2); } } // Epoch-Specific Output // --------------------- bncSettings settings; if (Qt::CheckState(settings.value("reqcLogSummaryOnly").toInt()) == Qt::Checked) { return; } *_log << endl; for (int iEpo = 0; iEpo < _qcFile._qcEpo.size(); iEpo++) { const t_qcEpo& qcEpo = _qcFile._qcEpo[iEpo]; unsigned year, month, day, hour, min; double sec; qcEpo._epoTime.civil_date(year, month, day); qcEpo._epoTime.civil_time(hour, min, sec); QString dateStr; QTextStream(&dateStr) << QString("> %1 %2 %3 %4 %5%6") .arg(year, 4) .arg(month, 2, 10, QChar('0')) .arg(day, 2, 10, QChar('0')) .arg(hour, 2, 10, QChar('0')) .arg(min, 2, 10, QChar('0')) .arg(sec, 11, 'f', 7); *_log << dateStr << QString(" %1").arg(qcEpo._qcSat.size(), 2) << QString(" %1").arg(qcEpo._PDOP, 4, 'f', 1) << endl; QMapIterator itSat(qcEpo._qcSat); while (itSat.hasNext()) { itSat.next(); const t_prn& prn = itSat.key(); const t_qcSat& qcSat = itSat.value(); *_log << prn.toString().c_str() << QString(" %1 %2").arg(qcSat._eleDeg, 6, 'f', 2).arg(qcSat._azDeg, 7, 'f', 2); int numObsTypes = 0; for (int iFrq = 0; iFrq < qcSat._qcFrq.size(); iFrq++) { const t_qcFrq& qcFrq = qcSat._qcFrq[iFrq]; if (qcFrq._phaseValid) { numObsTypes += 1; } if (qcFrq._codeValid) { numObsTypes += 1; } } *_log << QString(" %1").arg(numObsTypes, 2); for (int iFrq = 0; iFrq < qcSat._qcFrq.size(); iFrq++) { const t_qcFrq& qcFrq = qcSat._qcFrq[iFrq]; if (qcFrq._phaseValid) { *_log << " L" << qcFrq._rnxType2ch << ' '; if (qcFrq._slip) { *_log << 's'; } else { *_log << '.'; } if (qcFrq._gap) { *_log << 'g'; } else { *_log << '.'; } *_log << QString(" %1").arg(qcFrq._SNR, 4, 'f', 1); } if (qcFrq._codeValid) { *_log << " C" << qcFrq._rnxType2ch << ' '; if (qcFrq._gap) { *_log << " g"; } else { *_log << " ."; } *_log << QString(" %1").arg(qcFrq._stdMP, 3, 'f', 2); } } *_log << endl; } } _log->flush(); } // //////////////////////////////////////////////////////////////////////////// void t_reqcAnalyze::checkEphemerides() { QString navFileName; QStringListIterator namIt(_navFileNames); bool firstName = true; while (namIt.hasNext()) { QFileInfo navFi(namIt.next()); if (firstName) { firstName = false; navFileName += navFi.fileName(); } else { navFileName += ", " + navFi.fileName(); } } if (_log) { *_log << "Navigation File(s) : " << navFileName << endl; } QStringListIterator it(_navFileNames); while (it.hasNext()) { const QString& fileName = it.next(); unsigned numOK = 0; unsigned numBad = 0; bncEphUser ephUser(false); t_rnxNavFile rnxNavFile(fileName, t_rnxNavFile::input); for (unsigned ii = 0; ii < rnxNavFile.ephs().size(); ii++) { t_eph* eph = rnxNavFile.ephs()[ii]; ephUser.putNewEph(eph, true); if (eph->checkState() == t_eph::bad) { ++numBad; } else { ++numOK; } } if (_log) { *_log << "Ephemeris : " << numOK << " OK " << numBad << " BAD" << endl; } if (numBad > 0) { for (unsigned ii = 0; ii < rnxNavFile.ephs().size(); ii++) { t_eph* eph = rnxNavFile.ephs()[ii]; if (eph->checkState() == t_eph::bad) { QFileInfo navFi(fileName); if (_log) { *_log << " Bad Ephemeris : " << navFi.fileName() << ' ' << eph->toString(3.0).left(24) << endl; } } } } } if (_log) { *_log << endl; } }