Diff [360c8bbc74f8b9ba85e29afb3769876f4b7fd8b1:fa9d1d1f9bdda596edc780e18f57c4ea62847227] for / – MoleCuilder

configure.ac

r360c8b	rfa9d1d
122	122	BOOST_RANDOM
123	123	BOOST_SMART_PTR
124		~~BOOST_STRING_ALGO~~
125	124	BOOST_TOKENIZER
126	125

src/Actions/MoleculeAction/FillVoidWithMoleculeAction.cpp

-              r360c8b
+              rfa9d1d
 #include "Descriptors/MoleculeOrderDescriptor.hpp"
 #include "molecule.hpp"
-#include "Parser/FormatParserInterface.hpp"
 #include "Parser/FormatParserStorage.hpp"
 #include "World.hpp"
 …
   input.open(params.fillername.string().c_str());
   ParserTypes type = FormatParserStorage::getInstance().getTypeFromSuffix(FilenameSuffix);
   FormatParserInterface &parser = FormatParserStorage::getInstance().get(type);
+  FormatParser &parser = FormatParserStorage::getInstance().get(type);
   parser.load(&input);

src/Actions/MoleculeAction/FillWithMoleculeAction.cpp

-              r360c8b
+              rfa9d1d
 #include "Descriptors/MoleculeOrderDescriptor.hpp"
 #include "molecule.hpp"
-#include "Parser/FormatParserInterface.hpp"
 #include "Parser/FormatParserStorage.hpp"
 #include "World.hpp"
 …
   input.open(params.fillername.string().c_str());
   ParserTypes type = FormatParserStorage::getInstance().getTypeFromSuffix(FilenameSuffix);
   FormatParserInterface &parser = FormatParserStorage::getInstance().get(type);
+  FormatParser &parser = FormatParserStorage::getInstance().get(type);
   parser.load(&input);

src/Actions/MoleculeAction/LoadAction.cpp

-              r360c8b
+              rfa9d1d
 #include "CodePatterns/Verbose.hpp"
 #include "Descriptors/MoleculeIdDescriptor.hpp"
-#include "Parser/FormatParserInterface.hpp"
 #include "Parser/FormatParserStorage.hpp"
 #include "Parser/FormatParser_Parameters.hpp"
 …
     // get undo state for parser
     enum ParserTypes type = FormatParserStorage::getInstance().getTypeFromSuffix(FilenameSuffix);
-    ASSERT(type != ParserTypes_end,
-        "MoleculeLoadAction::performCall() - unknown file suffix "+FilenameSuffix+".");
     FormatParser_Parameters *ParserParams = FormatParserStorage::getInstance().get(type).parameters;
     if (ParserParams != NULL)

src/Actions/ParserAction/ParseTremoloPotentialsAction.cpp

-              r360c8b
+              rfa9d1d
   boost::filesystem::ifstream test;
   FormatParser<tremolo> &parser = FormatParserStorage::getInstance().getParser<tremolo>();
+  TremoloParser &tremolo = FormatParserStorage::getInstance().getTremolo();
   // parsing file if present
   if (!boost::filesystem::exists(params.filename)) {
     DoLog(1) && (Log() << Verbose(1) << "Specified potentials file " << params.filename << " not found." << endl);
     // DONT FAIL: it's just empty we re-create default id-mapping
     parser.createKnownTypesByIdentity();
+    tremolo.createKnownTypesByIdentity();
   } else {
 …
     // parse the file
     test.open(params.filename);
+    parser.parseKnownTypes(test);
+    TremoloParser &tremolo = FormatParserStorage::getInstance().getTremolo();
+    tremolo.parseKnownTypes(test);
     test.close();
+  }

src/Actions/ParserAction/SetMpqcParametersAction.cpp

