Index: trunk/BNC/bncmapview.cpp
===================================================================
--- trunk/BNC/bncmapview.cpp	(revision 3407)
+++ trunk/BNC/bncmapview.cpp	(revision 3408)
@@ -91,5 +91,5 @@
 
 // -------------
-void BncMapView::mouseReleaseEvent(QMouseEvent* event) 
+void BncMapView::mouseReleaseEvent(QMouseEvent* /* event */) 
 {   
    setCursor(Qt::OpenHandCursor);
Index: trunk/BNC/bncmodel.cpp
===================================================================
--- trunk/BNC/bncmodel.cpp	(revision 3407)
+++ trunk/BNC/bncmodel.cpp	(revision 3408)
@@ -52,16 +52,13 @@
 #include "bnctides.h"
 #include "bncantex.h"
+#include "bnccomb.h"
 
 using namespace std;
 
-const unsigned MINOBS           =    5;
-const double   MINELE_GPS       = 10.0 * M_PI / 180.0;
-const double   MINELE_GLO       = 10.0 * M_PI / 180.0;
-const double   MINELE_GAL       = 10.0 * M_PI / 180.0;
-const double   MAXRES_CODE_GPS  = 10.0;
-const double   MAXRES_PHASE_GPS = 0.05;
-const double   MAXRES_PHASE_GLO = 0.05;
-const double   MAXRES_CODE_GAL  = 10.0;
-const double   MAXRES_PHASE_GAL = 0.05;
+const unsigned MINOBS                = 5;
+const double   MINELE                = 10.0 * M_PI / 180.0;
+const double   MAXRES_CODE           = 10.0;
+const double   MAXRES_PHASE          = 0.02;
+const double   GLONASS_WEIGHT_FACTOR = 5.0;
 
 // Constructor
@@ -257,4 +254,8 @@
   _xcBanc.ReSize(4);  _xcBanc  = 0.0;
   _ellBanc.ReSize(3); _ellBanc = 0.0;
+
+  // Save copy of data (used in outlier detection)
+  // ---------------------------------------------
+  _epoData_sav = new t_epoData();
 }
 
@@ -271,4 +272,5 @@
     delete _params[iPar-1];
   }
+  delete _epoData_sav;
 }
 
@@ -322,22 +324,24 @@
   Tracer tracer("bncModel::cmpBancroft");
 
