Index: /trunk/BNC/src/PPP/pppClient.cpp
===================================================================
--- /trunk/BNC/src/PPP/pppClient.cpp	(revision 5818)
+++ /trunk/BNC/src/PPP/pppClient.cpp	(revision 5819)
@@ -78,5 +78,5 @@
   _log      = new ostringstream();
   _ephPool  = new t_pppEphPool();
-  _obsPool  = new t_pppObsPool();
+  _obsPool  = new t_frqObsPool();
   _staRover = new t_pppStation();
   _filter   = new t_pppFilter();
@@ -150,6 +150,6 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-t_irc t_pppClient::prepareObs(const vector<t_pppSatObs*>& pppSatObs,
-                              vector<t_satObs*>& obsVector, bncTime& epoTime) {
+t_irc t_pppClient::prepareObs(const vector<t_satObs*>& pppSatObs,
+                              vector<t_pppSatObs*>& obsVector, bncTime& epoTime) {
   // Default 
   // -------
@@ -162,5 +162,5 @@
     char system = pppSatObs[ii]->_prn.system();
     if (system == 'G' || (system == 'R' && OPT->useGlonass())) {
-      t_satObs* satObs = new t_satObs(*pppSatObs[ii]);
+      t_pppSatObs* satObs = new t_pppSatObs(*pppSatObs[ii]);
       if (satObs->isValid()) {
         obsVector.push_back(satObs);
@@ -180,5 +180,5 @@
   double meanDt = 0.0;
   for (unsigned ii = 0; ii < obsVector.size(); ii++) {
-    const t_satObs* satObs = obsVector.at(ii);
+    const t_pppSatObs* satObs = obsVector.at(ii);
     if (epoTime.undef()) {
       epoTime = satObs->time();
@@ -204,5 +204,5 @@
 //////////////////////////////////////////////////////////////////////////////
 t_irc t_pppClient::cmpBancroft(const bncTime& epoTime, 
-                                  vector<t_satObs*>& obsVector,
+                                  vector<t_pppSatObs*>& obsVector,
                                   ColumnVector& xyzc, bool print) {
 
@@ -213,5 +213,5 @@
     int iObs = -1;
     for (unsigned ii = 0; ii < obsVector.size(); ii++) {
-      const t_satObs* satObs = obsVector.at(ii);
+      const t_pppSatObs* satObs = obsVector.at(ii);
       if ( satObs->isValid() && satObs->prn().system() == 'G' &&
            (!satObs->modelSet() || satObs->eleSat() >= OPT->_minEle) ) {
@@ -238,5 +238,5 @@
     unsigned maxResIndex = 0;
     for (unsigned ii = 0; ii < obsVector.size(); ii++) {
-      const t_satObs* satObs = obsVector.at(ii);
+      const t_pppSatObs* satObs = obsVector.at(ii);
       if ( satObs->isValid() && satObs->prn().system() == 'G' &&
            (!satObs->modelSet() || satObs->eleSat() >= OPT->_minEle) ) {
@@ -262,5 +262,5 @@
     }
     else {
-      t_satObs* satObs = obsVector.at(maxResIndex);
+      t_pppSatObs* satObs = obsVector.at(maxResIndex);
       LOG << "t_pppClient::cmpBancroft outlier " << satObs->prn().toString()
           << " " << maxRes << endl;
@@ -275,5 +275,5 @@
 // Compute A Priori GPS-Glonass Offset
 //////////////////////////////////////////////////////////////////////////////
-double t_pppClient::cmpOffGG(vector<t_satObs*>& obsVector) {
+double t_pppClient::cmpOffGG(vector<t_pppSatObs*>& obsVector) {
 
   t_lc::type tLC   = (OPT->dualFreqRequired() ? t_lc::cIF : t_lc::c1);
@@ -286,5 +286,5 @@
       unsigned nObs  = 0;
       for (unsigned ii = 0; ii < obsVector.size(); ii++) {
-        t_satObs* satObs = obsVector.at(ii);
+        t_pppSatObs* satObs = obsVector.at(ii);
         if ( !satObs->outlier() && satObs->isValid() && satObs->prn().system() == 'R' &&
              (!satObs->modelSet() || satObs->eleSat() >= OPT->_minEle) ) {
@@ -360,5 +360,5 @@
 //////////////////////////////////////////////////////////////////////////////
 t_irc t_pppClient::cmpModel(t_pppStation* station, const ColumnVector& xyzc,
-                               vector<t_satObs*>& obsVector) {
+                               vector<t_pppSatObs*>& obsVector) {
 
   bncTime time;
@@ -384,7 +384,7 @@
   // Observation model
   // -----------------
-  vector<t_satObs*>::iterator it = obsVector.begin();
+  vector<t_pppSatObs*>::iterator it = obsVector.begin();
   while (it != obsVector.end()) {
-    t_satObs* satObs = *it;
+    t_pppSatObs* satObs = *it;
     satObs->cmpModel(station);
     if (satObs->isValid() && satObs->eleSat() >= OPT->_minEle) {
@@ -402,5 +402,5 @@
 // 
 //////////////////////////////////////////////////////////////////////////////
-void t_pppClient::processEpoch(const vector<t_pppSatObs*>& pppSatObs, t_output* output) {
+void t_pppClient::processEpoch(const vector<t_satObs*>& pppSatObs, t_output* output) {
 
   try {
Index: /trunk/BNC/src/PPP/pppClient.h
===================================================================
--- /trunk/BNC/src/PPP/pppClient.h	(revision 5818)
+++ /trunk/BNC/src/PPP/pppClient.h	(revision 5819)
@@ -14,6 +14,6 @@
 
 class t_pppEphPool;
-class t_pppObsPool;
-class t_satObs;
+class t_frqObsPool;
+class t_pppSatObs;
 class t_pppStation;
 class t_pppFilter;
@@ -28,8 +28,8 @@
   void putClkCorrections(const std::vector<t_clkCorr*>& corr); 
   void putBiases(const std::vector<t_satBiases*>& biases);   
-  void processEpoch(const std::vector<t_pppSatObs*>& pppSatObs, t_output* output);
+  void processEpoch(const std::vector<t_satObs*>& pppSatObs, t_output* output);
 
   const t_pppEphPool* ephPool() const {return _ephPool;}
-  const t_pppObsPool* obsPool() const {return _obsPool;}
+  const t_frqObsPool* obsPool() const {return _obsPool;}
   const bncAntex*  antex() const {return _antex;}
   const t_pppStation* staRover() const {return _staRover;}
@@ -47,15 +47,15 @@
   void finish(t_irc irc);
   void clearObs();
-  t_irc prepareObs(const std::vector<t_pppSatObs*>& pppSatObs,
-                   std::vector<t_satObs*>& obsVector, bncTime& epoTime);
+  t_irc prepareObs(const std::vector<t_satObs*>& pppSatObs,
+                   std::vector<t_pppSatObs*>& obsVector, bncTime& epoTime);
   t_irc cmpModel(t_pppStation* station, const ColumnVector& xyzc,
-                 std::vector<t_satObs*>& obsVector);
-  t_irc cmpBancroft(const bncTime& epoTime, std::vector<t_satObs*>& obsVector, 
+                 std::vector<t_pppSatObs*>& obsVector);
+  t_irc cmpBancroft(const bncTime& epoTime, std::vector<t_pppSatObs*>& obsVector, 
                     ColumnVector& xyzc, bool print);
-  double cmpOffGG(std::vector<t_satObs*>& obsVector);
+  double cmpOffGG(std::vector<t_pppSatObs*>& obsVector);
 
   t_output*              _output;
   t_pppEphPool*             _ephPool;
-  t_pppObsPool*             _obsPool;
+  t_frqObsPool*             _obsPool;
   bncTime                _epoTimeRover;
   t_pppStation*             _staRover;
@@ -63,5 +63,5 @@
   t_pppFilter*              _filter;
   double                 _offGG;
-  std::vector<t_satObs*> _obsRover;
+  std::vector<t_pppSatObs*> _obsRover;
   std::ostringstream*    _log; 
   t_pppOptions*             _opt; 
Index: /trunk/BNC/src/PPP/pppFilter.cpp
===================================================================
--- /trunk/BNC/src/PPP/pppFilter.cpp	(revision 5818)
+++ /trunk/BNC/src/PPP/pppFilter.cpp	(revision 5819)
@@ -30,5 +30,5 @@
 // Process Single Epoch
 ////////////////////////////////////////////////////////////////////////////
-t_irc t_pppFilter::processEpoch(t_pppObsPool* obsPool) {
+t_irc t_pppFilter::processEpoch(t_frqObsPool* obsPool) {
 
   _numSat     = 0;
@@ -40,9 +40,9 @@
   // Vector of all Observations
   // --------------------------
-  t_pppObsPool::t_epoch* epoch = obsPool->lastEpoch();
+  t_frqObsPool::t_epoch* epoch = obsPool->lastEpoch();
   if (!epoch) {
     return failure;
   }
-  vector<t_satObs*>& obsVector = epoch->obsVector();
+  vector<t_pppSatObs*>& obsVector = epoch->obsVector();
 
   // Time of the Epoch
@@ -128,5 +128,5 @@
 ////////////////////////////////////////////////////////////////////////////
 t_irc t_pppFilter::processLC(const vector<t_lc::type>& LCs, 
-                               vector<t_satObs*>& obsVector) {
+                               vector<t_pppSatObs*>& obsVector) {
 
   LOG.setf(ios::fixed);
@@ -160,8 +160,8 @@
     
     int iObs = -1;
-    vector<t_satObs*>  usedObs;
+    vector<t_pppSatObs*>  usedObs;
     vector<t_lc::type> usedTypes;
     for (unsigned ii = 0; ii < obsVector.size(); ii++) {
-      t_satObs* obs = obsVector[ii];
+      t_pppSatObs* obs = obsVector[ii];
       if (!obs->outlier()) {
         Matrix CC(LCs.size(), 4);
@@ -237,5 +237,5 @@
     // --------------------------------------------
     if (maxOutlierIndex > -1) {
-      t_satObs* obs = usedObs[maxOutlierIndex];
+      t_pppSatObs* obs = usedObs[maxOutlierIndex];
       t_pppParam* par = 0;
       LOG << epoTimeStr << " Outlier " << t_lc::toString(maxOutlierLC) << ' ' 
@@ -269,5 +269,5 @@
         for (unsigned ii = 0; ii < usedObs.size(); ii++) {
           const t_lc::type tLC = usedTypes[ii];
-          t_satObs*        obs = usedObs[ii];
+          t_pppSatObs*        obs = usedObs[ii];
           if (tLC == LCs[jj]) {
             obs->setRes(tLC, vv[ii]);
@@ -290,5 +290,5 @@
 ////////////////////////////////////////////////////////////////////////////
 t_irc t_pppFilter::detectCycleSlips(const vector<t_lc::type>& LCs, 
-                                      const vector<t_satObs*>& obsVector) {
+                                      const vector<t_pppSatObs*>& obsVector) {
 
   const double            SLIP       = 20.0;  // slip threshold
@@ -300,5 +300,5 @@
     if (t_lc::includesPhase(tLC)) {
       for (unsigned iObs = 0; iObs < obsVector.size(); iObs++) {
-        const t_satObs* obs = obsVector[iObs];
+        const t_pppSatObs* obs = obsVector[iObs];
 
         // Check set Slips and Jump Counters 
@@ -358,5 +358,5 @@
 // Reset Ambiguity Parameter (cycle slip)
 ////////////////////////////////////////////////////////////////////////////
-t_irc t_pppFilter::resetAmb(t_prn prn, const vector<t_satObs*>& obsVector,
+t_irc t_pppFilter::resetAmb(t_prn prn, const vector<t_pppSatObs*>& obsVector,
                          SymmetricMatrix* QSav, ColumnVector* xSav) {
   t_irc irc = failure;
Index: /trunk/BNC/src/PPP/pppFilter.h
===================================================================
--- /trunk/BNC/src/PPP/pppFilter.h	(revision 5818)
+++ /trunk/BNC/src/PPP/pppFilter.h	(revision 5819)
@@ -12,6 +12,6 @@
 
 class t_pppParlist;
-class t_pppObsPool;
-class t_satObs;
+class t_frqObsPool;
+class t_pppSatObs;
 
 class t_pppFilter {
@@ -20,5 +20,5 @@
   ~t_pppFilter();
 
-  t_irc processEpoch(t_pppObsPool* obsPool);
+  t_irc processEpoch(t_frqObsPool* obsPool);
 
   const ColumnVector&    x() const {return _xFlt;}
@@ -50,10 +50,10 @@
     double G;
   };
-  t_irc processLC(const std::vector<t_lc::type>& LCs, std::vector<t_satObs*>& obsVector);
+  t_irc processLC(const std::vector<t_lc::type>& LCs, std::vector<t_pppSatObs*>& obsVector);
 
   t_irc detectCycleSlips(const std::vector<t_lc::type>& LCs, 
-                         const std::vector<t_satObs*>& obsVector);
+                         const std::vector<t_pppSatObs*>& obsVector);
 
-  t_irc resetAmb(t_prn prn, const std::vector<t_satObs*>& obsVector,
+  t_irc resetAmb(t_prn prn, const std::vector<t_pppSatObs*>& obsVector,
                  SymmetricMatrix* QSav = 0, ColumnVector* xSav = 0);
 
Index: /trunk/BNC/src/PPP/pppInclude.h
===================================================================
--- /trunk/BNC/src/PPP/pppInclude.h	(revision 5818)
+++ /trunk/BNC/src/PPP/pppInclude.h	(revision 5819)
@@ -33,7 +33,7 @@
 };
 
-class t_pppObs  {
+class t_frqObs  {
  public:
-  t_pppObs() {
+  t_frqObs() {
     _code            = 0.0;          
     _codeValid       = false;     
@@ -62,11 +62,11 @@
 };
 
-class t_pppSatObs {
+class t_satObs {
  public:
-  t_pppSatObs() {}
-  ~t_pppSatObs() {for (unsigned ii = 0; ii < _obs.size(); ii++) delete _obs[ii];}
+  t_satObs() {}
+  ~t_satObs() {for (unsigned ii = 0; ii < _obs.size(); ii++) delete _obs[ii];}
   t_prn                  _prn;
   bncTime                _time;
-  std::vector<t_pppObs*> _obs;
+  std::vector<t_frqObs*> _obs;
 };
 
Index: /trunk/BNC/src/PPP/pppObsPool.cpp
===================================================================
--- /trunk/BNC/src/PPP/pppObsPool.cpp	(revision 5818)
+++ /trunk/BNC/src/PPP/pppObsPool.cpp	(revision 5819)
@@ -46,5 +46,5 @@
 // Constructor
 /////////////////////////////////////////////////////////////////////////////
-t_pppObsPool::t_epoch::t_epoch(const bncTime& epoTime, vector<t_satObs*>& obsVector) {
+t_frqObsPool::t_epoch::t_epoch(const bncTime& epoTime, vector<t_pppSatObs*>& obsVector) {
   _epoTime   = epoTime;
   for (unsigned ii = 0; ii < obsVector.size(); ii++) {
@@ -56,5 +56,5 @@
 // Destructor
 /////////////////////////////////////////////////////////////////////////////
-t_pppObsPool::t_epoch::~t_epoch() {
+t_frqObsPool::t_epoch::~t_epoch() {
   for (unsigned ii = 0; ii < _obsVector.size(); ii++) {
     delete _obsVector[ii];
@@ -64,5 +64,5 @@
 // Constructor
 /////////////////////////////////////////////////////////////////////////////
-t_pppObsPool::t_pppObsPool() {
+t_frqObsPool::t_frqObsPool() {
   for (unsigned ii = 0; ii <= t_prn::MAXPRN; ii++) {
     _satBiases[ii] = 0;
@@ -72,5 +72,5 @@
 // Destructor
 /////////////////////////////////////////////////////////////////////////////
-t_pppObsPool::~t_pppObsPool() {
+t_frqObsPool::~t_frqObsPool() {
   for (unsigned ii = 0; ii <= t_prn::MAXPRN; ii++) {
     delete _satBiases[ii];
@@ -84,5 +84,5 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-void t_pppObsPool::putBiases(t_pppSatBias* satBias) {
+void t_frqObsPool::putBiases(t_pppSatBias* satBias) {
   int iPrn = satBias->prn().toInt();
   delete _satBiases[iPrn];
@@ -92,5 +92,5 @@
 //
 /////////////////////////////////////////////////////////////////////////////
-void t_pppObsPool::putEpoch(const bncTime& epoTime, vector<t_satObs*>& obsVector) {
+void t_frqObsPool::putEpoch(const bncTime& epoTime, vector<t_pppSatObs*>& obsVector) {
   const unsigned MAXSIZE = 2;
   _epochs.push_back(new t_epoch(epoTime, obsVector));
Index: /trunk/BNC/src/PPP/pppObsPool.h
===================================================================
--- /trunk/BNC/src/PPP/pppObsPool.h	(revision 5818)
+++ /trunk/BNC/src/PPP/pppObsPool.h	(revision 5819)
@@ -10,24 +10,24 @@
 namespace BNC_PPP {
 
-class t_pppObsPool {
+class t_frqObsPool {
  public: 
 
   class t_epoch {
    public:
-    t_epoch(const bncTime& epoTime, std::vector<t_satObs*>& obsVector);
+    t_epoch(const bncTime& epoTime, std::vector<t_pppSatObs*>& obsVector);
     ~t_epoch();
-    std::vector<t_satObs*>& obsVector() {return _obsVector;}
-    const std::vector<t_satObs*>& obsVector() const {return _obsVector;}
+    std::vector<t_pppSatObs*>& obsVector() {return _obsVector;}
+    const std::vector<t_pppSatObs*>& obsVector() const {return _obsVector;}
     const bncTime& epoTime() const {return _epoTime;}
    private:
     bncTime                _epoTime;
-    std::vector<t_satObs*> _obsVector;
+    std::vector<t_pppSatObs*> _obsVector;
   };
 
-  t_pppObsPool();
-  ~t_pppObsPool();
+  t_frqObsPool();
+  ~t_frqObsPool();
   void putBiases(t_pppSatBias* satBias);
 
-  void putEpoch(const bncTime& epoTime, std::vector<t_satObs*>& obsVector);
+  void putEpoch(const bncTime& epoTime, std::vector<t_pppSatObs*>& obsVector);
 
   const t_pppSatBias* satBias(const t_prn& prn) const {  
Index: /trunk/BNC/src/PPP/pppParlist.cpp
===================================================================
--- /trunk/BNC/src/PPP/pppParlist.cpp	(revision 5818)
+++ /trunk/BNC/src/PPP/pppParlist.cpp	(revision 5819)
@@ -19,5 +19,5 @@
 ////////////////////////////////////////////////////////////////////////////
 t_pppParam::t_pppParam(e_type type, const t_prn& prn, t_lc::type tLC,
-                 const vector<t_satObs*>* obsVector) {
+                 const vector<t_pppSatObs*>* obsVector) {
 
   _type     = type;
@@ -51,5 +51,5 @@
      if (obsVector) {
        for (unsigned ii = 0; ii < obsVector->size(); ii++) {
-         const t_satObs* obs = obsVector->at(ii);
+         const t_pppSatObs* obs = obsVector->at(ii);
          if (obs->prn() == _prn) {
            double offGG = 0;
@@ -90,5 +90,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-double t_pppParam::partial(const bncTime& /* epoTime */, const t_satObs* obs, 
+double t_pppParam::partial(const bncTime& /* epoTime */, const t_pppSatObs* obs, 
                         const t_lc::type& tLC) const {
 
@@ -196,5 +196,5 @@
 ////////////////////////////////////////////////////////////////////////////
 t_irc t_pppParlist::set(const bncTime& epoTime, const vector<t_lc::type>& ambLCs, 
-                     const vector<t_satObs*>& obsVector) {
+                     const vector<t_pppSatObs*>& obsVector) {
 
   // Remove some Parameters
@@ -243,5 +243,5 @@
     else {
       for (unsigned jj = 0; jj < obsVector.size(); jj++) {
-        const t_satObs* satObs = obsVector[jj];
+        const t_pppSatObs* satObs = obsVector[jj];
         if (satObs->prn() == par->prn()) {
           par->setLastObsTime(epoTime);
@@ -293,5 +293,5 @@
     const t_lc::type& tLC = ambLCs[ii];
     for (unsigned jj = 0; jj < obsVector.size(); jj++) {
-      const t_satObs* satObs = obsVector[jj];
+      const t_pppSatObs* satObs = obsVector[jj];
       required.push_back(new t_pppParam(t_pppParam::amb, satObs->prn(), tLC, &obsVector));
     }
@@ -327,5 +327,5 @@
     par->setIndex(ii);
     for (unsigned jj = 0; jj < obsVector.size(); jj++) {
-      const t_satObs* satObs = obsVector[jj];
+      const t_pppSatObs* satObs = obsVector[jj];
       if (satObs->prn() == par->prn()) {
         par->setAmbEleSat(satObs->eleSat());
Index: /trunk/BNC/src/PPP/pppParlist.h
===================================================================
--- /trunk/BNC/src/PPP/pppParlist.h	(revision 5818)
+++ /trunk/BNC/src/PPP/pppParlist.h	(revision 5819)
@@ -10,5 +10,5 @@
 namespace BNC_PPP {
 
-class t_satObs;
+class t_pppSatObs;
 
 class t_pppParam {
@@ -17,10 +17,10 @@
 
   t_pppParam(e_type type, const t_prn& prn, t_lc::type tLC,
-          const std::vector<t_satObs*>* obsVector = 0);
+          const std::vector<t_pppSatObs*>* obsVector = 0);
 
   ~t_pppParam();
   e_type type() const {return _type;}
   double x0()  const {return _x0;}
-  double partial(const bncTime& epoTime, const t_satObs* obs, 
+  double partial(const bncTime& epoTime, const t_pppSatObs* obs, 
                  const t_lc::type& tLC) const;
   bool   epoSpec() const {return _epoSpec;}
@@ -98,5 +98,5 @@
 
   t_irc set(const bncTime& epoTime, const std::vector<t_lc::type>& ambLCs,
-            const std::vector<t_satObs*>& obsVector);
+            const std::vector<t_pppSatObs*>& obsVector);
 
   unsigned nPar() const {return _params.size();}
Index: /trunk/BNC/src/PPP/pppThread.cpp
===================================================================
--- /trunk/BNC/src/PPP/pppThread.cpp	(revision 5818)
+++ /trunk/BNC/src/PPP/pppThread.cpp	(revision 5819)
@@ -171,5 +171,5 @@
   while (it.hasNext()) {
     const t_obs& oldObs = it.next();
-    t_pppSatObs* newObs = new t_pppSatObs;
+    t_satObs* newObs = new t_satObs;
    
     newObs->_prn.set(oldObs.satSys, oldObs.satNum);
@@ -198,5 +198,5 @@
     if (epoData != 0) {
       epoData->_pppSatObs.push_back(newObs);
-      map<string, t_pppObs*> pppObsMap;
+      map<string, t_frqObs*> pppObsMap;
       for (unsigned iEntry = 0; iEntry < GNSSENTRY_NUMBER; iEntry++) {
         string hlp(oldObs.rnxStr(iEntry).toAscii().data());
@@ -205,7 +205,7 @@
           string rnxType2ch = hlp.substr(1);
           if (obsType == 'C' || obsType == 'L') {
-            t_pppObs* pppObs = 0;
+            t_frqObs* pppObs = 0;
             if (pppObsMap.find(rnxType2ch) == pppObsMap.end()) {
-              pppObs                = new t_pppObs();
+              pppObs                = new t_frqObs();
               pppObsMap[rnxType2ch] = pppObs;
               pppObs->_rnxType2ch   = rnxType2ch;
@@ -233,5 +233,5 @@
   if (_pppEpochs.size() > 1) {
 
-    const vector<t_pppSatObs*>& pppSatObs = _pppEpochs.front()->_pppSatObs;
+    const vector<t_satObs*>& pppSatObs = _pppEpochs.front()->_pppSatObs;
 
     t_output output;
Index: /trunk/BNC/src/PPP/pppThread.h
===================================================================
--- /trunk/BNC/src/PPP/pppThread.h	(revision 5818)
+++ /trunk/BNC/src/PPP/pppThread.h	(revision 5819)
@@ -38,5 +38,5 @@
     }
     bncTime                   _time;
-    std::vector<t_pppSatObs*> _pppSatObs;
+    std::vector<t_satObs*> _pppSatObs;
   };
 
Index: /trunk/BNC/src/PPP/satobs.cpp
===================================================================
--- /trunk/BNC/src/PPP/satobs.cpp	(revision 5818)
+++ /trunk/BNC/src/PPP/satobs.cpp	(revision 5819)
@@ -27,5 +27,5 @@
  * -------------------------------------------------------------------------
  *
- * Class:      t_satObs
+ * Class:      t_pppSatObs
  *
  * Purpose:    Satellite observations
@@ -57,12 +57,12 @@
 // Constructor
 ////////////////////////////////////////////////////////////////////////////
-t_satObs::t_satObs(const t_pppSatObs& pppSatObs) {
+t_pppSatObs::t_pppSatObs(const t_satObs& pppSatObs) {
   _prn  = pppSatObs._prn;
   _time = pppSatObs._time;
   _outlier    = false;
   for (unsigned ii = 0; ii < pppSatObs._obs.size(); ii++) {
-    const t_pppObs* obs = pppSatObs._obs[ii];
+    const t_frqObs* obs = pppSatObs._obs[ii];
     t_obsType obsType = string(obs->_rnxType2ch).substr(0,2);
-    _allObs[obsType] = new t_pppObs(*obs);
+    _allObs[obsType] = new t_frqObs(*obs);
   }
   prepareObs();
@@ -71,6 +71,6 @@
 // Destructor
 ////////////////////////////////////////////////////////////////////////////
-t_satObs::~t_satObs() {
-  map<t_obsType, t_pppObs*>::const_iterator it;
+t_pppSatObs::~t_pppSatObs() {
+  map<t_obsType, t_frqObs*>::const_iterator it;
   for (it = _allObs.begin(); it != _allObs.end(); it++) {
     delete it->second;
@@ -80,5 +80,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-void t_satObs::prepareObs() {
+void t_pppSatObs::prepareObs() {
   _model.reset();
   _valid     = true;
@@ -95,5 +95,5 @@
     obsType1[1] = preferredAttrib[iPref];
     if (_validObs1 == 0 && _allObs.find(obsType1) != _allObs.end()) {
-      t_pppObs* obs = _allObs[obsType1];
+      t_frqObs* obs = _allObs[obsType1];
       if (obs->_codeValid && obs->_phaseValid) {
         _validObs1 = obs;
@@ -104,5 +104,5 @@
       obsType2[1] = preferredAttrib[iPref];
       if (_validObs2 == 0 && _allObs.find(obsType2) != _allObs.end()) {
-        t_pppObs* obs = _allObs[obsType2];
+        t_frqObs* obs = _allObs[obsType2];
         if (obs->_codeValid && obs->_phaseValid) {
           _validObs2 = obs;
@@ -174,5 +174,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-t_irc t_satObs::cmpModel(const t_pppStation* station) {
+t_irc t_pppSatObs::cmpModel(const t_pppStation* station) {
 
   // Reset all model values
@@ -301,5 +301,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-void t_satObs::printModel() const {
+void t_pppSatObs::printModel() const {
   LOG.setf(ios::fixed);
   LOG << "MODEL for Satellite " << _prn.toString() << endl
@@ -348,5 +348,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-double t_satObs::obsValue(t_lc::type tLC) const {
+double t_pppSatObs::obsValue(t_lc::type tLC) const {
 
   if (!_validObs2 && t_lc::need2ndFreq(tLC)) {
@@ -359,5 +359,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-double t_satObs::cmpValueForBanc(t_lc::type tLC) const {
+double t_pppSatObs::cmpValueForBanc(t_lc::type tLC) const {
   return cmpValue(tLC) - _model._rho - _model._sagnac - _model._recClkM;
 }
@@ -365,5 +365,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-double t_satObs::cmpValue(t_lc::type tLC) const {
+double t_pppSatObs::cmpValue(t_lc::type tLC) const {
 
   if (!_validObs2 && t_lc::need2ndFreq(tLC)) {
@@ -389,5 +389,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-double t_satObs::lc(t_lc::type tLC, 
+double t_pppSatObs::lc(t_lc::type tLC, 
                     double L1, double L2, double C1, double C2,
                     ColumnVector* coeff) const {
@@ -458,5 +458,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-t_irc t_satObs::createDifference(const t_satObs* obsBase) {
+t_irc t_pppSatObs::createDifference(const t_pppSatObs* obsBase) {
 
   _rawC1          -= obsBase->_rawC1;
@@ -484,5 +484,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-double t_satObs::lambda(t_lc::type tLC) const {
+double t_pppSatObs::lambda(t_lc::type tLC) const {
 
   if      (tLC == t_lc::l1) {
@@ -507,5 +507,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-double t_satObs::sigma(t_lc::type tLC) const {
+double t_pppSatObs::sigma(t_lc::type tLC) const {
 
   ColumnVector sig(4);
@@ -535,5 +535,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-void t_satObs::setRes(t_lc::type tLC, double res) {
+void t_pppSatObs::setRes(t_lc::type tLC, double res) {
   _res[tLC] = res;
 }
@@ -541,5 +541,5 @@
 // 
 ////////////////////////////////////////////////////////////////////////////
-double t_satObs::getRes(t_lc::type tLC) const {
+double t_pppSatObs::getRes(t_lc::type tLC) const {
   map<t_lc::type, double>::const_iterator it = _res.find(tLC);
   if (it != _res.end()) {
Index: /trunk/BNC/src/PPP/satobs.h
===================================================================
--- /trunk/BNC/src/PPP/satobs.h	(revision 5818)
+++ /trunk/BNC/src/PPP/satobs.h	(revision 5819)
@@ -14,8 +14,8 @@
 class t_pppStation;
 
-class t_satObs {
+class t_pppSatObs {
  public:
-  t_satObs(const t_pppSatObs& pppSatObs);
-  ~t_satObs();
+  t_pppSatObs(const t_satObs& pppSatObs);
+  ~t_pppSatObs();
   bool                isValid() const {return _valid;}
   void                prepareObs();
@@ -32,5 +32,5 @@
   bool                modelSet() const {return _model._set;}
   void                printModel() const;
-  t_irc               createDifference(const t_satObs* obsBase);
+  t_irc               createDifference(const t_pppSatObs* obsBase);
   double              lc(t_lc::type tLC, double L1, double L2, 
                          double C1, double C2, ColumnVector* coeff = 0) const;
@@ -44,5 +44,5 @@
 
   bool slip() const {
-    std::map<t_obsType, t_pppObs*>::const_iterator it;
+    std::map<t_obsType, t_frqObs*>::const_iterator it;
     for (it = _allObs.begin(); it != _allObs.end(); it++) {
       if (it->second->_slip) {
@@ -55,5 +55,5 @@
   int slipCounter() const {
     int cnt = -1;
-    std::map<t_obsType, t_pppObs*>::const_iterator it;
+    std::map<t_obsType, t_frqObs*>::const_iterator it;
     for (it = _allObs.begin(); it != _allObs.end(); it++) {
       if (it->second->_slipCounter > cnt) {
@@ -66,5 +66,5 @@
   int biasJumpCounter() const {
     int jmp = -1;
-    std::map<t_obsType, t_pppObs*>::const_iterator it;
+    std::map<t_obsType, t_frqObs*>::const_iterator it;
     for (it = _allObs.begin(); it != _allObs.end(); it++) {
       if (it->second->_biasJumpCounter > jmp) {
@@ -121,8 +121,8 @@
   bncTime                        _time;
   int                            _channel;
-  std::map<t_obsType, t_pppObs*> _allObs;
+  std::map<t_obsType, t_frqObs*> _allObs;
   bool                           _valid;
-  t_pppObs*                      _validObs1;
-  t_pppObs*                      _validObs2;
+  t_frqObs*                      _validObs1;
+  t_frqObs*                      _validObs2;
   double                         _f1;
   double                         _f2;