-              r360c8b
+              rfa9d1d
 /** =========== define the function ====================== */
 Action::state_ptr ParserSetMpqcParametersAction::performCall() {
   MpqcParser_Parameters &parser = FormatParserStorage::getInstance().getParser<mpqc>().getParams();
+  MpqcParser_Parameters &mpqc = FormatParserStorage::getInstance().getMpqc().getParams();
   std::stringstream oldparamstream;
   oldparamstream << parser;
+  oldparamstream << mpqc;
   // obtain information
   getParametersfromValueStorage();
   std::stringstream newparamstream(params.newparams);
   newparamstream >> parser;
+  newparamstream >> mpqc;
   return Action::state_ptr(new ParserSetMpqcParametersState(oldparamstream.str(), params));
 …
   ParserSetMpqcParametersState *state = assert_cast<ParserSetMpqcParametersState*>(_state.get());
   MpqcParser_Parameters &parser = FormatParserStorage::getInstance().getParser<mpqc>().getParams();
+  MpqcParser_Parameters &mpqc = FormatParserStorage::getInstance().getMpqc().getParams();
   std::stringstream oldparamstream(state->oldparams);
   oldparamstream >> parser;
+  oldparamstream >> mpqc;
   return Action::state_ptr(_state);
 …
   ParserSetMpqcParametersState *state = assert_cast<ParserSetMpqcParametersState*>(_state.get());
   MpqcParser_Parameters &parser = FormatParserStorage::getInstance().getParser<mpqc>().getParams();
+  MpqcParser_Parameters &mpqc = FormatParserStorage::getInstance().getMpqc().getParams();
   std::stringstream newparamstream(state->params.newparams);
   newparamstream >> parser;
+  newparamstream >> mpqc;
   return Action::state_ptr(_state);

src/Actions/ParserAction/SetTremoloAtomdataAction.cpp

-              r360c8b
+              rfa9d1d
   getParametersfromValueStorage();
   FormatParser<tremolo> &parser = FormatParserStorage::getInstance().getParser<tremolo>();
+  TremoloParser &tremolo = FormatParserStorage::getInstance().getTremolo();
   DoLog(1) && (Log() << Verbose(1) << "Setting Tremolo's ATOMDATA to: '" << params.atomdata_string << "'" << std::endl);
   parser.setAtomData(params.atomdata_string);
+  tremolo.setAtomData(params.atomdata_string);
   return Action::success;

src/Parser/FormatParser.hpp

-              r360c8b
+              rfa9d1d
 #endif
-#include <iosfwd>
-#include <string>
-#include <vector>
+#include "CodePatterns/Assert.hpp"
+#include "CodePatterns/Observer.hpp"
+#include "ChangeTracker.hpp"
+#include "FormatParser_Parameters.hpp"
+#include "FormatParserTrait.hpp"
+#include "FormatParserInterface.hpp"
+#include "FormatParser_common.hpp"
+#include "ParserTypes.hpp"
+namespace MoleCuilder {
+  class MoleculeLoadAction;
+}
 class atom;
 /**
- * @file
- * <H1> FormatParser Howto </H1>
+ *
- * <H2> Introduction </H2>
+ *
- * FormatParsers parse external streams (files) and bring their information
- * into the World. That is they implement load and save functions that work
- * on a specific vector atoms.
+ *
- * <H2> Building your own Parsers </H2>
+ *
- * Building Parsers is easy. All you have to do is the following:
- * -# add a new parser type to the file ParserTypes.def.
- * -# add a new template specialization of FormatParser in a new header and
- *    module that implement the virtual load and save functions.
- * -# Add the header file of your new parser to FormatParserStorage.cpp.
+ *
- * <H3> Specific notes on the macros </H3>
+ *
- * To clarify a bit the internals of all the different FormatParser... files, here
- * are some notes:
- * -# We make use of boost::preprocessor to generate lists from the sequence
- *    given in ParserTypes.def (and undefined in ParserTypes.undef). These might
- *    be forward declarations of even implementations. This is to assure that
- *    none are forgotten when a new FormatParser is added.
- * -# Thanks to the above construct FormatParserStorage also immediately knows
- *    about any new parsers and can get and add such instances.
- */
-/**
  * General parser which observes the change tracker.
  */
+template <enum ParserTypes Ptype>
+class FormatParser : virtual public FormatParserInterface, public FormatParser_common {
+  FormatParser() :
+    FormatParser_common(NULL)
+  {
+    ASSERT(0, "FormatParser<>::FormatParser() - unspecialized function cannot be called.");
+  }
+  virtual ~FormatParser()
+  {
+    ASSERT(0, "FormatParser<>::~FormatParser() - unspecialized function cannot be called.");
+  }
+class FormatParser : public Observer {
+  friend class MoleCuilder::MoleculeLoadAction;
+public:
+  FormatParser();
+  virtual ~FormatParser();
+  virtual void save(std::ostream* file, const std::vector<atom *> &atoms)=0;
+  virtual void load(std::istream* file)=0;
+  void setOstream(std::ostream* file);
+  void load(std::istream *file)
+  {
+    ASSERT(0, "FormatParser<>::load() - unspecialized function cannot be called.");
+  }
+  void save(std::ostream *file, const std::vector<atom *> &atoms)
+  {
+    ASSERT(0, "FormatParser<>::save() - unspecialized function cannot be called.");
+  }
+protected:
+  void update(Observable *publisher);
+  void recieveNotification(Observable *publisher, Notification_ptr notification);
+  void subjectKilled(Observable *publisher);
+  // these functions are called when atoms are inserted or removed
+  virtual void AtomInserted(atomId_t) {};
+  virtual void AtomRemoved(atomId_t) {};
+  FormatParser_Parameters *parameters;
+private:
+  std::ostream* saveStream;
 };
-#include "FormatParser_specializations_header.hpp"
 #endif /* FORMATPARSER_HPP_ */

src/Parser/FormatParserStorage.cpp

-              r360c8b
+              rfa9d1d
 #include <fstream>
+#include <boost/preprocessor/iteration/local.hpp>
+#include "Parser/FormatParserStorage.hpp"
+#include "CodePatterns/Log.hpp"
+#include "CodePatterns/Verbose.hpp"
 #include "CodePatterns/Assert.hpp"
-#include "CodePatterns/Log.hpp"
 #include "molecule.hpp"
-#include "FormatParserStorage.hpp"
-#include "ParserTypes.hpp"
-#include "MpqcParser.hpp"
-#include "PcpParser.hpp"
-#include "PdbParser.hpp"
-#include "Psi3Parser.hpp"
-#include "TremoloParser.hpp"
-#include "XyzParser.hpp"
 #include "CodePatterns/Singleton_impl.hpp"
+/** Increment operator for the enumeration ParserTypes to allow loops.
+ * \param &type value
+ * \return value incremented by one
+ */
+ParserTypes &operator++(ParserTypes &type)
+{
+  return type = ParserTypes(type+1);
+}
 /** Constructor of class FormatParserStorage.
 …
   ParserPresent.resize(ParserTypes_end, false);
+#include "ParserTypes.def"
+#define insert_print(z,n,seq,map, before, after) \
+   map .insert( std::make_pair(  \
+     BOOST_PP_SEQ_ELEM(n, seq) \
+     , before < \
+       BOOST_PP_SEQ_ELEM(n, seq) \
+       > after \
+     ) );
+#define insert_invert_print(z,n,seq,map, before, after) \
+   map .insert( std::make_pair( before < \
+   BOOST_PP_SEQ_ELEM(n, seq) \
+   > after, \
+   BOOST_PP_SEQ_ELEM(n, seq) \
+  ) );
+  // fill ParserNames
+#if defined ParserTypes_END // do we have parameters at all?
+#define BOOST_PP_LOCAL_MACRO(n) insert_print(~, n, PARSERSEQUENCE, ParserNames, FormatParserTrait, ::name)
+#define BOOST_PP_LOCAL_LIMITS  (0, ParserTypes_END-1)
+#include BOOST_PP_LOCAL_ITERATE()
+#endif
+  // fill ParserLookupNames
+#if defined ParserTypes_END // do we have parameters at all?
+#define BOOST_PP_LOCAL_MACRO(n) insert_invert_print(~, n, PARSERSEQUENCE, ParserLookupNames, FormatParserTrait, ::name)
+#define BOOST_PP_LOCAL_LIMITS  (0, ParserTypes_END-1)
+#include BOOST_PP_LOCAL_ITERATE()
+#endif
+  // fill ParserSuffixes
+#if defined ParserTypes_END // do we have parameters at all?
+#define BOOST_PP_LOCAL_MACRO(n) insert_print(~, n, PARSERSEQUENCE, ParserSuffixes, FormatParserTrait, ::suffix)
+#define BOOST_PP_LOCAL_LIMITS  (0, ParserTypes_END-1)
+#include BOOST_PP_LOCAL_ITERATE()
+#endif
+  // fill ParserLookupSuffixes
+#if defined ParserTypes_END // do we have parameters at all?
+#define BOOST_PP_LOCAL_MACRO(n) insert_invert_print(~, n, PARSERSEQUENCE, ParserLookupSuffixes, FormatParserTrait, ::suffix)
+#define BOOST_PP_LOCAL_LIMITS  (0, ParserTypes_END-1)
+#include BOOST_PP_LOCAL_ITERATE()
+#endif
+  // fill ParserAddFunction
+#if defined ParserTypes_END // do we have parameters at all?
+#define BOOST_PP_LOCAL_MACRO(n) insert_print(~, n, PARSERSEQUENCE, ParserAddFunction, &FormatParserStorage::addParser, )
+#define BOOST_PP_LOCAL_LIMITS  (0, ParserTypes_END-1)
+#include BOOST_PP_LOCAL_ITERATE()
+#endif
+#undef insert_print
+#undef insert_invert_print
+#include "ParserTypes.undef"
+  //std::cout << "ParserNames:" << std::endl << ParserNames << std::endl;
+  //std::cout << "ParserSuffixes:" << std::endl << ParserSuffixes << std::endl;
+  //std::cout << "ParserLookupNames:" << std::endl << ParserLookupNames << std::endl;
+  //std::cout << "ParserLookupSuffixes:" << std::endl << ParserLookupSuffixes << std::endl;
+  //std::cout << "ParserAddFunction:" << std::endl << ParserAddFunction << std::endl;
+  ParserNames[mpqc] = "mpqc";
+  ParserNames[pcp] = "pcp";
+  ParserNames[pdb] = "pdb";
+  ParserNames[tremolo] = "tremolo";
+  ParserNames[xyz] = "xyz";
+  for (std::map<ParserTypes, std::string>::const_iterator it = ParserNames.begin(); it != ParserNames.end(); ++it)
+    ParserLookupNames.insert(pair<std::string, ParserTypes>(it->second,it->first) );
+  ParserSuffixes[mpqc] = "in";
+  ParserSuffixes[pcp] = "conf";
+  ParserSuffixes[pdb] = "pdb";
+  ParserSuffixes[tremolo] = "data";
+  ParserSuffixes[xyz] = "xyz";
+  for (std::map<ParserTypes, std::string>::const_iterator it = ParserSuffixes.begin(); it != ParserSuffixes.end(); ++it)
+    ParserLookupSuffixes.insert(pair<std::string, ParserTypes>(it->second,it->first) );
+  ParserAddFunction[mpqc] = &FormatParserStorage::addMpqc;
+  ParserAddFunction[pcp] = &FormatParserStorage::addPcp;
+  ParserAddFunction[pdb] = &FormatParserStorage::addPdb;
+  ParserAddFunction[tremolo] = &FormatParserStorage::addTremolo;
+  ParserAddFunction[xyz] = &FormatParserStorage::addXyz;
+}
 …
+/** Adds an MpqcParser to the storage.
+ */
+void FormatParserStorage::addMpqc()
+{
+  if (!ParserPresent[mpqc]) {
+    ParserList[mpqc] = dynamic_cast<FormatParser *>(new MpqcParser);
+    ParserPresent[mpqc] = true;
+  }
+  else
+    DoeLog(2) && (eLog() << Verbose(2) << "Parser mpqc is already present." << endl
+        << "Note that you don't need to add '-o mpqc' if the input file is of type mpqc." << endl);
+}
+/** Adds an PcpParser to the storage.
+ */
+void FormatParserStorage::addPcp()
+{
+  if (!ParserPresent[pcp]) {
+    ParserList[pcp] = new PcpParser();
+    ParserPresent[pcp] = true;
+  } else
+    DoeLog(2) && (eLog() << Verbose(2) << "Parser pcp is already present." << endl
+        << "Note that you don't need to add '-o pcp' if the input file is of type pcp." << endl);
+}
+/** Adds an PdbParser to the storage.
+ */
+void FormatParserStorage::addPdb()
+{
+  if (!ParserPresent[pdb]) {
+    ParserList[pdb] = new PdbParser();
+    ParserPresent[pdb] = true;
+  } else
+    DoeLog(2) && (eLog() << Verbose(2) << "Parser pdb is already present." << endl
+        << "Note that you don't need to add '-o pdb' if the input file is of type pdb." << endl);
+}
+/** Adds an TremoloParser to the storage.
+ */
+void FormatParserStorage::addTremolo()
+{
+  if (!ParserPresent[tremolo]) {
+    ParserList[tremolo] = new TremoloParser();
+    ParserPresent[tremolo] = true;
+  } else
+    DoeLog(2) && (eLog() << Verbose(2) << "Parser tremolo is already present." << endl
+        << "Note that you don't need to add '-o tremolo' if the input file is of type tremolo." << endl);
+}
+/** Adds an XyzParser to the storage.
+ */
+void FormatParserStorage::addXyz()
+{
+  if (!ParserPresent[xyz]) {
+    ParserList[xyz] = new XyzParser();
+    ParserPresent[xyz] = true;
+  } else
+    DoeLog(2) && (eLog() << Verbose(2) << "Parser xyz is already present." << endl
+        << "Note that you don't need to add '-o xyz' if the input file is of type xyz." << endl);
+}
 ParserTypes FormatParserStorage::getTypeFromName(std::string type)
+{
 …
   if (ptype != ParserTypes_end) {
     if (ParserAddFunction.find(ptype) != ParserAddFunction.end()) {
       LOG(0, "STATUS: Adding " << ParserNames[ptype] << " type to output.");
+      DoLog(0) && (Log() << Verbose(0) << "Adding " << ParserNames[ptype] << " type to output." << endl);
       (getInstance().*(ParserAddFunction[ptype]))(); // we still need an object to work on ...
       return true;
     } else {
       ELOG(1, "No parser to add for this known type " << ParserNames[ptype] << ", not implemented?");
+      DoeLog(1) && (eLog() << Verbose(1) << "No parser to add for this known type " << ParserNames[ptype] << ", not implemented?" << endl);
       return false;
+    }
 …
 bool FormatParserStorage::add(std::string type)
+{
+  enum ParserTypes Ptype = getTypeFromName(type);
+  return add(Ptype);
+  return add(getTypeFromName(type));
+}
 …
 bool FormatParserStorage::load(std::istream &input, std::string suffix)
+{
+  enum ParserTypes type = getTypeFromSuffix(suffix);
+  if (type != ParserTypes_end)
+    get(type).load(&input);
+  else
+  if (suffix == ParserSuffixes[mpqc]) {
+    getMpqc().load(&input);
+  } else if (suffix == ParserSuffixes[pcp]) {
+    getPcp().load(&input);
+  } else if (suffix == ParserSuffixes[pdb]) {
+    getPdb().load(&input);
+  } else if (suffix == ParserSuffixes[tremolo]) {
+    getTremolo().load(&input);
+  } else if (suffix == ParserSuffixes[xyz]) {
+    getXyz().load(&input);
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "Unknown suffix " << suffix << " to for FormatParserStorage::get()." << endl);
     return false;
+  }
   return true;
+}
 …
 bool FormatParserStorage::save(std::ostream &output, std::string suffix, const std::vector<atom *> &atoms)
+{
+  enum ParserTypes type = getTypeFromSuffix(suffix);
+  if (type != ParserTypes_end)
+    get(type).save(&output, atoms);
+  else
+  if (suffix == ParserSuffixes[mpqc]) {
+    getMpqc().save(&output, atoms);
+  } else if (suffix == ParserSuffixes[pcp]) {
+    getPcp().save(&output, atoms);
+  } else if (suffix == ParserSuffixes[pdb]) {
+    getPdb().save(&output, atoms);
+  } else if (suffix == ParserSuffixes[tremolo]) {
+    getTremolo().save(&output, atoms);
+  } else if (suffix == ParserSuffixes[xyz]) {
+    getXyz().save(&output, atoms);
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "Unknown suffix " << suffix << " to for FormatParserStorage::put()." << endl);
     return false;
+  }
   return true;
+}
+/** Returns reference to the output MpqcParser, adds if not present.
+ * \return reference to the output MpqcParser
+ */
+MpqcParser &FormatParserStorage::getMpqc()
+{
+  if (!ParserPresent[mpqc])
+    addMpqc();
+  return dynamic_cast<MpqcParser &>(*ParserList[mpqc]);
+}
+/** Returns reference to the output PcpParser, adds if not present.
+ * \return reference to the output PcpParser
+ */
+PcpParser &FormatParserStorage::getPcp()
+{
+  if (!ParserPresent[pcp])
+    addPcp();
+  return dynamic_cast<PcpParser &>(*ParserList[pcp]);
+}
+/** Returns reference to the output PdbParser, adds if not present.
+ * \return reference to the output PdbParser
+ */
+PdbParser &FormatParserStorage::getPdb()
+{
+  if (!ParserPresent[pdb])
+    addPdb();
+  return dynamic_cast<PdbParser &>(*ParserList[pdb]);
+}
+/** Returns reference to the output TremoloParser, adds if not present.
+ * \return reference to the output TremoloParser
+ */
+TremoloParser &FormatParserStorage::getTremolo()
+{
+  if (!ParserPresent[tremolo])
+    addTremolo();
+  return dynamic_cast<TremoloParser &>(*ParserList[tremolo]);
+}
+/** Returns reference to the output XyzParser, adds if not present.
+ * \return reference to the output XyzParser
+ */
+XyzParser &FormatParserStorage::getXyz()
+{
+  if (!ParserPresent[xyz])
+    addXyz();
+  return dynamic_cast<XyzParser &>(*ParserList[xyz]);
+}
 …
  * \return reference to the output FormatParser with desired type
  */
 FormatParserInterface &FormatParserStorage::get(ParserTypes _type)
+FormatParser &FormatParserStorage::get(ParserTypes _type)
+{
   if (!ParserPresent[_type]) {

src/Parser/FormatParserStorage.hpp

-              r360c8b
+              rfa9d1d
 #include "CodePatterns/Singleton.hpp"
 #include <iosfwd>
+#include <string>
 #include <map>
-#include <string>
 #include <vector>
+#include "CodePatterns/Assert.hpp"
+#include "CodePatterns/Log.hpp"
+#include "FormatParser.hpp"
+#include "ParserTypes.hpp"
+#include "Parser/FormatParser.hpp"
+#include "Parser/MpqcParser.hpp"
+#include "Parser/PcpParser.hpp"
+#include "Parser/PdbParser.hpp"
+#include "Parser/TremoloParser.hpp"
+#include "Parser/XyzParser.hpp"
 class atom;
+class FormatParserInterface;
+// enum has to be outside of class for operator++ to be possible
+enum ParserTypes { mpqc, pcp, pdb, tremolo, xyz, ParserTypes_end, ParserTypes_begin = mpqc };
+typedef enum ParserTypes ParserTypes;
+ParserTypes &operator++(ParserTypes &type);
 class FormatParserStorage : public Singleton<FormatParserStorage> {
 …
 public:
+  void addMpqc();
+  void addPcp();
+  void addPdb();
+  void addTremolo();
+  void addXyz();
   bool add(std::string type);
   bool add(ParserTypes type);
 …
   bool saveSelectedMolecules(std::ostream &output, std::string suffix);
   bool saveWorld(std::ostream &output, std::string suffix);
+  FormatParserInterface &get(ParserTypes _type);
+  MpqcParser &getMpqc();
+  PcpParser &getPcp();
+  PdbParser &getPdb();
+  TremoloParser &getTremolo();
+  XyzParser &getXyz();
+  FormatParser &get(enum ParserTypes _type);
   ParserTypes getTypeFromName(std::string type);
 …
   // list of allocated parsers
   std::vector<FormatParserInterface *> ParserList;
+  std::vector<FormatParser *> ParserList;
   // list of allocated strams
 …
   std::map<std::string, ParserTypes> ParserLookupNames;
   // prefix of the filenames to use on save
   std::string prefix;
-public:
-  template<ParserTypes Ptype> void addParser()
+  {
-    if (!ParserPresent[Ptype]) {
-      ParserList[Ptype] = new FormatParser<Ptype>();
-      ParserPresent[Ptype] = true;
-    } else {
-      ASSERT(ParserNames.find(Ptype) != ParserNames.end(),
-          "FormatParserStorage::addParser() - ParserNames unknown for type"+toString((size_t)Ptype)+".");
-      ASSERT(ParserSuffixes.find(Ptype) != ParserSuffixes.end(),
-          "FormatParserStorage::addParser() - ParserSuffixes unknown for type"+toString((size_t)Ptype)+".");
-      LOG(2, "INFO: Parser " << ParserNames[Ptype] << " is already present." << std::endl
-          << "Note that you don't need to add '-o "
-          << ParserSuffixes[Ptype] << "' if the input file is non-empty and of type "
-          << ParserSuffixes[Ptype] << "." << std::endl);
+    }
+  }
-  template<ParserTypes Ptype> FormatParser<Ptype> &getParser()
+  {
-    if(!ParserPresent[Ptype])
-      addParser< Ptype >();
-    return dynamic_cast<FormatParser<Ptype> &>(*ParserList[Ptype]);
+  }
 };

src/Parser/FormatParser_Parameters.hpp

-              r360c8b
+              rfa9d1d
 #endif
-#include <iosfwd>
 #include "CodePatterns/Clone.hpp"
-#include "Parser/Parameters/ParameterStorage.hpp"
-class Parameter;
 /** This class is an interface to the internal parameters of any FormatParser.
 …
 class FormatParser_Parameters : public Clone<FormatParser_Parameters>
+{
-  //!> allow operator access to storage for easier printing.
-  friend std::ostream & operator << (std::ostream& ost, const FormatParser_Parameters &params);
 public:
+  FormatParser_Parameters();
+  FormatParser_Parameters(const FormatParser_Parameters &_parameters);
+  ~FormatParser_Parameters();
+  FormatParser_Parameters() {}
+  ~FormatParser_Parameters() {}
+  // cloning
+  FormatParser_Parameters* clone() const;
+  void makeClone(const FormatParser_Parameters &_instance);
+  // accessing parameters in storage
+  void appendParameter(Parameter *instance);
+  bool haveParameter(const std::string &_name) const;
+  Parameter *getParameter(const std::string &_name) const;
+protected:
+  ParameterStorage *storage;
+  /** Makes this instance a clone of given \a _instance.
+   *
+   * @param _instance instance to clone
+   */
+  virtual void makeClone(const FormatParser_Parameters & _instance)=0;
 };
-std::ostream & operator << (std::ostream& ost, const FormatParser_Parameters &params);
-std::istream & operator >> (std::istream& ist, FormatParser_Parameters &params);

src/Parser/Makefile.am

-              r360c8b
+              rfa9d1d
 PARSERSOURCE = \
   Parser/ChangeTracker.cpp \
+  Parser/FormatParser_common.cpp \
+  Parser/FormatParser_Parameters.cpp \
+  Parser/FormatParser.cpp \
   Parser/FormatParserStorage.cpp \
   Parser/MpqcParser.cpp \
   Parser/MpqcParser_Parameters.cpp \
   Parser/MpqcParser_Parameters_initBasis.cpp \
-  Parser/ParserTypes.cpp \
   Parser/PcpParser.cpp \
   Parser/PdbAtomInfoContainer.cpp \
   Parser/PdbParser.cpp \
-  Parser/Psi3Parser.cpp \
-  Parser/Psi3Parser_Parameters.cpp \
   Parser/TremoloParser.cpp \
   Parser/TremoloAtomInfoContainer.cpp \
 …
   Parser/ChangeTracker.hpp \
   Parser/FormatParser.hpp \
-  Parser/FormatParser_specializations_header.hpp \
-  Parser/FormatParser_common.hpp \
-  Parser/FormatParserInterface.hpp \
-  Parser/FormatParserTrait.hpp \
-  Parser/FormatParserTrait_specializations_header.hpp \
   Parser/FormatParser_Parameters.hpp \
   Parser/FormatParserStorage.hpp \
   Parser/MpqcParser.hpp \
   Parser/MpqcParser_Parameters.hpp \
-  Parser/ParserTypes.hpp \
-  Parser/ParserTypes.def \
-  Parser/ParserTypes.undef \
   Parser/PcpParser.hpp \
   Parser/PdbAtomInfoContainer.hpp \
   Parser/PdbKey.hpp \
   Parser/PdbParser.hpp \
-  Parser/Psi3Parser.hpp \
-  Parser/Psi3Parser_Parameters.hpp \
   Parser/TremoloKey.hpp \
   Parser/TremoloParser.hpp \
 …
   Parser/XyzParser.hpp
-PARSERPARAMETERSSOURCE = \
-        Parser/Parameters/ParameterStorage.cpp \
-        Parser/Parameters/StringParameter.cpp
-PARSERPARAMETERSHEADER = \
-        Parser/Parameters/ParameterStorage.hpp \
-        Parser/Parameters/ContinuousParameter.hpp \
-        Parser/Parameters/ContinuousParameter_impl.hpp \
-        Parser/Parameters/ContinuousValue.hpp \
-        Parser/Parameters/ContinuousValue_impl.hpp \
-        Parser/Parameters/DiscreteParameter.hpp \
-        Parser/Parameters/DiscreteParameter_impl.hpp \
-        Parser/Parameters/DiscreteValue.hpp \
-        Parser/Parameters/DiscreteValue_impl.hpp \
-        Parser/Parameters/Parameter.hpp \
-        Parser/Parameters/StringParameter.hpp \
-        Parser/Parameters/ValueInterface.hpp
 noinst_LTLIBRARIES += libMolecuilderParser.la
 libMolecuilderParser_la_includedir = $(includedir)/MoleCuilder/Parser/
 nobase_libMolecuilderParser_la_include_HEADERS = ${PARSERHEADER} ${PARSERPARAMETERSHEADER}
+nobase_libMolecuilderParser_la_include_HEADERS = ${PARSERHEADER}
 ## Define the source file list for the "libexample-@MOLECUILDER_API_VERSION@.la"
 …
 ## from each source file.  Note that it is not necessary to list header files
 ## which are already listed elsewhere in a _HEADERS variable assignment.
 libMolecuilderParser_la_SOURCES = ${PARSERSOURCE} ${PARSERPARAMETERSSOURCE}
+libMolecuilderParser_la_SOURCES = ${PARSERSOURCE}
 ## Instruct libtool to include ABI version information in the generated shared

src/Parser/MpqcParser.cpp

-              r360c8b
+              rfa9d1d
 #include "World.hpp"
-// declare specialized static variables
-const std::string FormatParserTrait<mpqc>::name = "mpqc";
-const std::string FormatParserTrait<mpqc>::suffix = "in";
-const ParserTypes FormatParserTrait<mpqc>::type = mpqc;
-// a converter we often need
-ConvertTo<bool> FormatParser<mpqc>::Converter;
 /** Constructor of MpqcParser.
+ *
  */
+FormatParser< mpqc >::FormatParser() :
+  FormatParser_common(new MpqcParser_Parameters())
+{}
+MpqcParser::MpqcParser()
+{
+  parameters = new MpqcParser_Parameters();
+}
 /** Destructor of MpqcParser.
+ *
  */
+FormatParser< mpqc >::~FormatParser()
+{}
+MpqcParser::~MpqcParser()
+{
+  delete parameters;
+}
 /** Load an MPQC config file into the World.
  * \param *file input stream
  */
 void FormatParser< mpqc >::load(istream *file)
+void MpqcParser::load(istream *file)
+{
   bool MpqcSection = false;
 …
         tokenizer::iterator tok_iter = tokens.begin();
         ASSERT(tok_iter != tokens.end(),
             "FormatParser< mpqc >::load() - missing token for MoleculeSection in line "+linestring+"!");
+            "MpqcParser::load() - missing token for MoleculeSection in line "+linestring+"!");
         std::stringstream whitespacefilter(*tok_iter++);
         std::string element;
         whitespacefilter >> ws >> element;
         ASSERT(tok_iter != tokens.end(),
             "FormatParser< mpqc >::load() - missing token for MoleculeSection in line "+linestring+"!");
+            "MpqcParser::load() - missing token for MoleculeSection in line "+linestring+"!");
         std::string vector = *tok_iter;
         tokenizer vectorcomponents(vector, whitesep);
 …
         ++tok_iter;
         ASSERT(tok_iter != tokens.end(),
             "FormatParser< mpqc >::load() - missing token in brackets<> for mole< in line "+linestring+"!");
+            "MpqcParser::load() - missing token in brackets<> for mole< in line "+linestring+"!");
         std::string value(*tok_iter);
         std::stringstream linestream("theory = "+value);
 …
         ++tok_iter;
         ASSERT(tok_iter != tokens.end(),
             "FormatParser< mpqc >::load() - missing token in brackets<> for integrals< in line "+linestring+"!");
+            "MpqcParser::load() - missing token in brackets<> for integrals< in line "+linestring+"!");
         std::string value(*tok_iter);
         std::stringstream linestream("integration = "+value);
 …
         tokenizer::iterator tok_iter = tokens.begin();
         ASSERT(tok_iter != tokens.end(),
             "FormatParser< mpqc >::load() - missing token before '=' for MpqcSection in line "+linestring+"!");
+            "MpqcParser::load() - missing token before '=' for MpqcSection in line "+linestring+"!");
         std::stringstream whitespacefilter(*tok_iter);
         std::string key;
         whitespacefilter >> ws >> key;
         if (getParams().haveParameter(key)) {
+        if (getParams().haveParam(key)) {
           std::stringstream linestream(linestring);
           linestream >> getParams();
 …
       tokenizer::iterator tok_iter = tokens.begin();
       ASSERT(tok_iter != tokens.end(),
           "FormatParser< mpqc >::load() - missing token for BasisSection in line "+linestring+"!");
+          "MpqcParser::load() - missing token for BasisSection in line "+linestring+"!");
       std::string key(*tok_iter++);
       ASSERT(tok_iter != tokens.end(),
           "FormatParser< mpqc >::load() - missing value for BasisSection after key "+key+" in line "+linestring+"!");
+          "MpqcParser::load() - missing value for BasisSection after key "+key+" in line "+linestring+"!");
       std::string value(*tok_iter);
       tok_iter++;
       // TODO: use exception instead of ASSERT
       ASSERT(tok_iter == tokens.end(),
           "FormatParser< mpqc >::load() - more than (key = value) on line "+linestring+".");
+          "MpqcParser::load() - more than (key = value) on line "+linestring+".");
       if (key == "name") {
         std::stringstream linestream("basis = "+value);
 …
       tokenizer::iterator tok_iter = tokens.begin();
       ASSERT(tok_iter != tokens.end(),
           "FormatParser< mpqc >::load() - missing token for AuxBasisSection in line "+linestring+"!");
+          "MpqcParser::load() - missing token for AuxBasisSection in line "+linestring+"!");
       std::string key(*tok_iter++);
       ASSERT(tok_iter != tokens.end(),
           "FormatParser< mpqc >::load() - missing value for BasisSection after key "+key+" in line "+linestring+"!");
+          "MpqcParser::load() - missing value for BasisSection after key "+key+" in line "+linestring+"!");
       std::string value(*tok_iter);
       tok_iter++;
       // TODO: use exception instead of ASSERT
       ASSERT(tok_iter == tokens.end(),
           "FormatParser< mpqc >::load() - more than (key = value) on line "+linestring+".");
