Index: src/Parser/TremoloParser.cpp
===================================================================
--- src/Parser/TremoloParser.cpp	(revision 4415da8b5d52d38b3578718b456b8c0b28cad75d)
+++ src/Parser/TremoloParser.cpp	(revision b8d4a36310666e7e35fa9d7064e994e48d9b0e54)
@@ -6,13 +6,18 @@
  */
 
+#include "Helpers/Assert.hpp"
 #include "TremoloParser.hpp"
 #include "World.hpp"
 #include "atom.hpp"
 #include "element.hpp"
+#include "bond.hpp"
 #include "periodentafel.hpp"
+#include "Descriptors/AtomIdDescriptor.hpp"
 #include <map>
 #include <vector>
 
+
 using namespace std;
+using namespace boost;
 
 /**
@@ -20,25 +25,26 @@
  */
 TremoloParser::TremoloParser() {
-  knownKeys[" "] = noKey; // so we can detect invalid keys
-  knownKeys["x"] = x;
-  knownKeys["u"] = u;
-  knownKeys["F"] = F;
-  knownKeys["stress"] = stress;
-  knownKeys["Id"] = Id;
-  knownKeys["neighbors"] = neighbors;
-  knownKeys["imprData"] = imprData;
-  knownKeys["GroupMeasureTypeNo"] = GroupMeasureTypeNo;
-  knownKeys["Type"] = Type;
-  knownKeys["extType"] = extType;
-  knownKeys["name"] = name;
-  knownKeys["resName"] = resName;
-  knownKeys["chainID"] = chainID;
-  knownKeys["resSeq"] = resSeq;
-  knownKeys["occupancy"] = occupancy;
-  knownKeys["tempFactor"] = tempFactor;
-  knownKeys["segID"] = segID;
-  knownKeys["Charge"] = Charge;
-  knownKeys["charge"] = charge;
-  knownKeys["GrpTypeNo"] = GrpTypeNo;
+  knownKeys[" "] = TremoloKey::noKey; // with this we can detect invalid keys
+  knownKeys["x"] = TremoloKey::x;
+  knownKeys["u"] = TremoloKey::u;
+  knownKeys["F"] = TremoloKey::F;
+  knownKeys["stress"] = TremoloKey::stress;
+  knownKeys["Id"] = TremoloKey::Id;
+  knownKeys["neighbors"] = TremoloKey::neighbors;
+  knownKeys["imprData"] = TremoloKey::imprData;
+  knownKeys["GroupMeasureTypeNo"] = TremoloKey::GroupMeasureTypeNo;
+  knownKeys["Type"] = TremoloKey::Type;
+  knownKeys["extType"] = TremoloKey::extType;
+  knownKeys["name"] = TremoloKey::name;
+  knownKeys["resName"] = TremoloKey::resName;
+  knownKeys["chainID"] = TremoloKey::chainID;
+  knownKeys["resSeq"] = TremoloKey::resSeq;
+  knownKeys["occupancy"] = TremoloKey::occupancy;
+  knownKeys["tempFactor"] = TremoloKey::tempFactor;
+  knownKeys["segID"] = TremoloKey::segID;
+  knownKeys["Charge"] = TremoloKey::Charge;
+  knownKeys["charge"] = TremoloKey::charge;
+  knownKeys["GrpTypeNo"] = TremoloKey::GrpTypeNo;
+  knownKeys["torsion"] = TremoloKey::torsion;
 }
 
@@ -47,140 +53,9 @@
  */
 TremoloParser::~TremoloParser() {
-}
-
-/**
- * Stores keys from the ATOMDATA line.
- *
- * \param line to parse the keys from
- * \param with which offset the keys begin within the line
- */
-void TremoloParser::parseAtomDataKeysLine(string line, int offset) {
-  string keyword;
-  stringstream lineStream;
-
-  lineStream << line.substr(offset);
-  while (lineStream.good()) {
-    lineStream >> keyword;
-    if (knownKeys[keyword.substr(0, keyword.find("="))] == noKey) {
-      // throw exception about unknown key
-      cout << "Unknown key: " << keyword << " is not part of the tremolo format specification." << endl;
-      break;
-    }
-    usedFields.push_back(keyword);
-  }
-}
-
-/**
- * Reads one data line of a tremolo file and interprets it according to the keys
- * obtained from the ATOMDATA line.
- *
- * \param line to parse as an atom
- */
-void TremoloParser::readAtomDataLine(string line) {
-  vector<string>::iterator it;
-  stringstream lineStream;
-  atom* newAtom = World::getInstance().createAtom();
-  TremoloAtomInfoContainer atomInfo = *(new TremoloAtomInfoContainer());
-  atomDataKey currentField;
-  string word;
-
-  lineStream << line;
-  for (it=usedFields.begin(); it < usedFields.end(); it++) {
-    cout << *it << " -- " << it->substr(0, it->find("=")) << " -- " << knownKeys[it->substr(0, it->find("="))] << endl;
-    currentField = knownKeys[it->substr(0, it->find("="))];
-    switch (currentField) {
-      case x :
-        // for the moment, assume there are always three dimensions
-        lineStream >> newAtom->x.x[0];
-        lineStream >> newAtom->x.x[1];
-        lineStream >> newAtom->x.x[2];
-        break;
-      case u :
-        // for the moment, assume there are always three dimensions
-        lineStream >> newAtom->v.x[0];
-        lineStream >> newAtom->v.x[1];
-        lineStream >> newAtom->v.x[2];
-        break;
-      case F :
-        lineStream >> word;
-        atomInfo.F = word;
-        break;
-      case stress :
-        lineStream >> word;
-        atomInfo.F = word;
-       break;
-      case Id :
-        // this ID is not used
-        break;
-      case neighbors :
-        // TODO neighbor information
-        lineStream >> word;
-        break;
-      case imprData :
-        lineStream >> word;
-        atomInfo.imprData = word;
-        break;
-      case GroupMeasureTypeNo :
-        lineStream >> word;
-        atomInfo.GroupMeasureTypeNo = word;
-        break;
-      case Type :
-        char type[3];
-        lineStream >> type;
-        newAtom->setType(World::getInstance().getPeriode()->FindElement(type));
-        break;
-      case extType :
-        lineStream >> word;
-        atomInfo.extType = word;
-        break;
-      case name :
-        lineStream >> word;
-        atomInfo.name = word;
-        break;
-      case resName :
-        lineStream >> word;
-        atomInfo.resName = word;
-        break;
-      case chainID :
-        lineStream >> word;
-        atomInfo.chainID = word;
-        break;
-      case resSeq :
-        lineStream >> word;
-        atomInfo.resSeq = word;
-        break;
-      case occupancy :
-        lineStream >> word;
-        atomInfo.occupancy = word;
-        break;
-      case tempFactor :
-        lineStream >> word;
-        atomInfo.segID = word;
-        break;
-      case segID :
-        lineStream >> word;
-        atomInfo.F = word;
-        break;
-      case Charge :
-        lineStream >> word;
-        atomInfo.Charge = word;
-        break;
-      case charge :
-        lineStream >> word;
-        atomInfo.charge = word;
-        break;
-      case GrpTypeNo :
-        lineStream >> word;
-        atomInfo.GrpTypeNo = word;
-        break;
-      default :
-        lineStream >> word;
-        cout << "Unknown key: " << *it << ", word: " << word << endl;
-        break;
-    }
-  }
-  moreData[newAtom->getId()] = atomInfo;
-}
-
+  usedFields.clear();
+  additionalAtomData.clear();
+  atomIdMap.clear();
+  knownKeys.clear();
+}
 
 /**
@@ -206,4 +81,8 @@
     }
   }
+
+  processNeighborInformation();
+  adaptImprData();
+  adaptTorsion();
 }
 
@@ -214,30 +93,403 @@
  */
 void TremoloParser::save(ostream* file) {
-/*
-write header
-for (each atom in world) {
-  write coordinates and additional data
-}
-*/
-}
+  vector<atom*>::iterator atomIt;
+  vector<string>::iterator it;
+
+  *file << "# ATOMDATA";
+  for (it=usedFields.begin(); it < usedFields.end(); it++) {
+    *file << "\t" << *it;
+  }
+  *file << endl;
+  vector<atom *> AtomList = World::getInstance().getAllAtoms();
+  for (atomIt = AtomList.begin(); atomIt != AtomList.end(); atomIt++) {
+    saveLine(file, *atomIt);
+  }
+}
+
+/**
+ * Sets the keys for which data should be written to the stream when save is
+ * called.
+ *
+ * \param string of field names with the same syntax as for an ATOMDATA line
+ *        but without the prexix "ATOMDATA"
+ */
+void TremoloParser::setFieldsForSave(std::string atomDataLine) {
+  parseAtomDataKeysLine(atomDataLine, 0);
+}
+
+
+/**
+ * Writes one line of tremolo-formatted data to the provided stream.
+ *
+ * \param stream where to write the line to
+ * \param reference to the atom of which information should be written
+ */
+void TremoloParser::saveLine(ostream* file, atom* currentAtom) {
+  vector<string>::iterator it;
+  TremoloKey::atomDataKey currentField;
+
+  for (it = usedFields.begin(); it != usedFields.end(); it++) {
+    currentField = knownKeys[it->substr(0, it->find("="))];
+    switch (currentField) {
+      case TremoloKey::x :
+        // for the moment, assume there are always three dimensions
+        *file << currentAtom->x.x[0] << "\t";
+        *file << currentAtom->x.x[1] << "\t";
+        *file << currentAtom->x.x[2] << "\t";
+        break;
+      case TremoloKey::u :
+        // for the moment, assume there are always three dimensions
+        *file << currentAtom->v.x[0] << "\t";
+        *file << currentAtom->v.x[1] << "\t";
+        *file << currentAtom->v.x[2] << "\t";
+        break;
+      case TremoloKey::Type :
+        *file << currentAtom->getType()->getSymbol() << "\t";
+        break;
+      case TremoloKey::Id :
+        *file << currentAtom->getId() << "\t";
+        break;
+      case TremoloKey::neighbors :
+        writeNeighbors(file, atoi(it->substr(it->find("=") + 1, 1).c_str()), currentAtom);
+        break;
+      default :
+        *file << (additionalAtomData.find(currentAtom->getId()) != additionalAtomData.end()
+          ? additionalAtomData[currentAtom->getId()].get(currentField)
+          : defaultAdditionalData.get(currentField));
+        *file << "\t";
+        break;
+    }
+  }
+
+  *file << endl;
+}
+
+/**
+ * Writes the neighbor information of one atom to the provided stream.
+ *
+ * \param stream where to write neighbor information to
+ * \param number of neighbors
+ * \param reference to the atom of which to take the neighbor information
+ */
+void TremoloParser::writeNeighbors(ostream* file, int numberOfNeighbors, atom* currentAtom) {
+  BondList::iterator currentBond = currentAtom->ListOfBonds.begin();
+  for (int i = 0; i < numberOfNeighbors; i++) {
+    *file << (currentBond != currentAtom->ListOfBonds.end()
+        ? (*currentBond)->GetOtherAtom(currentAtom)->getId() : 0) << "\t";
+  }
+}
+
+/**
+ * Stores keys from the ATOMDATA line.
+ *
+ * \param line to parse the keys from
+ * \param with which offset the keys begin within the line
+ */
+void TremoloParser::parseAtomDataKeysLine(string line, int offset) {
+  string keyword;
+  stringstream lineStream;
+
+  lineStream << line.substr(offset);
+  while (lineStream.good()) {
+    lineStream >> keyword;
+    if (knownKeys[keyword.substr(0, keyword.find("="))] == TremoloKey::noKey) {
+      // throw exception about unknown key
+      cout << "Unknown key: " << keyword << " is not part of the tremolo format specification." << endl;
+      break;
+    }
+    usedFields.push_back(keyword);
+  }
+}
+
+/**
+ * Reads one data line of a tremolo file and interprets it according to the keys
+ * obtained from the ATOMDATA line.
+ *
+ * \param line to parse as an atom
+ */
+void TremoloParser::readAtomDataLine(string line) {
+  vector<string>::iterator it;
+  stringstream lineStream;
+  atom* newAtom = World::getInstance().createAtom();
+  TremoloAtomInfoContainer *atomInfo = NULL;
+  additionalAtomData[newAtom->getId()] = *(new TremoloAtomInfoContainer);
+  atomInfo = &additionalAtomData[newAtom->getId()];
+  TremoloKey::atomDataKey currentField;
+  string word;
+  int oldId;
+
+  lineStream << line;
+  for (it = usedFields.begin(); it < usedFields.end(); it++) {
+    currentField = knownKeys[it->substr(0, it->find("="))];
+    switch (currentField) {
+      case TremoloKey::x :
+        // for the moment, assume there are always three dimensions
+        lineStream >> newAtom->x.x[0];
+        lineStream >> newAtom->x.x[1];
+        lineStream >> newAtom->x.x[2];
+        break;
+      case TremoloKey::u :
+        // for the moment, assume there are always three dimensions
+        lineStream >> newAtom->v.x[0];
+        lineStream >> newAtom->v.x[1];
+        lineStream >> newAtom->v.x[2];
+        break;
+      case TremoloKey::Type :
+        char type[3];
+        lineStream >> type;
+        newAtom->setType(World::getInstance().getPeriode()->FindElement(type));
+        ASSERT(newAtom->getType(), "Type was not set for this atom");
+        break;
+      case TremoloKey::Id :
+        lineStream >> oldId;
+        atomIdMap[oldId] = newAtom->getId();
+        break;
+      case TremoloKey::neighbors :
+        readNeighbors(&lineStream,
+            atoi(it->substr(it->find("=") + 1, 1).c_str()), newAtom->getId());
+        break;
+      default :
+        lineStream >> word;
+        atomInfo->set(currentField, word);
+        break;
+    }
+  }
+}
+
+/**
+ * Reads neighbor information for one atom from the input.
+ *
+ * \param stream where to read the information from
+ * \param number of neighbors to read
+ * \param world id of the atom the information belongs to
+ */
+void TremoloParser::readNeighbors(stringstream* line, int numberOfNeighbors, int atomId) {
+  int neighborId = 0;
+  for (int i = 0; i < numberOfNeighbors; i++) {
+    *line >> neighborId;
+    // 0 is used to fill empty neighbor positions in the tremolo file.
+    if (neighborId > 0) {
+      additionalAtomData[atomId].neighbors.push_back(neighborId);
+    }
+  }
+}
+
+/**
+ * Checks whether the provided name is within the list of used fields.
+ *
+ * \param field name to check
+ *
+ * \return true if the field name is used
+ */
+bool TremoloParser::isUsedField(string fieldName) {
+  bool fieldNameExists = false;
+  for (vector<string>::iterator usedField = usedFields.begin(); usedField != usedFields.end(); usedField++) {
+    if (usedField->substr(0, usedField->find("=")) == fieldName)
+      fieldNameExists = true;
+  }
+
+  return fieldNameExists;
+}
+
+
+/**
+ * Adds the collected neighbor information to the atoms in the world. The atoms
+ * are found by their current ID and mapped to the corresponding atoms with the
+ * Id found in the parsed file.
+ */
+void TremoloParser::processNeighborInformation() {
+  if (!isUsedField("neighbors")) {
+    return;
+  }
+
+  for(map<int, TremoloAtomInfoContainer>::iterator currentInfo = additionalAtomData.begin();
+    currentInfo != additionalAtomData.end(); currentInfo++
+  ) {
+    for(vector<int>::iterator neighbor = currentInfo->second.neighbors.begin();
+      neighbor != currentInfo->second.neighbors.end(); neighbor++
+    ) {
+      World::getInstance().getAtom(AtomById(currentInfo->first))
+          ->addBond(World::getInstance().getAtom(AtomById(atomIdMap[*neighbor])));
+    }
+  }
+}
+
+/**
+ * Replaces atom IDs read from the file by the corresponding world IDs. All IDs
+ * IDs of the input string will be replaced; expected separating characters are
+ * "-" and ",".
+ *
+ * \param string in which atom IDs should be adapted
+ *
+ * \return input string with modified atom IDs
+ */
+string TremoloParser::adaptIdDependentDataString(string data) {
+  // there might be no IDs
+  if (data == "-") {
+    return "-";
+  }
+
+  char separator;
+  int id;
+  stringstream line, result;
+  line << data;
+
+  line >> id;
+  result << atomIdMap[id];
+  while (line.good()) {
+    line >> separator >> id;
+    result << separator << atomIdMap[id];
+  }
+
+  return result.str();
+}
+
+/**
+ * Corrects the atom IDs in each imprData entry to the corresponding world IDs
+ * as they might differ from the originally read IDs.
+ */
+void TremoloParser::adaptImprData() {
+  if (!isUsedField("imprData")) {
+    return;
+  }
+
+  for(map<int, TremoloAtomInfoContainer>::iterator currentInfo = additionalAtomData.begin();
+    currentInfo != additionalAtomData.end(); currentInfo++
+  ) {
+    currentInfo->second.imprData = adaptIdDependentDataString(currentInfo->second.imprData);
+  }
+}
+
+/**
+ * Corrects the atom IDs in each torsion entry to the corresponding world IDs
+ * as they might differ from the originally read IDs.
+ */
+void TremoloParser::adaptTorsion() {
+  if (!isUsedField("torsion")) {
+    return;
+  }
+
+  for(map<int, TremoloAtomInfoContainer>::iterator currentInfo = additionalAtomData.begin();
+    currentInfo != additionalAtomData.end(); currentInfo++
+  ) {
+    currentInfo->second.torsion = adaptIdDependentDataString(currentInfo->second.torsion);
+  }
+}
+
 
 TremoloAtomInfoContainer::TremoloAtomInfoContainer() {
-  name = "none";
-  /* Add suitable default values.
-  std::string F;
-  std::string stress;
-  std::string imprData;
-  std::string GroupMeasureTypeNo;
-  std::string extType;
-  std::string name;
-  std::string resName;
-  std::string chainID;
-  std::string resSeq;
-  std::string occupancy;
-  std::string tempFactor;
-  std::string segID;
-  std::string Charge;
-  std::string charge;
-  std::string GrpTypeNo;
-*/
-};
+  F = "0";
+  stress = "0";
+  imprData = "-";
+  GroupMeasureTypeNo = "0";
+  extType = "-";
+  name = "-";
+  resName = "-";
+  chainID = "0";
+  resSeq = "0";
+  occupancy = "0";
+  tempFactor = "0";
+  segID = "0";
+  Charge = "0";
+  charge = "0";
+  GrpTypeNo = "0";
+  torsion = "-";
+  neighbors = vector<int>(0, 5);
+}
+
+void TremoloAtomInfoContainer::set(TremoloKey::atomDataKey key, string value) {
+  switch (key) {
+    case TremoloKey::F :
+      F = value;
+      break;
+    case TremoloKey::stress :
+      stress = value;
+     break;
+    case TremoloKey::imprData :
+      imprData = value;
+      break;
+    case TremoloKey::GroupMeasureTypeNo :
+      GroupMeasureTypeNo = value;
+      break;
+    case TremoloKey::extType :
+      extType = value;
+      break;
+    case TremoloKey::name :
+      name = value;
+      break;
+    case TremoloKey::resName :
+      resName = value;
+      break;
+    case TremoloKey::chainID :
+      chainID = value;
+      break;
+    case TremoloKey::resSeq :
+      resSeq = value;
+      break;
+    case TremoloKey::occupancy :
+      occupancy = value;
+      break;
+    case TremoloKey::tempFactor :
+      tempFactor = value;
+      break;
+    case TremoloKey::segID :
+      segID = value;
+      break;
+    case TremoloKey::Charge :
+      Charge = value;
+      break;
+    case TremoloKey::charge :
+      charge = value;
+      break;
+    case TremoloKey::GrpTypeNo :
+      GrpTypeNo = value;
+      break;
+    case TremoloKey::torsion :
+      torsion = value;
+      break;
+    default :
+      cout << "Unknown key: " << key << ", value: " << value << endl;
+      break;
+  }
+}
+
+string TremoloAtomInfoContainer::get(TremoloKey::atomDataKey key) {
+  switch (key) {
+    case TremoloKey::F :
+      return F;
+    case TremoloKey::stress :
+      return stress;
+    case TremoloKey::imprData :
+      return imprData;
+    case TremoloKey::GroupMeasureTypeNo :
+      return GroupMeasureTypeNo;
+    case TremoloKey::extType :
+      return extType;
+    case TremoloKey::name :
+      return name;
+    case TremoloKey::resName :
+      return resName;
+    case TremoloKey::chainID :
+      return chainID;
+    case TremoloKey::resSeq :
+      return resSeq;
+    case TremoloKey::occupancy :
+      return occupancy;
+    case TremoloKey::tempFactor :
+      return tempFactor;
+    case TremoloKey::segID :
+      return segID;
+    case TremoloKey::Charge :
+      return Charge;
+    case TremoloKey::charge :
+      return charge;
+    case TremoloKey::GrpTypeNo :
+      return GrpTypeNo;
+    case TremoloKey::torsion :
+      return torsion;
+    default :
+      cout << "Unknown key: " << key << endl;
+      return "";
+  }
+}
+
Index: src/Parser/TremoloParser.hpp
===================================================================
--- src/Parser/TremoloParser.hpp	(revision 4415da8b5d52d38b3578718b456b8c0b28cad75d)
+++ src/Parser/TremoloParser.hpp	(revision b8d4a36310666e7e35fa9d7064e994e48d9b0e54)
@@ -13,44 +13,8 @@
 
 /**
- * Holds tremolo-specific information which is not store in the atom class.
+ * Known keys for the ATOMDATA line.
  */
