Changeset 8dcfb9

Timestamp:

May 18, 2016, 10:04:49 PM (9 years ago)

Author:

Frederik Heber <heber@…>

Branches:

CombiningParticlePotentialParsing

Children:

9bb977

Parents:

ff4fff9

git-author:

Frederik Heber <heber@…> (03/09/16 11:54:33)

git-committer:

Frederik Heber <heber@…> (05/18/16 22:04:49)

Message:

ParsePotentialsAction parses both EmpiricalPotentials and Particles.

File:

• src/Actions/PotentialAction/ParsePotentialsAction.cpp (modified) (1 diff)

src/Actions/PotentialAction/ParsePotentialsAction.cpp

@@ -65 +65 @@
     std::ifstream returnstream(params.potential_file.get().string().c_str());
     if (returnstream.good()) {
-      try {
-        RegistryDeserializer<EmpiricalPotential> deserialize(
-            returnstream,
-            PotentialFactory::getInstance(),
-            PotentialRegistry::getInstance(),
-            std::string("potential"));
-        deserialize();
-      } catch (SerializerMissingValueException &e) {
-        if (const std::string *key = boost::get_error_info<SerializerKey>(e))
-          STATUS("Missing value when parsing information for potential "+*key+".");
-        else
-          STATUS("Missing value parsing information for potential with unknown key.");
-        return Action::failure;
-      } catch (SerializerIllegalKeyException &e) {
-        if (const std::string *key = boost::get_error_info<SerializerKey>(e))
-          STATUS("Illegal key parsing information for potential "+*key+".");
-        else
-          STATUS("Illegal key parsing information for potential with unknown key.");
-        return Action::failure;
+      std::string linestring;
+      std::string token;
+      while (returnstream.good()) {
+        getline(returnstream, linestring);
+        const std::string comment("#");
+        if (linestring.find(comment) != std::string::npos) {
+          LOG(4, "DEBUG: Skippeing comment line:"+linestring);
+          continue;
+        }
+        const std::string whitespace(" \t");
+        const size_t strBegin = linestring.find_first_not_of(whitespace);
+        const size_t curlyopenpos = linestring.find("{");
+        const size_t curlyclosedpos = linestring.find("}");
+        if (curlyopenpos != std::string::npos) {
+          // begin of new type section
+          token = linestring.substr(strBegin, curlyopenpos);
+          const size_t tokenEnd = token.find_first_of(whitespace);
+          token = token.substr(0, tokenEnd);
+          LOG(1, "INFO: Token is " << token);
+          const type_name_map_t::right_const_iterator tokeniter = TypeNameMap.right.find(token);
+          ASSERT( tokeniter != TypeNameMap.right.end(),
+              "PotentialParsePotentialsAction::performCall() - could not find type to "
+              +toString(token)+".");
+          const tokentype_t tokentype = tokeniter->second;
+          // get either particles {} or potentials {}
+          switch (tokentype) {
+            case particles:
+            {
+              if (!parseItems<Particle>(
+                    returnstream,
+                    ParticleFactory::getInstance(),
+                    ParticleRegistry::getInstance(),
+                    std::string("particle")))
+                return Action::failure;
+              break;
+            }
+            case bonds:
+            case angles:
+            case torsions:
+            case impropers:
+            case nonbonded_2body_potentials:
+            {
+              if (!parseItems<EmpiricalPotential>(
+                  returnstream,
+                  PotentialFactory::getInstance(),
+                  PotentialRegistry::getInstance(),
+                  std::string("potential")))
+                return Action::failure;
+              break;
+            }
+            default:
+              ASSERT( 0,
+                  "PotentialParsePotentialsAction::performCall() - token type "
+                  +toString(tokentype)+" is unknown.");
+          }
+        } else if (curlyclosedpos != std::string::npos) {
+          // section end encountered, just read next line
+        } else {
+          ELOG(0, "Parser confused, neither curly open nor curly closed on line "
+              << linestring);
+          return Action::failure;
+        }
       }
     } else {