Changes in src/Actions/MapOfActions.cpp [980dd6:4e4c4d]

File:

• src/Actions/MapOfActions.cpp (modified) (26 diffs)

src/Actions/MapOfActions.cpp

@@ -6 +6 @@
  */
 
+#include "Helpers/MemDebug.hpp"
+
 using namespace std;
 
+#include "Actions/MapOfActions.hpp"
+#include "Descriptors/AtomIdDescriptor.hpp"
+#include "Descriptors/MoleculeIdDescriptor.hpp"
+#include "Helpers/Assert.hpp"
 #include "Patterns/Singleton_impl.hpp"
-#include "Actions/MapOfActions.hpp"
-#include "Helpers/Assert.hpp"
 
 #include <boost/lexical_cast.hpp>
@@ -16 +20 @@
 #include <boost/program_options.hpp>
 
+#include <iostream>
+
+#include "atom.hpp"
+#include "Box.hpp"
 #include "CommandLineParser.hpp"
+#include "element.hpp"
 #include "log.hpp"
+#include "Matrix.hpp"
+#include "molecule.hpp"
+#include "periodentafel.hpp"
+#include "vector.hpp"
 #include "verbose.hpp"
 
+#include "Actions/ActionRegistry.hpp"
+#include "Actions/AnalysisAction/MolecularVolumeAction.hpp"
+#include "Actions/AnalysisAction/PairCorrelationAction.hpp"
+#include "Actions/AnalysisAction/PointCorrelationAction.hpp"
+#include "Actions/AnalysisAction/PrincipalAxisSystemAction.hpp"
+#include "Actions/AnalysisAction/SurfaceCorrelationAction.hpp"
+#include "Actions/AtomAction/AddAction.hpp"
+#include "Actions/AtomAction/ChangeElementAction.hpp"
+#include "Actions/AtomAction/RemoveAction.hpp"
+#include "Actions/CmdAction/BondLengthTableAction.hpp"
+#include "Actions/CmdAction/ElementDbAction.hpp"
+#include "Actions/CmdAction/FastParsingAction.hpp"
+#include "Actions/CmdAction/HelpAction.hpp"
+#include "Actions/CmdAction/VerboseAction.hpp"
+#include "Actions/CmdAction/VersionAction.hpp"
+#include "Actions/FragmentationAction/DepthFirstSearchAction.hpp"
+#include "Actions/FragmentationAction/SubgraphDissectionAction.hpp"
+#include "Actions/FragmentationAction/FragmentationAction.hpp"
+#include "Actions/MoleculeAction/BondFileAction.hpp"
+#include "Actions/MoleculeAction/ChangeNameAction.hpp"
+#include "Actions/MoleculeAction/FillWithMoleculeAction.hpp"
+#include "Actions/MoleculeAction/LinearInterpolationofTrajectoriesAction.hpp"
+#include "Actions/MoleculeAction/RotateToPrincipalAxisSystemAction.hpp"
+#include "Actions/MoleculeAction/SaveAdjacencyAction.hpp"
+#include "Actions/MoleculeAction/SaveBondsAction.hpp"
+#include "Actions/MoleculeAction/SaveTemperatureAction.hpp"
+#include "Actions/MoleculeAction/SuspendInWaterAction.hpp"
+#include "Actions/MoleculeAction/TranslateAction.hpp"
+#include "Actions/MoleculeAction/VerletIntegrationAction.hpp"
+#include "Actions/ParserAction/LoadXyzAction.hpp"
+#include "Actions/ParserAction/SaveXyzAction.hpp"
+#include "Actions/SelectionAction/AllAtomsAction.hpp"
+#include "Actions/SelectionAction/AllMoleculesAction.hpp"
+#include "Actions/SelectionAction/AtomByIdAction.hpp"
+#include "Actions/SelectionAction/MoleculeByIdAction.hpp"
+#include "Actions/SelectionAction/NotAllAtomsAction.hpp"
+#include "Actions/SelectionAction/NotAllMoleculesAction.hpp"
+#include "Actions/SelectionAction/NotAtomByIdAction.hpp"
+#include "Actions/SelectionAction/NotMoleculeByIdAction.hpp"
+#include "Actions/TesselationAction/ConvexEnvelopeAction.hpp"
+#include "Actions/TesselationAction/NonConvexEnvelopeAction.hpp"
+#include "Actions/WorldAction/AddEmptyBoundaryAction.hpp"
+#include "Actions/WorldAction/BoundInBoxAction.hpp"
+#include "Actions/WorldAction/CenterInBoxAction.hpp"
+#include "Actions/WorldAction/CenterOnEdgeAction.hpp"
+#include "Actions/WorldAction/ChangeBoxAction.hpp"
+#include "Actions/WorldAction/InputAction.hpp"
+#include "Actions/WorldAction/OutputAction.hpp"
+#include "Actions/WorldAction/RemoveSphereOfAtomsAction.hpp"
+#include "Actions/WorldAction/RepeatBoxAction.hpp"
+#include "Actions/WorldAction/ScaleBoxAction.hpp"
+#include "Actions/WorldAction/SetDefaultNameAction.hpp"
+#include "Actions/WorldAction/SetGaussianBasisAction.hpp"
+#include "Actions/WorldAction/SetOutputFormatsAction.hpp"
 #include "Actions/Values.hpp"
 