+          "MpqcParser::load() - more than (key = value) on line "+linestring+".");
       if (key == "name") {
         std::stringstream linestream("aux_basis = "+value);
 …
  * \param atoms atoms to store
  */
 void FormatParser< mpqc >::save(ostream *file, const std::vector<atom *> &atoms)
+void MpqcParser::save(ostream *file, const std::vector<atom *> &atoms)
+{
   Vector center;
 …
     *file << "% Created by MoleCuilder" << endl;
     *file << "mpqc: (" << endl;
     *file << "\tsavestate = " << getParams().getParameter(MpqcParser_Parameters::savestateParam) << endl;
     *file << "\tdo_gradient = " << getParams().getParameter(MpqcParser_Parameters::do_gradientParam) << endl;
     if (Converter(getParams().getParameter(MpqcParser_Parameters::hessianParam))) {
+    *file << "\tsavestate = " << getParams().getString(MpqcParser_Parameters::savestateParam) << endl;
+    *file << "\tdo_gradient = " << getParams().getString(MpqcParser_Parameters::do_gradientParam) << endl;
+    if (getParams().getBool(MpqcParser_Parameters::hessianParam)) {
       *file << "\tfreq<MolecularFrequencies>: (" << endl;
       *file << "\t\tmolecule=$:molecule" << endl;
       *file << "\t)" << endl;
+    }
+    const std::string theory = getParams().getParameter(MpqcParser_Parameters::theoryParam);
+    if (theory == getParams().getTheoryName(MpqcParser_Parameters::CLHF)) {
+      *file << "\tmole<" << getParams().getParameter(MpqcParser_Parameters::theoryParam) << ">: (" << endl;
+      *file << "\t\tmolecule = $:molecule" << endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::basisParam) << " = $:basis" << endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::maxiterParam)
+          << " = " << getParams().getParameter(MpqcParser_Parameters::maxiterParam)<< endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::memoryParam)
+          << " = " << getParams().getParameter(MpqcParser_Parameters::memoryParam) << endl;
+      *file << "\t)" << endl;
+    } else if (theory == getParams().getTheoryName(MpqcParser_Parameters::CLKS)) {
+      *file << "\tmole<" << getParams().getParameter(MpqcParser_Parameters::theoryParam) << ">: (" << endl;
+      *file << "\t\tfunctional<StdDenFunctional>:(name=B3LYP)" << endl;
+      *file << "\t\tmolecule = $:molecule" << endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::basisParam) << " = $:basis" << endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::maxiterParam)
+          << " = " << getParams().getParameter(MpqcParser_Parameters::maxiterParam)<< endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::memoryParam)
+          << " = " << getParams().getParameter(MpqcParser_Parameters::memoryParam) << endl;
+      *file << "\t)" << endl;
+    } else if (theory == getParams().getTheoryName(MpqcParser_Parameters::MBPT2)) {
+      *file << "\tmole<" << getParams().getParameter(MpqcParser_Parameters::theoryParam) << ">: (" << endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::basisParam) << " = $:basis" << endl;
+      *file << "\t\tmolecule = $:molecule" << endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::memoryParam)
+          << " = " << getParams().getParameter(MpqcParser_Parameters::memoryParam) << endl;
+      *file << "\t\treference<CLHF>: (" << endl;
+      *file << "\t\t\t" << getParams().getParameterName(MpqcParser_Parameters::maxiterParam)
+          << " = " << getParams().getParameter(MpqcParser_Parameters::maxiterParam)<< endl;
+      *file << "\t\t\t" << getParams().getParameterName(MpqcParser_Parameters::basisParam) << " = $:basis" << endl;
+      *file << "\t\t\tmolecule = $:molecule" << endl;
+      *file << "\t\t\t" << getParams().getParameterName(MpqcParser_Parameters::memoryParam)
+          << " = " << getParams().getParameter(MpqcParser_Parameters::memoryParam) << endl;
+      *file << "\t\t)" << endl;
+      *file << "\t)" << endl;
+    } else if (theory == getParams().getTheoryName(MpqcParser_Parameters::MBPT2_R12)) {
+      *file << "\tmole<" << getParams().getParameter(MpqcParser_Parameters::theoryParam) << ">: (" << endl;
+      *file << "\t\tmolecule = $:molecule" << endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::basisParam) << " = $:basis" << endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::aux_basisParam) << " = $:abasis" << endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::stdapproxParam)
+          << " = \"" << getParams().getParameter(MpqcParser_Parameters::stdapproxParam) << "\"" << endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::nfzcParam)
+          << " = " << getParams().getParameter(MpqcParser_Parameters::nfzcParam) << endl;
+      *file << "\t\t" << getParams().getParameterName(MpqcParser_Parameters::memoryParam)
+          << " = " << getParams().getParameter(MpqcParser_Parameters::memoryParam) << endl;
+      *file << "\t\tintegrals<IntegralCints>:()" << endl;
+      *file << "\t\treference<CLHF>: (" << endl;
+      *file << "\t\t\tmolecule = $:molecule" << endl;
+      *file << "\t\t\t" << getParams().getParameterName(MpqcParser_Parameters::basisParam) << " = $:basis" << endl;
+      *file << "\t\t\tmaxiter = " << getParams().getParameter(MpqcParser_Parameters::maxiterParam) << endl;
+      *file << "\t\t\tmemory = " << getParams().getParameter(MpqcParser_Parameters::memoryParam) << endl;
+      *file << "\t\t\tintegrals<" << getParams().getParameter(MpqcParser_Parameters::integrationParam) << ">:()" << endl;
+      *file << "\t\t)" << endl;
+      *file << "\t)" << endl;
+    } else {
+      DoeLog(0) && (eLog() << Verbose(0)
+          << "Unknown level of theory requested for MPQC output file." << std::endl);
+    switch (getParams().getTheory()) {
+      case MpqcParser_Parameters::CLHF:
+        *file << "\tmole<" << getParams().getString(MpqcParser_Parameters::theoryParam) << ">: (" << endl;
+        *file << "\t\tmolecule = $:molecule" << endl;
+        *file << "\t\tbasis = $:basis" << endl;
+        *file << "\t\tmaxiter = " << toString(getParams().getInt(MpqcParser_Parameters::maxiterParam))<< endl;
+        *file << "\t\tmemory = " << toString(getParams().getInt(MpqcParser_Parameters::memoryParam)) << endl;
+        *file << "\t)" << endl;
+        break;
+      case MpqcParser_Parameters::CLKS:
+        *file << "\tmole<" << getParams().getString(MpqcParser_Parameters::theoryParam) << ">: (" << endl;
+        *file << "\t\tfunctional<StdDenFunctional>:(name=B3LYP)" << endl;
+        *file << "\t\tmolecule = $:molecule" << endl;
+        *file << "\t\tbasis = $:basis" << endl;
+        *file << "\t\tmaxiter = " << toString(getParams().getInt(MpqcParser_Parameters::maxiterParam))<< endl;
+        *file << "\t\tmemory = " << toString(getParams().getInt(MpqcParser_Parameters::memoryParam)) << endl;
+        *file << "\t)" << endl;
+        break;
+      case MpqcParser_Parameters::MBPT2:
+        *file << "\tmole<" << getParams().getString(MpqcParser_Parameters::theoryParam) << ">: (" << endl;
+        *file << "\t\tbasis = $:basis" << endl;
+        *file << "\t\tmolecule = $:molecule" << endl;
+        *file << "\t\tmemory = " << toString(getParams().getInt(MpqcParser_Parameters::memoryParam)) << endl;
+        *file << "\t\treference<CLHF>: (" << endl;
+        *file << "\t\t\tmaxiter = " << toString(getParams().getInt(MpqcParser_Parameters::maxiterParam))<< endl;
+        *file << "\t\t\tbasis = $:basis" << endl;
+        *file << "\t\t\tmolecule = $:molecule" << endl;
+        *file << "\t\t\tmemory = " << toString(getParams().getInt(MpqcParser_Parameters::memoryParam)) << endl;
+        *file << "\t\t)" << endl;
+        *file << "\t)" << endl;
+        break;
+      case MpqcParser_Parameters::MBPT2_R12:
+        *file << "\tmole<" << getParams().getString(MpqcParser_Parameters::theoryParam) << ">: (" << endl;
+        *file << "\t\tmolecule = $:molecule" << endl;
+        *file << "\t\tbasis = $:basis" << endl;
+        *file << "\t\taux_basis = $:abasis" << endl;
+        *file << "\t\tstdapprox = \"" << getParams().getString(MpqcParser_Parameters::stdapproxParam) << "\"" << endl;
+        *file << "\t\tnfzc = " << toString(getParams().getInt(MpqcParser_Parameters::nfzcParam)) << endl;
+        *file << "\t\tmemory = " << toString(getParams().getInt(MpqcParser_Parameters::memoryParam)) << endl;
+        *file << "\t\tintegrals<IntegralCints>:()" << endl;
+        *file << "\t\treference<CLHF>: (" << endl;
+        *file << "\t\t\tmolecule = $:molecule" << endl;
+        *file << "\t\t\tbasis = $:basis" << endl;
+        *file << "\t\t\tmaxiter = " << toString(getParams().getInt(MpqcParser_Parameters::maxiterParam)) << endl;
+        *file << "\t\t\tmemory = " << toString(getParams().getInt(MpqcParser_Parameters::memoryParam)) << endl;
+        *file << "\t\t\tintegrals<" << getParams().getString(MpqcParser_Parameters::integrationParam) << ">:()" << endl;
+        *file << "\t\t)" << endl;
+        *file << "\t)" << endl;
+        break;
+      default:
+        DoeLog(0) && (eLog() << Verbose(0)
+            << "Unknown level of theory requested for MPQC output file." << std::endl);
+        break;
+    }
     *file << ")" << endl;
 …
     *file << ")" << endl;
     *file << "basis<GaussianBasisSet>: (" << endl;
     *file << "\tname = \"" << getParams().getParameter(MpqcParser_Parameters::basisParam) << "\"" << endl;
+    *file << "\tname = \"" << getParams().getString(MpqcParser_Parameters::basisParam) << "\"" << endl;
     *file << "\tmolecule = $:molecule" << endl;
     *file << ")" << endl;
     if (theory == getParams().getTheoryName(MpqcParser_Parameters::MBPT2_R12)) {
+    if (getParams().getTheory() == MpqcParser_Parameters::MBPT2_R12) {
       *file << "% auxiliary basis set specification" << endl;
       *file << "\tabasis<GaussianBasisSet>: (" << endl;
       *file << "\tname = \"" << getParams().getParameter(MpqcParser_Parameters::aux_basisParam) << "\"" << endl;
+      *file << "\tname = \"" << getParams().getString(MpqcParser_Parameters::aux_basisParam) << "\"" << endl;
       *file << "\tmolecule = $:molecule" << endl;
       *file << ")" << endl;

src/Parser/MpqcParser.hpp

-              r360c8b
+              rfa9d1d
 #endif
-#include "CodePatterns/toString.hpp"
 #include "FormatParser.hpp"
-#include "FormatParserTrait.hpp"
-#include "FormatParserInterface.hpp"
-#include "FormatParser_common.hpp"
-#include "ParserTypes.hpp"
 #include "MpqcParser_Parameters.hpp"
 #include <iosfwd>
-// declaration of specialized FormatParserTrait
-template<>
-struct FormatParserTrait<mpqc>
+{
-  //!> Name of the parser
-  static const std::string name;
-  //!> suffix of the files the parser understands to read and write
-  static const std::string suffix;
-  //!> ParserTypes enumeration for the parser
-  static const enum ParserTypes type;
-};
 /**
  * Loads a MPQC config file into the World and saves the World as a tremolo file.
  */
+template <>
+class FormatParser< mpqc >  : virtual public FormatParserInterface, public FormatParser_common
+class MpqcParser : public FormatParser
+{
   friend class ParserMpqcUnitTest;
 public:
-  FormatParser();
-  virtual ~FormatParser();
+  void load(std::istream *file);
+  void save(std::ostream *file, const std::vector<atom *> &atoms);
+  MpqcParser();
+  virtual ~MpqcParser();
+  void load(std::istream* file);
+  void save(std::ostream* file, const std::vector<atom *> &atoms);
   /** Getter for parameter set.
 …
    */
   MpqcParser_Parameters & getParams() { return *static_cast<MpqcParser_Parameters *>(parameters); }
-private:
-  static ConvertTo<bool> Converter;
 };

src/Parser/MpqcParser_Parameters.cpp

-              r360c8b
+              rfa9d1d
 #endif
+#include <iostream>
+#include <boost/tokenizer.hpp>
+#include <string>
 #include "CodePatterns/MemDebug.hpp"
-#include <string>
 #include "CodePatterns/Log.hpp"
+#include "CodePatterns/Verbose.hpp"
 #include "MpqcParser.hpp"
 #include "MpqcParser_Parameters.hpp"
+#include "Parser/Parameters/ContinuousParameter.hpp"
+#include "Parser/Parameters/DiscreteParameter.hpp"
+#include "Parser/Parameters/StringParameter.hpp"
+template <>
+const std::string ContinuousValue<bool>::get() const
+{
+  ASSERT(ValueSet,
+      "ContinuousValue<bool>::get() - requesting unset value.");
+  if (value)
+    return std::string("yes");
+  else
+    return std::string("no");
+}
+template <>
+void ContinuousValue<bool>::set(const std::string _value)
+{
+  if (_value == std::string("yes")) {
+    setValue(true);
+  } else if (_value == std::string("no")) {
+    setValue(false);
+  } else {
+    ASSERT(0,
+        "void ContinuousValue<bool>::set() - value "+_value+" is neither yes or no.");
+  }
+}
+using boost::any_cast;
 MpqcParser_Parameters::MpqcParser_Parameters()
 …
   initBasis();
+  // add all parameter names
+  // add all theory names
+  TheoryNames[CLHF]="CLHF";
+  TheoryNames[CLKS]="CLKS";
+  TheoryNames[MBPT2]="MBPT2";
+  TheoryNames[MBPT2_R12]="MBPT2_R12";
+  {
     ParamNames.clear();
     ParamNames.resize(unknownParam);
     ParamNames[hessianParam] = "Hessian";
     ParamNames[savestateParam] = "savestate";
     ParamNames[do_gradientParam] = "do_gradient";
     ParamNames[maxiterParam] = "maxiter";
     ParamNames[memoryParam] = "memory";
     ParamNames[stdapproxParam] = "stdapprox";
     ParamNames[nfzcParam] = "nfzc";
     ParamNames[basisParam] = "basis";
     ParamNames[aux_basisParam] = "aux_basis";
     ParamNames[integrationParam] = "integration";
     ParamNames[theoryParam] = "theory";
+  }
   // create theory parameter
+    // TODO: throw exception instead of eLog()
+    std::pair<TheoryLookupType::iterator, bool> inserter;
+    for (TheoryNamesType::iterator iter = TheoryNames.begin();
+        iter != TheoryNames.end();
+        ++iter) {
+      inserter = TheoryLookup.insert( make_pair(iter->second, iter->first) );
+      if (!inserter.second)
+        DoeLog(0) && (eLog() << Verbose(0)
+            << "MpqcParser_Parameters::MpqcParser_Parameters() - Theory name already present: "
+            << (inserter.first)->second << " and " << iter->first << "!"
+            << std::endl);
+    }
+  }
+  // add all integration names
+  IntegrationNames[IntegralCints] = "IntegralCints";
+  {
+    ValidTheories.clear();
+    ValidTheories.resize(unknownTheory);
+    ValidTheories[CLHF]="CLHF";
+    ValidTheories[CLKS]="CLKS";
+    ValidTheories[MBPT2]="MBPT2";
+    ValidTheories[MBPT2_R12]="MBPT2_R12";
+    appendParameter(
+        new DiscreteParameter<std::string>(
+            ParamNames[theoryParam],
+            ValidTheories,
+            ValidTheories[MBPT2]));
+  }
+  //InvertMap<TheoryNamesType,TheoryLookupType>(TheoryNames,TheoryLookup);
+  // create integration parameter
+    // TODO: throw exception instead of eLog()
+    std::pair<IntegrationLookupType::iterator, bool> inserter;
+    for (IntegrationNamesType::iterator iter = IntegrationNames.begin();
+        iter != IntegrationNames.end();
+        ++iter) {
+      inserter = IntegrationLookup.insert( make_pair(iter->second, iter->first) );
+      if (!inserter.second)
+        DoeLog(0) && (eLog() << Verbose(0)
+            << "MpqcParser_Parameters::MpqcParser_Parameters() - Integration name already present: "
+            << (inserter.first)->second << " and " << iter->first << "!"
+            << std::endl);
+    }
+  }
+  // have names for all parmaters
+  ParamNames[hessianParam] = "Hessian";
+  ParamNames[savestateParam] = "savestate";
+  ParamNames[do_gradientParam] = "do_gradient";
+  ParamNames[maxiterParam] = "maxiter";
+  ParamNames[memoryParam] = "memory";
+  ParamNames[stdapproxParam] = "stdapprox";
+  ParamNames[nfzcParam] = "nfzc";
+  ParamNames[basisParam] = "basis";
+  ParamNames[aux_basisParam] = "aux_basis";
+  ParamNames[integrationParam] = "integration";
+  ParamNames[theoryParam] = "theory";
+  {
+    ValidIntegrationMethods.clear();
+    ValidIntegrationMethods.resize(unknownIntegration);
+    ValidIntegrationMethods[IntegralCints] = "IntegralCints";
+    appendParameter(
+        new DiscreteParameter<std::string>(
+            ParamNames[integrationParam],
+            ValidIntegrationMethods,
+            ValidIntegrationMethods[IntegralCints]));
+  }
+  // add all continuous parameters
+  {
+    appendParameter(new ContinuousParameter<bool>(ParamNames[hessianParam], false));
+    appendParameter(new ContinuousParameter<bool>(ParamNames[savestateParam], false));
+    appendParameter(new ContinuousParameter<bool>(ParamNames[do_gradientParam], true));
+    appendParameter(new ContinuousParameter<int>(ParamNames[maxiterParam], 1000));
+    appendParameter(new ContinuousParameter<int>(ParamNames[memoryParam], 16000000));
+    appendParameter(new StringParameter(ParamNames[stdapproxParam], "A'"));
+    appendParameter(new ContinuousParameter<int>(ParamNames[nfzcParam], 1));
+    appendParameter(new StringParameter(ParamNames[basisParam], "3-21G"));
+    appendParameter(new StringParameter(ParamNames[aux_basisParam], "aug-cc-pVDZ"));
+  }
+    // TODO: throw exception instead of eLog()
+    std::pair<ParamLookupType::iterator, bool> inserter;
+    for (ParamNamesType::iterator iter = ParamNames.begin();
+        iter != ParamNames.end();
+        ++iter) {
+      inserter = ParamLookup.insert( make_pair(iter->second, iter->first) );
+      if (!inserter.second)
+        DoeLog(0) && (eLog() << Verbose(0)
+            << "MpqcParser_Parameters::MpqcParser_Parameters() - parameter name already present: "
+            << (inserter.first)->second << " and " << iter->first << "!"
+            << std::endl);
+    }
+  }
+  initParameters();
+}
+MpqcParser_Parameters::MpqcParser_Parameters(const MpqcParser_Parameters & state)
+{
+  // init
+  Init();
+  // copy values
+  copyParameters(state);
+}
+void MpqcParser_Parameters::copyParameters(const MpqcParser_Parameters & state)
+{
+  appendParameter(hessianParam, state.getBool(hessianParam));
+  appendParameter(savestateParam, state.getBool(savestateParam));
+  appendParameter(do_gradientParam, state.getBool(do_gradientParam));
+  appendParameter(maxiterParam, state.getInt(maxiterParam));
+  appendParameter(memoryParam, state.getInt(memoryParam));
+  appendParameter(stdapproxParam, state.getString(stdapproxParam));
+  appendParameter(nfzcParam, state.getInt(nfzcParam));
+  appendParameter(basisParam, state.getString(basisParam));
+  appendParameter(aux_basisParam, state.getString(aux_basisParam));
+  appendParameter(integrationParam, state.getIntegration());
+  appendParameter(theoryParam, state.getTheory());
+}
+FormatParser_Parameters* MpqcParser_Parameters::clone() const
+{
+  //LOG(3, "Cloning parameters.");
+  MpqcParser_Parameters *instance = new MpqcParser_Parameters(*this);
+  return instance;
+}
+void MpqcParser_Parameters::makeClone(const FormatParser_Parameters & _state)
+{
+  //LOG(3, "Cloning parameters from other instance.");
+  copyParameters(static_cast<const MpqcParser_Parameters &>(_state));
+}
+void MpqcParser_Parameters::initParameters()
+{
+        appendParameter(hessianParam, bool(false));
+        appendParameter(savestateParam, bool(false));
+        appendParameter(do_gradientParam, bool(true));
+        appendParameter(maxiterParam, int(1000));
+        appendParameter(memoryParam, int(16000000));
+        appendParameter(stdapproxParam, std::string("A'"));
+        appendParameter(nfzcParam, int(1));
+        appendParameter(basisParam, std::string("3-21G"));
+        appendParameter(aux_basisParam, std::string("aug-cc-pVDZ"));
+        appendParameter(integrationParam, IntegralCints);
+        appendParameter(theoryParam, MBPT2);
+}
 …
 {}
