Changeset 8555 in ntrip for trunk/BNC/src/rinex/reqcanalyze.cpp


Ignore:
Timestamp:
Dec 12, 2018, 12:02:14 PM (5 years ago)
Author:
mervart
Message:

Analyze more than two signals

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/BNC/src/rinex/reqcanalyze.cpp

    r8542 r8555  
    7474    _reqcPlotSignals = _defaultSignalTypes.join(" ");
    7575  }
    76   analyzePlotSignals(_signalTypes);
     76  analyzePlotSignals();
    7777
    7878  connect(this, SIGNAL(dspSkyPlot(const QString&, const QString&, QVector<t_polarPoint*>*,
     
    150150//
    151151////////////////////////////////////////////////////////////////////////////
    152 void t_reqcAnalyze::analyzePlotSignals(QMap<char, QVector<QString> >& signalTypes) {
     152void t_reqcAnalyze::analyzePlotSignals() {
    153153
    154154  QStringList signalsOpt = _reqcPlotSignals.split(" ", QString::SkipEmptyParts);
     
    157157    QStringList input = signalsOpt.at(ii).split(QRegExp("[:&]"), QString::SkipEmptyParts);
    158158    if (input.size() > 1 && input[0].length() == 1) {
    159       char system = input[0].toLatin1().constData()[0];
    160       QStringList sysValid       = _defaultSignalTypes.filter(QString(system));
    161       QStringList defaultSignals = sysValid.at(0).split(QRegExp("[:&]"));
    162       if (sysValid.isEmpty()) {continue;}
    163       if (input[1][0].isDigit()) {
    164         signalTypes[system].append(input[1]);
    165       }
    166       else {
    167         signalTypes[system].append(defaultSignals[1]);
    168       }
    169       if (input.size() > 2) {
    170         if (input[2][0].isDigit()) {
    171           signalTypes[system].append(input[2]);
    172         }
    173         else {
    174           signalTypes[system].append(defaultSignals[2]);
    175         }
    176       } else {
    177         signalTypes[system].append(defaultSignals[2]);
    178         if (signalTypes[system][0] == signalTypes[system][1]) {
    179           signalTypes[system][0] = defaultSignals[1];
     159      char        system   = input[0].toLatin1().constData()[0];
     160      QStringList sysValid = _defaultSignalTypes.filter(QString(system));
     161      if (!sysValid.isEmpty()) {
     162        for (int iSig = 1; iSig < input.size(); iSig++) {
     163          if (input[iSig].length() == 1 && input[iSig][0].isDigit()) {
     164            _signalTypes[system].append(input[iSig][0].toLatin1());
     165          }
    180166        }
    181167      }
     
    397383      t_frequency::type fB = t_frequency::dummy;
    398384      char sys             = satObs._prn.system();
    399       std::string frqType1, frqType2;
    400       if (_signalTypes.find(sys) != _signalTypes.end()) {
    401         frqType1.push_back(sys);
    402         frqType1.push_back(_signalTypes[sys][0][0].toLatin1());
    403         frqType2.push_back(sys);
    404         frqType2.push_back(_signalTypes[sys][1][0].toLatin1());
    405         if      (frqObs->_rnxType2ch[0] == frqType1[1]) {
    406           fA = t_frequency::toInt(frqType1);
    407           fB = t_frequency::toInt(frqType2);
    408         }
    409         else if (frqObs->_rnxType2ch[0] == frqType2[1]) {
    410           fA = t_frequency::toInt(frqType2);
    411           fB = t_frequency::toInt(frqType1);
    412         }
    413       }
    414       if (fA != t_frequency::dummy && fB != t_frequency::dummy) {
    415         double f_a = t_CST::freq(fA, qcSat._slotNum);
    416         double f_b = t_CST::freq(fB, qcSat._slotNum);
    417         double C_a = frqObs->_code;
    418 
    419         bool   foundA = false;
    420         double L_a    = 0.0;
    421         bool   foundB = false;
    422         double L_b    = 0.0;
    423         for (unsigned jj = 0; jj < satObs._obs.size(); jj++) {
    424           const t_frqObs* frqObsHlp = satObs._obs[jj];
    425           if      (frqObsHlp->_rnxType2ch[0] == t_frequency::toString(fA)[1] &&
    426               frqObsHlp->_phaseValid) {
    427             foundA = true;
    428             L_a    = frqObsHlp->_phase * t_CST::c / f_a;
    429           }
    430           else if (frqObsHlp->_rnxType2ch[0] == t_frequency::toString(fB)[1] &&
    431               frqObsHlp->_phaseValid) {
    432             foundB = true;
    433             L_b    = frqObsHlp->_phase * t_CST::c / f_b;
    434           }
    435         }
    436         if (foundA && foundB) {
    437           qcFrq._setMP = true;
    438           qcFrq._rawMP = C_a - L_a - 2.0*f_b*f_b/(f_a*f_a-f_b*f_b) * (L_a - L_b);
     385      for (int iSig = 1; iSig < _signalTypes[sys].size(); iSig++) {
     386        std::string frqType1, frqType2;
     387        if (_signalTypes.find(sys) != _signalTypes.end()) {
     388          frqType1.push_back(sys);
     389          frqType1.push_back(_signalTypes[sys][0]);
     390          frqType2.push_back(sys);
     391          frqType2.push_back(_signalTypes[sys][iSig]);
     392          if      (frqObs->_rnxType2ch[0] == frqType1[1]) {
     393            fA = t_frequency::toInt(frqType1);
     394            fB = t_frequency::toInt(frqType2);
     395          }
     396          else if (frqObs->_rnxType2ch[0] == frqType2[1]) {
     397            fA = t_frequency::toInt(frqType2);
     398            fB = t_frequency::toInt(frqType1);
     399          }
     400        }
     401        if (fA != t_frequency::dummy && fB != t_frequency::dummy) {
     402          double f_a = t_CST::freq(fA, qcSat._slotNum);
     403          double f_b = t_CST::freq(fB, qcSat._slotNum);
     404          double C_a = frqObs->_code;
     405       
     406          bool   foundA = false;
     407          double L_a    = 0.0;
     408          bool   foundB = false;
     409          double L_b    = 0.0;
     410          for (unsigned jj = 0; jj < satObs._obs.size(); jj++) {
     411            const t_frqObs* frqObsHlp = satObs._obs[jj];
     412            if      (frqObsHlp->_rnxType2ch[0] == t_frequency::toString(fA)[1] &&
     413                frqObsHlp->_phaseValid) {
     414              foundA = true;
     415              L_a    = frqObsHlp->_phase * t_CST::c / f_a;
     416            }
     417            else if (frqObsHlp->_rnxType2ch[0] == t_frequency::toString(fB)[1] &&
     418                frqObsHlp->_phaseValid) {
     419              foundB = true;
     420              L_b    = frqObsHlp->_phase * t_CST::c / f_b;
     421            }
     422          }
     423          if (foundA && foundB) {
     424            qcFrq._setMP = true;
     425            qcFrq._rawMP = C_a - L_a - 2.0*f_b*f_b/(f_a*f_a-f_b*f_b) * (L_a - L_b);
     426          }
    439427        }
    440428      }
     
    552540  QString sn2Title = "Signal-to-Noise Ratio\n";
    553541
    554   for(QMap<char, QVector<QString> >::iterator it = _signalTypes.begin();
     542  for(QMap<char, QVector<char> >::iterator it = _signalTypes.begin();
    555543      it != _signalTypes.end(); it++) {
    556544      mp1Title += QString(it.key()) + ":" + it.value()[0] + " ";
     
    583571          for (int ii = 0; ii < 2; ii++) {
    584572            if (frqType[ii].isEmpty()) {
    585               QMapIterator<char, QVector<QString> > it(_signalTypes);
     573              QMapIterator<char, QVector<char> > it(_signalTypes);
    586574              while (it.hasNext()) {
    587575                it.next();
    588576                if (it.key() == prn.system()) {
    589                   if (it.value()[ii] == qcFrq._rnxType2ch || it.value()[ii] == qcFrq._rnxType2ch.left(1)) {
     577                  if (QString(it.value()[ii]) == qcFrq._rnxType2ch.left(1)) {
    590578                    frqType[ii] = qcFrq._rnxType2ch;
    591579                    break;
     
    725713      }
    726714
    727       char frqChar1 = _signalTypes[prn.system()][0][0].toLatin1();
    728       char frqChar2 = _signalTypes[prn.system()][1][0].toLatin1();
    729 
    730       QString frqType1;
    731       QString frqType2;
    732       for (int iFrq = 0; iFrq < qcSat._qcFrq.size(); iFrq++) {
    733         const t_qcFrq& qcFrq = qcSat._qcFrq[iFrq];
    734         if (qcFrq._rnxType2ch[0] == frqChar1 && frqType1.isEmpty()) {
    735           frqType1 = qcFrq._rnxType2ch;
    736         }
    737         if (qcFrq._rnxType2ch[0] == frqChar2 && frqType2.isEmpty()) {
    738           frqType2 = qcFrq._rnxType2ch;
    739         }
    740         if      (qcFrq._rnxType2ch == frqType1) {
    741           if      (qcFrq._slip) {
    742             data._L1slip << mjdX24;
    743           }
    744           else if (qcFrq._gap) {
    745             data._L1gap << mjdX24;
    746           }
    747           else {
    748             data._L1ok << mjdX24;
    749           }
    750         }
    751         else if (qcFrq._rnxType2ch == frqType2) {
    752           if      (qcFrq._slip) {
    753             data._L2slip << mjdX24;
    754           }
    755           else if (qcFrq._gap) {
    756             data._L2gap << mjdX24;
    757           }
    758           else {
    759             data._L2ok << mjdX24;
     715      for (int iSig = 0; iSig < _signalTypes[prn.system()].size(); iSig++) {
     716        char    frqChar = _signalTypes[prn.system()][iSig];
     717        QString frqType;
     718        for (int iFrq = 0; iFrq < qcSat._qcFrq.size(); iFrq++) {
     719          const t_qcFrq& qcFrq = qcSat._qcFrq[iFrq];
     720          if (qcFrq._rnxType2ch[0] == frqChar && frqType.isEmpty()) {
     721            frqType = qcFrq._rnxType2ch;
     722          }
     723          if      (qcFrq._rnxType2ch == frqType) {
     724            t_plotData::t_hlpStatus& status = data._status[frqChar];
     725            if      (qcFrq._slip) {
     726              status._slip << mjdX24;
     727            }
     728            else if (qcFrq._gap) {
     729              status._gap << mjdX24;
     730            }
     731            else {
     732              status._ok << mjdX24;
     733            }
    760734          }
    761735        }
Note: See TracChangeset for help on using the changeset viewer.