@@ -25 +92 @@
 {
   VectorValue VV;
-  if (values.size() != 3) {
-    cerr <<  "Specified vector does not have three components but " << values.size() << endl;
+  std::vector<std::string> components;
+
+  // split comma-separated values
+  if (values.size() != 1) {
+    cerr <<  "Not one vector but " << components.size() << " given " << endl;
+    throw boost::program_options::validation_error("Unequal to one vector given");
+  }
+  std::string argument(values.at(0));
+  std::string::iterator Aiter = argument.begin();
+  std::string::iterator Biter = argument.begin();
+  for (; Aiter != argument.end(); ++Aiter) {
+    if (*Aiter == ',') {
+      components.push_back(string(Biter,Aiter));
+      do {
+        Aiter++;
+      } while (*Aiter == ' ' || *Aiter == '\t');
+      Biter = Aiter;
+    }
+  }
+  components.push_back(string(Biter,argument.end()));
+
+  if (components.size() != 3) {
+    cerr <<  "Specified vector does not have three components but " << components.size() << endl;
     throw boost::program_options::validation_error("Specified vector does not have three components");
   }
-  VV.x = boost::lexical_cast<double>(values.at(0));
-  VV.y = boost::lexical_cast<double>(values.at(1));
-  VV.z = boost::lexical_cast<double>(values.at(2));
+  VV.x = boost::lexical_cast<double>(components.at(0));
+  VV.y = boost::lexical_cast<double>(components.at(1));
+  VV.z = boost::lexical_cast<double>(components.at(2));
   v = boost::any(VectorValue(VV));
 }
@@ -38 +126 @@
 {
   BoxValue BV;
-  if (values.size() != 6) {
-    cerr <<  "Specified vector does not have three components but " << values.size() << endl;
+  std::vector<std::string> components;
+
+  // split comma-separated values
+  if (values.size() != 1) {
+    cerr <<  "Not one vector but " << components.size() << " given " << endl;
+    throw boost::program_options::validation_error("Unequal to one vector given");
+  }
+  std::string argument(values.at(0));
+  std::string::iterator Aiter = argument.begin();
+  std::string::iterator Biter = argument.begin();
+  for (; Aiter != argument.end(); ++Aiter) {
+    if (*Aiter == ',') {
+      components.push_back(string(Biter,Aiter));
+      do {
+        Aiter++;
+      } while (*Aiter == ' ' || *Aiter == '\t');
+      Biter = Aiter;
+    }
+  }
+  components.push_back(string(Biter,argument.end()));
+
+  if (components.size() != 6) {
+    cerr <<  "Specified vector does not have three components but " << components.size() << endl;
     throw boost::program_options::validation_error("Specified symmetric box matrix does not have six components");
   }
-  BV.xx = boost::lexical_cast<double>(values.at(0));
-  BV.xy = boost::lexical_cast<double>(values.at(1));
-  BV.xz = boost::lexical_cast<double>(values.at(2));
-  BV.yy = boost::lexical_cast<double>(values.at(3));
-  BV.yz = boost::lexical_cast<double>(values.at(4));
-  BV.zz = boost::lexical_cast<double>(values.at(5));
+  BV.xx = boost::lexical_cast<double>(components.at(0));
+  BV.yx = boost::lexical_cast<double>(components.at(1));
+  BV.yy = boost::lexical_cast<double>(components.at(2));
+  BV.zx = boost::lexical_cast<double>(components.at(3));
+  BV.zy = boost::lexical_cast<double>(components.at(4));
+  BV.zz = boost::lexical_cast<double>(components.at(5));
   v = boost::any(BoxValue(BV));
 }
@@ -81 +190 @@
   DescriptionMap["fragment-mol"] = "create for a given molecule into fragments up to given order";
   DescriptionMap["help"] = "Give this help screen";
+  DescriptionMap["input"] = "specify input files";
   DescriptionMap["linear-interpolate"] = "linear interpolation in discrete steps between start and end position of a molecule";
+  DescriptionMap["molecular-volume"] = "calculate the volume of a given molecule";
   DescriptionMap["nonconvex-envelope"] = "create the non-convex envelope for a molecule";
-  DescriptionMap["molecular-volume"] = "calculate the volume of a given molecule";
-  DescriptionMap["pair-correlation"] = "pair correlation analysis between two elements, element and point or element and surface";
+  DescriptionMap["output"] = "write output files";
+  DescriptionMap["set-output"] = "specify output formats";
+  DescriptionMap["pair-correlation"] = "pair correlation analysis between two elements";
   DescriptionMap["parse-xyz"] = "parse xyz file into World";
+  DescriptionMap["point-correlation"] = "pair correlation analysis between element and point";
   DescriptionMap["principal-axis-system"] = "calculate the principal axis system of the specified molecule";
   DescriptionMap["remove-atom"] = "remove a specified atom";
@@ -91 +204 @@
   DescriptionMap["repeat-box"] = "create periodic copies of the simulation box per axis";
   DescriptionMap["rotate-to-pas"] = "calculate the principal axis system of the specified molecule and rotate specified axis to align with main axis";
-  DescriptionMap["set-basis"] = "set the name of the gaussian basis set for MPQC";
   DescriptionMap["save-adjacency"] = "name of the adjacency file to write to";
   DescriptionMap["save-bonds"] = "name of the bonds file to write to";
   DescriptionMap["save-temperature"] = "name of the temperature file to write to";
+  DescriptionMap["SaveXyz"] = "save world as xyz file";
   DescriptionMap["scale-box"] = "scale box and atomic positions inside";
+  DescriptionMap["select-all-atoms"] = "select all atoms";
+  DescriptionMap["select-all-molecules"] = "select all molecules";
+  DescriptionMap["select-atom-by-id"] = "select an atom by index";
+  DescriptionMap["select-molecule-by-id"] = "select a molecule by index";
+  DescriptionMap["set-basis"] = "set the name of the gaussian basis set for MPQC";
+  DescriptionMap["set-output"] = "specify output formats";
   DescriptionMap["subgraph-dissect"] = "dissect the molecular system into molecules representing disconnected subgraphs";
+  DescriptionMap["surface-correlation"] = "pair correlation analysis between element and surface";
   DescriptionMap["suspend-in-water"] = "suspend the given molecule in water such that in the domain the mean density is as specified";
   DescriptionMap["translate-mol"] = "translate molecule by given vector";
+  DescriptionMap["unselect-all-atoms"] = "unselect all atoms";
+  DescriptionMap["unselect-all-molecules"] = "unselect all molecules";
+  DescriptionMap["unselect-atom-by-id"] = "unselect an atom by index";
+  DescriptionMap["unselect-molecule-by-id"] = "unselect a molecule by index";
   DescriptionMap["verbose"] = "set verbosity level";
   DescriptionMap["verlet-integrate"] = "perform verlet integration of a given force file";
   DescriptionMap["version"] = "show version";
   // keys for values
-  DescriptionMap["atom-by-id"] = "index of an atom";
   DescriptionMap["bin-output-file"] = "name of the bin output file";
   DescriptionMap["bin-end"] = "start of the last bin";
@@ -121 +244 @@
   DescriptionMap["MaxDistance"] = "maximum distance in space";
   DescriptionMap["molecule-by-id"] = "index of a molecule";
-  DescriptionMap["molecule-by-name"] = "name of a molecule";
   DescriptionMap["nonconvex-file"] = "filename of the non-convex envelope";
   DescriptionMap["order"] = "order of a discretization, dissection, ...";
@@ -127 +249 @@
   DescriptionMap["periodic"] = "system is constraint to periodic boundary conditions (y/n)";
   DescriptionMap["position"] = "position in R^3 space";
-  DescriptionMap["sphere-radius"] = "radius of tesselation sphere";
   DescriptionMap["start-step"] = "first or start step";
 
@@ -139 +260 @@
   ShortFormMap["center-in-box"] = "b";
   ShortFormMap["change-element"] = "E";
-  ShortFormMap["convex-envelope"] = "o";
+//  ShortFormMap["convex-envelope"] = "x";
   ShortFormMap["default-molname"] = "X";
   ShortFormMap["depth-first-search"] = "D";
@@ -150 +271 @@
   ShortFormMap["linear-interpolate"] = "L";
   ShortFormMap["nonconvex-envelope"] = "N";
-  ShortFormMap["pair-correlation"] = "C";
+//  ShortFormMap["output"] = "o";
+//  ShortFormMap["pair-correlation"] = "C";
   ShortFormMap["parse-xyz"] = "p";
   ShortFormMap["remove-atom"] = "r";
@@ -161 +283 @@
   ShortFormMap["scale-box"] = "s";
   ShortFormMap["set-basis"] = "M";
+  ShortFormMap["set-output"] = "o";
   ShortFormMap["subgraph-dissect"] = "I";
   ShortFormMap["suspend-in-water"] = "u";
@@ -169 +292 @@
 
   // value types for the actions
-  TypeMap["add-atom"] = Element;
-  TypeMap["bond-file"] = String;
-  TypeMap["bond-table"] = String;
-  TypeMap["boundary"] = Vector;
-  TypeMap["center-in-box"] = Box;
-  TypeMap["change-box"] = Box;
-  TypeMap["change-element"] = Atom;
-  TypeMap["change-molname"] = String;
-  TypeMap["convex-envelope"] = Molecule;
-  TypeMap["default-molname"] = String;
-  TypeMap["depth-first-search"] = Double;
-  TypeMap["element-db"] = String;
-  TypeMap["fastparsing"] = Boolean;
-  TypeMap["fill-molecule"] = String;
-  TypeMap["fragment-mol"] = Molecule;
-  TypeMap["input"] = String;
-  TypeMap["linear-interpolate"] = String;
-  TypeMap["molecular-volume"] = Molecule;
-  TypeMap["nonconvex-envelope"] = Molecule;
-  TypeMap["parse-xyz"] = String;
-  TypeMap["pair-correlation"] = String;
-  TypeMap["principal-axis-system"] = Molecule;
-  TypeMap["remove-atom"] = Atom;
-  TypeMap["remove-sphere"] = Double;
-  TypeMap["repeat-box"] = Vector;
-  TypeMap["rotate-to-pas"] = Molecule;
-  TypeMap["save-adjacency"] = String;
-  TypeMap["save-bonds"] = String;
-  TypeMap["save-temperature"] = String;
-  TypeMap["scale-box"] = Vector;
-  TypeMap["set-basis"] = String;
-  TypeMap["subgraph-dissect"] = None;
-  TypeMap["suspend-in-water"] = Double;
-  TypeMap["translate-mol"] = Vector;
-  TypeMap["verlet-integrate"] = String;
-  TypeMap["verbose"] = Integer;
+  TypeMap["add-atom"] = &typeid(element);
+  TypeMap["bond-file"] = &typeid(std::string);
+  TypeMap["bond-table"] = &typeid(std::string);
+  TypeMap["boundary"] = &typeid(VectorValue);
+  TypeMap["center-in-box"] = &typeid(BoxValue);
+  TypeMap["change-box"] = &typeid(BoxValue);
+  TypeMap["change-element"] = &typeid(element);
+  TypeMap["change-molname"] = &typeid(std::string);
+  TypeMap["convex-envelope"] = &typeid(void);
+  TypeMap["default-molname"] = &typeid(std::string);
+  TypeMap["depth-first-search"] = &typeid(double);
+  TypeMap["element-db"] = &typeid(std::string);
+  TypeMap["fastparsing"] = &typeid(bool);
+  TypeMap["fill-molecule"] = &typeid(std::string);
+  TypeMap["fragment-mol"] = &typeid(std::string);
+  TypeMap["input"] = &typeid(std::string);
+  TypeMap["linear-interpolate"] = &typeid(std::string);
+  TypeMap["molecular-volume"] = &typeid(molecule);
+  TypeMap["nonconvex-envelope"] = &typeid(double);
+  TypeMap["output"] = &typeid(void);
+  TypeMap["parse-xyz"] = &typeid(std::string);
+  TypeMap["pair-correlation"] = &typeid(void);
+  TypeMap["point-correlation"] = &typeid(void);
+  TypeMap["principal-axis-system"] = &typeid(void);
+  TypeMap["remove-atom"] = &typeid(void);
+  TypeMap["remove-sphere"] = &typeid(double);
+  TypeMap["repeat-box"] = &typeid(VectorValue);
+  TypeMap["rotate-to-pas"] = &typeid(molecule);
+  TypeMap["save-adjacency"] = &typeid(std::string);
+  TypeMap["save-bonds"] = &typeid(std::string);
+  TypeMap["save-temperature"] = &typeid(std::string);
+  TypeMap["scale-box"] = &typeid(VectorValue);
+  TypeMap["set-basis"] = &typeid(std::string);
+  TypeMap["set-output"] = &typeid(std::vector<std::string>);
+  TypeMap["subgraph-dissect"] = &typeid(void);
+  TypeMap["surface-correlation"] = &typeid(void);
+  TypeMap["suspend-in-water"] = &typeid(double);
+  TypeMap["translate-mol"] = &typeid(VectorValue);
+  TypeMap["verlet-integrate"] = &typeid(std::string);
+  TypeMap["verbose"] = &typeid(int);
 
   // value types for the values
-  TypeMap["atom-by-id"] = Atom;
-  TypeMap["bin-output-file"] = String;
-  TypeMap["bin-end"] = Double;
-  TypeMap["bin-start"] = Double;
-  TypeMap["bin-width"] = Double;
-  TypeMap["convex-file"] = String;
-  TypeMap["distance"] = Double;
-  TypeMap["distances"] = Vector;
-  TypeMap["DoRotate"] = Boolean;
-  TypeMap["element"] = Element;
-  TypeMap["elements"] = ListOfElements;
-  TypeMap["end-step"] = Integer;
-  TypeMap["id-mapping"] = Boolean;
-  TypeMap["length"] = Double;
-  TypeMap["lengths"] = Vector;
-  TypeMap["MaxDistance"] = Double;
-  TypeMap["molecule-by-id"] = Molecule;
-  TypeMap["molecule-by-name"] = Molecule;
-  TypeMap["nonconvex-file"] = String;
-  TypeMap["order"] = Integer;
-  TypeMap["output-file"] = String;
-  TypeMap["periodic"] = Boolean;
-  TypeMap["position"] = Vector;
-  TypeMap["sphere-radius"] = Double;
-  TypeMap["start-step"] = Integer;
+  TypeMap["bin-output-file"] = &typeid(std::string);
+  TypeMap["bin-end"] = &typeid(double);
+  TypeMap["bin-start"] = &typeid(double);
+  TypeMap["bin-width"] = &typeid(double);
+  TypeMap["convex-file"] = &typeid(std::string);
+  TypeMap["distance"] = &typeid(double);
+  TypeMap["distances"] = &typeid(VectorValue);
+  TypeMap["DoRotate"] = &typeid(bool);
+  TypeMap["element"] = &typeid(element);
+  TypeMap["elements"] = &typeid(std::vector<element *>);
+  TypeMap["end-step"] = &typeid(int);
+  TypeMap["id-mapping"] = &typeid(bool);
+  TypeMap["length"] = &typeid(double);
+  TypeMap["lengths"] = &typeid(VectorValue);
+  TypeMap["MaxDistance"] = &typeid(double);
+  TypeMap["molecule-by-id"] = &typeid(molecule);
+  TypeMap["nonconvex-file"] = &typeid(std::string);
+  TypeMap["order"] = &typeid(int);
+  TypeMap["output-file"] = &typeid(std::string);
+  TypeMap["periodic"] = &typeid(bool);
+  TypeMap["position"] = &typeid(VectorValue);
+  TypeMap["select-all-atoms"] = &typeid(void);
+  TypeMap["select-all-molecules"] = &typeid(void);
+  TypeMap["select-atom-by-id"] = &typeid(atom);
+  TypeMap["select-molecule-by-id"] = &typeid(molecule);
+  TypeMap["start-step"] = &typeid(int);
+  TypeMap["unselect-all-atoms"] = &typeid(void);
+  TypeMap["unselect-all-molecules"] = &typeid(void);
+  TypeMap["unselect-atom-by-id"] = &typeid(atom);
+  TypeMap["unselect-molecule-by-id"] = &typeid(molecule);
+
+  TypeEnumMap[&typeid(void)] = None;
+  TypeEnumMap[&typeid(bool)] = Boolean;
+  TypeEnumMap[&typeid(int)] = Integer;
+  TypeEnumMap[&typeid(std::vector<int>)] = ListOfIntegers;
+  TypeEnumMap[&typeid(double)] = Double;
+  TypeEnumMap[&typeid(std::vector<double>)] = ListOfDoubles;
+  TypeEnumMap[&typeid(std::string)] = String;
+  TypeEnumMap[&typeid(std::vector<std::string>)] = ListOfStrings;
+  TypeEnumMap[&typeid(VectorValue)] = Vector;
+  TypeEnumMap[&typeid(std::vector<VectorValue>)] = ListOfVectors;
+  TypeEnumMap[&typeid(BoxValue)] = Box;
+  TypeEnumMap[&typeid(molecule)] = Molecule;
+  TypeEnumMap[&typeid(std::vector<molecule *>)] = ListOfMolecules;
+  TypeEnumMap[&typeid(atom)] = Atom;
+  TypeEnumMap[&typeid(std::vector<atom *>)] = ListOfAtoms;
+  TypeEnumMap[&typeid(element)] = Element;
+  TypeEnumMap[&typeid(std::vector<element *>)] = ListOfElements;
 
   // default values for any action that needs one (always string!)
-  DefaultValue["bin-width"] = "0.5";
-  DefaultValue["fastparsing"] = "0";
-  DefaultValue["atom-by-id"] = "-1";
-  DefaultValue["molecule-by-id"] = "-1";
-  DefaultValue["periodic"] = "0";
-
-
-  // list of generic actions
+  CurrentValue["bin-width"] = "0.5";
+  CurrentValue["fastparsing"] = "0";
+  CurrentValue["periodic"] = "0";
+
+  // put action into each menu category
+  MenuDescription["analysis"] = pair<std::string,std::string>("Analysis (pair correlation, volume)", "Analysis");
+  MenuDescription["atom"] = pair<std::string,std::string>("Edit atoms", "Atoms");
+  MenuDescription["command"] = pair<std::string,std::string>("Configuration", "configuration options");
+  MenuDescription["fragmentation"] = pair<std::string,std::string>("Fragmentation", "Fragmentation");
+  MenuDescription["molecule"] = pair<std::string,std::string>("Parse files into system", "Molecules");
+  MenuDescription["parser"] = pair<std::string,std::string>("Edit molecules (load, parse, save)", "Input/Output");
+  MenuDescription["selection"] = pair<std::string,std::string>("Select atoms/molecules", "Selection");
+  MenuDescription["tesselation"] = pair<std::string,std::string>("Tesselate molecules", "Tesselation");
+  MenuDescription["world"] = pair<std::string,std::string>("Edit world", "Globals");
+
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "molecular-volume") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "pair-correlation") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "point-correlation") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "surface-correlation") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("analysis", "principal-axis-system") );
+
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("atom", "add-atom") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("atom", "change-element") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("atom", "remove-atom") );
+
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("command", "bond-table") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("command", "element-db") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("command", "fastparsing") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("command", "verbose") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("command", "version") );
+
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("fragmentation", "depth-first-search") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("fragmentation", "fragment-mol") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("fragmentation", "subgraph-dissect") );
+
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "bond-file") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "change-molname") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "fill-molecule") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "linear-interpolate") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "rotate-to-pas") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "save-adjacency") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "save-bonds") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "save-temperature") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "suspend-in-water") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "translate-mol") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("molecule", "verlet-integrate") );
+
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("parser", "parse-xyz") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("parser", "SaveXyz") );
+
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-atom-by-id") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "select-molecule-by-id") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-atom-by-id") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("selection", "unselect-molecule-by-id") );
+
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("tesselation", "convex-envelope") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("tesselation", "nonconvex-envelope") );
+
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "boundary") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "bound-in-box") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "center-in-box") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "center-edge") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "change-box") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "input") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "output") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "remove-sphere") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "repeat-box") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "scale-box") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "default-molname") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "set-basis") );
+  MenuContainsActionMap.insert( pair<std::string, std::string> ("world", "set-output") );
+
+  // put actions into command line category
         generic.insert("add-atom");
   generic.insert("bond-file");