+/** Getter for a specific Parameter.
+std::ostream & operator << (std::ostream& ost, MpqcParser_Parameters const &_mpqc_params)
+{
+  // this is ugly, but with boost::any to safeguard const-ness is plain impossible
+  MpqcParser_Parameters &mpqc_params = const_cast<MpqcParser_Parameters &>(_mpqc_params);
+  std::ostringstream output;
+  output << "Hessian=" << mpqc_params.getBool(MpqcParser_Parameters::hessianParam) << ";";
+  output << "savestate=" << mpqc_params.getBool(MpqcParser_Parameters::savestateParam) << ";";
+  output << "do_gradient=" << mpqc_params.getBool(MpqcParser_Parameters::do_gradientParam) << ";";
+  output << "maxiter=" << mpqc_params.getInt(MpqcParser_Parameters::maxiterParam) << ";";
+  output << "memory=" << mpqc_params.getInt(MpqcParser_Parameters::memoryParam) << ";";
+  output << "stdapprox=" << mpqc_params.getString(MpqcParser_Parameters::stdapproxParam) << ";";
+  output << "nfzc=" << mpqc_params.getInt(MpqcParser_Parameters::nfzcParam) << ";";
+  output << "basis=" << mpqc_params.getString(MpqcParser_Parameters::basisParam) << ";";
+  output << "aux_basis=" << mpqc_params.getString(MpqcParser_Parameters::aux_basisParam) << ";";
+  output << "integration=" << mpqc_params.getString(MpqcParser_Parameters::integrationParam) << ";";
+  output << "theory=" << mpqc_params.getString(MpqcParser_Parameters::theoryParam) << ";";
+  ost << output.str();
+  return ost;
+}
+std::istream & operator >> (std::istream& ist, MpqcParser_Parameters &params)
+{
+  typedef boost::tokenizer<boost::char_separator<char> >
+      tokenizer;
+  boost::char_separator<char> semicolonsep(";");
+  boost::char_separator<char> equalitysep(" =");
+  boost::char_separator<char> ticksep("\"");
+  std::string line;
+  std::getline( ist, line );
+  //DoLog(0) && (Log() << Verbose(0) << "INFO: full line of parameters is '" << line << "'" << std::endl);
+  tokenizer tokens(line, semicolonsep);
+  ASSERT(tokens.begin() != tokens.end(),
+      "operator<< on MpqcParser_Parameters - empty string, need at least ';' in line "+line+"!");
+  for (tokenizer::iterator tok_iter = tokens.begin();
+        tok_iter != tokens.end(); ++tok_iter) {
+    tokenizer paramtokens(*tok_iter, equalitysep);
+    if (paramtokens.begin() != paramtokens.end()) {
+      tokenizer::iterator tok_paramiter = paramtokens.begin();
+      tokenizer::iterator tok_valueiter = tok_paramiter;
+      tokenizer::iterator tok_checkiter = ++tok_valueiter;
+      ++tok_checkiter;
+      // TODO: throw exception instead of ASSERT
+      ASSERT(tok_paramiter != paramtokens.end(),
+          "operator<< on MpqcParser_Parameters - missing value before ' =' in token "+*tok_iter+"!");
+      ASSERT(tok_valueiter != paramtokens.end(),
+          "operator<< on MpqcParser_Parameters - missing value after ' =' in token "+*tok_iter+"!");
+      ASSERT(tok_checkiter == paramtokens.end(),
+          "operator<< on MpqcParser_Parameters - still more tokens after ' =' in token "+*tok_iter+":"
+          +*tok_checkiter+"!");
+      std::stringstream keystream(*tok_paramiter);
+      std::string key;
+      keystream >> ws >> key;
+      tokenizer ticklesstokens(*tok_valueiter, ticksep);
+      ASSERT(ticklesstokens.begin() != ticklesstokens.end(),
+          "operator<< on MpqcParser_Parameters - no tokens present after removing ticks in token "+*tok_valueiter+"!");
+      std::stringstream valuestream(*(ticklesstokens.begin()));
+      DoLog(2) && (Log() << Verbose(2)
+          << "INFO: Token pair is " << key << "," << valuestream.str() << std::endl);
+      // TODO: throw exception instead of DoeLog()
+      ASSERT(params.haveParam(key),
+          "operator >> on MpqcParser_Parameters - unknown parameter name '"
+          +key+"' with value "+valuestream.str()+"!");
+      if (params.haveParam(key))
+        params.setter(params.getParam(key), valuestream);
+    } else {
+      ist.setstate(std::ios::eofbit);
+    }
+  }
+  return ist;
+}
+/** Sets a desired value in the params from a string.
+ *
+ * @param param index among enum Parameters
+ * @return value of the desired Parameters
+ * This is due to strict typing of C++ very ugly and boost::any does not make
+ * it any better because it offers to functions to use values directly from
+ * stringstream. Probably, because value is unknown to is as well and hence
+ * the author could not implement it beautifully, so he dropped it altogether.
+ * Grrr ....
+ *
+ * @param _param param to set
+ * @param _desired stringstream containing value as next argument
+ * @return true - type ok, false - unknown type in params.
  */
+const std::string MpqcParser_Parameters::getParameter(const enum Parameters param) const
+{
+  return FormatParser_Parameters::getParameter(ParamNames[param])->get();
+}
+/** Setter for a specific Parameter.
+ *
+ * @param param index among enum Parameters
+ * @param _value value to set desired Parameter to
+ */
+void MpqcParser_Parameters::setParameter(const enum Parameters param, const std::string &_value)
+{
+  const std::string &name = getParameterName(param);
+  FormatParser_Parameters::getParameter(name)->set(_value);
+}
+/** Getter for name of a specific Parameter.
+ *
+ * @param param index among enum Parameters
+ * @return name of the desired Parameter
+ */
+const std::string &MpqcParser_Parameters::getParameterName(const enum Parameters param) const
+{
+  return ParamNames[param];
+}
+/** Getter for name of a specific Parameter.
+ *
+ * @param param index among enum Theory
+ * @return name of the desired Theory
+ */
+const std::string &MpqcParser_Parameters::getTheoryName(const enum Theory theory) const
+{
+  return ValidTheories[theory];
+}
+/** Getter for the name of specific of IntegrationMethod.
+ *
+ * @param param index among enum IntegrationMethod
+ * @return value of the desired IntegrationMethod
+ */
+const std::string &MpqcParser_Parameters::getIntegrationMethodName(const enum IntegrationMethod integration) const
+{
+  return ValidIntegrationMethods[integration];
+}
+bool MpqcParser_Parameters::setter(enum Parameters _param, std::stringstream& _desired) {
+  if (_param == integrationParam) {
+     std::string tmp;
+    _desired >> tmp;
+    params[_param] = IntegrationLookup[tmp];
+  } else if(_param == theoryParam) {
+    std::string tmp;
+    _desired >> tmp;
+    params[_param] = TheoryLookup[tmp];
+  } else if (params[_param].type() == typeid(std::string)) {
+    std::string tmp;
+    _desired >> tmp;
+    params[_param] = tmp;
+  } else if (params[_param].type() ==  typeid(int)) {
+    int tmp;
+    _desired >> tmp;
+    params[_param] = tmp;
+  } else if (params[_param].type() == typeid(double)) {
+    double tmp;
+    _desired >> tmp;
+    params[_param] = tmp;
+  } else if (params[_param].type() == typeid(bool)) {
+    std::string tmp;
+    _desired >> tmp;
+    if ((tmp == "yes") || (tmp == "1")) {
+      params[_param] = bool(true);
+    } else if ((tmp == "no") || (tmp == "0")) {
+      params[_param] = bool(false);
+    } else {
+      DoeLog(0) && (eLog() << Verbose(0)
+          << "MpqcParser_Parameters::setter() - unknown boolean key "
+          << tmp << "!" << std::endl);
+    }
+  } else {
+    DoeLog(0) && (eLog() << Verbose(0)
+        << "MpqcParser_Parameters::setter() - unknown type!" << std::endl);
+    return false;
+  }
+  return true;
+}
+void MpqcParser_Parameters::setTheory(enum Theory _theory)
+{
+  // TODO: throw exception instead of eLog()
+//  try {
+    params[theoryParam] = _theory;
+//  } catch(const boost::bad_any_cast &) {
+//    DoeLog(0) && (eLog() << Verbose(0)
+//        << "MpqcParser_Parameters::setTheory() - could not set boolean!" << std::endl);
+//  }
+}
+void MpqcParser_Parameters::setIntegration(enum MpqcParser_Parameters::IntegrationMethod _integration){
+  // TODO: throw exception instead of eLog()
+//  try {
+    params[integrationParam] = _integration;
+//  } catch(const boost::bad_any_cast &) {
+//    DoeLog(0) && (eLog() << Verbose(0)
+//        << "MpqcParser_Parameters::setIntegration() - could not set boolean!" << std::endl);
+//  }
+}
+bool MpqcParser_Parameters::haveParam(std::string _name) const
+{
+  return ParamLookup.count(_name) != 0;
+}
+enum MpqcParser_Parameters::Parameters MpqcParser_Parameters::getParam(std::string _name) const
+{
+  ParamLookupType::const_iterator iter = ParamLookup.find(_name);
+  return iter->second;
+}
+enum MpqcParser_Parameters::IntegrationMethod MpqcParser_Parameters::getIntegration() const
+{
+  parameterlist::const_iterator iter = params.find(integrationParam);
+  enum IntegrationMethod value;
+  // TODO: throw exception instead of eLog()
+//  try {
+    value = boost::any_cast<enum IntegrationMethod>(iter->second);
+//  } catch(const boost::bad_any_cast &) {
+//    DoeLog(0) && (eLog() << Verbose(0)
+//        << "MpqcParser_Parameters::getIntegration() - could not convert "
+//        +ParamNames[integrationParam]+" to enum IntegrationMethod!" << std::endl);
+//  }
+  return value;
+}
+enum MpqcParser_Parameters::Theory MpqcParser_Parameters::getTheory() const
+{
+  parameterlist::const_iterator iter = params.find(theoryParam);
+  enum Theory value;
+  // TODO: throw exception instead of eLog()
+//  try {
+    value = boost::any_cast<enum Theory>(iter->second);
+//  } catch(const boost::bad_any_cast &) {
+//    DoeLog(0) && (eLog() << Verbose(0)
+//        << "MpqcParser_Parameters::getTheory() - could not convert "
+//        +ParamNames[theoryParam]+" to enum Theory!" << std::endl);
+//  }
+  return value;
+}
+std::string MpqcParser_Parameters::getString(enum Parameters _param) const
+{
+  std::string value;
+  enum IntegrationMethod Iindex;
+  enum Theory Tindex;
+  bool test;
+  parameterlist::const_iterator iter = params.find(_param);
+  switch (_param) {
+    case hessianParam:
+    case savestateParam:
+    case do_gradientParam:
+      test = boost::any_cast<bool>(iter->second);
+      if (test)
+        value = "yes";
+      else
+        value = "no";
+      break;
+    case integrationParam:
+      // TODO: throw exception instead of eLog()
+//      try {
+        Iindex = boost::any_cast<enum IntegrationMethod>(iter->second);
+//      } catch(const boost::bad_any_cast &) {
+//        DoeLog(0) && (eLog() << Verbose(0)
+//            << "MpqcParser_Parameters::getString() - could not convert "
+//            +ParamNames[_param]+" to string!" << std::endl);
+//      }
+      {
+        IntegrationNamesType::const_iterator Iiter = IntegrationNames.find(Iindex);
+        value = Iiter->second;
+      }
+      break;
+    case theoryParam:
+      // TODO: throw exception instead of eLog()
+//      try {
+        Tindex = boost::any_cast<enum Theory>(iter->second);
+//      } catch(const boost::bad_any_cast &) {
+//        DoeLog(0) && (eLog() << Verbose(0)
+//            << "MpqcParser_Parameters::getString() - could not convert "
+//            +ParamNames[_param]+" to string!" << std::endl);
+//      }
+        {
+          TheoryNamesType::const_iterator Titer = TheoryNames.find(Tindex);
+          value = Titer->second;
+        }
+      break;
+    default:
+      // TODO: throw exception instead of eLog()
+//      try {
+        value = boost::any_cast<std::string>(iter->second);
+//      } catch(const boost::bad_any_cast &) {
+//        DoeLog(0) && (eLog() << Verbose(0)
+//            << "MpqcParser_Parameters::getString() - could not convert "
+//            +ParamNames[_param]+" to string!" << std::endl);
+//      }
+      break;
+  }
+  return value;
+}
+int MpqcParser_Parameters::getInt(enum Parameters _param) const
+{
+  int value;
+  parameterlist::const_iterator iter = params.find(_param);
+  switch (_param) {
+    default:
+      // TODO: throw exception instead of eLog()
+//      try {
+        value = boost::any_cast<int>(iter->second);
+//      } catch(const boost::bad_any_cast &) {
+//        DoeLog(0) && (eLog() << Verbose(0)
+//            << "MpqcParser_Parameters::getInt() - could not convert "
+//            +ParamNames[_param]+" to int!" << std::endl);
+//      }
+      break;
+  }
+  return value;
+}
+double MpqcParser_Parameters::getDouble(enum Parameters _param) const
+{
+  double value;
+  parameterlist::const_iterator iter = params.find(_param);
+  // TODO: throw exception instead of eLog()
+//  try {
+    value = boost::any_cast<double>(iter->second);
+//  } catch(const boost::bad_any_cast &) {
+//    DoeLog(0) && (eLog() << Verbose(0)
+//        << "MpqcParser_Parameters::getDouble() - could not convert "
+//        +ParamNames[_param]+" to double!" << std::endl);
+//  }
+  return value;
+}
+bool MpqcParser_Parameters::getBool(enum Parameters _param) const
+{
+  bool value;
+  parameterlist::const_iterator iter = params.find(_param);
+  // TODO: throw exception instead of eLog()
+//  try {
+    value = boost::any_cast<bool>(iter->second);
+//  } catch(const boost::bad_any_cast &) {
+//    DoeLog(0) && (eLog() << Verbose(0)
+//        << "MpqcParser_Parameters::getBool() - could not convert "
+//        +ParamNames[_param]+" to bool!" << std::endl);
+//  }
+  return value;
+}
 /** Checks whether all elements in the world also have parameters in the basis.

src/Parser/MpqcParser_Parameters.hpp

-              r360c8b
+              rfa9d1d
 #endif
+#include <iosfwd>
 #include <list>
 #include <map>
+#include <typeinfo>
 #include <vector>
 #include "CodePatterns/Clone.hpp"
 #include "CodePatterns/Log.hpp"
+#include "CodePatterns/Verbose.hpp"
+#include <boost/any.hpp>
 #include "Parser/FormatParser_Parameters.hpp"
-#include "Parser/Parameters/ContinuousParameter.hpp"
-// specialization for bool (we want "yes/no" not "1/0")
-template <> const std::string ContinuousValue<bool>::get() const;
-template <> void ContinuousValue<bool>::set(const std::string _value);
 class MpqcParser;
 …
   MpqcParser_Parameters();
+  /** Copy Constructor of MpqcParser_Parameters.
+   *
+   * @param state ref to instance to copy
+   */
+  MpqcParser_Parameters(const MpqcParser_Parameters & state);
   /** Destructor of MpqcParser_Parameters.
+   *
    */
   virtual ~MpqcParser_Parameters();
