Context Navigation

-              r4415da
+              rb8d4a3
  */
+#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;
 /**
 …
  */
 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;
+}
 …
  */
 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();
+}
 /**
 …
+    }
+  }
+  processNeighborInformation();
+  adaptImprData();
+  adaptTorsion();
+}
 …
  */
 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 "";
+  }
+}

src/Parser/TremoloParser.hpp

-              r4415da
+              rb8d4a3
 /**
  * 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,
 …
     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;
   /**
 …
    * 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;
 };

src/atom_bondedparticle.cpp

-              r4415da
+              rb8d4a3
       *BondFile << nr << "\t" << (*Runner)->GetOtherAtom(this)->nr << "\n";
 };
+/**
+ * Adds a bond between this bonded particle and another. Does nothing if this
+ * bond already exists.
+ *
+ * \param bonding partner
+ */
+void BondedParticle::addBond(BondedParticle* Partner) {
+  if (IsBondedTo(Partner)) {
+    return;
+  }
+  bond* newBond = new bond((atom*) this, (atom*) Partner, 1, 0);
+  RegisterBond(newBond);
+  Partner->RegisterBond(newBond);
+}
 /** Puts a given bond into atom::ListOfBonds.

src/atom_bondedparticle.hpp

r4415da	rb8d4a3
37	37	virtual ~BondedParticle();
38	38
	39	void addBond(BondedParticle* Partner);
39	40	bool RegisterBond(bond *Binder);
40	41	bool UnregisterBond(bond *Binder);

src/atom_particleinfo.cpp

-              r4415da
+              rb8d4a3
     nr(pointer->nr),
     Name(pointer->Name)
+    {}
+    {
+      if (Name == NULL)
+        Name = " ";
+    }

src/bond.cpp

-              r4415da
+              rb8d4a3
 /** Empty Constructor for class bond.
  */
+bond::bond() : leftatom(NULL), rightatom(NULL), previous(NULL), next(NULL), HydrogenBond(0), BondDegree(0), nr(-1), Cyclic(false), Type(Undetermined), Used(white)
+bond::bond()
+  : leftatom(NULL), rightatom(NULL), previous(NULL), next(NULL), HydrogenBond(0),
+    BondDegree(0), nr(-1), Cyclic(false), Type(Undetermined), Used(white)
+{
 };
 …
  * \param number increasing index
  */