@@ -260 +475 @@
   generic.insert("fragment-mol");
   generic.insert("help");
-        generic.insert("linear-interpolate");
+  generic.insert("input");
+  generic.insert("linear-interpolate");
 //  generic.insert("molecular-volume");
   generic.insert("nonconvex-envelope");
+  generic.insert("output");
         generic.insert("pair-correlation");
-//      generic.insert("parse-xyz");
+        generic.insert("parse-xyz");
+  generic.insert("point-correlation");
 //  generic.insert("principal-axis-system");
   generic.insert("remove-atom");
@@ -274 +492 @@
   generic.insert("save-temperature");
   generic.insert("scale-box");
+  generic.insert("select-all-atoms");
+  generic.insert("select-all-molecules");
+  generic.insert("select-atom-by-id");
+  generic.insert("select-molecule-by-id");
   generic.insert("set-basis");
+  generic.insert("set-output");
         generic.insert("subgraph-dissect");
+  generic.insert("surface-correlation");
   generic.insert("suspend-in-water");
   generic.insert("translate-mol");
+  generic.insert("unselect-all-atoms");
+  generic.insert("unselect-all-molecules");
+  generic.insert("unselect-atom-by-id");
+  generic.insert("unselect-molecule-by-id");
         generic.insert("verbose");
   generic.insert("verlet-integrate");