+  /** Enumeration of all known theories.
+   *
+   */
+  enum Theory {
+    CLHF,       //!< Closed Shell Hartree-Fock equations
+    CLKS,       //!< Closed Shell Kohn-Sham equations
+    MBPT2,      //!< Moeller Plesset Perturbation Theory second order
+    MBPT2_R12,  //!< Moeller Plesset Perturbation Theory second order with R12 integral
+    unknownTheory //!< designates an unknown theory
+  };
+  /** Enumeration of all known integration methods
+   *
+   */
+  enum IntegrationMethod {
+    IntegralCints,  //!< Integration method Cints in MBPT2 R12?
+    unknownIntegration //!< designates unknown integration method
+  };
   /** Enumeration of all known Parameters to allow placing them in vectors, maps.
 …
     unknownParam};   //!< unknownParam, designates an unknown parameter
+  /** Enumeration of all known theories.
+   *
+   */
+  enum Theory {
+    CLHF,       //!< Closed Shell Hartree-Fock equations
+    CLKS,       //!< Closed Shell Kohn-Sham equations
+    MBPT2,      //!< Moeller Plesset Perturbation Theory second order
+    MBPT2_R12,  //!< Moeller Plesset Perturbation Theory second order with R12 integral
+    unknownTheory //!< designates an unknown theory
+  };
+  /** Enumeration of all known integration methods
+   *
+   */
+  enum IntegrationMethod {
+    IntegralCints,  //!< Integration method Cints in MBPT2 R12?
+    unknownIntegration //!< designates unknown integration method
+  };
+  // enum to string getters
+  const std::string getParameter(const enum Parameters param) const;
+  void setParameter(const enum Parameters param, const std::string &);
+  const std::string &getParameterName(const enum Parameters param) const;
+  const std::string &getTheoryName(const enum Theory theory) const;
+  const std::string &getIntegrationMethodName(const enum IntegrationMethod integration) const;
+  bool checkWorldElementsAgainstCurrentBasis() const;
+  /** Sets the desired level of solving theory to use.
+   *
+   * \param _theory shorthand of the theory
+   */
+  void setTheory(enum Theory _theory);
+  /** Sets the desired level of solving integration to use.
+   *
+   * \param _integration shorthand of the integration
+   */
+  void setIntegration(enum IntegrationMethod _integration);
+  /** Getter for integration method in params.
+   *
+   * @return enumeration index of IntegrationMethod.
+   */
+  enum IntegrationMethod getIntegration() const;
+  /** Getter for current Theory in params.
+   *
+   * @return enumeration index of Theory
+   */
+  enum Theory getTheory() const;
+  /** Getter for a parameter in params as a string.
+   *
+   * @param _param enumeration index of desired Parameter
+   * @return string value
+   */
+  std::string getString(enum Parameters _param) const;
+  /** Getter for integer value of desired Parameter in params.
+   *
+   * Only if type in params matches int!
+   *
+   * @param _param enumeration index in Parameter
+   * @return integer value of parameter
+   */
+  int getInt(enum Parameters _param) const;
+  /** Getter for double value of desired Parameter in params.
+   *
+   * Only if type in params matches double!
+   *
+   * @param _param enumeration index in Parameter
+   * @return double value of parameter
+   */
+  double getDouble(enum Parameters _param) const;
+  /** Getter for bool value of desired Parameter in params.
+   *
+   * Only if type in params matches bool!
+   *
+   * @param _param enumeration index in Parameter
+   * @return bool value of parameter
+   */
+  bool getBool(enum Parameters _param) const;
+  /** Setter for a desired value of its type is known.
+   *
+   * We check whether given type matches present type in params.
+   *
+   * @param _param enumeration index of Parameter
+   * @param _desired desired value to set to
+   * @return true - type match, value set, false - type mismatch
+   */
+  template <class T> bool setter(enum Parameters _param, T _desired) {
+    if (typeid(T) == params[_param].type()) {
+      params[_param] = _desired;
+      return true;
+    } else
+      return false;
+  }
+  /** Sets a desired value in the params from a string.
+   *
+   * This is due to strict typing of C++ very ugly and boost::any does not make
+   * it any better because it offers to functions to use values directly from
+   * stringstream. Probably, because value is unknown to is as well and hence
+   * the author could not implement it beautifully, so he dropped it altogether.
+   * Grrr ....
+   *
+   * @param _param param to set
+   * @param _desired stringstream containing value as next argument
+   * @return true - type ok, false - unknown type in params.
+   */
+  bool setter(enum Parameters _param, std::stringstream& _desired);
+  /** Grants access to ParamLookup.
+   *
+   *  Does not check for unknown parameter.
+   *
+   * @param _name name of parameter
+   * @return enumeration index of Parameters
+   */
+  enum Parameters getParam(std::string _name) const;
+  /** Checker whether parameter with name is known.
+   *
+   * @param _name
+   * @return true - parameter known, false - parameter unknown
+   */
+  bool haveParam(std::string _name) const;
+  /** Creates a clone of the class.
+   *
+   * @return
+   */
+  FormatParser_Parameters* clone() const;
+  /** Applies a before returned undo state.
+   *
+   * @param undo state to set
+   */
+  void makeClone(const FormatParser_Parameters & _state);
+  /** Set the internal parameters to the one's from the given \a state.
+   *
+   * @param state set of parameters
+   */
+  void copyParameters(const MpqcParser_Parameters & state);
 private:
-  //!> vector with all available theories in same order as enum Theory.
-  std::vector<std::string> ValidTheories;
-  //!> vector with all available integration methods in same order as enum IntegrationMethod.
-  std::vector<std::string> ValidIntegrationMethods;
-  bool checkWorldElementsAgainstCurrentBasis() const;
   /** Global initialization in cstor.
+   *
 …
   void initBasis();
+  //!> vector with all parameter names in same order as enum Parameters
+  std::vector<std::string> ParamNames;
+  //!> typedef for the list of all available basis sets
+  /** Initializes params.
+   * Sets the type and the associated enumeration index.
+   */
+  void initParameters();
+  /** Internal function used by initParameters() to add parameters to params.
+   *
+   * @param _enum enumeration index to set
+   * @param _p (default) value to set with certain type
+   */
+  template <class T> void appendParameter(enum Parameters _enum, T _p) {
+    boost::any _p_value = _p;
+    params[_enum] = _p_value;
+  }
+  // all internal typedefs for lists below
   typedef std::map<std::string, std::list<std::string> > BasisMapType;
+  //!> list of all basis along with their present element parametrization
+  typedef std::map<enum Theory, std::string> TheoryNamesType;
+  typedef std::map<std::string, enum Theory> TheoryLookupType;
+  typedef std::map<enum IntegrationMethod, std::string> IntegrationNamesType;
+  typedef std::map<std::string, enum IntegrationMethod> IntegrationLookupType;
+  typedef std::map<enum Parameters, std::string> ParamNamesType;
+  typedef std::map<std::string, enum Parameters> ParamLookupType;
+  typedef std::map<enum Parameters, boost::any> parameterlist;
+  //!> boost::any container for all the parameters
+  parameterlist params;
+  // maps from names to enumerations
+  //!> contains basis and all elements the basis knows about
   BasisMapType BasisList;
+  //!> contains the name of a theory as string
+  TheoryNamesType TheoryNames;
+  //!> contains a lookup from theory name to enumeration index
+  TheoryLookupType TheoryLookup;
+  //!> contains the name of an integration method as string
+  IntegrationNamesType IntegrationNames;
+  //!> contains a lookup from integration method name to enumeration index
+  IntegrationLookupType IntegrationLookup;
+  //!> contains the name of a parameter
+  ParamNamesType ParamNames;
+  //!> contains a lookup from parameter name to enumeration index
+  ParamLookupType ParamLookup;
 };
+/** Output operator for the contents of MpqcParser_Parameters::params.
+ *
+ * @param ost output stream
+ * @param params reference to MpqcParser_Parameters containing params.
+ * @return reference to output stream for concatenation
+ */
+std::ostream & operator << (std::ostream& ost, const MpqcParser_Parameters &params);
+/** Input operator for a list of parameters to place into \a params.
+ *
+ * @param ist input stream
+ * @param params parameters to parse into
+ * @return input stream for concatenation
+ */
+std::istream & operator >> (std::istream& ist, MpqcParser_Parameters &params);
 #endif /* MPQCPARSER_PARAMETERS_HPP_ */

src/Parser/PcpParser.cpp

-              r360c8b
+              rfa9d1d
+// declare specialized static variables
+const std::string FormatParserTrait<pcp>::name = "pcp";
+const std::string FormatParserTrait<pcp>::suffix = "conf";
+const ParserTypes FormatParserTrait<pcp>::type = pcp;
+FormatParser< pcp >::StructParallelization::StructParallelization() :
+PcpParser::StructParallelization::StructParallelization() :
   ProcPEGamma(8),
   ProcPEPsi(1)
 {}
 FormatParser< pcp >::StructParallelization::~StructParallelization()
 {}
 FormatParser< pcp >::StructPaths::StructPaths() :
+PcpParser::StructParallelization::~StructParallelization()
+{}
+PcpParser::StructPaths::StructPaths() :
   databasepath(NULL),
   configname(NULL),
 …
 {}
 FormatParser< pcp >::StructPaths::~StructPaths()
 {}
 FormatParser< pcp >::StructSwitches::StructSwitches() :
+PcpParser::StructPaths::~StructPaths()
+{}
+PcpParser::StructSwitches::StructSwitches() :
   DoConstrainedMD(0),
   DoOutVis(0),
 …
 {}
 FormatParser< pcp >::StructSwitches::~StructSwitches()
 {}
 FormatParser< pcp >::StructLocalizedOrbitals::StructLocalizedOrbitals() :
+PcpParser::StructSwitches::~StructSwitches()
+{}
+PcpParser::StructLocalizedOrbitals::StructLocalizedOrbitals() :
   CommonWannier(0),
   SawtoothStart(0.01),
 …
 {}
 FormatParser< pcp >::StructLocalizedOrbitals::~StructLocalizedOrbitals()
 {}
 FormatParser< pcp >::StructStepCounts::StructStepCounts() :
+PcpParser::StructLocalizedOrbitals::~StructLocalizedOrbitals()
+{}
+PcpParser::StructStepCounts::StructStepCounts() :
   MaxMinStopStep(1),
   InitMaxMinStopStep(1),
 …
 {}
 FormatParser< pcp >::StructStepCounts::~StructStepCounts()
 {}
 FormatParser< pcp >::StructPlaneWaveSpecifics::StructPlaneWaveSpecifics() :
+PcpParser::StructStepCounts::~StructStepCounts()
+{}
+PcpParser::StructPlaneWaveSpecifics::StructPlaneWaveSpecifics() :
   PsiType(0),
   MaxPsiDouble(0),
 …
 {}
 FormatParser< pcp >::StructPlaneWaveSpecifics::~StructPlaneWaveSpecifics()
+PcpParser::StructPlaneWaveSpecifics::~StructPlaneWaveSpecifics()
 {}
 …
+ *
  */
+FormatParser< pcp >::FormatParser() :
+  FormatParser_common(NULL),
+PcpParser::PcpParser() :
   FastParsing(false),
   Deltat(0.01),
 …
+ *
  */
 FormatParser< pcp >::~FormatParser()
 {}
 void FormatParser< pcp >::load(std::istream* file)