-class TremoloAtomInfoContainer {
+class TremoloKey {
 public:
-  TremoloAtomInfoContainer();
-  std::string F;
-  std::string stress;
-  std::string imprData;
-  std::string GroupMeasureTypeNo;
-  std::string extType;
-  std::string name;
-  std::string resName;
-  std::string chainID;
-  std::string resSeq;
-  std::string occupancy;
-  std::string tempFactor;
-  std::string segID;
-  std::string Charge;
-  std::string charge;
-  std::string GrpTypeNo;
-};
-
-/**
- * Loads a tremolo file into the World and saves the World as a tremolo file.
- */
-class TremoloParser:public FormatParser
-{
-public:
-  TremoloParser();
-  ~TremoloParser();
-  void load(std::istream* file);
-  void save(std::ostream* file);
-
-private:
-  void readAtomDataLine(string line);
-  void parseAtomDataKeysLine(string line, int offset);
-
-  /**
-   * Known keys for the ATOMDATA line.
-   */
   enum atomDataKey {
     noKey,
@@ -74,11 +38,65 @@
     Charge,
     charge,
-    GrpTypeNo
+    GrpTypeNo,
+    torsion
   };
+};
+
+/**
+ * Holds tremolo-specific information which is not store in the atom class.
+ */
+class TremoloAtomInfoContainer {
+public:
+  TremoloAtomInfoContainer();
+  void set(TremoloKey::atomDataKey key, std::string value);
+  std::string get(TremoloKey::atomDataKey key);
+  std::string F;
+  std::string stress;
+  std::string imprData;
+  std::string GroupMeasureTypeNo;
+  std::string extType;
+  std::string name;
+  std::string resName;
+  std::string chainID;
+  std::string resSeq;
+  std::string occupancy;
+  std::string tempFactor;
+  std::string segID;
+  std::string Charge;
+  std::string charge;
+  std::string GrpTypeNo;
+  std::string torsion;
+  std::vector<int> neighbors;
+};
+
+/**
+ * Loads a tremolo file into the World and saves the World as a tremolo file.
+ */
+class TremoloParser : public FormatParser
+{
+public:
+  TremoloParser();
+  ~TremoloParser();
+  void load(std::istream* file);
+  void save(std::ostream* file);
+  void setFieldsForSave(std::string atomDataLine);
+
+
+private:
+  void readAtomDataLine(string line);
+  void parseAtomDataKeysLine(string line, int offset);
+  void readNeighbors(std::stringstream* line, int numberOfNeighbors, int atomId);
+  void processNeighborInformation();
+  void adaptImprData();
+  void adaptTorsion();
+  std::string adaptIdDependentDataString(std::string data);
+  bool isUsedField(std::string fieldName);
+  void writeNeighbors(std::ostream* file, int numberOfNeighbors, atom* currentAtom);
+  void saveLine(std::ostream* file, atom* currentAtom);
 
   /**
    * Map to associate the known keys with numbers.
    */
-  std::map<std::string, atomDataKey> knownKeys;
+  std::map<std::string, TremoloKey::atomDataKey> knownKeys;
 
   /**
@@ -91,5 +109,16 @@
    * file.
    */
-  std::map<int, TremoloAtomInfoContainer> moreData;
+  std::map<int, TremoloAtomInfoContainer> additionalAtomData;
+
+  /**
+   * Default additional atom data.
+   */
+  TremoloAtomInfoContainer defaultAdditionalData;
+
+  /**
+   * Maps original atom IDs received from the parsed file to atom IDs in the
+   * world.
+   */
+  std::map<int, int> atomIdMap;
 };
 