-  if (epoData->sizeGPS() < MINOBS) {
+  if (epoData->sizeSys('G') < MINOBS) {
     _log += "bncModel::cmpBancroft: not enough data\n";
     return failure;
   }
 
-  Matrix BB(epoData->sizeGPS(), 4);
-
-  QMapIterator<QString, t_satData*> it(epoData->satDataGPS);
+  Matrix BB(epoData->sizeSys('G'), 4);
+
+  QMapIterator<QString, t_satData*> it(epoData->satData);
   int iObsBanc = 0;
   while (it.hasNext()) {
-    ++iObsBanc;
     it.next();
-    QString    prn     = it.key();
     t_satData* satData = it.value();
-    BB(iObsBanc, 1) = satData->xx(1);
-    BB(iObsBanc, 2) = satData->xx(2);
-    BB(iObsBanc, 3) = satData->xx(3);
-    BB(iObsBanc, 4) = satData->P3 + satData->clk;
+    if (satData->system() == 'G') {
+      ++iObsBanc;
+      QString    prn     = it.key();
+      BB(iObsBanc, 1) = satData->xx(1);
+      BB(iObsBanc, 2) = satData->xx(2);
+      BB(iObsBanc, 3) = satData->xx(3);
+      BB(iObsBanc, 4) = satData->P3 + satData->clk;
+    }
   }
 
@@ -350,34 +354,12 @@
   // Compute Satellite Elevations
   // ----------------------------
-  QMutableMapIterator<QString, t_satData*> iGPS(epoData->satDataGPS);
-  while (iGPS.hasNext()) {
-    iGPS.next();
-    t_satData* satData = iGPS.value();
+  QMutableMapIterator<QString, t_satData*> im(epoData->satData);
+  while (im.hasNext()) {
+    im.next();
+    t_satData* satData = im.value();
     cmpEle(satData);
-    if (satData->eleSat < MINELE_GPS) {
+    if (satData->eleSat < MINELE) {
       delete satData;
-      iGPS.remove();
-    }
-  }
-
-  QMutableMapIterator<QString, t_satData*> iGlo(epoData->satDataGlo);
-  while (iGlo.hasNext()) {
-    iGlo.next();
-    t_satData* satData = iGlo.value();
-    cmpEle(satData);
-    if (satData->eleSat < MINELE_GLO) {
-      delete satData;
-      iGlo.remove();
-    }
-  }
-
-  QMutableMapIterator<QString, t_satData*> iGal(epoData->satDataGal);
-  while (iGal.hasNext()) {
-    iGal.next();
-    t_satData* satData = iGal.value();
-    cmpEle(satData);
-    if (satData->eleSat < MINELE_GAL) {
-      delete satData;
-      iGal.remove();
+      im.remove();
     }
   }
@@ -600,15 +582,13 @@
     // ------------------------------------------------
     int iPar = 0;
-    QMutableVectorIterator<bncParam*> it(_params);
-    while (it.hasNext()) {
-      bncParam* par = it.next();
+    QMutableVectorIterator<bncParam*> im(_params);
+    while (im.hasNext()) {
+      bncParam* par = im.next();
       bool removed = false;
       if (par->type == bncParam::AMB_L3) {
-        if (epoData->satDataGPS.find(par->prn) == epoData->satDataGPS.end() &&
-            epoData->satDataGlo.find(par->prn) == epoData->satDataGlo.end() && 
-            epoData->satDataGal.find(par->prn) == epoData->satDataGal.end() ) {
+        if (epoData->satData.find(par->prn) == epoData->satData.end()) {
           removed = true;
           delete par;
-          it.remove();
+          im.remove();
         }
       }
@@ -621,22 +601,8 @@
     // Add new ambiguity parameters
     // ----------------------------
-    QMapIterator<QString, t_satData*> iGPS(epoData->satDataGPS);
-    while (iGPS.hasNext()) {
-      iGPS.next();
-      t_satData* satData = iGPS.value();
-      addAmb(satData);
-    }
-
-    QMapIterator<QString, t_satData*> iGlo(epoData->satDataGlo);
-    while (iGlo.hasNext()) {
-      iGlo.next();
-      t_satData* satData = iGlo.value();
-      addAmb(satData);
-    }
-
-    QMapIterator<QString, t_satData*> iGal(epoData->satDataGal);
-    while (iGal.hasNext()) {
-      iGal.next();
-      t_satData* satData = iGal.value();
+    QMapIterator<QString, t_satData*> it(epoData->satData);
+    while (it.hasNext()) {
+      it.next();
+      t_satData* satData = it.value();
       addAmb(satData);
     }
@@ -691,4 +657,5 @@
   // ----------------------
   if (update_p(epoData) != success) {
+    emit newMessage(_log, false);
     return failure;
   }
@@ -936,95 +903,26 @@
 // Outlier Detection
 ////////////////////////////////////////////////////////////////////////////
-QString bncModel::outlierDetection(int iPhase, const SymmetricMatrix& QQsav, 
-                                   const ColumnVector& vv,
-                                   QMap<QString, t_satData*>& satDataGPS,
-                                   QMap<QString, t_satData*>& satDataGlo,
-                                   QMap<QString, t_satData*>& satDataGal) {
+bool bncModel::outlierDetection(int iPhase, const ColumnVector& vv,
+                                QMap<QString, t_satData*>& satData) {
 
   Tracer tracer("bncModel::outlierDetection");
 
-  QString prnCode;
-  QString prnPhase;
-  double  maxResCode  = 0.0;
-  double  maxResPhase = 0.0;
-
-  QString prnRemoved;
-  double  maxRes;
-
-  if (iPhase == 0) {
-
-    // Check GPS Code
-    // --------------
-    if (prnRemoved.isEmpty()) {
-      findMaxRes(iPhase, vv,satDataGPS, prnCode, maxResCode, prnPhase, maxResPhase);
-      if (maxResCode > MAXRES_CODE_GPS) {
-        satDataGPS.remove(prnCode);
-        prnRemoved = prnCode;
-        maxRes     = maxResCode;
-      }
-    }
-    
-    // Check Galileo Code
-    // ------------------
-    if (prnRemoved.isEmpty()) {
-      findMaxRes(iPhase, vv,satDataGal, prnCode, maxResCode, prnPhase, maxResPhase);
-      if (maxResCode > MAXRES_CODE_GAL) {
-        satDataGal.remove(prnCode);
-        prnRemoved = prnCode;
-        maxRes     = maxResCode;
-      }
-    }
-  }
-
+  QString prn;
+  double  maxRes  = 0.0;
+  findMaxRes(vv, satData, prn, maxRes);
+
+  if      (iPhase == 1 && maxRes > MAXRES_PHASE) {
+    _log += "Outlier Phase " + prn + " " 
+          + QByteArray::number(maxRes, 'f', 3) + "\n"; 
+    return true;
+  }
+  else if (iPhase == 0 && maxRes > MAXRES_CODE) {
+    _log += "Outlier Code  " + prn + " " 
+          + QByteArray::number(maxRes, 'f', 3) + "\n"; 
+    return true;
+  }
   else {
-
-    // Check Glonass Phase
-    // -------------------
-    if (prnRemoved.isEmpty()) {
-      findMaxRes(iPhase, vv,satDataGlo, prnCode, maxResCode, prnPhase, maxResPhase);
-      if (maxResPhase > MAXRES_PHASE_GLO) {
-        satDataGlo.remove(prnPhase);
-        prnRemoved = prnPhase;
-        maxRes     = maxResPhase;
-      }
-    }
-    
-    // Check Galileo Phase
-    // -------------------
-    if (prnRemoved.isEmpty()) {
-      findMaxRes(iPhase, vv,satDataGal, prnCode, maxResCode, prnPhase, maxResPhase);
-      if      (maxResPhase > MAXRES_PHASE_GAL) {
-        satDataGal.remove(prnPhase);
-        prnRemoved = prnPhase;
-        maxRes     = maxResPhase;
-      }
-    }
-    
-    // Check GPS Phase
-    // ---------------
-    if (prnRemoved.isEmpty()) {
-      findMaxRes(iPhase, vv,satDataGPS, prnCode, maxResCode, prnPhase, maxResPhase);
-      if      (maxResPhase > MAXRES_PHASE_GPS) {
-        satDataGPS.remove(prnPhase);
-        prnRemoved = prnPhase;
-        maxRes     = maxResPhase;
-      }
-    }
-  }
- 
-  if (!prnRemoved.isEmpty()) {
-    _log += "Outlier " + prnRemoved.toAscii() + " " 
-          + QByteArray::number(maxRes, 'f', 3) + "\n"; 
-    _QQ = QQsav;
-    QVectorIterator<bncParam*> itPar(_params);
-    while (itPar.hasNext()) {
-      bncParam* par = itPar.next();
-      if (par->type == bncParam::AMB_L3 && par->prn == prnRemoved) {
-        par->numEpo = 0;
-      }
-    }
-  }
-
-  return prnRemoved;
+    return false;
+  }
 }
 
@@ -1051,5 +949,5 @@
 }
 
-//// 
+//
 //////////////////////////////////////////////////////////////////////////////
 void bncModel::kalman(const Matrix& AA, const ColumnVector& ll, 
@@ -1223,13 +1121,18 @@
   }
 
+  // Remember Observation Index
+  // --------------------------
+  ++iObs;
+  satData->obsIndex = iObs;
+
   // Phase Observations
   // ------------------
   if (iPhase == 1) {
-    ++iObs;
     ll(iObs)      = satData->L3 - cmpValue(satData, true);
-    PP(iObs,iObs) = 1.0 / (_sigL3 * _sigL3) / (ellWgtCoef * ellWgtCoef);
+    double sigL3 = _sigL3;
     if (satData->system() == 'R') {
-      PP(iObs,iObs) /= 25.0;
-    }
+      sigL3 *= GLONASS_WEIGHT_FACTOR;
+    }
+    PP(iObs,iObs) = 1.0 / (sigL3 * sigL3) / (ellWgtCoef * ellWgtCoef);
     for (int iPar = 1; iPar <= _params.size(); iPar++) {
       if (_params[iPar-1]->type == bncParam::AMB_L3 &&
@@ -1239,5 +1142,4 @@
       AA(iObs, iPar) = _params[iPar-1]->partial(satData, true);
     }
-    satData->indexPhase = iObs;
   }
 
@@ -1245,5 +1147,4 @@
   // -----------------
   else {
-    ++iObs;
     ll(iObs)      = satData->P3 - cmpValue(satData, false);
     PP(iObs,iObs) = 1.0 / (_sigP3 * _sigP3) / (ellWgtCoef * ellWgtCoef);
@@ -1251,5 +1152,4 @@
       AA(iObs, iPar) = _params[iPar-1]->partial(satData, false);
     }
-    satData->indexCode = iObs;
   }
 }
@@ -1257,28 +1157,36 @@
 // 
 ///////////////////////////////////////////////////////////////////////////
-void bncModel::printRes(int iPhase, const ColumnVector& vv, 
-                        ostringstream& str, t_satData* satData) {
+QByteArray bncModel::printRes(int iPhase, const ColumnVector& vv, 
+                              const QMap<QString, t_satData*>& satDataMap) {
+
   Tracer tracer("bncModel::printRes");
-  if (iPhase == 1) {
-    str << _time.timestr(1)
-        << " RES " << satData->prn.toAscii().data() << "   L3 "
-        << setw(9) << setprecision(4) << vv(satData->indexPhase) << endl;
-  }
-  else {
-    str << _time.timestr(1)
-        << " RES " << satData->prn.toAscii().data() << "   P3 "
-        << setw(9) << setprecision(4) << vv(satData->indexCode) << endl;
-  }
+
+  ostringstream str;
+  str.setf(ios::fixed);
+        
+  QMapIterator<QString, t_satData*> it(satDataMap);
+  while (it.hasNext()) {
+    it.next();
+    t_satData* satData = it.value();
+    if (satData->obsIndex != 0) {
+      str << _time.timestr(1)
+          << " RES " << satData->prn.toAscii().data() 
+          << (iPhase ? "   L3 " : "   P3 ")
+          << setw(9) << setprecision(4) << vv(satData->obsIndex) << endl;
+    }
+  }
+
+  return QByteArray(str.str().c_str());
 }
 
 // 
 ///////////////////////////////////////////////////////////////////////////
-void bncModel::findMaxRes(int iPhase, const ColumnVector& vv,
+void bncModel::findMaxRes(const ColumnVector& vv,
                           const QMap<QString, t_satData*>& satData,
-                          QString& prnCode,  double& maxResCode, 
-                          QString& prnPhase, double& maxResPhase) {
+                          QString& prn,  double& maxRes) { 
+
   Tracer tracer("bncModel::findMaxRes");
-  maxResCode  = 0.0;
-  maxResPhase = 0.0;
+
+  maxRes  = 0.0;
 
   QMapIterator<QString, t_satData*> it(satData);
@@ -1286,19 +1194,7 @@
     it.next();
     t_satData* satData = it.value();
-    if (iPhase == 0) {
-      if (satData->indexCode) {
-        if (fabs(vv(satData->indexCode)) > maxResCode) {
-          maxResCode = fabs(vv(satData->indexCode));
-          prnCode    = satData->prn;
-        }
-      }
-    }
-    else {
-      if (satData->indexPhase) {
-        if (fabs(vv(satData->indexPhase)) > maxResPhase) {
-          maxResPhase = fabs(vv(satData->indexPhase));
-          prnPhase    = satData->prn;
-        }
-      }
+    if (satData->obsIndex != 0 && fabs(vv(satData->obsIndex)) > maxRes) {
+      maxRes = fabs(vv(satData->obsIndex));
+      prn    = satData->prn;
     }
   }
@@ -1311,172 +1207,147 @@
   Tracer tracer("bncModel::update_p");
 
-  rememberState();
-
-  for (int iPhase = 0; iPhase <= (_usePhase ? 1 : 0); iPhase++) {
-
-    SymmetricMatrix QQsav;
-    ColumnVector    vv;
-    ColumnVector    dx;
-
-    unsigned numOutliers = 0;
-
-    for (;;) {
+  // Save Variance-Covariance Matrix, and Status Vector
+  // --------------------------------------------------
+  rememberState(epoData);
+
+  ColumnVector dx;
+
+  std::vector<QString> allPrns; 
+  QMapIterator<QString, t_satData*> it(epoData->satData);
+  while (it.hasNext()) {
+    it.next();
+    t_satData* satData = it.value();
+    allPrns.push_back(satData->prn);
+  }
+  std::vector<QString> usedPrns;
+
+  // Try with all satellites, then with all minus one, etc.
+  // ------------------------------------------------------
+  const unsigned MAX_NEGLECT = 1;
+  for (unsigned nNeglected = 0; nNeglected <= MAX_NEGLECT; nNeglected++) {
+    usedPrns = allPrns;
+
+    for (unsigned ii = 0; ii < nNeglected && usedPrns.size() > 0; ii++) {
+      usedPrns.pop_back();
+    }
+
+    // Loop over all Combinations of used Satellites
+    // ---------------------------------------------
+    do {
+
+      QByteArray strResCode;
+      QByteArray strResPhase;
+      QString    strNeglected;
+
+      // Remove Neglected Satellites from epoData
+      // ----------------------------------------
+      for (unsigned ip = 0; ip < allPrns.size(); ip++) {
+        QString prn = allPrns[ip];
+        if ( !findInVector(usedPrns, prn) ) {
+          epoData->satData.remove(prn);
+          strNeglected += prn + " ";
+        }
+      }
+      if (epoData->sizeSys('G') < MINOBS) {
+        continue;
+      }
 
       // Bancroft Solution
       // -----------------
-      if (iPhase == 0) {      
-        if (cmpBancroft(epoData) != success) {
-          restoreState();
-          emit newMessage(_log, false);
-          return failure;
-        }
-      }
-      else {
-        if (epoData->sizeGPS() < MINOBS) {
-          restoreState();
-          _log += "bncModel::update_p: not enough data\n";
-          emit newMessage(_log, false);
-          return failure;
-        }
-        unsigned numSatNoSlip = 0;
-        QVectorIterator<bncParam*> itPar(_params);
-        while (itPar.hasNext()) {
-          bncParam* par = itPar.next();
-          if (par->type == bncParam::AMB_L3 && par->prn[0] == 'G') {
-            if (par->numEpo >= 1) {
-              ++numSatNoSlip;
-            }
+      if (cmpBancroft(epoData) != success) {
+        continue;
+      }
+
+      // First update using code observations, then phase observations
+      // -------------------------------------------------------------      
+      for (int iPhase = 0; iPhase <= (_usePhase ? 1 : 0); iPhase++) {
+      
+        // Status Prediction
+        // -----------------
+        predict(iPhase, epoData);
+        
+        // Create First-Design Matrix
+        // --------------------------
+        unsigned nPar = _params.size();
+        unsigned nObs = 0;
+        if (iPhase == 0) {
+          nObs = epoData->sizeAll() - epoData->sizeSys('R'); // Glonass code not used
+        }
+        else {
+          nObs = epoData->sizeAll();
+        }
+        
+        // Prepare first-design Matrix, vector observed-computed
+        // -----------------------------------------------------
+        Matrix          AA(nObs, nPar);  // first design matrix
+        ColumnVector    ll(nObs);        // tems observed-computed
+        DiagonalMatrix  PP(nObs); PP = 0.0;
+        
+        unsigned iObs = 0;
+        QMapIterator<QString, t_satData*> it(epoData->satData);
+        while (it.hasNext()) {
+          it.next();
+          t_satData* satData = it.value();
+          if (iPhase == 1 || satData->system() != 'R') {
+            QString prn = satData->prn;
+            addObs(iPhase, iObs, satData, AA, ll, PP);
           }
         }
-        if (numSatNoSlip > 0 && numSatNoSlip < MINOBS) {
-          restoreState();
-          _log += "bncModel::update_p: not enough GPS satellites without cycle-slips\n";
-          emit newMessage(_log, false);
-          return failure;
-        }
-      }
-      
-      // Status Prediction
-      // -----------------
-      predict(iPhase, epoData);
-      
-      // Create First-Design Matrix
-      // --------------------------
-      unsigned nPar = _params.size();
-      unsigned nObs = 0;
-      if (iPhase == 0) {
-        nObs = epoData->sizeGPS() + epoData->sizeGal(); // Glonass code not used
-      }
-      else {
-        nObs = epoData->sizeGPS() + epoData->sizeGal() + epoData->sizeGlo();
-      }
-    
-      Matrix          AA(nObs, nPar);  // first design matrix
-      ColumnVector    ll(nObs);        // tems observed-computed
-      DiagonalMatrix  PP(nObs); PP = 0.0;
-      
-      unsigned iObs = 0;
-    
-      // GPS
-      // ---
-      QMapIterator<QString, t_satData*> itGPS(epoData->satDataGPS);
-      while (itGPS.hasNext()) {
-        itGPS.next();
-        t_satData* satData = itGPS.value();
-        addObs(iPhase, iObs, satData, AA, ll, PP);
-      }
-    
-      // Glonass
-      // -------
-      if (iPhase == 1) {
-        QMapIterator<QString, t_satData*> itGlo(epoData->satDataGlo);
-        while (itGlo.hasNext()) {
-          itGlo.next();
-          t_satData* satData = itGlo.value();
-          addObs(iPhase, iObs, satData, AA, ll, PP);
-        }
-      }
-
-      // Galileo
-      // -------
-      QMapIterator<QString, t_satData*> itGal(epoData->satDataGal);
-      while (itGal.hasNext()) {
-        itGal.next();
-        t_satData* satData = itGal.value();
-        addObs(iPhase, iObs, satData, AA, ll, PP);
-      }
-    
-      // Compute Filter Update
-      // ---------------------
-      QQsav = _QQ;
-    
-      kalman(AA, ll, PP, _QQ, dx);
-    
-      vv = ll - AA * dx;
-
-      // Print Residuals
-      // ---------------
-      if (true) {
-        ostringstream str;
-        str.setf(ios::fixed);
-    
-        QMapIterator<QString, t_satData*> itGPS(epoData->satDataGPS);
-        while (itGPS.hasNext()) {
-          itGPS.next();
-          t_satData* satData = itGPS.value();
-          printRes(iPhase, vv, str, satData);
-        }
-        if (iPhase == 1) {
-          QMapIterator<QString, t_satData*> itGlo(epoData->satDataGlo);
-          while (itGlo.hasNext()) {
-            itGlo.next();
-            t_satData* satData = itGlo.value();
-            printRes(iPhase, vv, str, satData);
+
+        // Compute Filter Update
+        // ---------------------
+        kalman(AA, ll, PP, _QQ, dx);
+        
+        ColumnVector vv = ll - AA * dx;
+        
+        // Print Residuals
+        // ---------------
+        if (iPhase == 0) {
+          strResCode  = printRes(iPhase, vv, epoData->satData);
+        }
+        else {
+          strResPhase = printRes(iPhase, vv, epoData->satData);
+        }
+
+        // Check the residuals
+        // -------------------
+        if ( outlierDetection(iPhase, vv, epoData->satData) ) {
+          restoreState(epoData);
+          break;
+        }
+
+        // Set estimated values
+        // --------------------
+        else if (!_usePhase || iPhase == 1) {
+          QVectorIterator<bncParam*> itPar(_params);
+          while (itPar.hasNext()) {
+            bncParam* par = itPar.next();
+            par->xx += dx(par->index);
           }
-        }
-        QMapIterator<QString, t_satData*> itGal(epoData->satDataGal);
-        while (itGal.hasNext()) {
-          itGal.next();
-          t_satData* satData = itGal.value();
-          printRes(iPhase, vv, str, satData);
-        }
-        _log += str.str().c_str();
-      }
-    
-      QString prnRemoved = outlierDetection(iPhase, QQsav, vv, 
-                                            epoData->satDataGPS, 
-                                            epoData->satDataGlo, 
-                                            epoData->satDataGal);
-      if (prnRemoved.isEmpty()) {
-        break;
-      }
-      else if (prnRemoved[0] == 'G') {
-        ++numOutliers;
-      }
-
-      if (numOutliers > 1) {
-        restoreState();
-        _log += "bncModel::update_p: too many outliers\n";
-        emit newMessage(_log, false);
-        return failure;
-      }
-
-    }
-
-    // Update Parameters
-    // -----------------
-    QVectorIterator<bncParam*> itPar(_params);
-    while (itPar.hasNext()) {
-      bncParam* par = itPar.next();
-      par->xx += dx(par->index);
-    }
-  }
-
-  return success;
+
+          // Print Neglected PRNs
+          // --------------------
+          if (nNeglected > 0) {
+            _log += "Neglected PRNs: " + strNeglected + '\n';
+          }
+
+          _log += strResCode + strResPhase;
+        
+          return success;
+        }
+
+      } // for (int iPhase = 0; iPhase <= (_usePhase ? 1 : 0); iPhase++)
+
+    } while ( next_combination(allPrns.begin(), allPrns.end(),
+                               usedPrns.begin(), usedPrns.end()) );
+
+  } // for (unsigned nNeglected
+
+  return failure;
 }
 
 // Remeber Original State Vector and Variance-Covariance Matrix
 ////////////////////////////////////////////////////////////////////////////
-void bncModel::rememberState() {
+void bncModel::rememberState(t_epoData* epoData) {
 
   _QQ_sav = _QQ;
@@ -1494,9 +1365,11 @@
     _params_sav.push_back(new bncParam(*par));
   }
+
+  _epoData_sav->deepCopy(epoData);
 }
 
 // Restore Original State Vector and Variance-Covariance Matrix
 ////////////////////////////////////////////////////////////////////////////
-void bncModel::restoreState() {
+void bncModel::restoreState(t_epoData* epoData) {
 
   _QQ = _QQ_sav;
@@ -1514,4 +1387,5 @@
     _params.push_back(new bncParam(*par));
   }
-}
-
+
+  epoData->deepCopy(_epoData_sav);
+}
Index: trunk/BNC/bncmodel.h
===================================================================
--- trunk/BNC/bncmodel.h	(revision 3407)
+++ trunk/BNC/bncmodel.h	(revision 3408)
@@ -29,4 +29,5 @@
 #include <QtNetwork>
 #include <newmat.h>
+#include <vector>
 
 #include "bncconst.h"
@@ -59,5 +60,4 @@
   bncModel(QByteArray staID);
   ~bncModel();
-  t_irc cmpBancroft(t_epoData* epoData);
   t_irc update(t_epoData* epoData);
   bncTime time()  const {return _time;}
@@ -94,4 +94,5 @@
 
  private:
+  t_irc cmpBancroft(t_epoData* epoData);
   void   reset();
   void   cmpEle(t_satData* satData);
@@ -99,19 +100,15 @@
   void   addObs(int iPhase, unsigned& iObs, t_satData* satData,
                 Matrix& AA, ColumnVector& ll, DiagonalMatrix& PP);
-  void   printRes(int iPhase, const ColumnVector& vv, 
-                  std::ostringstream& str, t_satData* satData);
-  void   findMaxRes(int iPhase, const ColumnVector& vv,
+  QByteArray printRes(int iPhase, const ColumnVector& vv, 
+                      const QMap<QString, t_satData*>& satDataMap);
+  void   findMaxRes(const ColumnVector& vv,
                     const QMap<QString, t_satData*>& satData,
-                    QString& prnCode,  double& maxResCode, 
-                    QString& prnPhase, double& maxResPhase);
+                    QString& prn,  double& maxRes); 
   double cmpValue(t_satData* satData, bool phase);
   double delay_saast(double Ele);
   void   predict(int iPhase, t_epoData* epoData);
   t_irc  update_p(t_epoData* epoData);
-  QString outlierDetection(int iPhase, const SymmetricMatrix& QQsav, 
-                           const ColumnVector& vv,
-                           QMap<QString, t_satData*>& satDataGPS,
-                           QMap<QString, t_satData*>& satDataGlo,
-                           QMap<QString, t_satData*>& satDataGal);
+  bool   outlierDetection(int iPhase, const ColumnVector& vv,
+                          QMap<QString, t_satData*>& satData);
   void writeNMEAstr(const QString& nmStr);
 
@@ -121,6 +118,6 @@
   bncTime  _startTime;
 
-  void rememberState();
-  void restoreState();
+  void rememberState(t_epoData* epoData);
+  void restoreState(t_epoData* epoData);
 
   class pppPos {
@@ -142,4 +139,5 @@
   QVector<bncParam*>    _params_sav;
   SymmetricMatrix       _QQ_sav;
+  t_epoData*            _epoData_sav;
   ColumnVector          _xcBanc;
   ColumnVector          _ellBanc;
Index: trunk/BNC/bncpppclient.cpp
===================================================================
--- trunk/BNC/bncpppclient.cpp	(revision 3407)
+++ trunk/BNC/bncpppclient.cpp	(revision 3408)
@@ -194,5 +194,5 @@
       satData->lambda3 = c1 * t_CST::c / f1 + c2 * t_CST::c / f2;
 
-      _epoData.back()->satDataGPS[satData->prn] = satData;
+      _epoData.back()->satData[satData->prn] = satData;
     }
     else {
@@ -227,5 +227,5 @@
       satData->lambda3 = c1 * t_CST::c / f1 + c2 * t_CST::c / f2;
 
-      _epoData.back()->satDataGlo[satData->prn] = satData;
+      _epoData.back()->satData[satData->prn] = satData;
     }
     else {
@@ -250,5 +250,5 @@
       satData->L3      = c1 * satData->L1 + c5 * satData->L5;
       satData->lambda3 = c1 * t_CST::c / f1 + c5 * t_CST::c / f5;
-      _epoData.back()->satDataGal[satData->prn] = satData;
+      _epoData.back()->satData[satData->prn] = satData;
     }
     else {
@@ -459,39 +459,13 @@
   // Data Pre-Processing
   // -------------------
-  QMutableMapIterator<QString, t_satData*> iGPS(_epoData.front()->satDataGPS);
-  while (iGPS.hasNext()) {
-    iGPS.next();
-    QString    prn     = iGPS.key();
-    t_satData* satData = iGPS.value();
+  QMutableMapIterator<QString, t_satData*> it(_epoData.front()->satData);
+  while (it.hasNext()) {
+    it.next();
+    QString    prn     = it.key();
+    t_satData* satData = it.value();
 
     if (cmpToT(satData) != success) {
       delete satData;
-      iGPS.remove();
-      continue;
-    }
-  }
-
-  QMutableMapIterator<QString, t_satData*> iGlo(_epoData.front()->satDataGlo);
-  while (iGlo.hasNext()) {
-    iGlo.next();
-    QString    prn     = iGlo.key();
-    t_satData* satData = iGlo.value();
-
-    if (cmpToT(satData) != success) {
-      delete satData;
-      iGlo.remove();
-      continue;
-    }
-  }
-
-  QMutableMapIterator<QString, t_satData*> iGal(_epoData.front()->satDataGal);
-  while (iGal.hasNext()) {
-    iGal.next();
-    QString    prn     = iGal.key();
-    t_satData* satData = iGal.value();
-
-    if (cmpToT(satData) != success) {
-      delete satData;
-      iGal.remove();
+      it.remove();
       continue;
     }
Index: trunk/BNC/bncpppclient.h
===================================================================
--- trunk/BNC/bncpppclient.h	(revision 3407)
+++ trunk/BNC/bncpppclient.h	(revision 3408)
@@ -35,6 +35,5 @@
  public:
   t_satData() {
-    indexCode  = 0;
-    indexPhase = 0;
+    obsIndex = 0;
   }
   ~t_satData() {}
@@ -57,6 +56,5 @@
   bool         slipFlag;
   double       lambda3;
-  unsigned     indexCode;
-  unsigned     indexPhase;
+  unsigned     obsIndex;
   char system() const {return prn.toAscii()[0];}
 };
@@ -65,30 +63,43 @@
  public:
   t_epoData() {}
+
   ~t_epoData() {
-    QMapIterator<QString, t_satData*> itGPS(satDataGPS);
-    while (itGPS.hasNext()) {
-      itGPS.next();
-      delete itGPS.value();
+    clear();
+  }
+
+  void clear() {
+    QMapIterator<QString, t_satData*> it(satData);
+    while (it.hasNext()) {
+      it.next();
+      delete it.value();
     }
-    QMapIterator<QString, t_satData*> itGlo(satDataGlo);
-    while (itGlo.hasNext()) {
-      itGlo.next();
-      delete itGlo.value();
-    }
-    QMapIterator<QString, t_satData*> itGal(satDataGal);
-    while (itGal.hasNext()) {
-      itGal.next();
-      delete itGal.value();
+    satData.clear();
+  }
+
+  void deepCopy(const t_epoData* from) {
+    clear();
+    tt = from->tt;
+    QMapIterator<QString, t_satData*> it(from->satData);
+    while (it.hasNext()) {
+      it.next();
+      satData[it.key()] = new t_satData(*it.value());
     }
   }
-  unsigned sizeGPS() const {return satDataGPS.size();}
-  unsigned sizeGlo() const {return satDataGlo.size();}
-  unsigned sizeGal() const {return satDataGal.size();}
-  unsigned sizeAll() const {return satDataGPS.size() + satDataGlo.size() +
-                                   satDataGal.size();}
-  bncTime                    tt;
-  QMap<QString, t_satData*> satDataGPS;
-  QMap<QString, t_satData*> satDataGlo;
-  QMap<QString, t_satData*> satDataGal;
+
+  unsigned sizeSys(char system) const {
+    unsigned ans = 0;
+    QMapIterator<QString, t_satData*> it(satData);
+    while (it.hasNext()) {
+      it.next();
+      if (it.value()->system() == system) {
+        ++ans;
+      }
+    }
+    return ans;
+  }
+  unsigned sizeAll() const {return satData.size();}
+
+  bncTime                   tt;
+  QMap<QString, t_satData*> satData;
 };
 
Index: trunk/BNC/bncutils.cpp
===================================================================
--- trunk/BNC/bncutils.cpp	(revision 3407)
+++ trunk/BNC/bncutils.cpp	(revision 3408)
@@ -374,2 +374,15 @@
                dateTime.time().msec() / 1000.0) / 60.0) / 60.0) / 24.0;
 }
+
+// 
+////////////////////////////////////////////////////////////////////////////
+bool findInVector(const vector<QString>& vv, const QString& str) {
+  std::vector<QString>::const_iterator it;
+  for (it = vv.begin(); it != vv.end(); ++it) {
+    if ( (*it) == str) {
+      return true;
+    }
+  }
+  return false;
+}
+
Index: trunk/BNC/bncutils.h
===================================================================
--- trunk/BNC/bncutils.h	(revision 3407)
+++ trunk/BNC/bncutils.h	(revision 3408)
@@ -25,4 +25,6 @@
 #ifndef BNCUTILS_H
 #define BNCUTILS_H
+
+#include <vector>
 
 #include <QString>
@@ -68,3 +70,5 @@
 void mjdFromDateAndTime(const QDateTime& dateTime, int& mjd, double& dayfrac);
 
+bool findInVector(const std::vector<QString>& vv, const QString& str);
+
 #endif