Ignore:
Timestamp:
Feb 23, 2021, 10:53:00 PM (3 years ago)
Author:
stuerze
Message:

revert last changes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/BNC/src/upload/bncrtnetuploadcaster.cpp

    r9350 r9354  
    472472        }
    473473      }
    474 
    475       if (!outDatedBcep(eph)                    &&  // detected from storage because of no update
    476           eph->checkState() != t_eph::bad       &&
    477           eph->checkState() != t_eph::unhealthy &&
    478           eph->checkState() != t_eph::outdated) {   // detected during reception (bncephuser)
    479         QMap<QString, double> codeBiases;
    480         QList<phaseBiasSignal> phaseBiasList;
    481         phaseBiasesSat pbSat;
    482         _phaseBiasInformationDecoded = false;
    483 
    484         while (true) {
    485           QString key;
    486           int numVal = 0;
    487           in >> key;
    488           if (in.status() != QTextStream::Ok) {
     474    }
     475    if (eph &&
     476        !outDatedBcep(eph)                    &&  // detected from storage because of no update
     477        eph->checkState() != t_eph::bad       &&
     478        eph->checkState() != t_eph::unhealthy &&
     479        eph->checkState() != t_eph::outdated) {   // detected during reception (bncephuser)
     480      QMap<QString, double> codeBiases;
     481      QList<phaseBiasSignal> phaseBiasList;
     482      phaseBiasesSat pbSat;
     483      _phaseBiasInformationDecoded = false;
     484
     485      while (true) {
     486        QString key;
     487        int numVal = 0;
     488        in >> key;
     489        if (in.status() != QTextStream::Ok) {
     490          break;
     491        }
     492        if (key == "APC") {
     493          in >> numVal;
     494          rtnAPC.ReSize(3); rtnAPC = 0.0;
     495          for (int ii = 0; ii < numVal; ii++) {
     496            in >> rtnAPC[ii];
     497          }
     498        }
     499        else if (key == "Ura") {
     500          in >> numVal;
     501          if (numVal == 1)
     502            in >> rtnUra;
     503        }
     504        else if (key == "Clk") {
     505          in >> numVal;
     506          rtnClk.ReSize(3); rtnClk = 0.0;
     507          for (int ii = 0; ii < numVal; ii++) {
     508            in >> rtnClk[ii];
     509          }
     510        }
     511        else if (key == "ClkSig") {
     512          in >> numVal;
     513          rtnClkSig.ReSize(3); rtnClkSig = 0.0;
     514          for (int ii = 0; ii < numVal; ii++) {
     515            in >> rtnClkSig[ii];
     516          }
     517        }
     518        else if (key == "Vel") {
     519          in >> numVal;
     520          rtnVel.ReSize(3); rtnVel = 0.0;
     521          for (int ii = 0; ii < numVal; ii++) {
     522            in >> rtnVel[ii];
     523          }
     524        }
     525        else if (key == "CoM") {
     526          in >> numVal;
     527          rtnCoM.ReSize(3); rtnCoM = 0.0;
     528          for (int ii = 0; ii < numVal; ii++) {
     529            in >> rtnCoM[ii];
     530          }
     531        }
     532        else if (key == "CodeBias") {
     533          in >> numVal;
     534          for (int ii = 0; ii < numVal; ii++) {
     535            QString type;
     536            double value;
     537            in >> type >> value;
     538            codeBiases[type] = value;
     539          }
     540        }
     541        else if (key == "YawAngle") {
     542          _phaseBiasInformationDecoded = true;
     543          in >> numVal >> pbSat.yawAngle;
     544          if      (pbSat.yawAngle < 0.0) {
     545            pbSat.yawAngle += (2*M_PI);
     546          }
     547          else if (pbSat.yawAngle > 2*M_PI) {
     548            pbSat.yawAngle -= (2*M_PI);
     549          }
     550        }
     551        else if (key == "YawRate") {
     552          _phaseBiasInformationDecoded = true;
     553          in >> numVal >> pbSat.yawRate;
     554        }
     555        else if (key == "PhaseBias") {
     556          _phaseBiasInformationDecoded = true;
     557          in >> numVal;
     558          for (int ii = 0; ii < numVal; ii++) {
     559            phaseBiasSignal pb;
     560            in >> pb.type >> pb.bias >> pb.integerIndicator
     561              >> pb.wlIndicator >> pb.discontinuityCounter;
     562            phaseBiasList.append(pb);
     563          }
     564        }
     565        else {
     566          in >> numVal;
     567          for (int ii = 0; ii < numVal; ii++) {
     568            double dummy;
     569            in >> dummy;
     570          }
     571          emit(newMessage("                      RTNET format error: "
     572                          +  lines[ii].toLatin1(), false));
     573        }
     574      }
     575
     576      struct SsrCorr::ClockOrbit::SatData* sd = 0;
     577      if (prn.system() == 'G') {
     578        sd = co.Sat + co.NumberOfSat[CLOCKORBIT_SATGPS];
     579        ++co.NumberOfSat[CLOCKORBIT_SATGPS];
     580      }
     581      else if (prn.system() == 'R') {
     582        sd = co.Sat + CLOCKORBIT_NUMGPS + co.NumberOfSat[CLOCKORBIT_SATGLONASS];
     583        ++co.NumberOfSat[CLOCKORBIT_SATGLONASS];
     584      }
     585      else if (prn.system() == 'E') {
     586        sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     587           + co.NumberOfSat[CLOCKORBIT_SATGALILEO];
     588        ++co.NumberOfSat[CLOCKORBIT_SATGALILEO];
     589      }
     590      else if (prn.system() == 'J') {
     591        sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     592           + CLOCKORBIT_NUMGALILEO
     593           + co.NumberOfSat[CLOCKORBIT_SATQZSS];
     594        ++co.NumberOfSat[CLOCKORBIT_SATQZSS];
     595      }
     596      else if (prn.system() == 'S') {
     597        sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     598            + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     599            + co.NumberOfSat[CLOCKORBIT_SATSBAS];
     600        ++co.NumberOfSat[CLOCKORBIT_SATSBAS];
     601      }
     602      else if (prn.system() == 'C') {
     603        sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     604            + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     605            + CLOCKORBIT_NUMSBAS
     606            + co.NumberOfSat[CLOCKORBIT_SATBDS];
     607        ++co.NumberOfSat[CLOCKORBIT_SATBDS];
     608      }
     609      if (sd) {
     610        QString outLine;
     611        t_irc irc = processSatellite(eph, epoTime.gpsw(), epoTime.gpssec(), prnStr, rtnAPC,
     612                                     rtnUra, rtnClk, rtnVel, rtnCoM, rtnClkSig, sd, outLine);
     613        if (irc != success) {/*
     614          // very few cases: check states bad and unhealthy are excluded earlier
     615          sd->ID = prnStr.mid(1).toInt(); // to prevent G00, R00 entries
     616          sd->IOD = eph->IOD();
     617          */
     618          continue;
     619        }
     620      }
     621
     622      // Code Biases
     623      // -----------
     624      struct SsrCorr::CodeBias::BiasSat* biasSat = 0;
     625      if (!codeBiases.isEmpty()) {
     626        if (prn.system() == 'G') {
     627          biasSat = bias.Sat + bias.NumberOfSat[CLOCKORBIT_SATGPS];
     628          ++bias.NumberOfSat[CLOCKORBIT_SATGPS];
     629        }
     630        else if (prn.system() == 'R') {
     631          biasSat = bias.Sat + CLOCKORBIT_NUMGPS
     632                  + bias.NumberOfSat[CLOCKORBIT_SATGLONASS];
     633          ++bias.NumberOfSat[CLOCKORBIT_SATGLONASS];
     634        }
     635        else if (prn.system() == 'E') {
     636          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     637                  + bias.NumberOfSat[CLOCKORBIT_SATGALILEO];
     638          ++bias.NumberOfSat[CLOCKORBIT_SATGALILEO];
     639        }
     640        else if (prn.system() == 'J') {
     641          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     642                  + CLOCKORBIT_NUMGALILEO
     643                  + bias.NumberOfSat[CLOCKORBIT_SATQZSS];
     644          ++bias.NumberOfSat[CLOCKORBIT_SATQZSS];
     645        }
     646        else if (prn.system() == 'S') {
     647          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     648                  + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     649                  + bias.NumberOfSat[CLOCKORBIT_SATSBAS];
     650          ++bias.NumberOfSat[CLOCKORBIT_SATSBAS];
     651        }
     652        else if (prn.system() == 'C') {
     653          biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
     654                  + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     655                  + CLOCKORBIT_NUMSBAS
     656                  + bias.NumberOfSat[CLOCKORBIT_SATBDS];
     657          ++bias.NumberOfSat[CLOCKORBIT_SATBDS];
     658        }
     659      }
     660
     661      if (biasSat) {
     662        biasSat->ID = prn.number();
     663        biasSat->NumberOfCodeBiases = 0;
     664        QMapIterator<QString, double> it(codeBiases);
     665        while (it.hasNext()) {
     666          it.next();
     667          int ii = biasSat->NumberOfCodeBiases;
     668          if (ii >= CLOCKORBIT_NUMBIAS)
    489669            break;
    490           }
    491           if (key == "APC") {
    492             in >> numVal;
    493             rtnAPC.ReSize(3); rtnAPC = 0.0;
    494             for (int ii = 0; ii < numVal; ii++) {
    495               in >> rtnAPC[ii];
    496             }
    497           }
    498           else if (key == "Ura") {
    499             in >> numVal;
    500             if (numVal == 1)
    501               in >> rtnUra;
    502           }
    503           else if (key == "Clk") {
    504             in >> numVal;
    505             rtnClk.ReSize(3); rtnClk = 0.0;
    506             for (int ii = 0; ii < numVal; ii++) {
    507               in >> rtnClk[ii];
    508             }
    509           }
    510           else if (key == "ClkSig") {
    511             in >> numVal;
    512             rtnClkSig.ReSize(3); rtnClkSig = 0.0;
    513             for (int ii = 0; ii < numVal; ii++) {
    514               in >> rtnClkSig[ii];
    515             }
    516           }
    517           else if (key == "Vel") {
    518             in >> numVal;
    519             rtnVel.ReSize(3); rtnVel = 0.0;
    520             for (int ii = 0; ii < numVal; ii++) {
    521               in >> rtnVel[ii];
    522             }
    523           }
    524           else if (key == "CoM") {
    525             in >> numVal;
    526             rtnCoM.ReSize(3); rtnCoM = 0.0;
    527             for (int ii = 0; ii < numVal; ii++) {
    528               in >> rtnCoM[ii];
    529             }
    530           }
    531           else if (key == "CodeBias") {
    532             in >> numVal;
    533             for (int ii = 0; ii < numVal; ii++) {
    534               QString type;
    535               double value;
    536               in >> type >> value;
    537               codeBiases[type] = value;
    538             }
    539           }
    540           else if (key == "YawAngle") {
    541             _phaseBiasInformationDecoded = true;
    542             in >> numVal >> pbSat.yawAngle;
    543             if      (pbSat.yawAngle < 0.0) {
    544               pbSat.yawAngle += (2*M_PI);
    545             }
    546             else if (pbSat.yawAngle > 2*M_PI) {
    547               pbSat.yawAngle -= (2*M_PI);
    548             }
    549           }
    550           else if (key == "YawRate") {
    551             _phaseBiasInformationDecoded = true;
    552             in >> numVal >> pbSat.yawRate;
    553           }
    554           else if (key == "PhaseBias") {
    555             _phaseBiasInformationDecoded = true;
    556             in >> numVal;
    557             for (int ii = 0; ii < numVal; ii++) {
    558               phaseBiasSignal pb;
    559               in >> pb.type >> pb.bias >> pb.integerIndicator
    560                 >> pb.wlIndicator >> pb.discontinuityCounter;
    561               phaseBiasList.append(pb);
    562             }
    563           }
    564           else {
    565             in >> numVal;
    566             for (int ii = 0; ii < numVal; ii++) {
    567               double dummy;
    568               in >> dummy;
    569             }
    570             emit(newMessage("                      RTNET format error: "
    571                             +  lines[ii].toLatin1(), false));
    572           }
    573         }
    574 
    575         struct SsrCorr::ClockOrbit::SatData* sd = 0;
    576         if (prn.system() == 'G') {
    577           sd = co.Sat + co.NumberOfSat[CLOCKORBIT_SATGPS];
    578           ++co.NumberOfSat[CLOCKORBIT_SATGPS];
    579         }
    580         else if (prn.system() == 'R') {
    581           sd = co.Sat + CLOCKORBIT_NUMGPS + co.NumberOfSat[CLOCKORBIT_SATGLONASS];
    582           ++co.NumberOfSat[CLOCKORBIT_SATGLONASS];
    583         }
    584         else if (prn.system() == 'E') {
    585           sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    586              + co.NumberOfSat[CLOCKORBIT_SATGALILEO];
    587           ++co.NumberOfSat[CLOCKORBIT_SATGALILEO];
    588         }
    589         else if (prn.system() == 'J') {
    590           sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    591              + CLOCKORBIT_NUMGALILEO
    592              + co.NumberOfSat[CLOCKORBIT_SATQZSS];
    593           ++co.NumberOfSat[CLOCKORBIT_SATQZSS];
    594         }
    595         else if (prn.system() == 'S') {
    596           sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    597               + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    598               + co.NumberOfSat[CLOCKORBIT_SATSBAS];
    599           ++co.NumberOfSat[CLOCKORBIT_SATSBAS];
    600         }
    601         else if (prn.system() == 'C') {
    602           sd = co.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    603               + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    604               + CLOCKORBIT_NUMSBAS
    605               + co.NumberOfSat[CLOCKORBIT_SATBDS];
    606           ++co.NumberOfSat[CLOCKORBIT_SATBDS];
    607         }
    608         if (sd) {
    609           QString outLine;
    610           t_irc irc = processSatellite(eph, epoTime.gpsw(), epoTime.gpssec(), prnStr, rtnAPC,
    611                                        rtnUra, rtnClk, rtnVel, rtnCoM, rtnClkSig, sd, outLine);
    612           if (irc != success) {/*
    613             // very few cases: check states bad and unhealthy are excluded earlier
    614             sd->ID = prnStr.mid(1).toInt(); // to prevent G00, R00 entries
    615             sd->IOD = eph->IOD();
    616             */
    617             continue;
    618           }
    619         }
    620 
    621         // Code Biases
    622         // -----------
    623         struct SsrCorr::CodeBias::BiasSat* biasSat = 0;
    624         if (!codeBiases.isEmpty()) {
    625           if (prn.system() == 'G') {
    626             biasSat = bias.Sat + bias.NumberOfSat[CLOCKORBIT_SATGPS];
    627             ++bias.NumberOfSat[CLOCKORBIT_SATGPS];
    628           }
    629           else if (prn.system() == 'R') {
    630             biasSat = bias.Sat + CLOCKORBIT_NUMGPS
    631                     + bias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    632             ++bias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    633           }
    634           else if (prn.system() == 'E') {
    635             biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    636                     + bias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    637             ++bias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    638           }
    639           else if (prn.system() == 'J') {
    640             biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    641                     + CLOCKORBIT_NUMGALILEO
    642                     + bias.NumberOfSat[CLOCKORBIT_SATQZSS];
    643             ++bias.NumberOfSat[CLOCKORBIT_SATQZSS];
    644           }
    645           else if (prn.system() == 'S') {
    646             biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    647                     + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    648                     + bias.NumberOfSat[CLOCKORBIT_SATSBAS];
    649             ++bias.NumberOfSat[CLOCKORBIT_SATSBAS];
    650           }
    651           else if (prn.system() == 'C') {
    652             biasSat = bias.Sat + CLOCKORBIT_NUMGPS + CLOCKORBIT_NUMGLONASS
    653                     + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    654                     + CLOCKORBIT_NUMSBAS
    655                     + bias.NumberOfSat[CLOCKORBIT_SATBDS];
    656             ++bias.NumberOfSat[CLOCKORBIT_SATBDS];
    657           }
    658         }
    659 
    660         if (biasSat) {
    661           biasSat->ID = prn.number();
    662           biasSat->NumberOfCodeBiases = 0;
    663           QMapIterator<QString, double> it(codeBiases);
    664           while (it.hasNext()) {
    665             it.next();
    666             int ii = biasSat->NumberOfCodeBiases;
    667             if (ii >= CLOCKORBIT_NUMBIAS)
    668               break;
    669             SsrCorr::CodeType type = _ssrCorr->rnxTypeToCodeType(prn.system(), it.key().toStdString());
    670             if (type != _ssrCorr->RESERVED) {
    671               biasSat->NumberOfCodeBiases += 1;
    672               biasSat->Biases[ii].Type = type;
    673               biasSat->Biases[ii].Bias = it.value();
    674             }
    675           }
    676         }
    677 
    678         // Phase Biases
    679         // ------------
    680         struct SsrCorr::PhaseBias::PhaseBiasSat* phasebiasSat = 0;
    681         if (prn.system()      == 'G') {
    682           phasebiasSat = phasebias.Sat
    683                        + phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
    684           ++phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
    685         }
    686         else if (prn.system() == 'R') {
    687           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS
    688                        + phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    689           ++phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
    690         }
    691         else if (prn.system() == 'E') {
    692           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
    693                        + phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    694           ++phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
    695         }
    696         else if (prn.system() == 'J') {
    697           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
    698                        + CLOCKORBIT_NUMGALILEO
    699                        + phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
    700           ++phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
    701         }
    702         else if (prn.system() == 'S') {
    703           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
    704                        + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    705                        + phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
    706           ++phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
    707         }
    708         else if (prn.system() == 'C') {
    709           phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
    710                        + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
    711                        + CLOCKORBIT_NUMSBAS
    712                        + phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
    713           ++phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
    714         }
    715 
    716         if (phasebiasSat && _phaseBiasInformationDecoded) {
    717           phasebias.DispersiveBiasConsistencyIndicator = dispersiveBiasConsistenyIndicator;
    718           phasebias.MWConsistencyIndicator = mwConsistencyIndicator;
    719           phasebiasSat->ID = prn.number();
    720           phasebiasSat->NumberOfPhaseBiases = 0;
    721           phasebiasSat->YawAngle = pbSat.yawAngle;
    722           phasebiasSat->YawRate = pbSat.yawRate;
    723           QListIterator<phaseBiasSignal> it(phaseBiasList);
    724           while (it.hasNext()) {
    725             const phaseBiasSignal &pbSig = it.next();
    726             int ii = phasebiasSat->NumberOfPhaseBiases;
    727             if (ii >= CLOCKORBIT_NUMBIAS)
    728               break;
    729             SsrCorr::CodeType type = _ssrCorr->rnxTypeToCodeType(prn.system(), pbSig.type.toStdString());
    730             if (type != _ssrCorr->RESERVED) {
    731               phasebiasSat->NumberOfPhaseBiases += 1;
    732               phasebiasSat->Biases[ii].Type = type;
    733               phasebiasSat->Biases[ii].Bias = pbSig.bias;
    734               phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
    735               phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
    736               phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    737             }
     670          SsrCorr::CodeType type = _ssrCorr->rnxTypeToCodeType(prn.system(), it.key().toStdString());
     671          if (type != _ssrCorr->RESERVED) {
     672            biasSat->NumberOfCodeBiases += 1;
     673            biasSat->Biases[ii].Type = type;
     674            biasSat->Biases[ii].Bias = it.value();
     675          }
     676        }
     677      }
     678
     679      // Phase Biases
     680      // ------------
     681      struct SsrCorr::PhaseBias::PhaseBiasSat* phasebiasSat = 0;
     682      if (prn.system()      == 'G') {
     683        phasebiasSat = phasebias.Sat
     684                     + phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
     685        ++phasebias.NumberOfSat[CLOCKORBIT_SATGPS];
     686      }
     687      else if (prn.system() == 'R') {
     688        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS
     689                     + phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
     690        ++phasebias.NumberOfSat[CLOCKORBIT_SATGLONASS];
     691      }
     692      else if (prn.system() == 'E') {
     693        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     694                     + phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
     695        ++phasebias.NumberOfSat[CLOCKORBIT_SATGALILEO];
     696      }
     697      else if (prn.system() == 'J') {
     698        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     699                     + CLOCKORBIT_NUMGALILEO
     700                     + phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
     701        ++phasebias.NumberOfSat[CLOCKORBIT_SATQZSS];
     702      }
     703      else if (prn.system() == 'S') {
     704        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     705                     + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     706                     + phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
     707        ++phasebias.NumberOfSat[CLOCKORBIT_SATSBAS];
     708      }
     709      else if (prn.system() == 'C') {
     710        phasebiasSat = phasebias.Sat + CLOCKORBIT_NUMGPS  + CLOCKORBIT_NUMGLONASS
     711                     + CLOCKORBIT_NUMGALILEO + CLOCKORBIT_NUMQZSS
     712                     + CLOCKORBIT_NUMSBAS
     713                     + phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
     714        ++phasebias.NumberOfSat[CLOCKORBIT_SATBDS];
     715      }
     716
     717      if (phasebiasSat && _phaseBiasInformationDecoded) {
     718        phasebias.DispersiveBiasConsistencyIndicator = dispersiveBiasConsistenyIndicator;
     719        phasebias.MWConsistencyIndicator = mwConsistencyIndicator;
     720        phasebiasSat->ID = prn.number();
     721        phasebiasSat->NumberOfPhaseBiases = 0;
     722        phasebiasSat->YawAngle = pbSat.yawAngle;
     723        phasebiasSat->YawRate = pbSat.yawRate;
     724        QListIterator<phaseBiasSignal> it(phaseBiasList);
     725        while (it.hasNext()) {
     726          const phaseBiasSignal &pbSig = it.next();
     727          int ii = phasebiasSat->NumberOfPhaseBiases;
     728          if (ii >= CLOCKORBIT_NUMBIAS)
     729            break;
     730          SsrCorr::CodeType type = _ssrCorr->rnxTypeToCodeType(prn.system(), pbSig.type.toStdString());
     731          if (type != _ssrCorr->RESERVED) {
     732            phasebiasSat->NumberOfPhaseBiases += 1;
     733            phasebiasSat->Biases[ii].Type = type;
     734            phasebiasSat->Biases[ii].Bias = pbSig.bias;
     735            phasebiasSat->Biases[ii].SignalIntegerIndicator = pbSig.integerIndicator;
     736            phasebiasSat->Biases[ii].SignalsWideLaneIntegerIndicator = pbSig.wlIndicator;
     737            phasebiasSat->Biases[ii].SignalDiscontinuityCounter = pbSig.discontinuityCounter;
    738738          }
    739739        }
Note: See TracChangeset for help on using the changeset viewer.