+PcpParser::~PcpParser()
+{}
+void PcpParser::load(std::istream* file)
+{
   if (file->fail()) {
 …
  * \param atoms atoms to store
  */
 void FormatParser< pcp >::save(std::ostream* file, const std::vector<atom *> &atoms)
+void PcpParser::save(std::ostream* file, const std::vector<atom *> &atoms)
+{
   DoLog(0) && (Log() << Verbose(0) << "Saving changes to pcp." << std::endl);
 …
     *file << "DoFullCurrent\t" << Switches.DoFullCurrent << "\t# Do full perturbation" << endl;
     *file << "DoConstrainedMD\t" << Switches.DoConstrainedMD << "\t# Do perform a constrained (>0, relating to current MD step) instead of unconstrained (0) MD" << endl;
     ASSERT(Thermostats != NULL, "FormatParser< pcp >::save() - Thermostats not initialized!");
+    ASSERT(Thermostats != NULL, "PcpParser::save() - Thermostats not initialized!");
     *file << "Thermostat\t" << Thermostats->activeThermostat->name() << "\t";
     *file << Thermostats->activeThermostat->writeParams();
 …
  * \param &allatoms all atoms to store away
  */
 void FormatParser< pcp >::CalculateOrbitals(const std::vector<atom *> &allatoms)
+void PcpParser::CalculateOrbitals(const std::vector<atom *> &allatoms)
+{
   PlaneWaveSpecifics.MaxPsiDouble = PlaneWaveSpecifics.PsiMaxNoDown = PlaneWaveSpecifics.PsiMaxNoUp = PlaneWaveSpecifics.PsiType = 0;
 …
  * \param &ZtoIndexMap map of which atoms belong to which ion number
  */
 void FormatParser< pcp >::OutputElements(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap)
+void PcpParser::OutputElements(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap)
+{
   map<int, int> PresentElements;
 …
  * \param &ZtoIndexMap map of which atoms belong to which ion number
  */
 void FormatParser< pcp >::OutputAtoms(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap)
+void PcpParser::OutputAtoms(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap)
+{
   *file << "#Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)" << endl;
 …
  * \param *fb file buffer containing the config file
  */
 void FormatParser< pcp >::ParseThermostats(class ConfigFileBuffer * const fb)
+void PcpParser::ParseThermostats(class ConfigFileBuffer * const fb)
+{
   char * const thermo = new char[12];
 …
 };
 bool FormatParser< pcp >::operator==(const FormatParser< pcp >& b) const
+bool PcpParser::operator==(const PcpParser& b) const
+{
   ASSERT(Parallelization.ProcPEGamma == b.Parallelization.ProcPEGamma, "PcpParser ==: ProcPEGamma not");

src/Parser/PcpParser.hpp

-              r360c8b
+              rfa9d1d
 #endif
 #include <iosfwd>
+#include <map>
+#include <string>
+#include <vector>
+#include "FormatParser.hpp"
+#include "FormatParserTrait.hpp"
+#include "FormatParserInterface.hpp"
+#include "FormatParser_common.hpp"
+#include "ParserTypes.hpp"
+class atom;
+// declaration of specialized FormatParserTrait
+template<>
+struct FormatParserTrait<pcp>
+{
+  //!> Name of the parser
+  static const std::string name;
+  //!> suffix of the files the parser understands to read and write
+  static const std::string suffix;
+  //!> ParserTypes enumeration for the parser
+  static const enum ParserTypes type;
+};
+#include "Parser/FormatParser.hpp"
 /**
  * Parser for PCP config files.
  */
+template <>
+class FormatParser< pcp >  : virtual public FormatParserInterface, public FormatParser_common
+{
+class PcpParser : public FormatParser {
 public:
   FormatParser();
   virtual ~FormatParser();
+  PcpParser();
+  virtual ~PcpParser();
   void load(std::istream* file);
   void save(std::ostream* file, const std::vector<atom *> &atoms);
   bool operator==(const FormatParser< pcp >& b) const;
+  bool operator==(const PcpParser& b) const;
 private:
   void ParseThermostats(class ConfigFileBuffer * const fb);
   void OutputAtoms(std::ostream *file, const std::vector<atom *> &allatoms, std::map<int, int> &ZtoIndexMap);
   void OutputElements(std::ostream *file, const std::vector<atom *> &allatoms, std::map<int, int> &ZtoIndexMap);
+  void OutputAtoms(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap);
+  void OutputElements(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap);
   void CalculateOrbitals(const std::vector<atom *> &allatoms);
 …
   int StructOpt;
   int MaxTypes;
   std::string basis;
+  string basis;
 };

src/Parser/PdbAtomInfoContainer.hpp

-              r360c8b
+              rfa9d1d
 #endif
+#include "PdbKey.hpp"
+class PdbParser;
+class Vector;
 #include <string>
 #include <typeinfo>
-#include "LinearAlgebra/Vector.hpp"
-#include "PdbKey.hpp"
-#include "ParserTypes.hpp"
-//template <class T> class FormatParser;
-//template<> class FormatParser< pdb >;
 /**
 …
  */
 class PdbAtomInfoContainer {
+  //!> Grant all FormatParser specializations access, otherwise we have to fully define FormatParser<pdb>
+  template<enum ParserTypes> friend class FormatParser;
+  friend class PdbParser;
 public:
   PdbAtomInfoContainer();

src/Parser/PdbParser.cpp

-              r360c8b
+              rfa9d1d
 using namespace std;
-// declare specialized static variables
-const std::string FormatParserTrait<pdb>::name = "pdb";
-const std::string FormatParserTrait<pdb>::suffix = "pdb";
-const ParserTypes FormatParserTrait<pdb>::type = pdb;
 /**
  * Constructor.
  */
+FormatParser< pdb >::FormatParser() :
+  FormatParser_common(NULL)
+{
+PdbParser::PdbParser() {
   knownTokens["ATOM"] = PdbKey::Atom;
   knownTokens["HETATM"] = PdbKey::Atom;
 …
  * Destructor.
  */
+FormatParser< pdb >::~FormatParser()
+{
+PdbParser::~PdbParser() {
   PdbAtomInfoContainer::clearknownDataKeys();
   additionalAtomData.clear();
 …
  * @return token type
  */
 enum PdbKey::KnownTokens FormatParser< pdb >::getToken(string &line)
+enum PdbKey::KnownTokens PdbParser::getToken(string &line)
+{
   // look for first space
 …
  * \param PDB file
  */
 void FormatParser< pdb >::load(istream* file) {
+void PdbParser::load(istream* file) {
   string line;
   size_t linecount  = 0;
 …
             // TODO: put a throw here
             DoeLog(2) && (eLog() << Verbose(2) << "Unknown token: '" << line << "' for time step " << step << "." << std::endl);
             //ASSERT(0, "FormatParser< pdb >::load() - Unknown token in line "+toString(linecount)+": "+line+".");
+            //ASSERT(0, "PdbParser::load() - Unknown token in line "+toString(linecount)+": "+line+".");
             break;
+        }
 …
  * \param atoms atoms to store
  */
 void FormatParser< pdb >::save(ostream* file, const std::vector<atom *> &AtomList)
+void PdbParser::save(ostream* file, const std::vector<atom *> &AtomList)
+{
   DoLog(0) && (Log() << Verbose(0) << "Saving changes to pdb." << std::endl);
 …
         } else {
           ASSERT(MolIdMap.find(mol->getId()) != MolIdMap.end(),
               "FormatParser< pdb >::save() - Mol id "+toString(mol->getId())+" not present despite we set it?!");
+              "PdbParser::save() - Mol id "+toString(mol->getId())+" not present despite we set it?!");
           MolNo = MolIdMap[mol->getId()];
           atomInfo.set(PdbKey::resSeq, toString(MolIdMap[mol->getId()]));
 …
  * @param id of atom
  */
 void FormatParser< pdb >::AtomInserted(atomId_t id)
+{
   //LOG(3, "FormatParser< pdb >::AtomInserted() - notified of atom " << id << "'s insertion.");
+void PdbParser::AtomInserted(atomId_t id)
+{
+  //LOG(3, "PdbParser::AtomInserted() - notified of atom " << id << "'s insertion.");
   ASSERT(!isPresentadditionalAtomData(id),
       "FormatParser< pdb >::AtomInserted() - additionalAtomData already present for newly added atom "
+      "PdbParser::AtomInserted() - additionalAtomData already present for newly added atom "
       +toString(id)+".");
   // don't insert here as this is our check whether we are in the first time step
 …
  * @param id of atom
  */
 void FormatParser< pdb >::AtomRemoved(atomId_t id)
+{
   //LOG(3, "FormatParser< pdb >::AtomRemoved() - notified of atom " << id << "'s removal.");
+void PdbParser::AtomRemoved(atomId_t id)
+{
+  //LOG(3, "PdbParser::AtomRemoved() - notified of atom " << id << "'s removal.");
   std::map<size_t, PdbAtomInfoContainer>::iterator iter = additionalAtomData.find(id);
   // as we do not insert AtomData on AtomInserted, we cannot be assured of its presence
 //  ASSERT(iter != additionalAtomData.end(),
 //      "FormatParser< pdb >::AtomRemoved() - additionalAtomData is not present for atom "
+//      "PdbParser::AtomRemoved() - additionalAtomData is not present for atom "
 //      +toString(id)+" to remove.");
   if (iter != additionalAtomData.end()) {
 …
  * @return true - entry present, false - only for atom's father or no entry
  */
 bool FormatParser< pdb >::isPresentadditionalAtomData(unsigned int _id)
+bool PdbParser::isPresentadditionalAtomData(unsigned int _id)
+{
   return (additionalAtomData.find(_id) != additionalAtomData.end());
 …
  * @return
  */
 PdbAtomInfoContainer& FormatParser< pdb >::getadditionalAtomData(atom *_atom)
+PdbAtomInfoContainer& PdbParser::getadditionalAtomData(atom *_atom)
+{
   if (additionalAtomData.find(_atom->getId()) != additionalAtomData.end()) {
 …
  * \param ResidueNo number of residue
  */
 void FormatParser< pdb >::saveLine(
+void PdbParser::saveLine(
     ostream* file,
     const PdbAtomInfoContainer &atomInfo)
 …
  * \param *currentAtom to the atom of which to take the neighbor information
  */
 void FormatParser< pdb >::writeNeighbors(ostream* file, int MaxnumberOfNeighbors, atom* currentAtom) {
+void PdbParser::writeNeighbors(ostream* file, int MaxnumberOfNeighbors, atom* currentAtom) {
   int MaxNo = MaxnumberOfNeighbors;
   int charsleft = 80;
 …
+}
 /** Retrieves a value from  FormatParser< pdb >::atomIdMap.
+/** Retrieves a value from PdbParser::atomIdMap.
  * \param atomid key
  * \return value
  */
 size_t FormatParser< pdb >::getSerial(const size_t atomid) const
+{
   ASSERT(atomIdMap.find(atomid) != atomIdMap.end(),
       "FormatParser< pdb >::getAtomId: atomid "+toString(atomid)+" not present in Map.");
+size_t PdbParser::getSerial(const size_t atomid) const
+{
+  ASSERT(atomIdMap.find(atomid) != atomIdMap.end(),
+      "PdbParser::getSerial() - atomid "+toString(atomid)+" not present in Map.");
   return (atomIdMap.find(atomid)->second);
+}
 /** Sets an entry in  FormatParser< pdb >::atomIdMap.
+/** Sets an entry in PdbParser::atomIdMap.
  * \param localatomid key
  * \param atomid value
  * \return true - key not present, false - value present
  */
 void FormatParser< pdb >::setSerial(const size_t localatomid, const size_t atomid)
+void PdbParser::setSerial(const size_t localatomid, const size_t atomid)
+{
   pair<std::map<size_t,size_t>::iterator, bool > inserter;
 //  DoLog(1) && (Log() << Verbose(1) << "FormatParser< pdb >::setAtomId() - Inserting ("
+//  DoLog(1) && (Log() << Verbose(1) << "PdbParser::setAtomId() - Inserting ("
 //      << localatomid << " -> " << atomid << ")." << std::endl);
   inserter = atomIdMap.insert( make_pair(localatomid, atomid) );
   ASSERT(inserter.second, "FormatParser< pdb >::setAtomId: atomId already present in Map.");
+  ASSERT(inserter.second, "PdbParser::setAtomId: atomId already present in Map.");
+}
 …
  * @return
  */
 atom* FormatParser< pdb >::getAtomToParse(std::string id_string) const
+atom* PdbParser::getAtomToParse(std::string id_string) const
+{
   // get the local ID
 …
  * @param line line containing key ATOM
  */
 void FormatParser< pdb >::readPdbAtomInfoContainer(PdbAtomInfoContainer &atomInfo, std::string &line) const
+void PdbParser::readPdbAtomInfoContainer(PdbAtomInfoContainer &atomInfo, std::string &line) const
+{
   const size_t length = line.length();
   if (length < 80)
     ELOG(2, "FormatParser< pdb >::readPdbAtomInfoContainer() - pdb is mal-formed, containing less than 80 chars!");
+    ELOG(2, "PdbParser::readPdbAtomInfoContainer() - pdb is mal-formed, containing less than 80 chars!");
   if (length >= 6) {
     LOG(4,"INFO: Parsing token from "+line.substr(0,6)+".");
 …
     atomInfo.set(PdbKey::serial, line.substr(6,5));
     ASSERT(atomInfo.get<int>(PdbKey::serial) != 0,
         "FormatParser< pdb >::readPdbAtomInfoContainer() - serial 0 is invalid (filler id for conect entries).");
+        "PdbParser::readPdbAtomInfoContainer() - serial 0 is invalid (filler id for conect entries).");
+  }
 …
  * \param newmol molecule to add parsed atoms to
  */
 void FormatParser< pdb >::readAtomDataLine(const unsigned int _step, std::string &line, molecule *newmol = NULL) {
+void PdbParser::readAtomDataLine(const unsigned int _step, std::string &line, molecule *newmol = NULL) {
   vector<string>::iterator it;
 …
   bool FirstTimestep = isPresentadditionalAtomData(newAtom->getId()) ? false : true;
   ASSERT((FirstTimestep && (_step == 0)) || (!FirstTimestep && (_step !=0)),
       "FormatParser< pdb >::readAtomDataLine() - additionalAtomData present though atom is newly parsed.");
+      "PdbParser::readAtomDataLine() - additionalAtomData present though atom is newly parsed.");
   if (FirstTimestep) {
     LOG(3,"INFO: Parsing new atom.");
 …
       SerialSet.insert(toSize_t(atomInfo.get<std::string>(PdbKey::serial)));
     ASSERT(Inserter.second,
         "FormatParser< pdb >::readAtomDataLine() - ATOM contains entry with serial "
+        "PdbParser::readAtomDataLine() - ATOM contains entry with serial "
         +atomInfo.get<std::string>(PdbKey::serial)+" already present!");
     setSerial(toSize_t(atomInfo.get<std::string>(PdbKey::serial)), newAtom->getId());
 …
         ->FindElement(value);
     ASSERT(elem != NULL,
         "FormatParser< pdb >::readAtomDataLine() - element "+atomInfo.get<std::string>(PdbKey::element)+" is unknown!");
+        "PdbParser::readAtomDataLine() - element "+atomInfo.get<std::string>(PdbKey::element)+" is unknown!");
     newAtom->setType(elem);
 …
     // then check additional info for consistency
     ASSERT(atomInfo.get<std::string>(PdbKey::token) == consistencyInfo.get<std::string>(PdbKey::token),
         "FormatParser< pdb >::readAtomDataLine() - difference in token on multiple time step for atom with id "
+        "PdbParser::readAtomDataLine() - difference in token on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::name) == consistencyInfo.get<std::string>(PdbKey::name),
         "FormatParser< pdb >::readAtomDataLine() - difference in name on multiple time step for atom with id "
+        "PdbParser::readAtomDataLine() - difference in name on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+":"
         +atomInfo.get<std::string>(PdbKey::name)+"!="
         +consistencyInfo.get<std::string>(PdbKey::name)+".");
     ASSERT(atomInfo.get<std::string>(PdbKey::altLoc) == consistencyInfo.get<std::string>(PdbKey::altLoc),
         "FormatParser< pdb >::readAtomDataLine() - difference in altLoc on multiple time step for atom with id "
+        "PdbParser::readAtomDataLine() - difference in altLoc on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::resName) == consistencyInfo.get<std::string>(PdbKey::resName),
         "FormatParser< pdb >::readAtomDataLine() - difference in resName on multiple time step for atom with id "
+        "PdbParser::readAtomDataLine() - difference in resName on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::chainID) == consistencyInfo.get<std::string>(PdbKey::chainID),
         "FormatParser< pdb >::readAtomDataLine() - difference in chainID on multiple time step for atom with id "
+        "PdbParser::readAtomDataLine() - difference in chainID on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::resSeq) == consistencyInfo.get<std::string>(PdbKey::resSeq),
         "FormatParser< pdb >::readAtomDataLine() - difference in resSeq on multiple time step for atom with id "
+        "PdbParser::readAtomDataLine() - difference in resSeq on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::iCode) == consistencyInfo.get<std::string>(PdbKey::iCode),
         "FormatParser< pdb >::readAtomDataLine() - difference in iCode on multiple time step for atom with id "
+        "PdbParser::readAtomDataLine() - difference in iCode on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::occupancy) == consistencyInfo.get<std::string>(PdbKey::occupancy),
         "FormatParser< pdb >::readAtomDataLine() - difference in occupancy on multiple time step for atom with id "
+        "PdbParser::readAtomDataLine() - difference in occupancy on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::tempFactor) == consistencyInfo.get<std::string>(PdbKey::tempFactor),
         "FormatParser< pdb >::readAtomDataLine() - difference in tempFactor on multiple time step for atom with id "
+        "PdbParser::readAtomDataLine() - difference in tempFactor on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::charge) == consistencyInfo.get<std::string>(PdbKey::charge),
         "FormatParser< pdb >::readAtomDataLine() - difference in charge on multiple time step for atom with id "
+        "PdbParser::readAtomDataLine() - difference in charge on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::element) == consistencyInfo.get<std::string>(PdbKey::element),
         "FormatParser< pdb >::readAtomDataLine() - difference in element on multiple time step for atom with id "
+        "PdbParser::readAtomDataLine() - difference in element on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     // and parse in trajectory
 …
+ *
  */
 void FormatParser< pdb >::printAtomInfo(const atom * const newAtom) const
+void PdbParser::printAtomInfo(const atom * const newAtom) const
+{
   const PdbAtomInfoContainer &atomInfo = additionalAtomData.at(newAtom->getId()); // operator[] const does not exist
 …
  * \param line to parse as an atom
  */
 void FormatParser< pdb >::readNeighbors(const unsigned int _step, std::string &line)
+void PdbParser::readNeighbors(const unsigned int _step, std::string &line)
+{
   const size_t length = line.length();
 …
   string output;
   ASSERT(length >=16,
       "FormatParser< pdb >::readNeighbors() - CONECT entry has not enough entries: "+line+"!");
 //  output = "Split line:|";
 //  output += line.substr(6,5) + "|";
+      "PdbParser::readNeighbors() - CONECT entry has not enough entries: "+line+"!");
+  output = "Split line:|";
+  output += line.substr(6,5) + "|";
   const size_t id = toSize_t(line.substr(6,5));
   for (size_t index = 11; index <= 26; index+=5) {
 …
         ListOfNeighbors.push_back(otherid);
       else
         ELOG(2, "FormatParser< pdb >::readNeighbors() - discarding conect entry with id 0.");
+        ELOG(2, "PdbParser::readNeighbors() - discarding conect entry with id 0.");
     } else  {
       break;
 …
  * \return input string with modified atom IDs
  */
 //string  FormatParser< pdb >::adaptIdDependentDataString(string data) {
+//string PdbParser::adaptIdDependentDataString(string data) {
 //  // there might be no IDs
 //  if (data == "-") {
 …
 bool FormatParser< pdb >::operator==(const FormatParser< pdb >& b) const
+bool PdbParser::operator==(const PdbParser& b) const
+{
   bool status = true;

src/Parser/PdbParser.hpp

-              r360c8b
+              rfa9d1d
 #endif
 #include <string>
 #include "FormatParser.hpp"
-#include "FormatParserTrait.hpp"
-#include "FormatParserInterface.hpp"
-#include "FormatParser_common.hpp"
-#include "ParserTypes.hpp"
 #include "PdbAtomInfoContainer.hpp"
 #include "PdbKey.hpp"
-class molecule;
-// declaration of specialized FormatParserTrait
-template<>
-struct FormatParserTrait<pdb>
+{
-  //!> Name of the parser
-  static const std::string name;
-  //!> suffix of the files the parser understands to read and write
-  static const std::string suffix;
-  //!> ParserTypes enumeration for the parser
-  static const enum ParserTypes type;
-};
 /**
  * Loads a PDB format 3.2 file into the World and saves the World as a PDB file.
  */
+template <>
+class FormatParser< pdb >  : virtual public FormatParserInterface, public FormatParser_common
+class PdbParser : public FormatParser
+{
 public:
   FormatParser();
   virtual ~FormatParser();
+  PdbParser();
+  virtual ~PdbParser();
   void load(std::istream* file);
   void save(std::ostream* file, const std::vector<atom *> &atoms);
   bool operator==(const FormatParser< pdb>& b) const;
+  bool operator==(const PdbParser& b) const;
   void printAtomInfo(const atom *newAtom) const;
 …
    */
   std::set<size_t> SerialSet;
 };

src/Parser/TremoloParser.cpp

-              r360c8b
+              rfa9d1d
 using namespace std;
-// declare specialized static variables
-const std::string FormatParserTrait<tremolo>::name = "tremolo";
-const std::string FormatParserTrait<tremolo>::suffix = "data";
-const ParserTypes FormatParserTrait<tremolo>::type = tremolo;
 /**
  * Constructor.
  */
+FormatParser< tremolo >::FormatParser()  :
+  FormatParser_common(NULL)
+{
+TremoloParser::TremoloParser() {
   knownKeys["x"] = TremoloKey::x;
   knownKeys["u"] = TremoloKey::u;
 …
  * Destructor.
  */
+FormatParser< tremolo >::~FormatParser()
+{
+  std::cerr << "Clearing usedFields." << std::endl;
+TremoloParser::~TremoloParser() {
+        std::cerr << "Clearing usedFields." << std::endl;
   usedFields.clear();
   additionalAtomData.clear();
 …
  * \param tremolo file
  */
 void FormatParser< tremolo >::load(istream* file) {
+void TremoloParser::load(istream* file) {
   string line;
   string::size_type location;
 …
  * \param atoms atoms to store
  */
 void FormatParser< tremolo >::save(ostream* file, const std::vector<atom *> &AtomList) {
+void TremoloParser::save(ostream* file, const std::vector<atom *> &AtomList) {
   DoLog(0) && (Log() << Verbose(0) << "Saving changes to tremolo." << std::endl);
 …
  * @param id of atom
  */
 void FormatParser< tremolo >::AtomInserted(atomId_t id)
+void TremoloParser::AtomInserted(atomId_t id)
+{
   std::map<int, TremoloAtomInfoContainer>::iterator iter = additionalAtomData.find(id);
   ASSERT(iter == additionalAtomData.end(),
       "FormatParser< tremolo >::AtomInserted() - additionalAtomData already present for newly added atom "
+      "TremoloParser::AtomInserted() - additionalAtomData already present for newly added atom "
       +toString(id)+".");
   // don't add entry, as this gives a default resSeq of 0 not the molecule id
 …
  * @param id of atom
  */
 void FormatParser< tremolo >::AtomRemoved(atomId_t id)
+void TremoloParser::AtomRemoved(atomId_t id)
+{
   std::map<int, TremoloAtomInfoContainer>::iterator iter = additionalAtomData.find(id);
   // as we do not insert AtomData on AtomInserted, we cannot be assured of its presence
 //  ASSERT(iter != additionalAtomData.end(),
 //      "FormatParser< tremolo >::AtomRemoved() - additionalAtomData is not present for atom "
+//      "TremoloParser::AtomRemoved() - additionalAtomData is not present for atom "
 //      +toString(id)+" to remove.");
   if (iter != additionalAtomData.end())
 …
  *        but without the prexix "ATOMDATA"
  */
 void FormatParser< tremolo >::setFieldsForSave(std::string atomDataLine) {
+void TremoloParser::setFieldsForSave(std::string atomDataLine) {
   parseAtomDataKeysLine(atomDataLine, 0);
+}
 …
  * \param reference to the atom of which information should be written
  */
+void FormatParser< tremolo >::saveLine(ostream* file, atom* currentAtom) {
+  //vector<string>::iterator it;
+  // TODO: Is unique for FormatParser< tremolo >::usedFields still required?
+  vector<string>::iterator it = unique(usedFields.begin(), usedFields.end()); // skips all duplicates in the vector
+void TremoloParser::saveLine(ostream* file, atom* currentAtom) {
+ /* vector<string>::iterator it;*/
+        vector<string>::iterator it = unique(usedFields.begin(), usedFields.end()); // skips all duplicates in the vector
   TremoloKey::atomDataKey currentField;
 …
  * \param reference to the atom of which to take the neighbor information
  */
 void FormatParser< tremolo >::writeNeighbors(ostream* file, int numberOfNeighbors, atom* currentAtom) {
+void TremoloParser::writeNeighbors(ostream* file, int numberOfNeighbors, atom* currentAtom) {
   const BondList& ListOfBonds = currentAtom->getListOfBonds();
   // sort bonded indices
 …
  * \param with which offset the keys begin within the line
  */
 void FormatParser< tremolo >::parseAtomDataKeysLine(string line, int offset) {
+void TremoloParser::parseAtomDataKeysLine(string line, int offset) {
   string keyword;
   stringstream lineStream;
 …
  *  \a atomdata_string.
+ *
  *  We just call \sa  FormatParser< tremolo >::parseAtomDataKeysLine() which is left
+ *  We just call \sa TremoloParser::parseAtomDataKeysLine() which is left
  *  private.,
+ *
  * @param atomdata_string line to parse with space-separated values
  */
 void FormatParser< tremolo >::setAtomData(const std::string &atomdata_string)
+void TremoloParser::setAtomData(const std::string &atomdata_string)
+{
   parseAtomDataKeysLine(atomdata_string, 0);
 …
  * \param *newmol molecule to add atom to
  */
 void FormatParser< tremolo >::readAtomDataLine(string line, molecule *newmol = NULL) {
+void TremoloParser::readAtomDataLine(string line, molecule *newmol = NULL) {
   vector<string>::iterator it;
   stringstream lineStream;
 …
   tokenizer tokens(line, whitespacesep);
   ASSERT(tokens.begin() != tokens.end(),
       "FormatParser< tremolo >::readAtomDataLine - empty string, need at least ' '!");
+      "TremoloParser::readAtomDataLine - empty string, need at least ' '!");
   tokenizer::iterator tok_iter = tokens.begin();
   // then associate each token to each file
 …
         // for the moment, assume there are always three dimensions
         for (int i=0;i<NDIM;i++) {
           ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for x["+toString(i)+"]!");
+          ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for x["+toString(i)+"]!");
           DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
           newAtom->set(i, toDouble(*tok_iter));
 …
         // for the moment, assume there are always three dimensions
         for (int i=0;i<NDIM;i++) {
           ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for u["+toString(i)+"]!");
+          ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for u["+toString(i)+"]!");
           DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
           tempVector[i] = toDouble(*tok_iter);
 …
       case TremoloKey::type :
+      {
         ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
+        ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for "+keyName+"!");
         DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
         std::string element(knownTypes[(*tok_iter)]);
 …
+      }
       case TremoloKey::Id :
         ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
+        ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for "+keyName+"!");
         DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
         atomIdMap[toInt(*tok_iter)] = newAtom->getId();
 …
       case TremoloKey::neighbors :
         for (int i=0;i<atoi(it->substr(it->find("=") + 1, 1).c_str());i++) {
           ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
+          ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for "+keyName+"!");
           DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
           lineStream << *tok_iter << "\t";
 …
         break;
       default :
         ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
+        ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for "+keyName+"!");
         DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
         atomInfo->set(currentField, *tok_iter);
 …
  * \param atomid world id of the atom the information belongs to
  */
 void FormatParser< tremolo >::readNeighbors(stringstream* line, int numberOfNeighbors, int atomId) {
+void TremoloParser::readNeighbors(stringstream* line, int numberOfNeighbors, int atomId) {
   int neighborId = 0;
   for (int i = 0; i < numberOfNeighbors; i++) {
 …
  * \return true if the field name is used
  */
 bool FormatParser< tremolo >::isUsedField(string fieldName) {
+bool TremoloParser::isUsedField(string fieldName) {
   bool fieldNameExists = false;
   for (vector<string>::iterator usedField = usedFields.begin(); usedField != usedFields.end(); usedField++) {
 …
  * Id found in the parsed file.
  */
 void FormatParser< tremolo >::processNeighborInformation() {
+void TremoloParser::processNeighborInformation() {
   if (!isUsedField("neighbors")) {
     return;
 …
  * \return input string with modified atom IDs
  */
 std::string FormatParser< tremolo >::adaptIdDependentDataString(string data) {
+string TremoloParser::adaptIdDependentDataString(string data) {
   // there might be no IDs
   if (data == "-") {
 …
  * as they might differ from the originally read IDs.
  */
 void FormatParser< tremolo >::adaptImprData() {
+void TremoloParser::adaptImprData() {
   if (!isUsedField("imprData")) {
     return;
 …
  * as they might differ from the originally read IDs.
  */
 void FormatParser< tremolo >::adaptTorsion() {
+void TremoloParser::adaptTorsion() {
   if (!isUsedField("torsion")) {
     return;
 …
+ *
  */
 void FormatParser< tremolo >::createKnownTypesByIdentity()
+void TremoloParser::createKnownTypesByIdentity()
+{
   // remove old mapping
 …
  * @param file input stream of .potentials file
  */
 void FormatParser< tremolo >::parseKnownTypes(std::istream &file)
+void TremoloParser::parseKnownTypes(std::istream &file)
+{
   const periodentafel *periode = World::getInstance().getPeriode();
 …
       tokenizer tokens(line, tokensep);
       ASSERT(tokens.begin() != tokens.end(),
           "FormatParser< tremolo >::parseKnownTypes() - line with 'particle:' but no particles separated by comma.");
+          "TremoloParser::parseKnownTypes() - line with 'particle:' but no particles separated by comma.");
       // look for particle_type
       std::string particle_type("NULL");
 …
           tokenizer token((*tok_iter), equalitysep);
           ASSERT(token.begin() != token.end(),
                     "FormatParser< tremolo >::parseKnownTypes() - could not split particle_type by equality sign");
+                    "TremoloParser::parseKnownTypes() - could not split particle_type by equality sign");
           tokenizer::iterator particle_iter = token.begin();
           particle_iter++;
 …
           tokenizer token((*tok_iter), equalitysep);
           ASSERT(token.begin() != token.end(),
                     "FormatParser< tremolo >::parseKnownTypes() - could not split particle_type by equality sign");
+                    "TremoloParser::parseKnownTypes() - could not split particle_type by equality sign");
           tokenizer::iterator element_iter = token.begin();
           element_iter++;

src/Parser/TremoloParser.hpp

-              r360c8b
+              rfa9d1d
 #endif
 #include <string>
+#include "FormatParser.hpp"
+#include "FormatParserTrait.hpp"
+#include "FormatParserInterface.hpp"
+#include "FormatParser_common.hpp"
+#include "ParserTypes.hpp"
+#include "Parser/FormatParser.hpp"
 #include "TremoloKey.hpp"
 …
 class molecule;
-// declaration of specialized FormatParserTrait
-template<>
-struct FormatParserTrait<tremolo>
+{
-  //!> Name of the parser
-  static const std::string name;
-  //!> suffix of the files the parser understands to read and write
-  static const std::string suffix;
-  //!> ParserTypes enumeration for the parser
-  static const enum ParserTypes type;
-};
 /**
  * Loads a tremolo file into the World and saves the World as a tremolo file.
  */
+template <>
+class FormatParser< tremolo >  : virtual public FormatParserInterface, public FormatParser_common
+class TremoloParser : public FormatParser
+{
 public:
   FormatParser();
   virtual ~FormatParser();
+  TremoloParser();
+  virtual ~TremoloParser();
   void load(std::istream* file);
   void save(std::ostream* file, const std::vector<atom *> &atoms);
 …
 private:
   void readAtomDataLine(std::string line);
   void readAtomDataLine(std::string line, molecule *newmol);
   void parseAtomDataKeysLine(std::string line, int offset);
+  void readAtomDataLine(string line);
+  void readAtomDataLine(string line, molecule *newmol);
+  void parseAtomDataKeysLine(string line, int offset);
   void readNeighbors(std::stringstream* line, int numberOfNeighbors, int atomId);
   void processNeighborInformation();

src/Parser/XyzParser.cpp

-              r360c8b
+              rfa9d1d
 using namespace std;
-// declare specialized static variables
-const std::string FormatParserTrait<xyz>::name = "xyz";
-const std::string FormatParserTrait<xyz>::suffix = "xyz";
-const ParserTypes FormatParserTrait<xyz>::type = xyz;
 /**
  * Constructor.
  */
+FormatParser< xyz >::FormatParser() :
+  FormatParser_common(NULL),
+XyzParser::XyzParser() :
   comment("")
 {}
 …
  * Destructor.
  */
+FormatParser< xyz >::~FormatParser()
 {}
+XyzParser::~XyzParser() {
+}
 /**
 …
  * \param XYZ file
  */
 void FormatParser< xyz >::load(istream* file)
+void XyzParser::load(istream* file)
+{
   atom* newAtom = NULL;
 …
         LOG(5, "INFO: Using present atom " << *newAtom << " from " << i << " th component of AddedAtoms.");
         ASSERT(newAtom->getType() == World::getInstance().getPeriode()->FindElement(type),
             "FormatParser< xyz >::load() - atom has different type "+newAtom->getType()->getSymbol()+" than parsed now "+type+", mixed up order?");
+            "XyzParser::load() - atom has different type "+newAtom->getType()->getSymbol()+" than parsed now "+type+", mixed up order?");
+      }
       newAtom->setPositionAtStep(step, tempVector);
 …
  * \param atoms atoms to store
  */
 void FormatParser< xyz >::save(ostream* file, const std::vector<atom *> &atoms) {
+void XyzParser::save(ostream* file, const std::vector<atom *> &atoms) {
   DoLog(0) && (Log() << Verbose(0) << "Saving changes to xyz." << std::endl);
 …
+  }
   ASSERT((min_trajectories == max_trajectories) || (min_trajectories == 1),
       "FormatParser< xyz >::save() - not all atoms have same number of trajectories.");
+      "XyzParser::save() - not all atoms have same number of trajectories.");
   LOG(2, "INFO: There are " << max_trajectories << " to save.");

src/Parser/XyzParser.hpp

-              r360c8b
+              rfa9d1d
 #endif
 #include <string>
+#include "FormatParser.hpp"
+#include "FormatParserTrait.hpp"
+#include "FormatParserInterface.hpp"
+#include "FormatParser_common.hpp"
+#include "ParserTypes.hpp"
+// declaration of specialized FormatParserTrait
+template<>
+struct FormatParserTrait<xyz>
+{
+  //!> Name of the parser
+  static const std::string name;
+  //!> suffix of the files the parser understands to read and write
+  static const std::string suffix;
+  //!> ParserTypes enumeration for the parser
+  static const enum ParserTypes type;
+};
+#include "Parser/FormatParser.hpp"
 /**
  * Parser for XYZ files.
  */
+template <>
+class FormatParser< xyz >  : virtual public FormatParserInterface, public FormatParser_common
+{
+class XyzParser : public FormatParser {
 public:
   FormatParser();
   virtual ~FormatParser();
+  XyzParser();
+  virtual ~XyzParser();
   void load(std::istream* file);
   void save(std::ostream* file, const std::vector<atom *> &atoms);

src/Parser/unittests/Makefile.am

-              r360c8b
+              rfa9d1d
 # Also indentation by a single tab
-include ../../src/Parser/Parameters/unittests/Makefile.am
 PARSERTESTSSOURCES = \
 …
         ../Parser/unittests/ParserPcpUnitTest.cpp \
         ../Parser/unittests/ParserPdbUnitTest.cpp \
-        ../Parser/unittests/ParserPsi3UnitTest.cpp \
         ../Parser/unittests/ParserTremoloUnitTest.cpp \
         ../Parser/unittests/ParserXyzUnitTest.cpp
 …
         ../Parser/unittests/ParserPcpUnitTest.hpp \
         ../Parser/unittests/ParserPdbUnitTest.hpp \
-        ../Parser/unittests/ParserPsi3UnitTest.hpp \
         ../Parser/unittests/ParserTremoloUnitTest.hpp \
         ../Parser/unittests/ParserXyzUnitTest.hpp
 …
   ParserPcpUnitTest \
   ParserPdbUnitTest \
-  ParserPsi3UnitTest \
   ParserTremoloUnitTest \
   ParserXyzUnitTest
 …
         ${CodePatterns_LIBS}
 #       $(BOOST_LIB)
 …
 ParserPdbUnitTest_LDADD = ${PARSERLIBS}
-ParserPsi3UnitTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
-        ../Parser/unittests/ParserPsi3UnitTest.cpp \
-        ../Parser/unittests/ParserPsi3UnitTest.hpp
-ParserPsi3UnitTest_LDADD = ${PARSERLIBS}
 ParserTremoloUnitTest_SOURCES = $(top_srcdir)/src/unittests/UnitTestMain.cpp \
         ../Parser/unittests/ParserTremoloUnitTest.cpp \

src/Parser/unittests/ParserMpqcUnitTest.cpp

-              r360c8b
+              rfa9d1d
 #include "Descriptors/AtomTypeDescriptor.hpp"
 #include "CodePatterns/Assert.hpp"
-#include "Parser/ChangeTracker.hpp"
-#include "Parser/MpqcParser.hpp"
 #ifdef HAVE_TESTRUNNER
 …
 )\n"; // basically tested with mpqc 3.0.0-alpha (no parse errors but did not calculate due to missing code)
+void ParserMpqcUnitTest::setUp()
+{
+  // failing asserts should be thrown
+  ASSERT_DO(Assert::Throw);
+  parser = new FormatParser<mpqc>();
+void ParserMpqcUnitTest::setUp() {
+  mpqc = new MpqcParser();
   World::getInstance();
 …
+}
+void ParserMpqcUnitTest::tearDown()
+{
+  delete parser;
+void ParserMpqcUnitTest::tearDown() {
+  delete mpqc;
   ChangeTracker::purgeInstance();
   World::purgeInstance();
 …
 /************************************ tests ***********************************/
+void ParserMpqcUnitTest::ParameterTypeTest() {
+  // check types in boost::any map
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::hessianParam].type() == typeid(bool));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::hessianParam].type() != typeid(int));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::savestateParam].type() == typeid(bool));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::do_gradientParam].type() == typeid(bool));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::maxiterParam].type() == typeid(int));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::memoryParam].type() == typeid(int));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::stdapproxParam].type() == typeid(std::string));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::nfzcParam].type() == typeid(int));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::basisParam].type() == typeid(std::string));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::aux_basisParam].type() == typeid(std::string));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::integrationParam].type() == typeid(MpqcParser_Parameters::IntegralCints));
+  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::theoryParam].type() == typeid(MpqcParser_Parameters::MBPT2));
+}
 void ParserMpqcUnitTest::ParameterDefaultTest() {
   // check default values
+  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::hessianParam) == std::string("no"));
+  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::savestateParam) == std::string("no"));
+  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::do_gradientParam) == std::string("yes"));
+  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::maxiterParam) == std::string("1000"));
+  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::memoryParam) == std::string("16000000"));
+  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::stdapproxParam) == std::string("A'"));
+  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::nfzcParam) == std::string("1"));
+  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::basisParam) == std::string("3-21G"));
+  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::aux_basisParam) == std::string("aug-cc-pVDZ"));
+  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::integrationParam) == std::string("IntegralCints"));
+  CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::theoryParam) == std::string("MBPT2"));
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) == "no");
+  CPPUNIT_ASSERT(!mpqc->getParams().getBool(MpqcParser_Parameters::hessianParam));
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::savestateParam) == "no");
+  CPPUNIT_ASSERT(!mpqc->getParams().getBool(MpqcParser_Parameters::savestateParam));
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::do_gradientParam) == "yes");
+  CPPUNIT_ASSERT(mpqc->getParams().getBool(MpqcParser_Parameters::do_gradientParam));
+  CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::maxiterParam) == 1000);
+  CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::memoryParam) == 16000000);
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::stdapproxParam) == "A'");
+  CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::nfzcParam) == 1);
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::basisParam) == "3-21G");
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::aux_basisParam) == "aug-cc-pVDZ");
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::integrationParam) == "IntegralCints");
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
+  CPPUNIT_ASSERT(mpqc->getParams().getTheory() == MpqcParser_Parameters::MBPT2);
+  CPPUNIT_ASSERT(mpqc->getParams().getIntegration() == MpqcParser_Parameters::IntegralCints);
+  // check that values are not removed
+  CPPUNIT_ASSERT(!mpqc->getParams().params[MpqcParser_Parameters::theoryParam].empty());
+  // check throw, for the moment aren't, are caught in getInt()
+  CPPUNIT_ASSERT_THROW(mpqc->getParams().getInt(MpqcParser_Parameters::integrationParam), boost::bad_any_cast);
+  CPPUNIT_ASSERT_THROW(mpqc->getParams().getInt(MpqcParser_Parameters::theoryParam), boost::bad_any_cast);
+}
 void ParserMpqcUnitTest::ParameterCloneTest() {
   FormatParser_Parameters *clone = parser->getParams().clone();
   CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::theoryParam) == std::string("MBPT2"));
+  FormatParser_Parameters *clone = mpqc->getParams().clone();
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
   std::stringstream setvalue("theory = CLHF");
   setvalue >> parser->getParams();
   CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::theoryParam) == std::string("CLHF"));
   parser->getParams().makeClone(*clone);
   CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::theoryParam) == std::string("MBPT2"));
+  setvalue >> mpqc->getParams();
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "CLHF");
+  mpqc->getParams().makeClone(*clone);
+  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
+}
 …
+  {
     std::stringstream setvalue("theory = CLHF");
     setvalue >> parser->getParams();
+    setvalue >> mpqc->getParams();
 //    std::cout << "integration method is "
 //        << parser->getParams().getString(MpqcParser_Parameters::theoryParam) << std::endl;
     CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::theoryParam) == std::string("CLHF"));
+//        << mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) << std::endl;
+    CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "CLHF");
+  }
   // test a bool