@@ -284 +512 @@
     // positional arguments
   generic.insert("input");
-  inputfile.insert("input");
 
     // hidden arguments
-  generic.insert("atom-by-id");
-  generic.insert("bin-end");
-  generic.insert("bin-output-file");
-  generic.insert("bin-start");
-  generic.insert("bin-width");
-  generic.insert("convex-file");
-  generic.insert("distance");
-  generic.insert("DoRotate");
-  generic.insert("distances");
-  generic.insert("element");
-  generic.insert("elements");
-  generic.insert("end-step");
-  generic.insert("id-mapping");
-  generic.insert("lengths");
-  generic.insert("MaxDistance");
-  generic.insert("molecule-by-id");
-  generic.insert("molecule-by-name");
-  generic.insert("nonconvex-file");
-  generic.insert("order");
-  generic.insert("output-file");
-  generic.insert("periodic");
-  generic.insert("position");
-  generic.insert("sphere-radius");
-  generic.insert("start-step");
+  hidden.insert("bin-end");
+  hidden.insert("bin-output-file");
+  hidden.insert("bin-start");
+  hidden.insert("bin-width");
+  hidden.insert("convex-file");
+  hidden.insert("distance");
+  hidden.insert("DoRotate");
+  hidden.insert("distances");
+  hidden.insert("element");
+  hidden.insert("elements");
+  hidden.insert("end-step");
+  hidden.insert("id-mapping");
+  hidden.insert("lengths");
+  hidden.insert("MaxDistance");
+  hidden.insert("molecule-by-id");
+  hidden.insert("nonconvex-file");
+  hidden.insert("order");
+  hidden.insert("output-file");
+  hidden.insert("periodic");
+  hidden.insert("position");
+  hidden.insert("start-step");
 }
 
@@ -321 +545 @@
 }
 
+void MapOfActions::queryCurrentValue(const char * name, class atom * &_T)
+{
+  int atomID = -1;
+  if (typeid( atom ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    atomID = lexical_cast<int>(CurrentValue[name].c_str());
+    CurrentValue.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+  _T = World::getInstance().getAtom(AtomById(atomID));
+}
+
+void MapOfActions::queryCurrentValue(const char * name, class element * &_T)  {
+  int Z = -1;
+  if (typeid( element ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    Z = lexical_cast<int>(CurrentValue[name].c_str());
+    CurrentValue.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+  _T = World::getInstance().getPeriode()->FindElement(Z);
+}
+
+void MapOfActions::queryCurrentValue(const char * name, class molecule * &_T) {
+  int molID = -1;
+  if (typeid( molecule ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    molID = lexical_cast<int>(CurrentValue[name].c_str());
+    CurrentValue.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+  _T = World::getInstance().getMolecule(MoleculeById(molID));
+}
+
+void MapOfActions::queryCurrentValue(const char * name, class Box &_T) {
+  Matrix M;
+  double tmp;
+  if (typeid( BoxValue ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValue[name]);
+    stream >> tmp;
+    M.set(0,0,tmp);
+    stream >> tmp;
+    M.set(0,1,tmp);
+    M.set(1,0,tmp);
+    stream >> tmp;
+    M.set(0,2,tmp);
+    M.set(2,0,tmp);
+    stream >> tmp;
+    M.set(1,1,tmp);
+    stream >> tmp;
+    M.set(1,2,tmp);
+    M.set(2,1,tmp);
+    stream >> tmp;
+    M.set(2,2,tmp);
+    _T = M;
+    CurrentValue.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void MapOfActions::queryCurrentValue(const char * name, class Vector &_T) {
+  if (typeid( VectorValue ) == *TypeMap[name]) {
+    std::istringstream stream(CurrentValue[name]);
+    CurrentValue.erase(name);
+    stream >> _T[0];
+    stream >> _T[1];
+    stream >> _T[2];
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void MapOfActions::queryCurrentValue(const char * name, std::vector<atom *>&_T)
+{
+  int atomID = -1;
+  atom *Walker = NULL;
+  if (typeid( std::vector<atom *> ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValue[name]);
+    CurrentValue.erase(name);
+    while (!stream.fail()) {
+      stream >> atomID >> ws;
+      Walker = World::getInstance().getAtom(AtomById(atomID));
+      if (Walker != NULL)
+        _T.push_back(Walker);
+      atomID = -1;
+      Walker = NULL;
+    }
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void MapOfActions::queryCurrentValue(const char * name, std::vector<element *>&_T)
+{
+  int Z = -1;
+  element *elemental = NULL;
+  if (typeid( std::vector<element *> ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValue[name]);
+    CurrentValue.erase(name);
+    while (!stream.fail()) {
+      stream >> Z >> ws;
+      elemental = World::getInstance().getPeriode()->FindElement(Z);
+      if (elemental != NULL)
+        _T.push_back(elemental);
+      Z = -1;
+    }
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void MapOfActions::queryCurrentValue(const char * name, std::vector<molecule *>&_T)
+{
+  int molID = -1;
+  molecule *mol = NULL;
+  if (typeid( std::vector<molecule *> ) == *TypeMap[name]) {
+    if (CurrentValue.find(name) == CurrentValue.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValue[name]);
+    CurrentValue.erase(name);
+    while (!stream.fail()) {
+      stream >> molID >> ws;
+      mol = World::getInstance().getMolecule(MoleculeById(molID));
+      if (mol != NULL)
+        _T.push_back(mol);
+      molID = -1;
+      mol = NULL;
+    }
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+
+void MapOfActions::setCurrentValue(const char * name, class atom * &_T)
+{
+  if (typeid( atom ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    stream << _T->getId();
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void MapOfActions::setCurrentValue(const char * name, class element * &_T)
+{
+  if (typeid( element ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    stream << _T->Z;
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void MapOfActions::setCurrentValue(const char * name, class molecule * &_T)
+{
+  if (typeid( molecule ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    stream << _T->getId();
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void MapOfActions::setCurrentValue(const char * name, class Box &_T)
+{
+  const Matrix &M = _T.getM();
+  if (typeid( BoxValue ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    stream << M.at(0,0) << " ";
+    stream << M.at(0,1) << " ";
+    stream << M.at(0,2) << " ";
+    stream << M.at(1,1) << " ";
+    stream << M.at(1,2) << " ";
+    stream << M.at(2,2) << " ";
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void MapOfActions::setCurrentValue(const char * name, class Vector &_T)
+{
+  if (typeid( VectorValue ) == *TypeMap[name]){
+    std::ostringstream stream;
+    stream << _T[0] << " ";
+    stream << _T[1] << " ";
+    stream << _T[2] << " ";
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void MapOfActions::setCurrentValue(const char * name, std::vector<atom *>&_T)
+{
+  if (typeid( std::vector<atom *> ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    for (std::vector<atom *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+      stream << (*iter)->getId() << " ";
+    }
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void MapOfActions::setCurrentValue(const char * name, std::vector<element *>&_T)
+{
+  if (typeid( std::vector<element *> ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    for (std::vector<element *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+      stream << (*iter)->Z << " ";
+    }
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void MapOfActions::setCurrentValue(const char * name, std::vector<molecule *>&_T)
+{
+  if (typeid( std::vector<molecule *> ) == *TypeMap[name]) {
+    std::ostringstream stream;
+    for (std::vector<molecule *>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+      stream << (*iter)->getId() << " ";
+    }
+    CurrentValue[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+
+
+void MapOfActions::populateActions()
+{
+  new AnalysisMolecularVolumeAction();
+  new AnalysisPairCorrelationAction();
+  new AnalysisPointCorrelationAction();
+  new AnalysisPrincipalAxisSystemAction();
+  new AnalysisSurfaceCorrelationAction();
+
+  new AtomAddAction();
+  new AtomChangeElementAction();
+  new AtomRemoveAction();
+
+  new CommandLineBondLengthTableAction();
+  new CommandLineElementDbAction();
+  new CommandLineFastParsingAction();
+  new CommandLineHelpAction();
+  new CommandLineVerboseAction();
+  new CommandLineVersionAction();
+
+  new FragmentationDepthFirstSearchAction();
+  new FragmentationFragmentationAction();
+  new FragmentationSubgraphDissectionAction();
+
+  new MoleculeBondFileAction();
+  new MoleculeChangeNameAction();
+  new MoleculeFillWithMoleculeAction();
+  new MoleculeLinearInterpolationofTrajectoriesAction();
+  new MoleculeRotateToPrincipalAxisSystemAction();
+  new MoleculeSaveAdjacencyAction();
+  new MoleculeSaveBondsAction();
+  new MoleculeSaveTemperatureAction();
+  new MoleculeSuspendInWaterAction();
+  new MoleculeTranslateAction();
+  new MoleculeVerletIntegrationAction();
+
+  new ParserLoadXyzAction();
+  new ParserSaveXyzAction();
+
+  new SelectionAllAtomsAction();
+  new SelectionAllMoleculesAction();
+  new SelectionAtomByIdAction();
+  new SelectionMoleculeByIdAction();
+  new SelectionNotAllAtomsAction();
+  new SelectionNotAllMoleculesAction();
+  new SelectionNotAtomByIdAction();
+  new SelectionNotMoleculeByIdAction();
+
+  new TesselationConvexEnvelopeAction();
+  new TesselationNonConvexEnvelopeAction();
+
+  new WorldAddEmptyBoundaryAction();
+  new WorldBoundInBoxAction();
+  new WorldCenterInBoxAction();
+  new WorldCenterOnEdgeAction();
+  new WorldChangeBoxAction();
+  new WorldInputAction();
+  new WorldOutputAction();
+  new WorldRemoveSphereOfAtomsAction();
+  new WorldRepeatBoxAction();
+  new WorldScaleBoxAction();
+  new WorldSetDefaultNameAction();
+  new WorldSetGaussianBasisAction();
+  new WorldSetOutputFormatsAction();
+}
+
 /** Adds all options to the CommandLineParser.
  *
@@ -330 +854 @@
     for (set<string>::iterator OptionRunner = ListRunner->first->begin(); OptionRunner != ListRunner->first->end(); ++OptionRunner) {
       if (hasValue(*OptionRunner)) {
-        DoLog(0) && (Log() << Verbose(0) << "Adding option " << *OptionRunner << " with type " << TypeMap[*OptionRunner] << " to CommandLineParser." << endl);
-           switch((enum OptionTypes) TypeMap[*OptionRunner]) {
+        DoLog(1) && (Log() << Verbose(1) << "Adding option " << *OptionRunner << " with type " << TypeMap[*OptionRunner]->name() << " to CommandLineParser." << endl);
+           switch(TypeEnumMap[TypeMap[*OptionRunner]]) {
           default:
           case None:
@@ -341 +865 @@
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
-                  DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
-                        po::value< bool >()->default_value(atoi(DefaultValue[*OptionRunner].c_str())) :
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< bool >()->default_value(lexical_cast<int>(CurrentValue[*OptionRunner].c_str())) :
                         po::value< bool >(),
                   getDescription(*OptionRunner).c_str())
@@ -350 +874 @@
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
-                  po::value<BoxValue>()->multitoken(),
+                  po::value<BoxValue>(),
                   getDescription(*OptionRunner).c_str())
               ;
@@ -357 +881 @@
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
-                  DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
-                        po::value< int >()->default_value(atoi(DefaultValue[*OptionRunner].c_str())) :
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< int >()->default_value(lexical_cast<int>(CurrentValue[*OptionRunner].c_str())) :
                         po::value< int >(),
                   getDescription(*OptionRunner).c_str())
               ;
             break;
-          case ListOfInts:
+          case ListOfIntegers:
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
@@ -373 +897 @@
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
-                  DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
-                        po::value< double >()->default_value(atof(DefaultValue[*OptionRunner].c_str())) :
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< double >()->default_value(lexical_cast<double>(CurrentValue[*OptionRunner].c_str())) :
                         po::value< double >(),
                   getDescription(*OptionRunner).c_str())
@@ -389 +913 @@
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
-                  DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
-                        po::value< std::string >()->default_value(DefaultValue[*OptionRunner]) :
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< std::string >()->default_value(CurrentValue[*OptionRunner]) :
                         po::value< std::string >(),
                   getDescription(*OptionRunner).c_str())
               ;
             break;
-          case Axis:
-            ListRunner->second->add_options()
-              (getKeyAndShortForm(*OptionRunner).c_str(),
-                  DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
-                        po::value< int >()->default_value(atoi(DefaultValue[*OptionRunner].c_str())) :
+          case ListOfStrings:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  po::value< vector<std::string> >()->multitoken(),
+                  getDescription(*OptionRunner).c_str())
+              ;
+            break;
+          case Vector:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  po::value<VectorValue>(),
+                  getDescription(*OptionRunner).c_str())
+              ;
+            break;
+          case ListOfVectors:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  po::value< vector<VectorValue> >()->multitoken(),
+                  getDescription(*OptionRunner).c_str())
+              ;
+            break;
+          case Molecule:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< int >()->default_value(lexical_cast<int>(CurrentValue[*OptionRunner].c_str())) :
                         po::value< int >(),
                   getDescription(*OptionRunner).c_str())
               ;
             break;
-          case Vector:
-            ListRunner->second->add_options()
-              (getKeyAndShortForm(*OptionRunner).c_str(),
-                  po::value<VectorValue>()->multitoken(),
-                  getDescription(*OptionRunner).c_str())
-              ;
-            break;
-          case Molecule:
-            ListRunner->second->add_options()
-              (getKeyAndShortForm(*OptionRunner).c_str(),
-                  DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
-                        po::value< int >()->default_value(atoi(DefaultValue[*OptionRunner].c_str())) :
+          case ListOfMolecules:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  po::value< vector<int> >()->multitoken(),
+                  getDescription(*OptionRunner).c_str())
+              ;
+            break;
+          case Atom:
+            ListRunner->second->add_options()
+              (getKeyAndShortForm(*OptionRunner).c_str(),
+                  CurrentValue.find(*OptionRunner) != CurrentValue.end() ?
+                        po::value< int >()->default_value(lexical_cast<int>(CurrentValue[*OptionRunner].c_str())) :
                         po::value< int >(),
                   getDescription(*OptionRunner).c_str())
               ;
             break;
-          case ListOfMolecules:
+          case ListOfAtoms:
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
@@ -427 +972 @@
               ;
             break;
-          case Atom:
-            ListRunner->second->add_options()
-              (getKeyAndShortForm(*OptionRunner).c_str(),
-                  DefaultValue.find(*OptionRunner) != DefaultValue.end() ?
-                        po::value< int >()->default_value(atoi(DefaultValue[*OptionRunner].c_str())) :
-                        po::value< int >(),
-                  getDescription(*OptionRunner).c_str())
-              ;
-            break;
-          case ListOfAtoms:
-            ListRunner->second->add_options()
-              (getKeyAndShortForm(*OptionRunner).c_str(),
-                  po::value< vector<int> >()->multitoken(),
-                  getDescription(*OptionRunner).c_str())
-              ;
-            break;
           case Element:
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
-                  po::value< vector<int> >(),
+                  po::value< int >(),
                   getDescription(*OptionRunner).c_str())
               ;
@@ -459 +988 @@
         }
       } else {
-        DoLog(0) && (Log() << Verbose(0) << "Adding option " << *OptionRunner << " to CommandLineParser." << endl);
+        DoLog(3) && (Log() << Verbose(3) << "Adding option " << *OptionRunner << " to CommandLineParser." << endl);
         ListRunner->second->add_options()
           (getKeyAndShortForm(*OptionRunner).c_str(), getDescription(*OptionRunner).c_str())
@@ -466 +995 @@
     }
   }
-  // add positional arguments
-  for (set<string>::iterator OptionRunner = inputfile.begin(); OptionRunner != inputfile.end(); ++OptionRunner) {
-    DoLog(0) && (Log() << Verbose(0) << "Adding option " << *OptionRunner << " to positional CommandLineParser." << endl);
-    CommandLineParser::getInstance().inputfile.add((*OptionRunner).c_str(), -1);
-  }
-  cout << "Name for position 1: " << CommandLineParser::getInstance().inputfile.name_for_position(1) << endl;
 }
 
@@ -527 +1050 @@
  * \return type of the action
  */
-enum MapOfActions::OptionTypes MapOfActions::getValueType(string actionname)
-{
-  return TypeMap[actionname];
+std::string MapOfActions::getValueType(string actionname)
+{
+  return TypeMap[actionname]->name();
 }