Index: trunk/BNC/src/pppInclude.h
===================================================================
--- trunk/BNC/src/pppInclude.h	(revision 10409)
+++ trunk/BNC/src/pppInclude.h	(revision 10791)
@@ -5,4 +5,5 @@
 #include <vector>
 #include <newmat.h>
+#include <sstream>
 
 #include "bncconst.h"
@@ -14,4 +15,6 @@
 namespace BNC_PPP {
 
+const double ZEROVALUE = 1e-100;
+  
 class t_except {
  public:
@@ -40,127 +43,144 @@
 };
 
+class t_lc {
+public:
+  enum type {dummy = 0, code, phase, codeIF, phaseIF,  MW, CL, GIM, maxLc};
 
-class t_frqBand {
-public:
-  static t_frequency::type toFreq(char sys, char bb) {
-    switch (bb) {
-    case '1':
-      if      (sys == 'G') return t_frequency::G1;
-      else if (sys == 'R') return t_frequency::R1;
-      else if (sys == 'E') return t_frequency::E1;
-      else if (sys == 'C') return t_frequency::C1;
-      else                 return t_frequency::dummy;
-    case '2':
-      if      (sys == 'G') return t_frequency::G2;
-      else if (sys == 'R') return t_frequency::R2;
-      else if (sys == 'C') return t_frequency::C2;
-      else                 return t_frequency::dummy;
-    case '5':
-      if      (sys == 'G') return t_frequency::G5;
-      else if (sys == 'E') return t_frequency::E5;
-      else if (sys == 'C') return t_frequency::C5;
-      else                 return t_frequency::dummy;
-    case '6':
-      if      (sys == 'E') return t_frequency::E6;
-      else if (sys == 'C') return t_frequency::C6;
-      else                 return t_frequency::dummy;
-    case '7':
-      if      (sys == 'E') return t_frequency::E7;
-      else if (sys == 'C') return t_frequency::C7;
-      else                 return t_frequency::dummy;
-    case '8':
-      if      (sys == 'E') return t_frequency::E8;
-      else if (sys == 'C') return t_frequency::C8;
-      else                 return t_frequency::dummy;
-    }
-    return t_frequency::dummy;
+  t_lc() : _type(dummy), _frq1(t_frequency::dummy), _frq2(t_frequency::dummy) {}
+  
+  t_lc(type tt, t_frequency::type frq1, t_frequency::type frq2 = t_frequency::dummy)
+    : _type(tt), _frq1(frq1), _frq2(frq2) {
   }
-};
 
-class t_lc {
- public:
-  enum type {dummy = 0, c1, c2, cIF, l1, l2, lIF,  MW, CL, GIM, maxLc};
-
-  static bool includesPhase(type tt) {
-    switch (tt) {
-    case l1:
-    case l2:
-    case lIF:
-    case MW:
-    case CL:
-      return true;
-    case c1:
-    case c2:
-    case cIF:
-      return false;
-    case dummy:
-    case maxLc:
-    case GIM:
+  bool valid() const {
+    if      (_type == dummy) {
       return false;
     }
-    return false;
+    else if (_type == GIM) {
+      return true;
+    }
+    else {
+      if (_frq1 == t_frequency::dummy) {
+        return false;
+      }
+      if (t_lc::needs2ndFrq(_type) && _frq2 == t_frequency::dummy) {
+        return false;
+      }
+      return true;
+    }
   }
 
-  static bool includesCode(type tt) {
-    switch (tt) {
-    case c1:
-    case c2:
-    case cIF:
-    case MW:
-    case CL:
+  char system() const {
+    return t_frequency::toSystem(_frq1);
+  }
+
+  static bool needs2ndFrq(type tt) {
+    if (tt == codeIF || tt == phaseIF || tt == MW) {
       return true;
-    case l1:
-    case l2:
-    case lIF:
-      return false;
-    case dummy:
-    case maxLc:
-    case GIM:
+    }
+    else {
       return false;
     }
-    return false;
+  }
+  
+  bool includesPhase() const {
+    if (_type == phase || _type == phaseIF || _type == MW || _type == CL) {
+      return true;
+    }
+    else {
+      return false;
+    }
   }
 
-  static t_frequency::type toFreq(char sys, type tt) {
-    switch (tt) {
-    case l1: case c1:
-      if      (sys == 'G') return t_frequency::G1;
-      else if (sys == 'R') return t_frequency::R1;
-      else if (sys == 'E') return t_frequency::E1;
-      else if (sys == 'C') return t_frequency::C2;
-      else                 return t_frequency::dummy;
-    case l2: case c2:
-      if      (sys == 'G') return t_frequency::G2;
-      else if (sys == 'R') return t_frequency::R2;
-      else if (sys == 'E') return t_frequency::E5;
-      else if (sys == 'C') return t_frequency::C6;
-      else                 return t_frequency::dummy;
-    case lIF: case cIF: case MW: case CL:
-      return t_frequency::dummy;
-    case dummy:
-    case maxLc:
-    case GIM:
+  bool includesCode() const {
+    if (_type == code || _type == codeIF || _type == MW || _type == CL) {
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+
+  bool isIonoFree() const {
+    if (_type == codeIF || _type == phaseIF || _type == MW || _type == CL) {
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+  
+  bool isGeometryFree() const {
+    if (_type == MW || _type == CL || _type == GIM) {
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+  
+  t_frequency::type toFreq() const {
+    if (_frq2 != t_frequency::dummy) {
       return t_frequency::dummy;
     }
-    return t_frequency::dummy;
+    else {
+      return _frq1;
+    }
   }
 
-  static std::string toString(type tt) {
-    switch (tt) {
-    case l1:  return "l1";
-    case l2:  return "l2";
-    case lIF: return "lIF";
-    case MW:  return "MW";
-    case CL:  return "CL";
-    case c1:  return "c1";
-    case c2:  return "c2";
-    case cIF: return "cIF";
-    case GIM: return "GIM";
-    case dummy:
-    case maxLc:
-      return "";
+  std::string toString() const {
+    std::stringstream out;
+    if      (_type == code) {
+      out << 'c' << t_frequency::toString(_frq1);
     }
-    return "";
+    else if (_type == phase) {
+      out << 'l' << t_frequency::toString(_frq1);
+    }
+    else if (_type == codeIF) {
+      out << 'c' << t_frequency::toSystem(_frq1) << "IF" ;
+    }
+    else if (_type == phaseIF) {
+      out << 'l' << t_frequency::toSystem(_frq1) << "IF" ;
+    }
+    else if (_type == MW) {
+      out << t_frequency::toSystem(_frq1) << "MW" ;
+    }
+    else if (_type == CL) {
+      out << t_frequency::toSystem(_frq1) << "CL" ;
+    }
+    else if (_type == GIM) {
+      out << t_frequency::toSystem(_frq1) << "GIM" ;
+    }
+    return out.str();
   }
+
+  bool operator==(const t_lc& other) const {
+    if (_type == other._type && _frq1 == other._frq1 && _frq2 == other._frq2) {
+      return true;
+    }
+    else {
+      return false;
+    }
+  }
+
+  bool operator!=(const t_lc& other) const {
+    return !(*this == other);
+  }
+
+  bool operator <(const t_lc& other) const {
+    if      (_type != other._type) {
+      return _type < other._type;
+    }
+    else if (_frq1 != other._frq1) {
+      return _frq1 < other._frq1;
+    }
+    else {
+      return _frq2 < other._frq2;
+    }
+  }
+
+  type              _type;
+  t_frequency::type _frq1;
+  t_frequency::type _frq2;
 };