+  {
     std::stringstream setvalue("Hessian = yes");
     setvalue >> parser->getParams();
+    setvalue >> mpqc->getParams();
 //    std::cout << "Hessian is "
 //        << parser->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
     CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::hessianParam) == std::string("yes"));
+//        << mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
+    CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) == "yes");
+  }
   // test int
+  {
     std::stringstream setvalue("maxiter = 500");
     setvalue >> parser->getParams();
+    setvalue >> mpqc->getParams();
 //    std::cout << "maxiter is "
 //        << parser->getParams().getString(MpqcParser_Parameters::maxiterParam) << std::endl;
     CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::maxiterParam) == std::string("500"));
+//        << mpqc->getParams().getString(MpqcParser_Parameters::maxiterParam) << std::endl;
+    CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::maxiterParam) == 500);
+  }
   // test whether unknown key fails
 …
 #ifndef NDEBUG
     ASSERT_DO(Assert::Throw);
     CPPUNIT_ASSERT_THROW(setvalue >> parser->getParams(), Assert::AssertionFailure);
+    CPPUNIT_ASSERT_THROW(setvalue >> mpqc->getParams(), Assert::AssertionFailure);
 #else
     setvalue >> parser->getParams();
+    setvalue >> mpqc->getParams();
 #endif
 //    std::cout << "Hessian is still "
 //        << parser->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
     CPPUNIT_ASSERT(parser->getParams().getParameter(MpqcParser_Parameters::hessianParam) == std::string("yes"));