+bond::bond(atom *left, atom *right, const int degree, const int number) : leftatom(left), rightatom(right), previous(NULL), next(NULL), HydrogenBond(0), BondDegree(degree), nr(number), Cyclic(false), Type(Undetermined), Used(white)
+bond::bond(atom *left, atom *right, const int degree, const int number)
+  : leftatom(left), rightatom(right), previous(NULL), next(NULL), HydrogenBond(0),
+    BondDegree(degree), nr(number), Cyclic(false), Type(Undetermined), Used(white)
+{
   if ((left != NULL) && (right != NULL)) {

src/tesselation.cpp

-              r4415da
+              rb8d4a3
   node = NULL;
   nr = -1;
+  Name =  NULL;
+  Name = Malloc<char> (1, "TesselPoint::TtesselPoint - Name");
+  Name = strcpy(Name, "-");
 };

src/unittests/ParserUnitTest.cpp

-              r4415da
+              rb8d4a3
 #include "Parser/TremoloParser.hpp"
 #include "World.hpp"
+#include "atom.hpp"
 #include "element.hpp"
 #include "periodentafel.hpp"
+#include "Descriptors/AtomTypeDescriptor.hpp"
 #ifdef HAVE_TESTRUNNER
 …
 void ParserUnitTest::tearDown() {
+  World::purgeInstance();
+}
 …
+}
 void ParserUnitTest::rewriteTremoloTest() {
+void ParserUnitTest::readTremoloPreliminaryCommentsTest() {
   cout << "Testing the tremolo parser." << endl;
   TremoloParser* testParser = new TremoloParser();
+  stringstream input;
+  stringstream input, output;
+  string waterTremolo;
   // Atomdata beginning with "# ATOMDATA"
   string waterTremolo = "#\n# ATOMDATA Id name Type x=3\n\n\n";
+  waterTremolo = "# ATOMDATA\tId\tname\tType\tx=3\n";
   input << waterTremolo;
   testParser->load(&input);
+  testParser->save(&output);
+  CPPUNIT_ASSERT(waterTremolo == output.str());
   input.clear();
+  output.clear();
   // Atomdata beginning with "#ATOMDATA"
   waterTremolo = "#\n#ATOMDATA Id name Type x=3\n1 H hydrogen 3.0 4.5 0.1\n\n";
+  waterTremolo = "#\n#ATOMDATA Id name Type x=3\n1 hydrogen H 3.0 4.5 0.1\n\n";
   input << waterTremolo;
   testParser->load(&input);
+  testParser->save(&output);
+  CPPUNIT_ASSERT(output.str().find("hydrogen") != string::npos);
   input.clear();
+  // One simple data line
+  waterTremolo = "#\n#ATOMDATA Id name Type x=3\n1 H hydrogen 3.0 4.5 0.1\n\n";
+  input << waterTremolo;
+  testParser->load(&input);
+  input.clear();
+  output.clear();
   // Invalid key in Atomdata line
 …
   input << waterTremolo;
   testParser->load(&input);
+  //TODO: proove invalidity
   input.clear();
+}
+void ParserUnitTest::readTremoloCoordinatesTest() {
+  TremoloParser* testParser = new TremoloParser();
+  stringstream input;
+  string waterTremolo;
+  // One simple data line
+  waterTremolo = "#\n#ATOMDATA Id name Type x=3\n1 hydrogen H 3.0 4.5 0.1\n\n";
+  input << waterTremolo;
+  testParser->load(&input);
+  CPPUNIT_ASSERT(World::getInstance().getAtom(AtomByType(1))->x.x[0] == 3.0);
+  input.clear();
+}
+void ParserUnitTest::readTremoloVelocityTest() {
+  TremoloParser* testParser = new TremoloParser();
+  stringstream input;
+  string waterTremolo;
+  // One simple data line
+  waterTremolo = "#\n#ATOMDATA Id name Type u=3\n1 hydrogen H 3.0 4.5 0.1\n\n";
+  input << waterTremolo;
+  testParser->load(&input);
+  CPPUNIT_ASSERT(World::getInstance().getAtom(AtomByType(1))->v.x[0] == 3.0);
+  input.clear();
+}
+void ParserUnitTest::readTremoloNeighborInformationTest() {
+  TremoloParser* testParser = new TremoloParser();
+  stringstream input;
+  string waterTremolo;
+  // Neighbor data
+  waterTremolo = "#\n#ATOMDATA Id Type neighbors=2\n1 H 3 0\n2 H 3 0\n3 O 1 2\n";
+  input << waterTremolo;
+  testParser->load(&input);
+  CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
+  CPPUNIT_ASSERT(World::getInstance().getAtom(AtomByType(8))->
+      IsBondedTo(World::getInstance().getAtom(AtomByType(1))));
+  input.clear();
+}
+void ParserUnitTest::readAndWriteTremoloImprDataInformationTest() {
+  TremoloParser* testParser = new TremoloParser();
+  stringstream input, output;
+  string waterTremolo;
+  // Neighbor data
+  waterTremolo = "#\n#ATOMDATA Id Type imprData\n8 H 9-10\n9 H 10-8,8-10\n10 O -\n";
+  input << waterTremolo;
+  testParser->load(&input);
+  testParser->save(&output);
+  CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
+  CPPUNIT_ASSERT(output.str().find("2-0,0-2") != string::npos);
+  input.clear();
+  output.clear();
+}
+void ParserUnitTest::readAndWriteTremoloTorsionInformationTest() {
+  TremoloParser* testParser = new TremoloParser();
+  stringstream input, output;
+  string waterTremolo;
+  // Neighbor data
+  waterTremolo = "#\n#ATOMDATA Id Type torsion\n8 H 9-10\n9 H 10-8,8-10\n10 O -\n";
+  input << waterTremolo;
+  testParser->load(&input);
+  testParser->save(&output);
+  CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
+  CPPUNIT_ASSERT(output.str().find("2-0,0-2") != string::npos);
+  input.clear();
+  output.clear();
+}
+void ParserUnitTest::writeTremoloTest() {
+  TremoloParser* testParser = new TremoloParser();
+  stringstream output;
+  // with the maximum number of fields and minimal information, default values are printed
+  atom* newAtom = World::getInstance().createAtom();
+  newAtom->type = World::getInstance().getPeriode()->FindElement(1);
+  testParser->setFieldsForSave("x=3 u=3 F stress Id neighbors=5 imprData GroupMeasureTypeNo Type extType name resName chainID resSeq occupancy tempFactor segID Charge charge GrpTypeNo torsion");
+  testParser->save(&output);
+  CPPUNIT_ASSERT(output.str() == "# ATOMDATA\tx=3\tu=3\tF\tstress\tId\tneighbors=5\timprData\tGroupMeasureTypeNo\tType\textType\tname\tresName\tchainID\tresSeq\toccupancy\ttempFactor\tsegID\tCharge\tcharge\tGrpTypeNo\ttorsion\n0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t-\t0\tH\t-\t-\t-\t0\t0\t0\t0\t0\t0\t0\t0\t-\t\n");
   cout << "testing the tremolo parser is done" << endl;

src/unittests/ParserUnitTest.hpp

-              r4415da
+              rb8d4a3
   CPPUNIT_TEST_SUITE( ParserUnitTest ) ;
   CPPUNIT_TEST ( rewriteAnXyzTest );
+  CPPUNIT_TEST ( rewriteTremoloTest );
+  CPPUNIT_TEST ( readTremoloPreliminaryCommentsTest );
+  CPPUNIT_TEST ( readTremoloCoordinatesTest );
+  CPPUNIT_TEST ( readTremoloVelocityTest );
+  CPPUNIT_TEST ( readTremoloNeighborInformationTest );
+  CPPUNIT_TEST ( readAndWriteTremoloImprDataInformationTest );
+  CPPUNIT_TEST ( readAndWriteTremoloTorsionInformationTest );
+  CPPUNIT_TEST ( writeTremoloTest );
   CPPUNIT_TEST_SUITE_END();
 …
   void rewriteAnXyzTest();
+  void rewriteTremoloTest();
+  void readTremoloPreliminaryCommentsTest();
+  void readTremoloCoordinatesTest();
+  void readTremoloVelocityTest();
+  void readTremoloNeighborInformationTest();
+  void readAndWriteTremoloImprDataInformationTest();
+  void readAndWriteTremoloTorsionInformationTest();
+  void writeTremoloTest();
 };

src/unittests/SingletonTest.cpp

r4415da	rb8d4a3
52	52	count1++;
53	53	}
54		// explicit copy constructor to catch if thsi is ever called
	54	// explicit copy constructor to catch if this is ever called
55	55	SingletonStub2(const SingletonStub2&){
56	56	CPPUNIT_FAIL ( "Copy constructor of Singleton called" );

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset b8d4a3

Legend:

Download in other formats: