Index: /trunk/BNC/src/rinex/rnxobsfile.cpp
===================================================================
--- /trunk/BNC/src/rinex/rnxobsfile.cpp	(revision 6118)
+++ /trunk/BNC/src/rinex/rnxobsfile.cpp	(revision 6119)
@@ -48,5 +48,5 @@
 using namespace std;
 
-const QString t_rnxObsHeader::_emptyStr;
+const QString t_rnxObsHeader::defaultSystems = "GRES";
 
 // Constructor
@@ -162,5 +162,6 @@
       int nTypes;
       *in >> nTypes;
-      _obsTypesV2.clear();
+      char sys = defaultSystems[0].toAscii();
+      _obsTypes[sys].clear();
       for (int ii = 0; ii < nTypes; ii++) {
         if (ii > 0 && ii % 9 == 0) {
@@ -171,5 +172,9 @@
         QString hlp;
         *in >> hlp;
-        _obsTypesV2.append(hlp);
+        _obsTypes[sys].append(hlp);
+      }
+      for (int ii = 1; ii < defaultSystems.length(); ii++) {
+        char sys = defaultSystems[ii].toAscii();
+        _obsTypes[sys] = _obsTypes[0];
       }
     }
@@ -179,5 +184,5 @@
       int nTypes;
       *in >> sys >> nTypes;
-      _obsTypesV3[sys].clear();
+      _obsTypes[sys].clear();
       for (int ii = 0; ii < nTypes; ii++) {
         if (ii > 0 && ii % 13 == 0) {
@@ -188,5 +193,5 @@
         QString hlp;
         *in >> hlp;
-        _obsTypesV3[sys].push_back(hlp);
+        _obsTypes[sys].push_back(hlp);
       }
       delete in;
@@ -331,48 +336,45 @@
 }
 
+// Number of Different Systems
+////////////////////////////////////////////////////////////////////////////
+int t_rnxObsHeader::numSys() const {
+  return _obsTypes.size();
+}
+
 // Number of Observation Types (satellite-system specific)
 ////////////////////////////////////////////////////////////////////////////
 int t_rnxObsHeader::nTypes(char sys) const {
+  if (_obsTypes.contains(sys)) {
+    return _obsTypes[sys].size();
+  }
+  else {
+    return 0;
+  }
+}
+
+// Observation Type (satellite-system specific)
+////////////////////////////////////////////////////////////////////////////
+QString t_rnxObsHeader::obsType(char sys, int index) const {
+  if (_obsTypes.contains(sys)) {
+    return _obsTypes[sys].at(index);
+  }
+  else {
+    return "";
+  }
+}
+
+// Write Observation Types
+////////////////////////////////////////////////////////////////////////////
+QStringList t_rnxObsHeader::obsTypesStrings() const {
+
+  QStringList strList;
+
   if (_version < 3.0) {
-    return _obsTypesV2.size();
-  }
-  else {
-    if (_obsTypesV3.contains(sys)) {
-      return _obsTypesV3[sys].size();
-    }
-    else {
-      return 0;
-    }
-  }
-}
-
-// Observation Type (satellite-system specific)
-////////////////////////////////////////////////////////////////////////////
-const QString& t_rnxObsHeader::obsType(char sys, int index) const {
-  if (_version < 3.0) {
-    return _obsTypesV2.at(index);
-  }
-  else {
-    if (_obsTypesV3.contains(sys)) {
-      return _obsTypesV3[sys].at(index);
-    }
-    else {
-      return _emptyStr;
-    }
-  }
-}
-
-// Write Observation Types
-////////////////////////////////////////////////////////////////////////////
-QStringList t_rnxObsHeader::obsTypesStrings() const {
-
-  QStringList strList;
-
-  if (_version < 3.0) {
+    char sys = defaultSystems[0].toAscii();
     QString hlp;
-    QTextStream(&hlp) << QString("%1").arg(_obsTypesV2.size(), 6);
-    for (int ii = 0; ii < _obsTypesV2.size(); ii++) {
-      QTextStream(&hlp) << QString("%1").arg(_obsTypesV2[ii], 6);   
-      if ((ii+1) % 9 == 0 || ii == _obsTypesV2.size()-1) {
+    QTextStream(&hlp) << QString("%1").arg(_obsTypes[sys].size(), 6);
+    for (int ii = 0; ii < _obsTypes[sys].size(); ii++) {
+      QTextStream(&hlp) << QString("%1").arg(_obsTypes[sys][ii], 6);   
+      if ((ii+1) % 9 == 0 || ii == _obsTypes[sys].size()-1) {
         strList.append(hlp.leftJustified(60) + "# / TYPES OF OBSERV\n");
         hlp = QString().leftJustified(6);
@@ -381,5 +383,5 @@
   }
   else {
-    QMapIterator<char, QVector<QString> > it(_obsTypesV3);
+    QMapIterator<char, QVector<QString> > it(_obsTypes);
     while (it.hasNext()) {
       it.next();
@@ -407,5 +409,4 @@
   _stream       = 0;
   _flgPowerFail = false;
-  _trafo        = trafoNone;
   if (_inpOut == input) {
     openRead(fileName);
@@ -536,7 +537,5 @@
 ////////////////////////////////////////////////////////////////////////////
 t_rnxObsFile::t_rnxEpo* t_rnxObsFile::nextEpoch() {
-
   _currEpo.clear();
-
   if (version() < 3.0) {
     return nextEpochV2();
@@ -589,7 +588,7 @@
     for (int iSat = 0; iSat < numSat; iSat++) {
       line = _stream->readLine();
-      _currEpo.rnxSat[iSat].satSys = line.toAscii()[0];
-      readInt(line, 1, 2, _currEpo.rnxSat[iSat].satNum);
-      char sys = line.toAscii()[0];
+      t_prn prn; prn.set(line.left(3).toAscii().data());
+      _currEpo.rnxSat[iSat].prn = prn;
+      char sys = prn.system();
       for (int iType = 0; iType < _header.nTypes(sys); iType++) {
         int pos = 3 + 16*iType;
@@ -600,12 +599,11 @@
         readInt(line, pos + 14, 1, lli);
         readInt(line, pos + 15, 1, snr);
-
         if (_flgPowerFail) {
           lli |= 1;
         }
-
-        _currEpo.rnxSat[iSat].obs.push_back(obsValue);
-        _currEpo.rnxSat[iSat].lli.push_back(lli);
-        _currEpo.rnxSat[iSat].snr.push_back(snr);
+        QString type = obsType(sys, iType);
+        _currEpo.rnxSat[iSat].obs[type].value = obsValue;
+        _currEpo.rnxSat[iSat].obs[type].lli   = lli;
+        _currEpo.rnxSat[iSat].obs[type].snr   = snr;
       }
     }
@@ -672,10 +670,8 @@
       }
 
-      _currEpo.rnxSat[iSat].satSys = line.toAscii()[pos];
-      if (_currEpo.rnxSat[iSat].satSys == ' ') {
-        _currEpo.rnxSat[iSat].satSys = 'G';
-      }
-      readInt(line, pos + 1, 2, _currEpo.rnxSat[iSat].satNum);
-
+      char sys = line.toAscii()[pos];
+      int satNum; readInt(line, pos + 1, 2, satNum);
+      _currEpo.rnxSat[iSat].prn.set(sys, satNum);
+ 
       pos += 3;
     }
@@ -684,7 +680,8 @@
     // ------------------------
     for (int iSat = 0; iSat < numSat; iSat++) {
+      char sys = _currEpo.rnxSat[iSat].prn.system();
       line = _stream->readLine();
       pos  = 0;
-      for (int iType = 0; iType < _header.nTypes(_currEpo.rnxSat[iSat].satSys); iType++) {
+      for (int iType = 0; iType < _header.nTypes(sys); iType++) {
         if (iType > 0 && iType % 5 == 0) {
           line = _stream->readLine();
@@ -702,7 +699,8 @@
         }
 
-        _currEpo.rnxSat[iSat].obs.push_back(obsValue);
-        _currEpo.rnxSat[iSat].lli.push_back(lli);
-        _currEpo.rnxSat[iSat].snr.push_back(snr);
+        QString type = obsType(sys, iType);
+        _currEpo.rnxSat[iSat].obs[type].value = obsValue;
+        _currEpo.rnxSat[iSat].obs[type].lli   = lli;
+        _currEpo.rnxSat[iSat].obs[type].snr   = snr;
 
         pos += 16;
@@ -720,19 +718,13 @@
 // Set Header Information
 ////////////////////////////////////////////////////////////////////////////
-void t_rnxObsFile::setHeader(const t_rnxObsHeader& header, double version) {
-
-  if      (int(header._version) == int(version)) {
-    _trafo           = trafoNone;
-    _header._version = header._version;
-  }
-  else if (version >= 3.0) {
-    _trafo           = trafo2to3;
+void t_rnxObsFile::setHeader(const t_rnxObsHeader& header, double version, 
+                             const QStringList& useObsTypes) {
+
+  if (version >= 3.0) {
     _header._version = t_rnxObsHeader::defaultRnxObsVersion3;
   }
   else {
-    _trafo           = trafo3to2;
     _header._version = t_rnxObsHeader::defaultRnxObsVersion2;
   }
-
   _header._interval        = header._interval;    
   _header._antennaNumber   = header._antennaNumber; 
@@ -749,5 +741,5 @@
   _header._receiverType    = header._receiverType;   
   _header._receiverVersion = header._receiverVersion;
-
+  _header._startTime       =  header._startTime;   
   for (unsigned iPrn = 1; iPrn <= t_prn::MAXPRN_GPS; iPrn++) {
     _header._wlFactorsL1[iPrn] =  header._wlFactorsL1[iPrn]; 
@@ -755,72 +747,28 @@
   }
 
-  _header._startTime   =  header._startTime;   
-
-  static const string systems = "GRES";
-
-  _header._obsTypesV2.clear();
-  _header._obsTypesV3.clear();
-
-  // Copy Observation Types
-  // ----------------------
-  if      (_trafo == trafoNone) {
-    for (int ii = 0; ii < header._obsTypesV2.size(); ii++) {
-      _header._obsTypesV2.append(header._obsTypesV2[ii]);
-    }
-    QMapIterator<char, QVector<QString> > it(header._obsTypesV3);
-    while (it.hasNext()) {
-      it.next();
-      char                    sys     = it.key();
-      const QVector<QString>& typesV3 = it.value();
-      for (int ii = 0; ii < typesV3.size(); ii++) {
-        _header._obsTypesV3[sys].push_back(typesV3[ii]);
-      }
-    }
-  }
-
-  // Translate Observation Types v2 --> v3
-  // -------------------------------------
-  else if (_trafo == trafo2to3) {
-    for (int i2 = 0; i2 < header._obsTypesV2.size(); i2++) {
-      const QString& typeV2 = header._obsTypesV2[i2];
-      for (unsigned iSys = 0; iSys < systems.length(); iSys++) {
-        char    sys    = systems[iSys];
-        QString typeV3 = type2to3(sys, typeV2);
-        if (!typeV3.isEmpty()) {
-          _header._obsTypesV3[sys].push_back(typeV3);
-          int i3 = _header._obsTypesV3[sys].size() - 1;
-          _indexMap3to2[sys][i3] = i2;
-        }
-      }
-    }
-  }
-
-  // Translate Observation Types v3 --> v2
-  // -------------------------------------
-  else if (_trafo == trafo3to2) {
-    for (unsigned iSys = 0; iSys < systems.length(); iSys++) {
-      char sys = systems[iSys];
-      if (header._obsTypesV3.contains(sys)) {
-        const QVector<QString>& typesV3 = header._obsTypesV3[sys];
-        for (int i3 = 0; i3 < typesV3.size(); i3++) {
-          const QString& typeV3 = typesV3[i3];
-          QString        typeV2 = type3to2(typeV3);
-          if (!typeV2.isEmpty()) {
-            bool found = false;
-            for (int i2 = 0; i2 < _header._obsTypesV2.size(); i2++) {
-              if (_header._obsTypesV2[i2] == typeV2) {
-                found = true;
-                if (_indexMap2to3[sys].find(i2) == _indexMap2to3[sys].end()) {
-                  _indexMap2to3[sys][i2] = i3;
-                }
-                break;
-              }
-            }
-            if (!found) {
-              _header._obsTypesV2.append(typeV2);
-              int i2 = _header._obsTypesV2.size() - 1;
-              _indexMap2to3[sys][i2] = i3; 
-            }
-          }
+  // Set observation types
+  // ---------------------
+  _header._obsTypes.clear();
+  if (useObsTypes.size() == 0) {
+    _header._obsTypes = header._obsTypes;
+  }
+  else {
+    if (_header._version < 3.0) {
+      char sys = t_rnxObsHeader::defaultSystems[0].toAscii();
+      for (int ii = 0; ii < useObsTypes.size(); ii++) {
+        _header._obsTypes[sys].push_back(useObsTypes[ii]);
+      }
+      for (int ii = 1; ii < t_rnxObsHeader::defaultSystems.length(); ii++) {
+        char sys = t_rnxObsHeader::defaultSystems[ii].toAscii();
+        _header._obsTypes[sys] = _header._obsTypes[0];
+      }
+    }
+    else {
+      for (int ii = 0; ii < useObsTypes.size(); ii++) {
+        QStringList hlp = useObsTypes[ii].split(":", QString::SkipEmptyParts);
+        if (hlp.size() == 2 && hlp[0].length() == 1) {
+          char    sys  = hlp[0][0].toAscii();
+          QString type = hlp[1];
+          _header._obsTypes[sys].push_back(type);
         }
       }
@@ -866,5 +814,5 @@
       *_stream << endl << QString().leftJustified(32);
     }
-    *_stream << rnxSat.satSys << QString("%1").arg(rnxSat.satNum, 2);
+    *_stream << rnxSat.prn;
   }
   *_stream << endl;
@@ -872,35 +820,25 @@
 
     const t_rnxSat& rnxSat = epo->rnxSat[iSat];
-    char            sys    = rnxSat.satSys;
-
-    for (int iTypeV2 = 0; iTypeV2 < nTypes(sys); iTypeV2++) {
-
-      if (iTypeV2 > 0 && iTypeV2 % 5 == 0) {
+    char            sys    = rnxSat.prn.system();
+
+    for (int iType = 0; iType < nTypes(sys); iType++) {
+      if (iType > 0 && iType % 5 == 0) {
         *_stream << endl;
       }
-
-      int iType = -1;
-      if   (_trafo == trafoNone) {
-        iType = iTypeV2;
+      QString type = obsType(sys, iType);
+      if (!rnxSat.obs.contains(type)) {
+        *_stream << QString().leftJustified(16);
       }
       else {
-        if (_indexMap2to3[sys].find(iTypeV2) != _indexMap2to3[sys].end()) {
-          iType = _indexMap2to3[sys][iTypeV2];
-        }
-      }
-
-      if (iType == -1 || rnxSat.obs[iType] == 0.0) {
-        *_stream << QString().leftJustified(16);
-      }
-      else {
-        *_stream << QString("%1").arg(rnxSat.obs[iType], 14, 'f', 3);
-        if (rnxSat.lli[iType] != 0.0) {
-          *_stream << QString("%1").arg(rnxSat.lli[iType],1);
+        const t_rnxObs& rnxObs = rnxSat.obs[type]; 
+        *_stream << QString("%1").arg(rnxObs.value, 14, 'f', 3);
+        if (rnxObs.lli != 0.0) {
+          *_stream << QString("%1").arg(rnxObs.lli,1);
         }
         else {
           *_stream << ' ';
         }
-        if (rnxSat.snr[iType] != 0.0) {
-          *_stream << QString("%1").arg(rnxSat.snr[iType],1);
+        if (rnxObs.snr != 0.0) {
+          *_stream << QString("%1").arg(rnxObs.snr,1);
         }
         else {
@@ -937,33 +875,23 @@
   for (unsigned iSat = 0; iSat < epo->rnxSat.size(); iSat++) {
     const t_rnxSat& rnxSat = epo->rnxSat[iSat];
-    char            sys    = rnxSat.satSys;
-    *_stream << sys 
-             << QString("%1").arg(rnxSat.satNum, 2, 10, QChar('0'));
-
-    for (int iTypeV3 = 0; iTypeV3 < nTypes(sys); iTypeV3++) {
-
-      int iType = -1;
-      if   (_trafo == trafoNone) {
-        iType = iTypeV3;
+    char            sys    = rnxSat.prn.system();
+
+    *_stream << rnxSat.prn;
+    for (int iType = 0; iType < nTypes(sys); iType++) {
+      QString type = obsType(sys, iType);
+      if (!rnxSat.obs.contains(type)) {
+        *_stream << QString().leftJustified(16);
       }
       else {
-        if (_indexMap3to2[sys].find(iTypeV3) != _indexMap3to2[sys].end()) {
-          iType = _indexMap3to2[sys][iTypeV3];
-        }
-      }
-
-      if (iType == -1 || rnxSat.obs[iType] == 0.0) {
-        *_stream << QString().leftJustified(16);
-      }
-      else {
-        *_stream << QString("%1").arg(rnxSat.obs[iType], 14, 'f', 3);
-        if (rnxSat.lli[iType] != 0.0) {
-          *_stream << QString("%1").arg(rnxSat.lli[iType],1);
+        const t_rnxObs& rnxObs = rnxSat.obs[type];
+        *_stream << QString("%1").arg(rnxObs.value, 14, 'f', 3);
+        if (rnxObs.lli != 0.0) {
+          *_stream << QString("%1").arg(rnxObs.lli,1);
         }
         else {
           *_stream << ' ';
         }
-        if (rnxSat.snr[iType] != 0.0) {
-          *_stream << QString("%1").arg(rnxSat.snr[iType],1);
+        if (rnxObs.snr != 0.0) {
+          *_stream << QString("%1").arg(rnxObs.snr,1);
         }
         else {
@@ -1068,25 +996,17 @@
 
   t_rnxObsHeader oldHeader(_header);
-  setHeader(header, oldHeader._version);
+  setHeader(header, oldHeader._version, QStringList());
 
   // Check Observation Types
   // -----------------------
   bool same = true;
-  if (_header._version < 3.0) {
-    if (_header._obsTypesV2 != oldHeader._obsTypesV2) {
+  QMapIterator<char, QVector<QString> > it(_header._obsTypes);
+  while (it.hasNext()) {
+    it.next();
+    char                    sys   = it.key();
+    const QVector<QString>& types = it.value();
+    if (!oldHeader._obsTypes.contains(sys) || oldHeader._obsTypes[sys] != types) {
       same = false;
-    }
-  }
-  else {
-    QMapIterator<char, QVector<QString> > it(_header._obsTypesV3);
-    while (it.hasNext()) {
-      it.next();
-      char                    sys     = it.key();
-      const QVector<QString>& typesV3 = it.value();
-      if (!oldHeader._obsTypesV3.contains(sys) ||
-          oldHeader._obsTypesV3[sys] != typesV3) {
-        same = false;
-        break;
-      }
+      break;
     }
   }
@@ -1115,25 +1035,42 @@
           sizeof(obs.StatID));
 
-  obs.satSys   = rnxSat.satSys;
-  obs.satNum   = rnxSat.satNum;
+  obs.satSys   = rnxSat.prn.system();
+  obs.satNum   = rnxSat.prn.number();
   obs.GPSWeek  = epo->tt.gpsw();
   obs.GPSWeeks = epo->tt.gpssec();
 
   for (int iType = 0; iType < rnxObsFile->nTypes(obs.satSys); iType++) {
-    QString type = rnxObsFile->obsType(obs.satSys,iType).toAscii();
-    obs.setMeasdata(type, rnxObsFile->version(), rnxSat.obs[iType]);
-    if      (type.indexOf("L1") == 0) {
-      obs.snrL1  = rnxSat.snr[iType];
-      obs.slipL1 = (rnxSat.lli[iType] & 1);
-    }
-    else if (type.indexOf("L2") == 0) {
-      obs.snrL2  = rnxSat.snr[iType];
-      obs.slipL2 = (rnxSat.lli[iType] & 1);
-    }
-    else if (type.indexOf("L5") == 0) {
-      obs.snrL5  = rnxSat.snr[iType];
-      obs.slipL5 = (rnxSat.lli[iType] & 1);
-    }
-  }
-}
-
+    QString type   = rnxObsFile->obsType(obs.satSys, iType);
+    if (rnxSat.obs.contains(type)) {
+      const t_rnxObs& rnxObs = rnxSat.obs[type];
+      obs.setMeasdata(type, rnxObsFile->version(), rnxObs.value);
+      if      (type.indexOf("L1") == 0) {
+        obs.snrL1  = rnxObs.snr;
+        obs.slipL1 = (rnxObs.lli & 1);
+      }
+      else if (type.indexOf("L2") == 0) {
+        obs.snrL2  = rnxObs.snr;
+        obs.slipL2 = (rnxObs.lli & 1);
+      }
+      else if (type.indexOf("L5") == 0) {
+        obs.snrL5  = rnxObs.snr;
+        obs.slipL5 = (rnxObs.lli & 1);
+      }
+    }
+  }
+}
+
+// Set Observations from RINEX File
+////////////////////////////////////////////////////////////////////////////
+bool t_rnxObsFile::useType(const QStringList& useObsTypes, const QString& type) {
+
+  if (useObsTypes.size() == 0) {
+    return true;
+  }
+  for (int ii = 0; ii < useObsTypes.size(); ii++) {
+    if (type.left(2) == useObsTypes[ii].left(2)) {
+      return true;
+    }
+  }
+  return false;
+}
Index: /trunk/BNC/src/rinex/rnxobsfile.h
===================================================================
--- /trunk/BNC/src/rinex/rnxobsfile.h	(revision 6118)
+++ /trunk/BNC/src/rinex/rnxobsfile.h	(revision 6119)
@@ -39,19 +39,23 @@
 
 class t_rnxObsHeader {
+
+ friend class t_rnxObsFile;
+
  public:
-  static const double defaultRnxObsVersion2 = 2.11;
-  static const double defaultRnxObsVersion3 = 3.02;
+  static const double  defaultRnxObsVersion2 = 2.11;
+  static const double  defaultRnxObsVersion3 = 3.02;
+  static const QString defaultSystems;
 
   t_rnxObsHeader();
   ~t_rnxObsHeader();
 
-  t_irc           read(QTextStream* stream, int maxLines = 0);
-  int             nTypes(char sys) const;
-  const QString&  obsType(char sys, int index) const;
-  QStringList     obsTypesStrings() const;
-  void            write(QTextStream* stream,
-                        const QMap<QString, QString>* txtMap = 0) const;
+  t_irc       read(QTextStream* stream, int maxLines = 0);
+  int         numSys() const;
+  int         nTypes(char sys) const;
+  QString     obsType(char sys, int index) const;
+  QStringList obsTypesStrings() const;
+  void        write(QTextStream* stream, const QMap<QString, QString>* txtMap = 0) const;
 
-  static const QString          _emptyStr;
+ private:
   float                         _version;
   double                        _interval;
@@ -70,6 +74,5 @@
   ColumnVector                  _antBSG;
   ColumnVector                  _xyz;
-  QVector<QString>              _obsTypesV2;
-  QMap<char, QVector<QString> > _obsTypesV3;
+  QMap<char, QVector<QString> > _obsTypes;
   int                           _wlFactorsL1[t_prn::MAXPRN_GPS+1];
   int                           _wlFactorsL2[t_prn::MAXPRN_GPS+1];
@@ -84,11 +87,15 @@
   }
 
+  class t_rnxObs {
+   public:
+    double value;
+    int    lli;
+    int    snr;
+  };
+
   class t_rnxSat {
    public:
-    char                satSys;
-    int                 satNum;
-    std::vector<double> obs;
-    std::vector<int>    lli;
-    std::vector<int>    snr;
+    t_prn                   prn;
+    QMap<QString, t_rnxObs> obs;
   };
 
@@ -96,4 +103,5 @@
    public:
     void clear() {
+      tt.reset();
       rnxSat.clear();
     }
@@ -107,13 +115,13 @@
   ~t_rnxObsFile();
   
-  float               version() const {return _header._version;}
-  double              interval() const {return _header._interval;}
-  int                 nTypes(char sys) const {return _header.nTypes(sys);}
-  const QString&      fileName() const {return _fileName;}
-  const QString&      obsType(char sys, int index) const {return _header.obsType(sys, index);}
-
-  const QString&      antennaName() const {return _header._antennaName;}
-  const QString&      markerName() const {return _header._markerName;}
-  const QString&      receiverType() const {return _header._receiverType;}
+  float          version() const {return _header._version;}
+  double         interval() const {return _header._interval;}
+  int            numSys() const {return _header.numSys();}
+  int            nTypes(char sys) const {return _header.nTypes(sys);}
+  const QString& fileName() const {return _fileName;}
+  QString        obsType(char sys, int index) const {return _header.obsType(sys, index);}
+  const QString& antennaName() const {return _header._antennaName;}
+  const QString& markerName() const {return _header._markerName;}
+  const QString& receiverType() const {return _header._receiverType;}
 
   void setInterval(double interval) {_header._interval = interval;}
@@ -154,6 +162,4 @@
 
  private:
-  enum e_trafo {trafoNone, trafo2to2, trafo3to3, trafo2to3, trafo3to2};
-
   t_rnxObsFile() {};
   void openRead(const QString& fileName);
@@ -179,5 +185,4 @@
   t_rnxEpo       _currEpo;
   bool           _flgPowerFail;
-  e_trafo        _trafo;
 };
 