+//        << mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
+    CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) == "yes");
+  }
+}
 …
 void ParserMpqcUnitTest::readMpqcTest() {
   stringstream input(waterMpqc_CLHF);
+  parser->getParams().setParameter(
+      MpqcParser_Parameters::theoryParam,
+      parser->getParams().getTheoryName(MpqcParser_Parameters::CLHF)
+          );
+  parser->load(&input);
+  mpqc->getParams().setTheory(MpqcParser_Parameters::CLHF);
+  mpqc->load(&input);
   CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
 …
     // compare both configs for CLHF
     stringstream output;
+    parser->getParams().setParameter(
+        MpqcParser_Parameters::theoryParam,
+        parser->getParams().getTheoryName(MpqcParser_Parameters::CLHF)
+            );
+    parser->save(&output, atoms);
+    mpqc->getParams().setTheory(MpqcParser_Parameters::CLHF);
+    mpqc->save(&output, atoms);
     stringstream input(waterMpqc_CLHF);
-    // check for non-empty streams
-    input.peek();
-    output.peek();
-    CPPUNIT_ASSERT(input.good() && output.good());
-    // check equality of streams per line (for debugging)
     for (; std::getline(input, first) && std::getline(output, second); ) {
       //std::cout << "Comparing '" << first << "' to '" << second << "'" << std::endl;
 …
     // compare both configs for CLKS
     stringstream output;
+    parser->getParams().setParameter(
+        MpqcParser_Parameters::theoryParam,
+        parser->getParams().getTheoryName(MpqcParser_Parameters::CLKS)
+            );
+    parser->save(&output, atoms);
+    mpqc->getParams().setTheory(MpqcParser_Parameters::CLKS);
+    mpqc->save(&output, atoms);
     stringstream input(waterMpqc_CLKS);
-    // check for non-empty streams
-    input.peek();
-    output.peek();
-    CPPUNIT_ASSERT(input.good() && output.good());
-    // check equality of streams per line (for debugging)
     for (; std::getline(input, first) && std::getline(output, second); ) {
       //std::cout << "Comparing '" << first << "' to '" << second << "'" << std::endl;
 …
     // compare both configs for MBPT2
     stringstream output;
+    parser->getParams().setParameter(
+        MpqcParser_Parameters::theoryParam,
+        parser->getParams().getTheoryName(MpqcParser_Parameters::MBPT2)
+            );
+    parser->save(&output, atoms);
+    mpqc->getParams().setTheory(MpqcParser_Parameters::MBPT2);
+    mpqc->save(&output, atoms);
     stringstream input(waterMpqc_MBPT2);
-    // check for non-empty streams
-    input.peek();
-    output.peek();
-    CPPUNIT_ASSERT(input.good() && output.good());
-    // check equality of streams per line (for debugging)
     for (; std::getline(input, first) && std::getline(output, second); ) {
       //std::cout << "Comparing '" << first << "' to '" << second << "'" << std::endl;
 …
     // compare both configs for MBPT2_R12
     stringstream output;
+    parser->getParams().setParameter(
+        MpqcParser_Parameters::theoryParam,
+        parser->getParams().getTheoryName(MpqcParser_Parameters::MBPT2_R12)
+            );
+    parser->save(&output, atoms);
+    mpqc->getParams().setTheory(MpqcParser_Parameters::MBPT2_R12);
+    mpqc->save(&output, atoms);
     stringstream input(waterMpqc_MBPT2_R12);
-    // check for non-empty streams
-    input.peek();
-    output.peek();
-    CPPUNIT_ASSERT(input.good() && output.good());
-    // check equality of streams per line (for debugging)
     for (; std::getline(input, first) && std::getline(output, second); ) {
       //std::cout << "Comparing '" << first << "' to '" << second << "'" << std::endl;

src/Parser/unittests/ParserMpqcUnitTest.hpp

-              r360c8b
+              rfa9d1d
+{
   CPPUNIT_TEST_SUITE( ParserMpqcUnitTest ) ;
+  CPPUNIT_TEST ( ParameterTypeTest );
   CPPUNIT_TEST ( ParameterDefaultTest );
   CPPUNIT_TEST ( ParameterSetterTest );
 …
   void tearDown();
+  void ParameterTypeTest();
   void ParameterDefaultTest();
   void ParameterSetterTest();
 …
 private:
   FormatParser<mpqc> *parser;
+  MpqcParser *mpqc;
 };

src/Parser/unittests/ParserPcpUnitTest.cpp

-              r360c8b
+              rfa9d1d
 #include <cppunit/ui/text/TestRunner.h>
+#include "Parser/PcpParser.hpp"
 #include "World.hpp"
 #include "atom.hpp"
 …
 #include "CodePatterns/Log.hpp"
 #include "Descriptors/AtomTypeDescriptor.hpp"
-#include "Parser/ChangeTracker.hpp"
-#include "Parser/PcpParser.hpp"
 #ifdef HAVE_TESTRUNNER
 …
   World::getInstance();
-  parser = new FormatParser<pcp>();
   setVerbosity(2);
 …
+}
+void ParserPcpUnitTest::tearDown()
+{
+  delete parser;
+void ParserPcpUnitTest::tearDown() {
   ChangeTracker::purgeInstance();
   World::purgeInstance();
 …
 void ParserPcpUnitTest::readwritePcpTest() {
   stringstream input(waterPcp);
+  parser->load(&input);
+  PcpParser* testParser = new PcpParser();
+  testParser->load(&input);
   input.clear();
 …
   // check that equality function is ok
   CPPUNIT_ASSERT(*parser == *parser);
+  CPPUNIT_ASSERT(*testParser == *testParser);
   stringstream output;
   std::vector<atom *> atoms = World::getInstance().getAllAtoms();
   parser->save(&output, atoms);
+  testParser->save(&output, atoms);
   input << output.str();
   FormatParser<pcp>* parser2 = new FormatParser<pcp>();
   parser2->load(&input);
+  PcpParser* testParser2 = new PcpParser();
+  testParser2->load(&input);
   CPPUNIT_ASSERT_EQUAL(6, World::getInstance().numAtoms());
+  CPPUNIT_ASSERT(*parser == *parser2);
+  delete parser2;
+  CPPUNIT_ASSERT(*testParser == *testParser2);
+}

src/Parser/unittests/ParserPcpUnitTest.hpp

-              r360c8b
+              rfa9d1d
 #endif
-#include "Parser/PcpParser.hpp"
 #include <cppunit/extensions/HelperMacros.h>
 …
   void readwritePcpTest();
-private:
-  FormatParser<pcp> *parser;
 };

src/Parser/unittests/ParserPdbUnitTest.cpp

-              r360c8b
+              rfa9d1d
 #include <cppunit/ui/text/TestRunner.h>
+#include "Parser/PdbParser.hpp"
 #include "World.hpp"
 #include "atom.hpp"
 …
 #include "CodePatterns/Log.hpp"
 #include "Descriptors/AtomTypeDescriptor.hpp"
-#include "Parser/ChangeTracker.hpp"
-#include "Parser/PdbParser.hpp"
 #ifdef HAVE_TESTRUNNER
 …
   World::getInstance();
-  parser = new FormatParser<pdb>();
   setVerbosity(2);
 …
+}
+void ParserPdbUnitTest::tearDown()
+{
+  delete parser;
+void ParserPdbUnitTest::tearDown() {
   ChangeTracker::purgeInstance();
   World::purgeInstance();
 …
   stringstream input;
   input << waterPdb;
+  parser->load(&input);
+  PdbParser* testParser = new PdbParser();
+  testParser->load(&input);
   input.clear();
 …
   stringstream output;
   std::vector<atom *> atoms = World::getInstance().getAllAtoms();
   parser->save(&output, atoms);
+  testParser->save(&output, atoms);
 //  std::cout << "Save PDB is:" << std::endl;
 …
   input << output.str();
   FormatParser<pdb>* parser2 = new FormatParser<pdb>();
   parser2->load(&input);
+  PdbParser* testParser2 = new PdbParser();
+  testParser2->load(&input);
   CPPUNIT_ASSERT_EQUAL(12, World::getInstance().numAtoms());
-  delete parser2;
+}

src/Parser/unittests/ParserPdbUnitTest.hpp

-              r360c8b
+              rfa9d1d
 #endif
-#include "Parser/PdbParser.hpp"
 #include <cppunit/extensions/HelperMacros.h>
 …
   void readwritePdbTest();
-private:
-  FormatParser<pdb> *parser;
 };

src/Parser/unittests/ParserTremoloUnitTest.cpp

-              r360c8b
+              rfa9d1d
 #include "Descriptors/AtomTypeDescriptor.hpp"
 #include "Element/element.hpp"
+#include "Parser/MpqcParser.hpp"
+#include "Parser/PdbParser.hpp"
+#include "Parser/PcpParser.hpp"
+#include "Parser/TremoloParser.hpp"
+#include "Parser/XyzParser.hpp"
 #include "Element/periodentafel.hpp"
-#include "Parser/TremoloParser.hpp"
-#include "Parser/ChangeTracker.hpp"
 #include "World.hpp"
 #include "WorldTime.hpp"
 …
   World::getInstance();
-  parser = new FormatParser<tremolo>();
   // we need hydrogens and oxygens in the following tests
   CPPUNIT_ASSERT(World::getInstance().getPeriode()->FindElement(1) != NULL);
 …
+}
+void ParserTremoloUnitTest::tearDown()
+{
+  delete parser;
+void ParserTremoloUnitTest::tearDown() {
   ChangeTracker::purgeInstance();
   World::purgeInstance();
 …
 void ParserTremoloUnitTest::readTremoloPreliminaryCommentsTest() {
   cout << "Testing the tremolo parser." << endl;
+  TremoloParser* testParser = new TremoloParser();
   stringstream input, output;
 …
+  {
     input << Tremolo_Atomdata1;
     parser->load(&input);
     std::vector<atom *> atoms = World::getInstance().getAllAtoms();
     parser->save(&output, atoms);
+    testParser->load(&input);
+    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
+    testParser->save(&output, atoms);
 //    std::cout << output.str() << std::endl;
 //    std::cout << Tremolo_Atomdata1 << std::endl;
 …
+  {
     input << Tremolo_Atomdata2;
     parser->load(&input);
     std::vector<atom *> atoms = World::getInstance().getAllAtoms();
     parser->save(&output, atoms);
+    testParser->load(&input);
+    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
+    testParser->save(&output, atoms);
     std::cout << output.str() << std::endl;
     CPPUNIT_ASSERT(output.str().find("hydrogen") != string::npos);
 …
   // Invalid key in Atomdata line
   input << Tremolo_invalidkey;
   parser->load(&input);
+  testParser->load(&input);
   //TODO: prove invalidity
   input.clear();
 …
 void ParserTremoloUnitTest::readTremoloCoordinatesTest() {
+  TremoloParser* testParser = new TremoloParser();
   stringstream input;
   // One simple data line
   input << Tremolo_Atomdata2;
   parser->load(&input);
+  testParser->load(&input);
   CPPUNIT_ASSERT(World::getInstance().getAtom(AtomByType(1))->at(0) == 3.0);
   input.clear();
 …
 void ParserTremoloUnitTest::readTremoloVelocityTest() {
+  TremoloParser* testParser = new TremoloParser();
   stringstream input;
   // One simple data line
   input << Tremolo_velocity;
   parser->load(&input);
+  testParser->load(&input);
   CPPUNIT_ASSERT(World::getInstance().getAtom(AtomByType(1))->getAtomicVelocity()[0] == 3.0);
   input.clear();
 …
 void ParserTremoloUnitTest::readTremoloNeighborInformationTest() {
+  TremoloParser* testParser = new TremoloParser();
   stringstream input;
   // Neighbor data
   input << Tremolo_neighbours;
   parser->load(&input);
+  testParser->load(&input);
   CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
 …
 void ParserTremoloUnitTest::readAndWriteTremoloImprDataInformationTest() {
+  TremoloParser* testParser = new TremoloParser();
   stringstream input, output;
 …
+  {
     input << Tremolo_improper;
     parser->load(&input);
     std::vector<atom *> atoms = World::getInstance().getAllAtoms();
     parser->save(&output, atoms);
+    testParser->load(&input);
+    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
+    testParser->save(&output, atoms);
     CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
     std::cout << output.str() << std::endl;
 …
 void ParserTremoloUnitTest::readAndWriteTremoloTorsionInformationTest() {
+  TremoloParser* testParser = new TremoloParser();
   stringstream input, output;
 …
+  {
     input << Tremolo_torsion;
     parser->load(&input);
     std::vector<atom *> atoms = World::getInstance().getAllAtoms();
     parser->save(&output, atoms);
+    testParser->load(&input);
+    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
+    testParser->save(&output, atoms);
     CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
     std::cout << output.str() << std::endl;
 …
 void ParserTremoloUnitTest::writeTremoloTest() {
+  TremoloParser* testParser = new TremoloParser();
   stringstream output;
 …
     atom* newAtom = World::getInstance().createAtom();
     newAtom->setType(1);
     parser->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");
     std::vector<atom *> atoms = World::getInstance().getAllAtoms();
     parser->save(&output, atoms);
+    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");
+    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
+    testParser->save(&output, atoms);
     CPPUNIT_ASSERT(output.str() == Tremolo_full);
+  }
 …
   cout << "testing the tremolo parser is done" << endl;
+}

src/Parser/unittests/ParserTremoloUnitTest.hpp

-              r360c8b
+              rfa9d1d
 #endif
-#include "Parser/TremoloParser.hpp"
 #include <cppunit/extensions/HelperMacros.h>
 …
   void readAndWriteTremoloTorsionInformationTest();
   void writeTremoloTest();
-private:
-  FormatParser<tremolo> *parser;
 };

src/Parser/unittests/ParserXyzUnitTest.cpp

-              r360c8b
+              rfa9d1d
 #include <cppunit/ui/text/TestRunner.h>
+#include "Parser/XyzParser.hpp"
 #include "World.hpp"
 #include "atom.hpp"
 …
 #include "CodePatterns/Log.hpp"
 #include "Descriptors/AtomTypeDescriptor.hpp"
-#include "Parser/ChangeTracker.hpp"
-#include "Parser/XyzParser.hpp"
 #ifdef HAVE_TESTRUNNER
 …
   World::getInstance();
-  parser = new FormatParser<xyz>();
   setVerbosity(2);
 …
+}
+void ParserXyzUnitTest::tearDown()
+{
+  delete parser;
+void ParserXyzUnitTest::tearDown() {
   ChangeTracker::purgeInstance();
   World::purgeInstance();
 …
 void ParserXyzUnitTest::rewriteAnXyzTest() {
   cout << "Testing the XYZ parser." << endl;
+  XyzParser* testParser = new XyzParser();
   stringstream input;
   input << waterXyz;
   parser->load(&input);
+  testParser->load(&input);
   input.clear();
 …
     stringstream output;
     std::vector<atom *> atoms = World::getInstance().getAllAtoms();
     parser->save(&output, atoms);
+    testParser->save(&output, atoms);
     input << output.str();
     parser->load(&input);
+    testParser->load(&input);
+  }
 …
 void ParserXyzUnitTest::readMultiXyzTest() {
   cout << "Testing the multi time step XYZ parser." << endl;
+  XyzParser* testParser = new XyzParser();
   stringstream input;
   input << waterMultiXyz;
   parser->load(&input);
+  testParser->load(&input);
   input.clear();
 …
 void ParserXyzUnitTest::writeMultiXyzTest() {
+  XyzParser* testParser = new XyzParser();
   stringstream input;
   input << waterMultiXyz;
   parser->load(&input);
+  testParser->load(&input);
   input.clear();
 …
     stringstream output;
     std::vector<atom *> atoms = World::getInstance().getAllAtoms();
     parser->save(&output, atoms);
+    testParser->save(&output, atoms);
     input << output.str();
     parser->load(&input);
+    testParser->load(&input);
+  }

src/Parser/unittests/ParserXyzUnitTest.hpp

-              r360c8b
+              rfa9d1d
 #endif
-#include "Parser/XyzParser.hpp"
 #include <cppunit/extensions/HelperMacros.h>
 …
   void readMultiXyzTest();
   void writeMultiXyzTest();
-private:
-  FormatParser<xyz> *parser;
 };

src/atom.cpp

-              r360c8b
+              rfa9d1d
 };
-void atom::OutputPsi3Line(ostream * const out, const Vector *center) const
+{
-  Vector recentered(getPosition());
-  recentered -= *center;
-  *out << "\t( " << getType()->getSymbol() << "\t" << recentered[0] << "\t" << recentered[1] << "\t" << recentered[2] << " )" << endl;
-};
 bool atom::Compare(const atom &ptr) const
+{

src/atom.hpp

-              r360c8b
+              rfa9d1d
    */
   void OutputMPQCLine(ostream * const out, const Vector *center) const;
-  /** Outputs the Psi3 configuration line for this atom.
-   * \param *out output stream
-   * \param *center center of molecule subtracted from position
-   * \param *AtomNo pointer to atom counter that is increased by one
-   */
-  void OutputPsi3Line(ostream * const out, const Vector *center) const;
   /** Initialises the component number array.

src/moleculelist.cpp

r360c8b	rfa9d1d
626	626	// atoms.resize((*ListRunner)->getAtomCount());
627	627	// std::copy((ListRunner)->begin(), (ListRunner)->end(), atoms.begin());
628		FormatParserStorage::getInstance().get~~(mpqc~~).save(&outfile, atoms);
	628	FormatParserStorage::getInstance().getMpqc().save(&outfile, atoms);
629	629	// if ((intermediateResult = World::getInstance().getConfig()->SaveMPQC(FragmentName.c_str(), (*ListRunner))))
630	630	output << " done.";

src/unittests/BoxUnitTest.cpp

-              r360c8b
+              rfa9d1d
 void BoxUnittest::setUp(){
-  // failing asserts should be thrown
   ASSERT_DO(Assert::Throw);
   unit = new RealSpaceMatrix;
   unit->setIdentity();

src/unittests/FormulaUnitTest.cpp

-              r360c8b
+              rfa9d1d
 CPPUNIT_TEST_SUITE_REGISTRATION( FormulaUnittest );
+void FormulaUnittest::setUp()
+{
+  // failing asserts should be thrown
+  ASSERT_DO(Assert::Throw);
+}
+void FormulaUnittest::tearDown()
+{
+void FormulaUnittest::setUp(){}
+void FormulaUnittest::tearDown(){
   World::purgeInstance();
+}

tests/regression/Makefile.am

-              r360c8b
+              rfa9d1d
         $(srcdir)/Parser/Pdb/testsuite-parser-pdb-save.at \
         $(srcdir)/Parser/Pdb/testsuite-parser-pdb-with-conects.at \
-        $(srcdir)/Parser/Psi3/testsuite-parser-psi3-empty.at \
-        $(srcdir)/Parser/Psi3/testsuite-parser-psi3-load.at \
-        $(srcdir)/Parser/Psi3/testsuite-parser-psi3-save.at \
         $(srcdir)/Parser/Tremolo/testsuite-parser-tremolo-empty.at \
         $(srcdir)/Parser/Tremolo/testsuite-parser-tremolo-load.at \

tests/regression/Parser/testsuite-parser.at

-              r360c8b
+              rfa9d1d
 m4_include([Parser/Pdb/testsuite-parser-pdb-load-various.at])
-# parsing mpqc
-m4_include([Parser/Psi3/testsuite-parser-psi3-empty.at])
-m4_include([Parser/Psi3/testsuite-parser-psi3-load.at])
-m4_include([Parser/Psi3/testsuite-parser-psi3-save.at])
 # parsing tremolo
 m4_include([Parser/Tremolo/testsuite-parser-tremolo-empty.at])

Context Navigation

Changes in / [360c8b:fa9d1d]

Legend:

Download in other formats: