Changeset 4391 in ntrip for trunk/BNC


Ignore:
Timestamp:
Jul 6, 2012, 4:09:16 PM (13 years ago)
Author:
mervart
Message:
 
Location:
trunk/BNC/src
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • trunk/BNC/src/RTCM/GPSDecoder.cpp

    r4389 r4391  
    8989  }
    9090}
    91 
    92 //
    93 //////////////////////////////////////////////////////////////////////////////
    94 double t_obs::c1() const {
    95   if (_measdata[GNSSENTRY_C1DATA]  != 0.0) return _measdata[GNSSENTRY_C1DATA];
    96   if (_measdata[GNSSENTRY_C1NDATA] != 0.0) return _measdata[GNSSENTRY_C1NDATA];
    97   return 0.0;
    98 }
    99 
    100 double t_obs::c2() const {
    101   if (_measdata[GNSSENTRY_C2DATA] != 0.0) return _measdata[GNSSENTRY_C2DATA];
    102   return 0.0;
    103 }
    104 
    105 double t_obs::c5() const {
    106   if (_measdata[GNSSENTRY_C5DATA]   != 0.0) return _measdata[GNSSENTRY_C5DATA];
    107   if (_measdata[GNSSENTRY_C5BDATA]  != 0.0) return _measdata[GNSSENTRY_C5BDATA];
    108   if (_measdata[GNSSENTRY_C5ABDATA] != 0.0) return _measdata[GNSSENTRY_C5ABDATA];
    109   return 0.0;
    110 }
    111 
    112 double t_obs::p1() const {
    113   if (_measdata[GNSSENTRY_P1DATA] != 0.0) return _measdata[GNSSENTRY_P1DATA];
    114   return 0.0;
    115 }
    116 
    117 double t_obs::p2() const {
    118   if (_measdata[GNSSENTRY_P2DATA] != 0.0) return _measdata[GNSSENTRY_P2DATA];
    119   return 0.0;
    120 }
    121 
    122 double t_obs::l1() const {
    123   if (_measdata[GNSSENTRY_L1CDATA] != 0.0) return _measdata[GNSSENTRY_L1CDATA];
    124   if (_measdata[GNSSENTRY_L1PDATA] != 0.0) return _measdata[GNSSENTRY_L1PDATA];
    125   if (_measdata[GNSSENTRY_L1NDATA] != 0.0) return _measdata[GNSSENTRY_L1NDATA];
    126   return 0.0;
    127 }
    128 
    129 double t_obs::l2() const {
    130   if (_measdata[GNSSENTRY_L2CDATA] != 0.0) return _measdata[GNSSENTRY_L2CDATA];
    131   if (_measdata[GNSSENTRY_L2PDATA] != 0.0) return _measdata[GNSSENTRY_L2PDATA];
    132   return 0.0;
    133 }
    134 
    135 double t_obs::l5() const {
    136   if (_measdata[GNSSENTRY_L5DATA]   != 0.0) return _measdata[GNSSENTRY_L5DATA];
    137   if (_measdata[GNSSENTRY_L5BDATA]  != 0.0) return _measdata[GNSSENTRY_L5BDATA];
    138   if (_measdata[GNSSENTRY_L5ABDATA] != 0.0) return _measdata[GNSSENTRY_L5ABDATA];
    139   return 0.0;
    140 }
    141 
    142 double t_obs::s1() const {
    143   if (_measdata[GNSSENTRY_S1CDATA] != 0.0) return _measdata[GNSSENTRY_S1CDATA];
    144   if (_measdata[GNSSENTRY_S1PDATA] != 0.0) return _measdata[GNSSENTRY_S1PDATA];
    145   if (_measdata[GNSSENTRY_S1NDATA] != 0.0) return _measdata[GNSSENTRY_S1NDATA];
    146   return 0.0;
    147 }
    148 
    149 double t_obs::s2() const {
    150   if (_measdata[GNSSENTRY_S2CDATA] != 0.0) return _measdata[GNSSENTRY_S2CDATA];
    151   if (_measdata[GNSSENTRY_S2PDATA] != 0.0) return _measdata[GNSSENTRY_S2PDATA];
    152   return 0.0;
    153 }
    154 
    155 //
    156 //////////////////////////////////////////////////////////////////////////////
    157 std::string t_obs::entry2str(int iEntry) const {
    158   if (iEntry == GNSSENTRY_C1DATA   ) return "C1";
    159   if (iEntry == GNSSENTRY_L1CDATA  ) return "L1C";
    160   if (iEntry == GNSSENTRY_D1CDATA  ) return "D1C";
    161   if (iEntry == GNSSENTRY_S1CDATA  ) return "S1C";
    162   if (iEntry == GNSSENTRY_C2DATA   ) return "C2";
    163   if (iEntry == GNSSENTRY_L2CDATA  ) return "L2C";
    164   if (iEntry == GNSSENTRY_D2CDATA  ) return "D2C";
    165   if (iEntry == GNSSENTRY_S2CDATA  ) return "S2C";
    166   if (iEntry == GNSSENTRY_P1DATA   ) return "P1";
    167   if (iEntry == GNSSENTRY_L1PDATA  ) return "L1P";
    168   if (iEntry == GNSSENTRY_D1PDATA  ) return "D1P";
    169   if (iEntry == GNSSENTRY_S1PDATA  ) return "S1P";
    170   if (iEntry == GNSSENTRY_P2DATA   ) return "P2";
    171   if (iEntry == GNSSENTRY_L2PDATA  ) return "L2P";
    172   if (iEntry == GNSSENTRY_D2PDATA  ) return "D2P";
    173   if (iEntry == GNSSENTRY_S2PDATA  ) return "S2P";
    174   if (iEntry == GNSSENTRY_C5DATA   ) return "C5";
    175   if (iEntry == GNSSENTRY_L5DATA   ) return "L5";
    176   if (iEntry == GNSSENTRY_D5DATA   ) return "D5";
    177   if (iEntry == GNSSENTRY_S5DATA   ) return "S5";
    178   if (iEntry == GNSSENTRY_C6DATA   ) return "C6";
    179   if (iEntry == GNSSENTRY_L6DATA   ) return "L6";
    180   if (iEntry == GNSSENTRY_D6DATA   ) return "D6";
    181   if (iEntry == GNSSENTRY_S6DATA   ) return "S6";
    182   if (iEntry == GNSSENTRY_C5BDATA  ) return "C5B";
    183   if (iEntry == GNSSENTRY_L5BDATA  ) return "L5B";
    184   if (iEntry == GNSSENTRY_D5BDATA  ) return "D5B";
    185   if (iEntry == GNSSENTRY_S5BDATA  ) return "S5B";
    186   if (iEntry == GNSSENTRY_C5ABDATA ) return "C5AB";
    187   if (iEntry == GNSSENTRY_L5ABDATA ) return "L5AB";
    188   if (iEntry == GNSSENTRY_D5ABDATA ) return "D5AB";
    189   if (iEntry == GNSSENTRY_S5ABDATA ) return "S5AB";
    190   if (iEntry == GNSSENTRY_CSAIFDATA) return "CSAIF";
    191   if (iEntry == GNSSENTRY_LSAIFDATA) return "LSAIF";
    192   if (iEntry == GNSSENTRY_DSAIFDATA) return "DSAIF";
    193   if (iEntry == GNSSENTRY_SSAIFDATA) return "SSAIF";
    194   if (iEntry == GNSSENTRY_C1NDATA  ) return "C1N";
    195   if (iEntry == GNSSENTRY_L1NDATA  ) return "L1N";
    196   if (iEntry == GNSSENTRY_D1NDATA  ) return "D1N";
    197   if (iEntry == GNSSENTRY_S1NDATA  ) return "S1N";
    198 
    199   throw "Error in t_obs::entry2str";
    200 }
    201 
    202 //
    203 //////////////////////////////////////////////////////////////////////////////
    204 int t_obs::str2entry(const char* strIn) const {
    205 
    206   string str(strIn);
    207 
    208   if (str == "C1"   ) return GNSSENTRY_C1DATA;
    209   if (str == "L1C"  ) return GNSSENTRY_L1CDATA;
    210   if (str == "D1C"  ) return GNSSENTRY_D1CDATA;
    211   if (str == "S1C"  ) return GNSSENTRY_S1CDATA;
    212   if (str == "C2"   ) return GNSSENTRY_C2DATA;
    213   if (str == "L2C"  ) return GNSSENTRY_L2CDATA;
    214   if (str == "D2C"  ) return GNSSENTRY_D2CDATA;
    215   if (str == "S2C"  ) return GNSSENTRY_S2CDATA;
    216   if (str == "P1"   ) return GNSSENTRY_P1DATA;
    217   if (str == "L1P"  ) return GNSSENTRY_L1PDATA;
    218   if (str == "D1P"  ) return GNSSENTRY_D1PDATA;
    219   if (str == "S1P"  ) return GNSSENTRY_S1PDATA;
    220   if (str == "P2"   ) return GNSSENTRY_P2DATA;
    221   if (str == "L2P"  ) return GNSSENTRY_L2PDATA;
    222   if (str == "D2P"  ) return GNSSENTRY_D2PDATA;
    223   if (str == "S2P"  ) return GNSSENTRY_S2PDATA;
    224   if (str == "C5"   ) return GNSSENTRY_C5DATA;
    225   if (str == "L5"   ) return GNSSENTRY_L5DATA;
    226   if (str == "D5"   ) return GNSSENTRY_D5DATA;
    227   if (str == "S5"   ) return GNSSENTRY_S5DATA;
    228   if (str == "C6"   ) return GNSSENTRY_C6DATA;
    229   if (str == "L6"   ) return GNSSENTRY_L6DATA;
    230   if (str == "D6"   ) return GNSSENTRY_D6DATA;
    231   if (str == "S6"   ) return GNSSENTRY_S6DATA;
    232   if (str == "C5B"  ) return GNSSENTRY_C5BDATA;
    233   if (str == "L5B"  ) return GNSSENTRY_L5BDATA;
    234   if (str == "D5B"  ) return GNSSENTRY_D5BDATA;
    235   if (str == "S5B"  ) return GNSSENTRY_S5BDATA;
    236   if (str == "C5AB" ) return GNSSENTRY_C5ABDATA;
    237   if (str == "L5AB" ) return GNSSENTRY_L5ABDATA;
    238   if (str == "D5AB" ) return GNSSENTRY_D5ABDATA;
    239   if (str == "S5AB" ) return GNSSENTRY_S5ABDATA;
    240   if (str == "CSAIF") return GNSSENTRY_CSAIFDATA;
    241   if (str == "LSAIF") return GNSSENTRY_LSAIFDATA;
    242   if (str == "DSAIF") return GNSSENTRY_DSAIFDATA;
    243   if (str == "SSAIF") return GNSSENTRY_SSAIFDATA;
    244   if (str == "C1N"  ) return GNSSENTRY_C1NDATA;
    245   if (str == "L1N"  ) return GNSSENTRY_L1NDATA;
    246   if (str == "D1N"  ) return GNSSENTRY_D1NDATA;
    247   if (str == "S1N"  ) return GNSSENTRY_S1NDATA;
    248 
    249   throw "Error in t_obs::str2entry";
    250 }

  • trunk/BNC/src/RTCM/GPSDecoder.h

    r4389 r4391  
    6161  ~t_obs() {}
    6262
    63   double c1() const;
    64   double c2() const;
    65   double c5() const;
    66   double p1() const;
    67   double p2() const;
    68   double l1() const;
    69   double l2() const;
    70   double l5() const;
    71   double s1() const;
    72   double s2() const;
    73   std::string entry2str(int iEntry) const;
    74   int str2entry(const char* str) const;
     63  double measdata(const QString& rnxStr) const;
     64  void   setMeasdata(const QString& rnxStr, double value);
    7565
    7666  char   StatID[20+1]; // Station ID

  • trunk/BNC/src/RTCM/RTCM2Decoder.cpp

    r4389 r4391  
    148148          obs.GPSWeek       = epochWeek;
    149149          obs.GPSWeeks      = epochSecs;
    150           obs._measdata[obs.str2entry("C1")] = _ObsBlock.rng_C1[iSat];
    151           obs._measdata[obs.str2entry("P1")] = _ObsBlock.rng_P1[iSat];
    152           obs._measdata[obs.str2entry("P2")] = _ObsBlock.rng_P2[iSat];
    153           obs._measdata[obs.str2entry("L1")] = _ObsBlock.resolvedPhase_L1(iSat);
    154           obs._measdata[obs.str2entry("L2")] = _ObsBlock.resolvedPhase_L2(iSat);
     150          obs.setMeasdata("C1", _ObsBlock.rng_C1[iSat]);
     151          obs.setMeasdata("P1", _ObsBlock.rng_P1[iSat]);
     152          obs.setMeasdata("P2", _ObsBlock.rng_P2[iSat]);
     153          obs.setMeasdata("L1", _ObsBlock.resolvedPhase_L1(iSat));
     154          obs.setMeasdata("L2", _ObsBlock.resolvedPhase_L2(iSat));
    155155          obs.slip_cnt_L1   = _ObsBlock.slip_L1[iSat];
    156156          obs.slip_cnt_L2   = _ObsBlock.slip_L2[iSat];
    … …  
    368368        switch (ii) {
    369369        case 0: // --- L1 ---
    370           new_obs->_measdata[new_obs->str2entry("L1")] = *obsVal / LAMBDA_1;
     370          new_obs->setMeasdata("L1", *obsVal / LAMBDA_1);
    371371          new_obs->slip_cnt_L1   = corr->lock1;
    372372          break;
    373373        case 1: // --- L2 ---
    374           new_obs->_measdata[new_obs->str2entry("L2")] = *obsVal / LAMBDA_2;
     374          new_obs->setMeasdata("L2", *obsVal / LAMBDA_2);
    375375          new_obs->slip_cnt_L2   = corr->lock2;
    376376          break;
    377377        case 2: // --- C1 / P1 ---
    378378          if ( corr->Pind1 )
    379             new_obs->_measdata[new_obs->str2entry("P1")] = *obsVal;
     379            new_obs->setMeasdata("P1", *obsVal);
    380380          else
    381             new_obs->_measdata[new_obs->str2entry("C1")] = *obsVal;
     381            new_obs->setMeasdata("C1", *obsVal);
    382382          break;
    383383        case 3: // --- C2 / P2 ---
    384384          if ( corr->Pind2 )
    385             new_obs->_measdata[new_obs->str2entry("P2")] = *obsVal;
     385            new_obs->setMeasdata("P2", *obsVal);
    386386          else
    387             new_obs->_measdata[new_obs->str2entry("C2")] = *obsVal;
     387            new_obs->setMeasdata("C2", *obsVal);
    388388          break;
    389389        default:

  • trunk/BNC/src/bncpppclient.cpp

    r4389 r4391  
    160160  // --------------------
    161161  if      (obs.satSys == 'G') {
    162     if ( (obs.p1() || obs.c1()) && (obs.p2() || obs.c2()) && obs.l1() && obs.l2() ) {
     162    double C1C = obs.measdata("C1C");
     163    double C1P = obs.measdata("C1P");
     164    double C2C = obs.measdata("C2C");
     165    double C2P = obs.measdata("C2P");
     166    double L1  = obs.measdata("L1");
     167    double L2  = obs.measdata("L2");
     168    if ( (C1P || C1C) && (C2P || C2C) && L1 && L2 ) {
    163169      double f1 = t_CST::freq1;
    164170      double f2 = t_CST::freq2;
    165171      double c1 =   f1 * f1 / (f1 * f1 - f2 * f2);
    166172      double c2 = - f2 * f2 / (f1 * f1 - f2 * f2);
    167       if (obs.p1()) {
    168         satData->P1 = obs.p1() + (bb ? bb->p1 : 0.0);
     173      if (C1P) {
     174        satData->P1 = C1P + (bb ? bb->p1 : 0.0);
    169175      }
    170176      else {
    171         satData->P1 = obs.c1() + (bb ? bb->c1 : 0.0);
    172       }
    173       if (obs.p2()) {
    174         satData->P2 = obs.p2() + (bb ? bb->p2 : 0.0);
     177        satData->P1 = C1C + (bb ? bb->c1 : 0.0);
     178      }
     179      if (C2P) {
     180        satData->P2 = C2P + (bb ? bb->p2 : 0.0);
    175181      }
    176182      else {
    177         satData->P2 = obs.c2();
    178       }
    179       satData->L1      = obs.l1() * t_CST::c / f1;
    180       satData->L2      = obs.l2() * t_CST::c / f2;
     183        satData->P2 = C2C;
     184      }
     185      satData->L1      = L1 * t_CST::c / f1;
     186      satData->L2      = L2 * t_CST::c / f2;
    181187      satData->P3      = c1 * satData->P1 + c2 * satData->P2;
    182188      satData->L3      = c1 * satData->L1 + c2 * satData->L2;
    … …  
    193199  // ------------------------
    194200  else if (obs.satSys == 'R') {
    195     if ( (obs.p1() || obs.c1()) && (obs.p2() || obs.c2()) && obs.l1() && obs.l2() ) {
     201    double C1C = obs.measdata("C1C");
     202    double C1P = obs.measdata("C1P");
     203    double C2C = obs.measdata("C2C");
     204    double C2P = obs.measdata("C2P");
     205    double L1  = obs.measdata("L1");
     206    double L2  = obs.measdata("L2");
     207    if ( (C1P || C1C) && (C2P || C2C) && L1 && L2 ) {
    196208      double f1 = t_CST::f1(obs.satSys, obs.slotNum);
    197209      double f2 = t_CST::f2(obs.satSys, obs.slotNum);
    198210      double c1 =   f1 * f1 / (f1 * f1 - f2 * f2);
    199211      double c2 = - f2 * f2 / (f1 * f1 - f2 * f2);
    200       if (obs.p1()) {
    201         satData->P1 = obs.p1() + (bb ? bb->p1 : 0.0);
     212      if (C1P) {
     213        satData->P1 = C1P + (bb ? bb->p1 : 0.0);
    202214      }
    203215      else {
    204         satData->P1 = obs.c1() + (bb ? bb->c1 : 0.0);
    205       }
    206       if (obs.p2()) {
    207         satData->P2 = obs.p2() + (bb ? bb->p2 : 0.0);
     216        satData->P1 = C1C + (bb ? bb->c1 : 0.0);
     217      }
     218      if (C2P) {
     219        satData->P2 = C2P + (bb ? bb->p2 : 0.0);
    208220      }
    209221      else {
    210         satData->P2 = obs.c2();
    211       }
    212       satData->L1      = obs.l1() * t_CST::c / f1;
    213       satData->L2      = obs.l2() * t_CST::c / f2;
     222        satData->P2 = C2C;
     223      }
     224      satData->L1      = L1 * t_CST::c / f1;
     225      satData->L2      = L2 * t_CST::c / f2;
    214226      satData->P3      = c1 * satData->P1 + c2 * satData->P2;
    215227      satData->L3      = c1 * satData->L1 + c2 * satData->L2;
    … …  
    226238  // ------------------------
    227239  else if (obs.satSys == 'E') {
    228     if ( obs.c1() && obs.c5() && obs.l1() && obs.l5()) {
     240    double C1 = obs.measdata("C1");
     241    double L1 = obs.measdata("L1");
     242    double C5 = obs.measdata("C5");
     243    double L5 = obs.measdata("L5");
     244    if ( C1 && C5 && L1 && L5) {
    229245      double f1 = t_CST::freq1;
    230246      double f5 = t_CST::freq5;
    … …  
    232248      double c5 = - f5 * f5 / (f1 * f1 - f5 * f5);
    233249
    234       satData->P1      = obs.c1();
    235       satData->P5      = obs.c5();
    236       satData->L1      = obs.l1() * t_CST::c / f1;
    237       satData->L5      = obs.l5() * t_CST::c / f5;
     250      satData->P1      = C1;
     251      satData->P5      = C5;
     252      satData->L1      = L1 * t_CST::c / f1;
     253      satData->L5      = L5 * t_CST::c / f5;
    238254      satData->P3      = c1 * satData->P1 + c5 * satData->P5;
    239255      satData->L3      = c1 * satData->L1 + c5 * satData->L5;

  • trunk/BNC/src/bncrinex.cpp

    r4390 r4391  
    694694    // ---------------
    695695    else {
    696       _out << setw(14) << setprecision(3) << obs.c1()  << ' '  << ' '
    697            << setw(14) << setprecision(3) << obs.p1()  << ' '  << ' '
    698            << setw(14) << setprecision(3) << obs.l1()  << lli1 << ' '
    699            << setw(14) << setprecision(3) << obs.s1()  << ' '  << ' '
    700            << setw(14) << setprecision(3) << obs.c2()  << ' '  << ' ' << endl
    701            << setw(14) << setprecision(3) << obs.p2()  << ' '  << ' '
    702            << setw(14) << setprecision(3) << obs.l2()  << lli2 << ' '
    703            << setw(14) << setprecision(3) << obs.s2()  << endl;
     696      _out << setw(14) << setprecision(3) << obs.measdata("C1")  << ' '  << ' '
     697           << setw(14) << setprecision(3) << obs.measdata("P1")  << ' '  << ' '
     698           << setw(14) << setprecision(3) << obs.measdata("L1")  << lli1 << ' '
     699           << setw(14) << setprecision(3) << obs.measdata("S1")  << ' '  << ' '
     700           << setw(14) << setprecision(3) << obs.measdata("C2")  << ' '  << ' ' << endl
     701           << setw(14) << setprecision(3) << obs.measdata("P2")  << ' '  << ' '
     702           << setw(14) << setprecision(3) << obs.measdata("L2")  << lli2 << ' '
     703           << setw(14) << setprecision(3) << obs.measdata("S2")  << endl;
    704704    }
    705705  }
    … …  
    727727}
    728728
    729 // One Line in RINEX v3 (static)
     729// One Line in RINEX v3
    730730////////////////////////////////////////////////////////////////////////////
    731731string bncRinex::rinexSatLine(const t_obs& obs, char lli1, char lli2,
    … …  
    737737      << setw(2) << setfill('0') << obs.satNum << setfill(' ');
    738738
    739   for (int iEntry = 0; iEntry < GNSSENTRY_NUMBER; iEntry++) {
    740     unsigned df = (1 << iEntry);
    741     if (df & obs._dataflags) {
    742       str << ' ' << obs.entry2str(iEntry) << ' ' << obs._codetype[iEntry] << ' '
    743           << setw(14) << setprecision(3) << obs._measdata[iEntry]  << ' ';
    744     }
     739  const QVector<QString>& types = _rnxTypes[obs.satSys];
     740  for (int ii = 0; ii < types.size(); ii++) {
     741    str << setw(14) << setprecision(3) << obs.measdata(types[ii]) << ' ';
    745742  }
    746743
    … …  
    778775  }
    779776
    780   for (int iEntry = 0; iEntry < GNSSENTRY_NUMBER; iEntry++) {
    781     unsigned df = (1 << iEntry);
    782     if (df & obs._dataflags) {
    783       str << ' ' << obs.entry2str(iEntry) << ' '
    784           << setw(14) << setprecision(3) << obs._measdata[iEntry]  << ' ';
    785       // TODO: handle slip counters
    786     }
    787   }
    788 
     777  if      (obs.satSys == 'G') { // GPS
     778    str << "  1C "
     779        << obsToStr(obs.measdata("C1C")) << ' ' 
     780        << obsToStr(obs.measdata("L1C")) << ' '
     781        << obsToStr(obs.measdata("D1C")) << ' '
     782        << obsToStr(obs.measdata("S1C"), 8, 3) << ' '
     783        << setw(2)  << obs.slip_cnt_L1;
     784    str << "  1W "
     785        << obsToStr(obs.measdata("C1W")) << ' ' 
     786        << obsToStr(obs.measdata("L1W")) << ' '
     787        << obsToStr(obs.measdata("D1W")) << ' '
     788        << obsToStr(obs.measdata("S1W"), 8, 3) << ' '
     789        << setw(2)  << obs.slip_cnt_L1;
     790    str << "  2P "
     791        << obsToStr(obs.measdata("C2P")) << ' '
     792        << obsToStr(obs.measdata("L2P")) << ' '
     793        << obsToStr(obs.measdata("D2P")) << ' '
     794        << obsToStr(obs.measdata("S2P"), 8, 3) << ' '
     795        << setw(2)  << obs.slip_cnt_L2;
     796    str << "  2X "
     797        << obsToStr(obs.measdata("C2X")) << ' ' 
     798        << obsToStr(obs.measdata("L2X")) << ' '
     799        << obsToStr(obs.measdata("D2X")) << ' '
     800        << obsToStr(obs.measdata("S2X"), 8, 3) << ' '
     801        << setw(2)  << obs.slip_cnt_L2;
     802    str << "  5C "
     803        << obsToStr(obs.measdata("C5")) << ' '
     804        << obsToStr(obs.measdata("L5")) << ' '
     805        << obsToStr(obs.measdata("D5")) << ' '
     806        << obsToStr(obs.measdata("S5"), 8, 3) << ' '
     807        << setw(2)  << obs.slip_cnt_L5;
     808  }
     809  else if (obs.satSys == 'R') { // Glonass
     810    str << "  1C "
     811        << obsToStr(obs.measdata("C1C")) << ' ' 
     812        << obsToStr(obs.measdata("L1C")) << ' '
     813        << obsToStr(obs.measdata("D1C")) << ' '
     814        << obsToStr(obs.measdata("S1C"), 8, 3) << ' '
     815        << setw(2)  << obs.slip_cnt_L1;
     816    str << "  1P "
     817        << obsToStr(obs.measdata("C1P")) << ' ' 
     818        << obsToStr(obs.measdata("L1P")) << ' '
     819        << obsToStr(obs.measdata("D1P")) << ' '
     820        << obsToStr(obs.measdata("S1P"), 8, 3) << ' '
     821        << setw(2)  << obs.slip_cnt_L1;
     822    str << "  2P "
     823        << obsToStr(obs.measdata("C2P")) << ' '
     824        << obsToStr(obs.measdata("L2P")) << ' '
     825        << obsToStr(obs.measdata("D2P")) << ' '
     826        << obsToStr(obs.measdata("S2P"), 8, 3) << ' '
     827        << setw(2)  << obs.slip_cnt_L2;
     828    str << "  2C "
     829        << obsToStr(obs.measdata("C2C")) << ' ' 
     830        << obsToStr(obs.measdata("L2C")) << ' '
     831        << obsToStr(obs.measdata("D2C")) << ' '
     832        << obsToStr(obs.measdata("S2C"), 8, 3) << ' '
     833        << setw(2)  << obs.slip_cnt_L2;
     834  }
     835  else if (obs.satSys == 'E') { // Galileo
     836    str << " 1C "
     837        << obsToStr(obs.measdata("C1")) << ' ' 
     838        << obsToStr(obs.measdata("L1")) << ' '
     839        << obsToStr(obs.measdata("D1")) << ' '
     840        << obsToStr(obs.measdata("S1"), 8, 3) << ' '
     841        << setw(2)  << obs.slip_cnt_L1;
     842
     843    str << "  5C "
     844        << obsToStr(obs.measdata("C5")) << ' '       
     845        << obsToStr(obs.measdata("L5")) << ' '
     846        << obsToStr(obs.measdata("D5")) << ' '
     847        << obsToStr(obs.measdata("S5"), 8, 3) << ' '
     848        << setw(2)  << obs.slip_cnt_L5;
     849  }
    789850  return str.str();
    790851}

  • trunk/BNC/src/bncrinex.h

    r4390 r4391  
    5454   }
    5555
    56    static std::string rinexSatLine(const t_obs& obs, char lli1, char lli2,
    57                                    char lli5);
     56   std::string rinexSatLine(const t_obs& obs, char lli1, char lli2, char lli5);
    5857
    5958   static std::string asciiSatLine(const t_obs& obs);

  • trunk/BNC/src/rinex/bncpostprocess.cpp

    r4389 r4391  
    118118
    119119  for (int iType = 0; iType < rnxObsFile->nTypes(obs.satSys); iType++) {
    120     QByteArray type = rnxObsFile->obsType(obs.satSys,iType).toAscii();
    121     int iEntry = obs.str2entry(type.data());
    122     obs._measdata[iEntry] = rnxSat.obs[iType];
     120    QString type = rnxObsFile->obsType(obs.satSys,iType).toAscii();
     121    obs.setMeasdata(type, rnxSat.obs[iType]);
    123122    // TOOD: handle slip flags
    124123  }

  • trunk/BNC/src/rinex/reqcanalyze.cpp

    r4362 r4391  
    237237  // Compute the Multipath
    238238  // ----------------------
    239   if (obs.l1() != 0.0 && obs.l2() != 0.0) {
     239  double L1 = obs.measdata("L1");
     240  double L2 = obs.measdata("L2");
     241  if (L1 != 0.0 && L2 != 0.0) {
    240242    double f1 = t_CST::f1(obs.satSys, obs.slotNum);
    241243    double f2 = t_CST::f2(obs.satSys, obs.slotNum);
    242244
    243     double L1 = obs.l1() * t_CST::c / f1;
    244     double L2 = obs.l2() * t_CST::c / f2;
    245 
    246     if (obs.p1() != 0.0) {
    247       newObs->_MP1 = obs.p1() - L1 - 2.0*f2*f2/(f1*f1-f2*f2) * (L1 - L2);
     245    L1 = L1 * t_CST::c / f1;
     246    L2 = L2 * t_CST::c / f2;
     247
     248    double P1 = obs.measdata("P1");
     249    if (P1 != 0.0) {
     250      newObs->_MP1 = P1 - L1 - 2.0*f2*f2/(f1*f1-f2*f2) * (L1 - L2);
    248251      okFlag = true;
    249252
    … …  
    255258      //// end test
    256259    }
    257     if (obs.p2() != 0.0) {
    258       newObs->_MP2 = obs.p2() - L2 - 2.0*f1*f1/(f1*f1-f2*f2) * (L1 - L2);
     260    double P2 = obs.measdata("P2");
     261    if (P2 != 0.0) {
     262      newObs->_MP2 = P2 - L2 - 2.0*f1*f1/(f1*f1-f2*f2) * (L1 - L2);
    259263      okFlag = true;
    260264    }
Note: See TracChangeset for help on using the changeset viewer.