Diff [06f4ef645cd755820805c9c8357f3bc4975bd8d6:b6da28aa93e0ef0e0a6bd47a13b2455fbe34caff] for / – MoleCuilder

ChangeLog

r06f4ef6	rb6da28
	1	18.04.2008
	2	+ essential switch in structure of ESPACK. Instead of having everything
	3	relative to pcp, we now have three tantamount packages: pcp, utilities and
	4	molecuilder

Makefile.am

r06f4ef6	rb6da28
7	7	doc:
8	8	cd doc && make doxygen-docs
	9
	10	unity:
	11	cd src && make unity

README

-              r06f4ef6
+              rb6da28
+<<<<<<< HEAD
 # Project: Molecuilder
+#
 …
 ... is a tool that started as a mean to edit pcp configuration files (adding/remvoing groups of atoms, measuring bond lengths and so forth) and has grown into the many-body fragmentation test base of a new method coined BOSSANOVA (Bond Order diSSection in an ANOVA (ANalysis Of VAriance) -like fashion). It spills out configuration files for each fragment and includes joining and analyzing programs, to put together the partial energies and forces of each fragment to the total energy and forces. It allows for a complete Born-Oppenheimer molecular dynamics run.
+=======
+# Project: ParallelCarParrinello
+# Jan Hamaekers
+# Frederik Heber
+# 2005
+#
+# File: README
+        Electronic Structure PACKage
+Is a collection of mathematical-physical programs to calculate via various ab-initio methods
+such as density functional theory or Hartree-Fock electronic(-magnetic) properties including
+the molecular (Car&Parrinello) dynamics of a many electron system. Especially, the linear
+response of the system to a external magnetic field in a perturbation approach in terms of
+susceptibility and chemical shielding is implemented via the Density Functional Perturbation
+Theory. It was developed mainly by Jan Hamaekers (pcp) with additional code by Frederik Heber
+(dfpt part in pcp) and also Ralf Wildenhuis (Gauss) at the Institute for Numerical Simulation
+at the University of Bonn[1].
+>>>>>>> FETCH_HEAD
 INSTALLATION NOTES
 ==================
+<<<<<<< HEAD
 The following packages are needed
 * GCC or alike
 * GSL (GNU Scientific Library, available at http://www.gnu.org/software/gsl)
+* Boost 1.4 or newer
+=======
+In general gcc or alike is needed to compile the sources, for more specific demands see the README files in the sub directory of each package part.
+LINKS
+=====
+[1] http://www.ins.uni-bonn.de/
+>>>>>>> FETCH_HEAD

configure.ac

-              r06f4ef6
+              rb6da28
 AC_CONFIG_HEADER([config.h])
 AM_INIT_AUTOMAKE(dist-bzip2)
+AM_INIT_AUTOMAKE(dist-bzip2 parallel-tests)
 # Checks for programs.
 …
 AX_BOOST_THREAD
 #AX_BOOST_SERIALIZATION
+#QT4 libraries
+gw_CHECK_QT4
+AX_CHECK_GLU
+AC_MSG_NOTICE(["GLU_CFLAGS: $GLU_CFLAGS, GLU_CXXFLAGS: $GLU_CXXFLAGS, GLU_LDFLAGS: $GLU_LDFLAGS, GLU_LIBS: $GLU_LIBS"])
 # Checks for header files.
 …
 # add replacement/saturation hydrogen or not
 AC_ARG_ENABLE([ecut],AS_HELP_STRING([--enable-ecut],[Use ECut TestRunnerClient (default is yes)]),
               [enable_ecut=$enableval], [enable_ecut=yes])
+AC_ARG_ENABLE([ecut],AS_HELP_STRING([--enable-ecut],[Use ECut TestRunnerClient (default is no)]),
+              [enable_ecut=$enableval], [enable_ecut=no])
 if test x"$enable_ecut" = xyes; then
   AC_DEFINE(HAVE_ECUT,1, ["Use ECut TestRunnerClient instead of our own."])

doc/Doxyfile

r06f4ef6	rb6da28
258	258	# Configuration::additions related to the search engine
259	259	#---------------------------------------------------------------------------
260		SEARCHENGINE = NO
	260	SEARCHENGINE = YES

doc/class structure.uxf

-              r06f4ef6
+              rb6da28
 // This text will be stored with each diagram;  use it for notes.</help_text><zoom_level>7</zoom_level><element><type>com.umlet.element.base.Class</type><coordinates><x>1855</x><y>294</y><w>147</w><h>70</h></coordinates><panel_attributes>AtomInfo
+// This text will be stored with each diagram;  use it for notes.</help_text><zoom_level>7</zoom_level><element><type>com.umlet.element.base.Class</type><coordinates><x>1855</x><y>210</y><w>147</w><h>70</h></coordinates><panel_attributes>AtomInfo
 --
 -x,v,F: Vector
 …
 #AtomInfo();
 #~AtomInfo();
 </panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1645</x><y>315</y><w>223</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>210;21;21;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1274</x><y>147</y><w>392</w><h>259</h></coordinates><panel_attributes>Element
+</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1645</x><y>231</y><w>223</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>210;21;21;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1274</x><y>63</y><w>392</w><h>259</h></coordinates><panel_attributes>Element
 --
 mass: double
 …
 #~element();
 #Output(ofstream * const out) const: bool
 #Checkout(ofstream * const out, const int No, const int NoOfAtoms) const: bool</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1960</x><y>532</y><w>280</w><h>161</h></coordinates><panel_attributes>BondedParticle
+#Checkout(ofstream * const out, const int No, const int NoOfAtoms) const: bool</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1960</x><y>448</y><w>280</w><h>161</h></coordinates><panel_attributes>BondedParticle
 --
 --
 …
 #OutputBondOfAtom() const
 #OutputAdjacency(ofstream *AdjacencyFile) const
 #OutputOrder(ofstream *file) const</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>2184</x><y>343</y><w>258</w><h>202</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>245;21;245;154;21;154;21;189</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1925</x><y>343</y><w>293</w><h>202</h></coordinates><panel_attributes>lt=&lt;&lt;-
 </panel_attributes><additional_attributes>21;21;21;154;280;154;280;189</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>2184</x><y>343</y><w>34</w><h>202</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;189</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2359</x><y>294</y><w>147</w><h>70</h></coordinates><panel_attributes>BondedParticleInfo
+#OutputOrder(ofstream *file) const</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>2184</x><y>259</y><w>258</w><h>202</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>245;21;245;154;21;154;21;189</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1925</x><y>259</y><w>293</w><h>202</h></coordinates><panel_attributes>lt=&lt;&lt;-
+</panel_attributes><additional_attributes>21;21;21;154;280;154;280;189</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>2184</x><y>259</y><w>34</w><h>202</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;189</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2359</x><y>210</y><w>147</w><h>70</h></coordinates><panel_attributes>BondedParticleInfo
 --
 AdaptiveOrder: unsigned char
 …
 #BondedParticleInfo()
 #~BondedParticleInfo()
 </panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2079</x><y>280</y><w>217</w><h>84</h></coordinates><panel_attributes>ParticleInfo
+</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2079</x><y>196</y><w>217</w><h>84</h></coordinates><panel_attributes>ParticleInfo
 --
 nr: int
 …
 #~ParticleInfo()
 #ostream &amp; operator &lt;&lt; (ostream &amp;ost) const
 </panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>2485</x><y>315</y><w>174</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>21;21;161;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2646</x><y>245</y><w>147</w><h>133</h></coordinates><panel_attributes>BondList
+</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>2485</x><y>231</y><w>174</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>21;21;161;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2646</x><y>161</y><w>147</w><h>133</h></coordinates><panel_attributes>BondList
 {Some Properties}
 --
 …
 Responsibilities
 -- Resp1
 *-- Resp2*</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1372</x><y>427</y><w>147</w><h>105</h></coordinates><panel_attributes>GraphNodeInfo
+*-- Resp2*</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1372</x><y>343</y><w>147</w><h>105</h></coordinates><panel_attributes>GraphNodeInfo
 --
 --
 …
 #GraphNodeInfo()
 #~GraphNodeInfo()
 </panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1484</x><y>609</y><w>126</w><h>70</h></coordinates><panel_attributes>GraphNode
+</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1484</x><y>525</y><w>126</w><h>70</h></coordinates><panel_attributes>GraphNode
 --
 --
 …
 #OutputGraphInfo() const
 #OutputComponentNumber() const
 </panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1484</x><y>343</y><w>748</w><h>279</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>735;21;735;70;217;70;217;210;21;210;21;266</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1484</x><y>511</y><w>34</w><h>111</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;98</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1288</x><y>756</y><w>588</w><h>245</h></coordinates><panel_attributes>Atom
+</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1484</x><y>259</y><w>748</w><h>279</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>735;21;735;70;217;70;217;210;21;210;21;266</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1484</x><y>427</y><w>34</w><h>111</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;98</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1288</x><y>672</y><w>588</w><h>245</h></coordinates><panel_attributes>Atom
 --
 sort: int*
 …
 #DistanceToVector(const Vector &amp;origin) const: double
 #DistanceSquaredToVector(const Vector &amp;origin) const: double
 #IsInParallelepiped(const Vector offset, const double *parallelepiped) const: bool</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1379</x><y>511</y><w>83</w><h>258</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;182;70;182;70;245</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2226</x><y>749</y><w>504</w><h>210</h></coordinates><panel_attributes>TrajectoryParticle
+#IsInParallelepiped(const Vector offset, const double *parallelepiped) const: bool</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1379</x><y>427</y><w>83</w><h>258</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;182;70;182;70;245</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2226</x><y>665</y><w>504</w><h>210</h></coordinates><panel_attributes>TrajectoryParticle
 --
 --
 …
 #Thermostat_Berendsen(int Step, double ScaleTempFactor, double *ekin, config *configuration)
 #Thermostat_NoseHoover_init(int Step, double *delta_alpha)
 #Thermostat_NoseHoover_scale(int Step, double *ekin, config *configuration)</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>2149</x><y>343</y><w>209</w><h>419</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;112;196;112;196;406</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1967</x><y>343</y><w>391</w><h>419</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;112;378;112;378;406</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1617</x><y>574</y><w>203</w><h>70</h></coordinates><panel_attributes>TrajectoryParticleInfo
+#Thermostat_NoseHoover_scale(int Step, double *ekin, config *configuration)</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>2149</x><y>259</y><w>209</w><h>419</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;112;196;112;196;406</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1967</x><y>259</y><w>391</w><h>419</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;112;378;112;378;406</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1617</x><y>490</y><w>203</w><h>70</h></coordinates><panel_attributes>TrajectoryParticleInfo
 --
 Trajectory: struct {vector&lt;Vector&gt; R,U,V}
 …
 --
 #TrajectoryParticleInfo()
 #~TrajectoryParticleInfo()</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1757</x><y>623</y><w>601</w><h>139</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;105;588;105;588;126</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1729</x><y>623</y><w>34</w><h>146</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;133</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1519</x><y>658</y><w>244</w><h>111</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;56;231;56;231;98</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1736</x><y>448</y><w>147</w><h>112</h></coordinates><panel_attributes>TesselPoint
+#~TrajectoryParticleInfo()</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1757</x><y>539</y><w>601</w><h>139</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;105;588;105;588;126</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1729</x><y>539</y><w>34</w><h>146</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;133</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1519</x><y>574</y><w>244</w><h>111</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>21;21;21;56;231;56;231;98</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1736</x><y>364</y><w>147</w><h>112</h></coordinates><panel_attributes>TesselPoint
 --
 -id: Long
 …
 Responsibilities
 -- Resp1
 *-- Resp2*</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1729</x><y>539</y><w>146</w><h>230</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>133;21;133;175;21;175;21;217</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1729</x><y>672</y><w>398</w><h>97</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>385;21;385;42;21;42;21;84</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1729</x><y>343</y><w>398</w><h>426</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>385;21;385;168;196;168;196;371;21;371;21;413</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1729</x><y>343</y><w>209</w><h>426</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>196;21;196;371;21;371;21;413</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>833</x><y>854</y><w>357</w><h>224</h></coordinates><panel_attributes>Bond
+*-- Resp2*</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1729</x><y>455</y><w>146</w><h>230</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>133;21;133;175;21;175;21;217</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1729</x><y>588</y><w>398</w><h>97</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>385;21;385;42;21;42;21;84</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1729</x><y>259</y><w>398</w><h>426</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>385;21;385;168;196;168;196;371;21;371;21;413</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1729</x><y>259</y><w>209</w><h>426</h></coordinates><panel_attributes>lt=&lt;&lt;-</panel_attributes><additional_attributes>196;21;196;371;21;371;21;413</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>833</x><y>770</y><w>357</w><h>224</h></coordinates><panel_attributes>Bond
 --
 HydrogenBond: int
 …
 #bond()
 #bond(atom *left, atom *right, const int degree=1, const int number=0)
 #~bond()</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1834</x><y>707</y><w>107</w><h>125</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-
 </panel_attributes><additional_attributes>42;112;91;112;91;35;21;35;21;49</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1169</x><y>896</y><w>132</w><h>49</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-
 </panel_attributes><additional_attributes>21;35;119;35</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>770</x><y>742</y><w>111</w><h>167</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-
 </panel_attributes><additional_attributes>63;154;28;154;28;35;98;35;98;112</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1113</x><y>1330</y><w>504</w><h>168</h></coordinates><panel_attributes>BondGraph
+#~bond()</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1834</x><y>623</y><w>107</w><h>125</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-
+</panel_attributes><additional_attributes>42;112;91;112;91;35;21;35;21;49</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1169</x><y>812</y><w>132</w><h>49</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-
+</panel_attributes><additional_attributes>21;35;119;35</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>770</x><y>658</y><w>111</w><h>167</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-
+</panel_attributes><additional_attributes>63;154;28;154;28;35;98;35;98;112</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1113</x><y>1246</y><w>504</w><h>168</h></coordinates><panel_attributes>BondGraph
 --
 max_distance: double
 …
                                                         double &amp;MinDistance, double &amp;MaxDistance, bool IsAngstroem)
 #CovalentMinMaxDistance(BondedParticle * const Walker, BondedParticle * const OtherWalker,
                                           double &amp;MinDistance, double &amp;MaxDistance, bool IsAngstroem)</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1596</x><y>1407</y><w>167</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>21;21;154;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1750</x><y>1365</y><w>147</w><h>133</h></coordinates><panel_attributes>MatrixContainer
+                                          double &amp;MinDistance, double &amp;MaxDistance, bool IsAngstroem)</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1596</x><y>1323</y><w>167</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>21;21;154;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1750</x><y>1281</y><w>147</w><h>133</h></coordinates><panel_attributes>MatrixContainer
 --
 -id: Long
 …
 Responsibilities
 -- Resp1
 *-- Resp2*</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>0</x><y>539</y><w>511</w><h>1050</h></coordinates><panel_attributes>config
+*-- Resp2*</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>0</x><y>455</y><w>511</w><h>1050</h></coordinates><panel_attributes>config
 --
 PsiType: int
 …
 #SetDefaultPath(const char * const path);
 #InitThermostats();
 #ParseThermostats(class ConfigFileBuffer * const fb);</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>490</x><y>1428</y><w>636</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>21;21;623;21</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1596</x><y>84</y><w>121</w><h>139</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-
 </panel_attributes><additional_attributes>70;126;105;126;105;35;21;35;21;63</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2520</x><y>980</y><w>224</w><h>140</h></coordinates><panel_attributes>&lt;&lt;Singleton&gt;&gt;
+#ParseThermostats(class ConfigFileBuffer * const fb);</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>490</x><y>1344</y><w>636</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>21;21;623;21</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1596</x><y>0</y><w>121</w><h>139</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-
+</panel_attributes><additional_attributes>70;126;105;126;105;35;21;35;21;63</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2520</x><y>896</y><w>224</w><h>140</h></coordinates><panel_attributes>&lt;&lt;Singleton&gt;&gt;
 errorLogger
 --
 …
 #static setVerbosity(int verbosityLevel);
 #protected errorLogger()
 #protected ~errorLogger()</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2093</x><y>1064</y><w>364</w><h>35</h></coordinates><panel_attributes>KeyCompare
+#protected ~errorLogger()</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>2093</x><y>980</y><w>364</w><h>35</h></coordinates><panel_attributes>KeyCompare
 --
 --
 #operator() (const KeySet SubgraphA, const KeySet SubgraphB) const: bool
 </panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1169</x><y>1218</y><w>147</w><h>105</h></coordinates><panel_attributes>UniqueFragments
+</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1169</x><y>1134</y><w>147</w><h>105</h></coordinates><panel_attributes>UniqueFragments
 --
 ANOVAOrder: int
 …
 ShortestPathList: int *
 UsedList: bool **
 BondsPerSPCount: int *</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>490</x><y>1253</y><w>692</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>679;21;21;21</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1120</x><y>980</y><w>251</w><h>307</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>49;294;21;294;21;224;238;224;238;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>840</x><y>1127</y><w>245</w><h>28</h></coordinates><panel_attributes>Graph
+BondsPerSPCount: int *</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>490</x><y>1169</y><w>692</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>679;21;21;21</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1120</x><y>896</y><w>251</w><h>307</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>49;294;21;294;21;224;238;224;238;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>840</x><y>1043</y><w>245</w><h>28</h></coordinates><panel_attributes>Graph
 {map &lt;KeySet, NumberValuePair, KeyCompare&gt;}
 </panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>861</x><y>1134</y><w>321</w><h>153</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>308;140;21;140;21;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>945</x><y>1190</y><w>56</w><h>28</h></coordinates><panel_attributes>KeySet
 {set&lt;int&gt;}</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>945</x><y>1197</y><w>237</w><h>90</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>224;77;21;77;21;21</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1085</x><y>1057</y><w>99</w><h>230</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-
 ...N X 0...N</panel_attributes><additional_attributes>84;217;56;217;56;112;21;112;21;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1736</x><y>2282</y><w>147</w><h>42</h></coordinates><panel_attributes>LSQ_params
+</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>861</x><y>1050</y><w>321</w><h>153</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>308;140;21;140;21;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>945</x><y>1106</y><w>56</w><h>28</h></coordinates><panel_attributes>KeySet
+{set&lt;int&gt;}</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>945</x><y>1113</y><w>237</w><h>90</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>224;77;21;77;21;21</additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1085</x><y>973</y><w>99</w><h>230</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-
+...N X 0...N</panel_attributes><additional_attributes>84;217;56;217;56;112;21;112;21;21</additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1736</x><y>2198</y><w>147</w><h>42</h></coordinates><panel_attributes>LSQ_params
 --
 vectors: const Vector **
 num: int
 </panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1043</x><y>266</y><w>147</w><h>35</h></coordinates><panel_attributes>lsq_params
 --
 x: gsl_vector *</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1169</x><y>266</y><w>118</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>21;21;105;21</additional_attributes></element></umlet_diagram>
+</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Class</type><coordinates><x>1043</x><y>182</y><w>147</w><h>35</h></coordinates><panel_attributes>lsq_params
+--
+x: gsl_vector *</panel_attributes><additional_attributes></additional_attributes></element><element><type>com.umlet.element.base.Relation</type><coordinates><x>1169</x><y>182</y><w>118</w><h>34</h></coordinates><panel_attributes>lt=&lt;&lt;&lt;&lt;-</panel_attributes><additional_attributes>21;21;105;21</additional_attributes></element></umlet_diagram>

src/Actions/Action.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/ActionRegistry.hpp"
 #include "Actions/ActionHistory.hpp"
+#include "Exceptions/MissingValueException.hpp"
+#include "UIElements/Dialog.hpp"
 #include "Helpers/MemDebug.hpp"
+#include "UIElements/UIFactory.hpp"
+#include "log.hpp"
+#include "verbose.hpp"
 using namespace std;
 …
+{
   if(_doRegister){
     ActionRegistry::getInstance().registerAction(this);
+    ActionRegistry::getInstance().registerInstance(this);
+  }
+}
 …
+}
+void Action::call(){
+Dialog * Action::createDialog(){
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  return fillDialog(dialog);
+}
+void Action::call(enum QueryOptions flag){
   if(!isActive()){
     return;
+  }
   // forward to private virtual
+  state_ptr state = performCall();
+  if (flag == Interactive) {
+    Dialog* dialog = createDialog();
+    if (dialog->hasQueries()) {
+      dialog->display();
+    }
+    delete(dialog);
+  }
+  state_ptr state = Action::failure;
+//  try {
+    state = performCall();
+//  } catch(MissingValueException&) {
+//    DoeLog(0) && (eLog() << Verbose(0) << "There is a value missing for action " << getName() << endl);
+//  };
   if(shouldUndo() && state != failure){
     if(canUndo()){

src/Actions/Action.hpp

-              r06f4ef6
+              rb6da28
 class ActionState;
 class ActionSequence;
+class Dialog;
 /**
 …
  * hasRedo() method respectively.
+ *
+ * Note that an Action always has two functions createDialog() and performCall(). The former
+ * returns a Dialog filled with query...() functions for all information that we need from the
+ * user. The latter must not contain any interaction but just uses these values (which are
+ * temporarily stored by class ValueStorage) to perform the Action.
+ *
+ * Furthermore, there is a global action function that makes the action callable with already
+ * present parameters (i.e. without user interaction and for internal use within the code only).
+ * This function is basically just a macro, that puts the parameters into the ValueStorage and
+ * calls Action::call(Action::NonInteractive).
+ *
  * Actions can be set to be active or inactive. If an action is set to inactive it is signaling, that
  * some condition necessary for this action to be executed is not currently met. For example the
 …
  * Building actions is fairly easy. Simply derive from the abstract Action base class and implement
  * the virtual methods. The main code that needs to be executed upon call() should be implemented in
+ * the performCall() method. You should also indicate whether the action supports undo by implementing
+ * the performCall() method. Any user interaction should be placed into the dialog returned by
+ * createDialog(). You should also indicate whether the action supports undo by implementing
  * the shouldUndo() and canUndo() methods to return the appropriate flags.
+ *
+ * Also, create the global function to allow for easy calling of your function internally (i.e.
+ * without user interaction). It should have the name of the Action class without the suffix Action.
+ *
  * The constructor of your derived class also needs to call the Base constructor, passing it the
 …
  *  <li/> derive YourAction from Action
  *  <li/> pass name and flag for registry to the base constructor
+ *  <li/> implement performCall(), performUndo(), performRedo()
+ *  <li/> implement createDialog(), performCall(), performUndo(), performRedo()
+ *  <li/> implement the global function call/macro.
  *  <li/> implement the functions that return the flags for the undo mechanism
  *  <li/> Derive YourActionState from ActionState as necessary
 …
+ *
  * <ul>
+ *  <li/> createDialog():
+ *  <ul>
+ *   <li/> Call makeDialog() from the UIFactory.
+ *   <li/> Call any needed Dialog->Query...() for the values you need with specific keywords.
+ *   <li/> if the action needs to save a state return a custom state object
+ *   <li/> otherwise return Action::success
+ *  </ul>
  *  <li/> performCall():
  *  <ul>
+ *   <li/> obtain parameters you need by ValueStorage::getCurrentValue, matching
+ *         key words from createDialog().
  *   <li/> do whatever is needed to make the action work
  *   <li/> if the action was abborted return Action::failure
 …
 public:
+  enum QueryOptions {Interactive, NonInteractive};
   /**
    * This type is used to store pointers to ActionStates while allowing multiple ownership
 …
    * If the call needs to undone you have to use the History, to avoid destroying
    * invariants used by the History.
+   */
+  void call();
+   *
+   * Note that this call can be Interactive (i.e. a dialog will ask the user for
+   * necessary information) and NonInteractive (i.e. the information will have to
+   * be present already within the ValueStorage class or else a MissingArgumentException
+   * is thrown)
+   */
+  void call(enum QueryOptions state = Interactive);
   /**
 …
   static state_ptr failure;
+  /**
+   * This creates the dialog requesting the information needed for this action from the user
+   * via means of the user interface.
+   */
+  Dialog * createDialog();
 private:
+  /**
+   * This is called internally when the call is being done. Implement this method to do the actuall
+  virtual Dialog * fillDialog(Dialog*)=0;
+  /**
+   * This is called internally when the call is being done. Implement this method to do the actual
    * work of the Action. Implement this in your Derived classes. Needs to return a state that can be
    * used to undo the action.

src/Actions/ActionHistory.cpp

-              r06f4ef6
+              rb6da28
+}
+Dialog* ActionHistory::UndoAction::fillDialog(Dialog *dialog){
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  return dialog;
+}
 Action::state_ptr ActionHistory::UndoAction::performCall(){
   hist->undoLast();
 …
+}
+Dialog* ActionHistory::RedoAction::fillDialog(Dialog *dialog){
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  return dialog;
+}
 Action::state_ptr ActionHistory::RedoAction::performCall(){
   hist->redoLast();

src/Actions/ActionHistory.hpp

-              r06f4ef6
+              rb6da28
     virtual bool isActive();
+  protected:
+    virtual Dialog * fillDialog(Dialog *dialog);
   private:
     virtual Action::state_ptr performCall();
 …
     virtual bool isActive();
+  protected:
+    virtual Dialog * fillDialog(Dialog *dialog);
   private:
     virtual Action::state_ptr performCall();

src/Actions/ActionRegistry.cpp

-              r06f4ef6
+              rb6da28
 /*
  * ActionRegistry.cpp
+ * Registry<Action>.cpp
+ *
  *  Created on: Jan 7, 2010
 …
 #include "Actions/ActionRegistry.hpp"
+#include "Actions/Action.hpp"
+#include "Patterns/Singleton_impl.hpp"
+#include "Patterns/Registry_impl.hpp"
+#include "Patterns/Singleton_impl.hpp"
+/** Constructor for class ActionRegistry.
+ */
+ActionRegistry::ActionRegistry()
+{}
+#include <string>
+#include "Helpers/Assert.hpp"
+#include <iostream>
+/** Destructor for class ActionRegistry.
+ */
+ActionRegistry::~ActionRegistry()
+{}
+using namespace std;
+ActionRegistry::ActionRegistry()
+/** Just passes on call to Registry<Action>::getByName().
+ * \param name name of Action
+ * \return pointer to Action
+ */
+Action* ActionRegistry::getActionByName(const std::string name)
+{
+  return getByName(name);
+}
+ActionRegistry::~ActionRegistry()
+/** Just passes on call to Registry<Action>::isPresentByName().
+ * \param name name of Action
+ * \return true - Action instance present, false - not
+ */
+bool ActionRegistry::isActionPresentByName(const std::string name)
+{
+  map<const string,Action*>::iterator iter;
+  for(iter=actionMap.begin();iter!=actionMap.end();++iter) {
+    delete iter->second;
+  }
+  actionMap.clear();
+}
+Action* ActionRegistry::getActionByName(const std::string name){
+  map<const string,Action*>::iterator iter;
+  iter = actionMap.find(name);
+  ASSERT(iter!=actionMap.end(),"Query for an action not stored in registry");
+  return iter->second;
+}
+bool ActionRegistry::isActionByNamePresent(const std::string name){
+  map<const string,Action*>::iterator iter;
+  iter = actionMap.find(name);
+  return iter!=actionMap.end();
+}
+void ActionRegistry::registerAction(Action* action){
+  pair<map<const string,Action*>::iterator,bool> ret;
+  ret = actionMap.insert(pair<const string,Action*>(action->getName(),action));
+  ASSERT(ret.second,"Two actions with the same name added to registry");
+}
+void ActionRegistry::unregisterAction(Action* action){
+  actionMap.erase(action->getName());
+}
+std::map<const std::string,Action*>::iterator ActionRegistry::getBeginIter()
+{
+  return actionMap.begin();
+}
+std::map<const std::string,Action*>::iterator ActionRegistry::getEndIter()
+{
+  return actionMap.end();
+  return isPresentByName(name);
+}
 CONSTRUCT_SINGLETON(ActionRegistry)
+CONSTRUCT_REGISTRY(Action)

src/Actions/ActionRegistry.hpp

-              r06f4ef6
+              rb6da28
 /*
  * ActionRegistry.hpp
+ * Registry<Action>.hpp
+ *
  *  Created on: Jan 7, 2010
 …
 #define ACTIONREGISTRY_HPP_
+#include <iosfwd>
 #include <string>
 #include <map>
+#include "Patterns/Registry.hpp"
 #include "Patterns/Singleton.hpp"
+#include "Actions/Action.hpp"
+class Action;
+class ActionRegistry : public Singleton<ActionRegistry>
+/** Action Registry.
+ *
+ * The Action registry is a storage for any Action instance to retrieved by name.
+ * It is a singleton and can be called from anywhere.
+ *
+ */
+class ActionRegistry : public Singleton<ActionRegistry>, public Registry<Action>
+{
   friend class Singleton<ActionRegistry>;
+  //friend class Registry<Action>;
 public:
+  Action* getActionByName(const std::string);
+  bool isActionByNamePresent(const std::string name);
+  void registerAction(Action*);
+  void unregisterAction(Action*);
+  std::map<const std::string,Action*>::iterator getBeginIter();
+  std::map<const std::string,Action*>::iterator getEndIter();
+private:
+  std::map<const std::string,Action*> actionMap;
+  Action* getActionByName(const std::string name);
+  bool isActionPresentByName(const std::string name);
 private:
   ActionRegistry();
   virtual ~ActionRegistry();
+  ~ActionRegistry();
 };

src/Actions/ActionSequence.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/ActionSequence.hpp"
 #include "Actions/Action.hpp"
+#include "UIElements/Dialog.hpp"
 #include "Helpers/Assert.hpp"
 …
     return theAction;
+  }
+}
+// this method is used outside the ActionModule
+// Each action registers itself with the history
+Dialog* ActionSequence::fillAllDialogs(Dialog *dialog){
+  for(actionSet::iterator it=actions.begin(); it!=actions.end(); it++){
+    dialog = (*it)->fillDialog(dialog);
+  }
+  return dialog;
+}

src/Actions/ActionSequence.hpp

r06f4ef6	rb6da28
36	36	protected:
37	37	stateSet callAll(bool); // Dummy parameter to allow overloading
	38	Dialog* fillAllDialogs(Dialog *dialog);
38	39	stateSet undoAll(stateSet);
39	40	stateSet redoAll(stateSet);

src/Actions/AnalysisAction/MolecularVolumeAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/AnalysisAction/MolecularVolumeAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "boundary.hpp"
 #include "config.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AnalysisMolecularVolumeAction::NAME[] = "molecular-volume";
 …
 {}
+void AnalysisMolecularVolume() {
+  ActionRegistry::getInstance().getActionByName(AnalysisMolecularVolumeAction::NAME)->call(Action::NonInteractive);
+};
+Dialog * AnalysisMolecularVolumeAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr AnalysisMolecularVolumeAction::performCall() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  molecule *mol = NULL;
+  int molID = -1;
+  // obtain information
+  ValueStorage::getInstance().queryCurrentValue(NAME, molID);
   dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
   if(dialog->display()) {
+  // execute action
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    molecule *mol = iter->second;
     class Tesselation *TesselStruct = NULL;
     const LinkedCell *LCList = NULL;
 …
     LCList = new LinkedCell(mol, 10.);
     config * const configuration = World::getInstance().getConfig();
+    //FindConvexBorder(mol, LCList, argv[argptr]);
+    Boundaries *BoundaryPoints = NULL;
+    //FindConvexBorder(mol, BoundaryPoints, TesselStruct, LCList, argv[argptr]);
     FindNonConvexBorder(mol, TesselStruct, LCList, 5., NULL);
     //RemoveAllBoundaryPoints(TesselStruct, mol, argv[argptr]);
 …
     delete(TesselStruct);
     delete(LCList);
-    delete dialog;
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}
 Action::state_ptr AnalysisMolecularVolumeAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr AnalysisMolecularVolumeAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool AnalysisMolecularVolumeAction::canUndo() {
   return false;
+  return true;
+}
 bool AnalysisMolecularVolumeAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/AnalysisAction/MolecularVolumeAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void AnalysisMolecularVolume();
 class AnalysisMolecularVolumeAction : public Action {
+  friend void AnalysisMolecularVolume();
 public:
   AnalysisMolecularVolumeAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog*);
 private:
   virtual Action::state_ptr performCall();

src/Actions/AnalysisAction/PairCorrelationAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/AnalysisAction/PairCorrelationAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "analysis_correlation.hpp"
 #include "boundary.hpp"
 #include "linkedcell.hpp"
+#include "verbose.hpp"
 #include "log.hpp"
 #include "element.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AnalysisPairCorrelationAction::NAME[] = "pair-correlation";
 …
 {}
+void AnalysisPairCorrelation(std::vector< element *> &elements, double BinStart, double BinWidth, double BinEnd, string &outputname, string &binoutputname, bool periodic) {
+  ValueStorage::getInstance().setCurrentValue("elements", elements);
+  ValueStorage::getInstance().setCurrentValue("bin-start", BinStart);
+  ValueStorage::getInstance().setCurrentValue("bin-width", BinWidth);
+  ValueStorage::getInstance().setCurrentValue("bin-end", BinEnd);
+  ValueStorage::getInstance().setCurrentValue("output-file", outputname);
+  ValueStorage::getInstance().setCurrentValue("bin-output-file", binoutputname);
+  ValueStorage::getInstance().setCurrentValue("periodic", periodic);
+  ActionRegistry::getInstance().getActionByName(AnalysisPairCorrelationAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* AnalysisPairCorrelationAction::fillDialog(Dialog* dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryElements("elements", ValueStorage::getInstance().getDescription("elements"));
+  dialog->queryDouble("bin-start", ValueStorage::getInstance().getDescription("bin-start"));
+  dialog->queryDouble("bin-width", ValueStorage::getInstance().getDescription("bin-width"));
+  dialog->queryDouble("bin-end", ValueStorage::getInstance().getDescription("bin-end"));
+  dialog->queryString("output-file", ValueStorage::getInstance().getDescription("output-file"));
+  dialog->queryString("bin-output-file", ValueStorage::getInstance().getDescription("bin-output-file"));
+  dialog->queryBoolean("periodic", ValueStorage::getInstance().getDescription("periodic"));
+  return dialog;
+}
 Action::state_ptr AnalysisPairCorrelationAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   int ranges[3] = {1, 1, 1};
   double BinEnd = 0.;
 …
   Vector Point;
   BinPairMap *binmap = NULL;
-  MoleculeListClass *molecules = World::getInstance().getMolecules();
   // first dialog: Obtain which type of correlation
   dialog->queryString(NAME, &type, MapOfActions::getInstance().getDescription(NAME));
   if(dialog->display()) {
     delete dialog;
   } else {
     delete dialog;
     return Action::failure;
+  }
+  // obtain information
+  ValueStorage::getInstance().queryCurrentValue("elements", elements);
+  ValueStorage::getInstance().queryCurrentValue("bin-start", BinStart);
+  ValueStorage::getInstance().queryCurrentValue("bin-width", BinWidth);
+  ValueStorage::getInstance().queryCurrentValue("bin-end", BinEnd);
+  ValueStorage::getInstance().queryCurrentValue("output-file", outputname);
+  ValueStorage::getInstance().queryCurrentValue("bin-output-file", binoutputname);
+  ValueStorage::getInstance().queryCurrentValue("periodic", periodic);
+  // second dialog: Obtain parameters specific to this type
+  dialog = UIFactory::getInstance().makeDialog();
+  if (type == "P")
+    dialog->queryVector("position", &Point, World::getInstance().getDomain(), false, MapOfActions::getInstance().getDescription("position"));
+  if (type == "S")
+    dialog->queryMolecule("molecule-by-id", &Boundary, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  dialog->queryElement("elements", &elements, MapOfActions::getInstance().getDescription("elements"));
+  dialog->queryDouble("bin-start", &BinStart, MapOfActions::getInstance().getDescription("bin-start"));
+  dialog->queryDouble("bin-width", &BinWidth, MapOfActions::getInstance().getDescription("bin-width"));
+  dialog->queryDouble("bin-end", &BinEnd, MapOfActions::getInstance().getDescription("bin-end"));
+  dialog->queryString("output-file", &outputname, MapOfActions::getInstance().getDescription("output-file"));
+  dialog->queryString("bin-output-file", &binoutputname, MapOfActions::getInstance().getDescription("bin-output-file"));
+  dialog->queryBoolean("periodic", &periodic, MapOfActions::getInstance().getDescription("periodic"));
+  if(dialog->display()) {
+    output.open(outputname.c_str());
+    binoutput.open(binoutputname.c_str());
+    PairCorrelationMap *correlationmap = NULL;
+    if (type == "E") {
+      PairCorrelationMap *correlationmap = NULL;
+      if (periodic)
+        correlationmap = PeriodicPairCorrelation(World::getInstance().getMolecules(), elements, ranges);
+      else
+        correlationmap = PairCorrelation(World::getInstance().getMolecules(), elements);
+      //OutputCorrelationToSurface(&output, correlationmap);
+      binmap = BinData( correlationmap, BinWidth, BinStart, BinEnd );
+    } else if (type == "P")  {
+      cout << "Point to correlate to is  " << Point << endl;
+      CorrelationToPointMap *correlationmap = NULL;
+      if (periodic)
+        correlationmap  = PeriodicCorrelationToPoint(molecules, elements, &Point, ranges);
+      else
+        correlationmap = CorrelationToPoint(molecules, elements, &Point);
+      //OutputCorrelationToSurface(&output, correlationmap);
+      binmap = BinData( correlationmap, BinWidth, BinStart, BinEnd );
+    } else if (type == "S") {
+      ASSERT(Boundary != NULL, "No molecule specified for SurfaceCorrelation.");
+      const double radius = 4.;
+      double LCWidth = 20.;
+      if (BinEnd > 0) {
+        if (BinEnd > 2.*radius)
+            LCWidth = BinEnd;
+        else
+          LCWidth = 2.*radius;
+      }
+      // get the boundary
+      class Tesselation *TesselStruct = NULL;
+      const LinkedCell *LCList = NULL;
+      // find biggest molecule
+      int counter  = molecules->ListOfMolecules.size();
+      bool *Actives = new bool[counter];
+      counter = 0;
+      for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
+        Actives[counter++] = (*BigFinder)->ActiveFlag;
+        (*BigFinder)->ActiveFlag = (*BigFinder == Boundary) ? false : true;
+      }
+      LCList = new LinkedCell(Boundary, LCWidth);
+      FindNonConvexBorder(Boundary, TesselStruct, LCList, radius, NULL);
+      CorrelationToSurfaceMap *surfacemap = NULL;
+      if (periodic)
+        surfacemap = PeriodicCorrelationToSurface( molecules, elements, TesselStruct, LCList, ranges);
+      else
+        surfacemap = CorrelationToSurface( molecules, elements, TesselStruct, LCList);
+      OutputCorrelationToSurface(&output, surfacemap);
+      // check whether radius was appropriate
+      {
+        double start; double end;
+        GetMinMax( surfacemap, start, end);
+        if (LCWidth < end)
+          DoeLog(1) && (eLog()<< Verbose(1) << "Linked Cell width is smaller than the found range of values! Bins can only be correct up to: " << radius << "." << endl);
+      }
+      binmap = BinData( surfacemap, BinWidth, BinStart, BinEnd );
+    } else
+      return Action::failure;
+    OutputCorrelation ( &binoutput, binmap );
+    output.close();
+    binoutput.close();
+    delete(binmap);
+    delete(correlationmap);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  // execute action
+  output.open(outputname.c_str());
+  binoutput.open(binoutputname.c_str());
+  PairCorrelationMap *correlationmap = NULL;
+  std::vector<molecule*> molecules = World::getInstance().getSelectedMolecules();
+  if (periodic)
+    correlationmap = PeriodicPairCorrelation(molecules, elements, ranges);
+  else
+    correlationmap = PairCorrelation(molecules, elements);
+  OutputPairCorrelation(&output, correlationmap);
+  binmap = BinData( correlationmap, BinWidth, BinStart, BinEnd );
+  OutputCorrelation ( &binoutput, binmap );
+  delete(binmap);
+  delete(correlationmap);
+  output.close();
+  binoutput.close();
+  return Action::success;
+}
 Action::state_ptr AnalysisPairCorrelationAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr AnalysisPairCorrelationAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool AnalysisPairCorrelationAction::canUndo() {
   return false;
+  return true;
+}
 bool AnalysisPairCorrelationAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/AnalysisAction/PairCorrelationAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+#include <string>
+#include <vector>
+class element;
+void AnalysisPairCorrelation(std::vector< element *> &elements, double BinStart, double BinWidth, double BinEnd, std::string &outputname, std::string &binoutputname, bool periodic);
 class AnalysisPairCorrelationAction : public Action {
+  friend void AnalysisPairCorrelation(std::vector< element *> &elements, double BinStart, double BinWidth, double BinEnd, std::string &outputname, std::string &binoutputname, bool periodic);
 public:
   AnalysisPairCorrelationAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog*);
 private:
   virtual Action::state_ptr performCall();
+   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);
   virtual Action::state_ptr performRedo(Action::state_ptr);

src/Actions/AnalysisAction/PrincipalAxisSystemAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/AnalysisAction/PrincipalAxisSystemAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "molecule.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AnalysisPrincipalAxisSystemAction::NAME[] = "principal-axis-system";
 …
 {}
+void AnalysisPrincipalAxisSystem() {
+  ActionRegistry::getInstance().getActionByName(AnalysisPrincipalAxisSystemAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* AnalysisPrincipalAxisSystemAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr AnalysisPrincipalAxisSystemAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
   dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
   if(dialog->display()) {
     DoLog(0) && (Log() << Verbose(0) << "Evaluating prinicipal axis." << endl);
+  ValueStorage::getInstance().queryCurrentValue(NAME, mol);
+  DoLog(0) && (Log() << Verbose(0) << "Evaluating prinicipal axis." << endl);
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    molecule *mol = iter->second;
     mol->PrincipalAxisSystem(false);
-    delete dialog;
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}
 Action::state_ptr AnalysisPrincipalAxisSystemAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr AnalysisPrincipalAxisSystemAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool AnalysisPrincipalAxisSystemAction::canUndo() {
   return false;
+  return true;
+}
 bool AnalysisPrincipalAxisSystemAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/AnalysisAction/PrincipalAxisSystemAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void AnalysisPrincipalAxisSystem();
 class AnalysisPrincipalAxisSystemAction : public Action {
+  friend void AnalysisPrincipalAxisSystem();
 public:
   AnalysisPrincipalAxisSystemAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *);
 private:
   virtual Action::state_ptr performCall();

src/Actions/AtomAction/AddAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/AtomAction/AddAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "element.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AtomAddAction::NAME[] = "add-atom";
 …
 {}
+void AtomAdd(element *elemental, Vector &position) {
+  ValueStorage::getInstance().setCurrentValue(AtomAddAction::NAME, elemental);
+  ValueStorage::getInstance().setCurrentValue("position", elemental);
+  ActionRegistry::getInstance().getActionByName(AtomAddAction::NAME)->call(Action::NonInteractive);
+};
+Dialog * AtomAddAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryElement(NAME, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryVector("position", true, ValueStorage::getInstance().getDescription("position"));
+  return dialog;
+}
 Action::state_ptr AtomAddAction::performCall() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  std::vector<element *> elements;
+  element * elemental = NULL;
   Vector position;
   dialog->queryElement(NAME, &elements, MapOfActions::getInstance().getDescription(NAME));
   dialog->queryVector("position", &position, World::getInstance().getDomain(), true, MapOfActions::getInstance().getDescription("position"));
   cout << "pre-dialog" << endl;
+  // obtain information
+  ValueStorage::getInstance().queryCurrentValue(NAME, elemental);
+  ValueStorage::getInstance().queryCurrentValue("position", position);
+  if(dialog->display()) {
+    cout << "post-dialog" << endl;
+    delete dialog;
+    if (elements.size() == 1) {
+      atom * first = World::getInstance().createAtom();
+      first->type = *(elements.begin());
+      first->x = position;
+      DoLog(1) && (Log() << Verbose(1) << "Adding new atom with element " << first->type->name << " at " << (first->x) << "." << endl);
+      // TODO: remove when all of World's atoms are stored.
+      std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
+      if (!molecules.empty()) {
+        std::vector<molecule *>::iterator iter = molecules.begin();
+        (*iter)->AddAtom(first);
+      }
+      return Action::success;
+    } else {
+      DoeLog(1) && (eLog()<< Verbose(1) << "Could not find the specified element." << endl);
+      return Action::failure;
+    }
+  } else {
+    delete dialog;
+    return Action::failure;
+  // execute action
+  atom * first = World::getInstance().createAtom();
+  first->type = elemental;
+  first->x = position;
+  DoLog(1) && (Log() << Verbose(1) << "Adding new atom with element " << first->type->name << " at " << (first->x) << "." << endl);
+  // TODO: remove when all of World's atoms are stored.
+  std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
+  if (!molecules.empty()) {
+    std::vector<molecule *>::iterator iter = molecules.begin();
+    (*iter)->AddAtom(first);
+  }
+  return Action::success;
+}

src/Actions/AtomAction/AddAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+#include "vector.hpp"
+class element;
+void AtomAdd(element *elemental, Vector &position);
 class AtomAddAction : public Action {
+  friend void AtomAdd(element *elemental, Vector &position);
 public:
   AtomAddAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *);
 private:
   virtual Action::state_ptr performCall();

src/Actions/AtomAction/ChangeElementAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/AtomAction/ChangeElementAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
+#include "element.hpp"
 #include "log.hpp"
 #include "vector.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AtomChangeElementAction::NAME[] = "change-element";
 …
 {}
+void AtomChangeElement(element *elemental) {
+  ValueStorage::getInstance().setCurrentValue(AtomChangeElementAction::NAME, elemental);
+  ActionRegistry::getInstance().getActionByName(AtomChangeElementAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* AtomChangeElementAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryElement(NAME, ValueStorage::getInstance().getDescription(NAME));
+return dialog;
+}
 Action::state_ptr AtomChangeElementAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   atom *first = NULL;
   std::vector<element *> elements;
+  element *elemental = NULL;
+  dialog->queryAtom(NAME, &first, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryElement("element", &elements, MapOfActions::getInstance().getDescription("element"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, elemental);
+  if(dialog->display()) {
+    delete dialog;
+    ASSERT(elements.size() == 1, "Unequal to one element specified when changing an atom's element");
+    ASSERT(first != NULL, "No valid atom specified");
+    DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << elements.at(0) << "." << endl);
+    if (elements.at(0) != NULL) {
+      first->type = elements.at(0);
+      return Action::success;
+    } else
+      return Action::failure;
+  } else {
+    delete dialog;
+    return Action::failure;
+  for (World::AtomSelectionIterator iter = World::getInstance().beginAtomSelection(); iter != World::getInstance().endAtomSelection(); ++iter) {
+    first = iter->second;
+    DoLog(1) && (Log() << Verbose(1) << "Changing atom " << *first << " to element " << elemental->symbol << "." << endl);
+    first->type = elemental;
+  }
+  return Action::success;
+}

src/Actions/AtomAction/ChangeElementAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+class element;
+void AtomChangeElement(element *elemental);
 class AtomChangeElementAction : public Action {
+  friend void AtomChangeElement(element *elemental);
 public:
   AtomChangeElementAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog*);
 private:
   virtual Action::state_ptr performCall();

src/Actions/AtomAction/RemoveAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/AtomAction/RemoveAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "Descriptors/AtomDescriptor.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char AtomRemoveAction::NAME[] = "remove-atom";
 …
 {}
+void AtomRemove() {
+  ActionRegistry::getInstance().getActionByName(AtomRemoveAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* AtomRemoveAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr AtomRemoveAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   atom *first = NULL;
+  dialog->queryAtom(NAME, &first, MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    delete dialog;
+  std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
+  for (World::AtomSelectionIterator iter = World::getInstance().beginAtomSelection(); iter != World::getInstance().endAtomSelection(); ++iter) {
+    first = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Removing atom " << first->getId() << "." << endl);
     // TODO: this is not necessary when atoms and their storing to file are handled by the World
     // simply try to erase in every molecule found
-    std::vector<molecule *> molecules = World::getInstance().getAllMolecules();
     for (std::vector<molecule *>::iterator iter = molecules.begin();iter != molecules.end(); ++iter) {
       (*iter)->erase(first);
+    }
     World::getInstance().destroyAtom(first);
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}

src/Actions/AtomAction/RemoveAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void AtomRemove();
 class AtomRemoveAction : public Action {
+  friend void AtomRemove();
 public:
   AtomRemoveAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog*);
 private:
   virtual Action::state_ptr performCall();

src/Actions/AtomsCalculation.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Calculation.hpp"
+class Dialog;
 template<typename T>
 class AtomsCalculation : public Calculation<std::vector<T> >
 …
 protected:
   virtual std::vector<T>* doCalc();
+  virtual Dialog *fillDialog(Dialog *dialog);
 private:

src/Actions/AtomsCalculation_impl.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/AtomsCalculation.hpp"
 #include "Actions/Calculation_impl.hpp"
-#include <iostream>
 using namespace std;
 …
   Process::setMaxSteps(steps);
   Process::start();
+  for(World::AtomIterator iter=world->getAtomIter(descr);iter!=world->atomEnd();++iter){
+  for(World::internal_AtomIterator
+      iter=world->getAtomIter_internal(descr);
+      iter!=world->atomEnd_internal();
+      ++iter){
     Process::setCurrStep(iter.getCount());
     res->push_back(op(*iter));
 …
+}
+template<typename T>
+Dialog *AtomsCalculation<T>::fillDialog(Dialog *dialog){
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  return dialog;
+}
 #endif /* ATOMSCALCULATION_IMPL_HPP_ */

src/Actions/CmdAction/BondLengthTableAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/CmdAction/BondLengthTableAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "bondgraph.hpp"
 #include "config.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char CommandLineBondLengthTableAction::NAME[] = "bond-table";
 …
 {}
+void CommandBondLengthTable(std::string &BondGraphFileName) {
+  ValueStorage::getInstance().setCurrentValue(CommandLineBondLengthTableAction::NAME, BondGraphFileName);
+  ActionRegistry::getInstance().getActionByName(CommandLineBondLengthTableAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineBondLengthTableAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr CommandLineBondLengthTableAction::performCall() {
   ostringstream usage;
   string BondGraphFileName;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  ValueStorage::getInstance().queryCurrentValue(NAME, BondGraphFileName);
+  DoLog(0) && (Log() << Verbose(0) << "Using " << BondGraphFileName << " as bond length table." << endl);
   config *configuration = World::getInstance().getConfig();
-  dialog->queryString(NAME, &BondGraphFileName, MapOfActions::getInstance().getDescription(NAME));
-  if(dialog->display()) {
-    DoLog(0) && (Log() << Verbose(0) << "Using " << BondGraphFileName << " as bond length table." << endl);
-    delete dialog;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
   if (configuration->BG == NULL) {
     configuration->BG = new BondGraph(configuration->GetIsAngstroem());

src/Actions/CmdAction/BondLengthTableAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void CommandBondLengthTable(std::string &BondGraphFileName);
 class CommandLineBondLengthTableAction : public Action {
+  friend void CommandBondLengthTable(std::string &BondGraphFileName);
 public:
   CommandLineBondLengthTableAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/CmdAction/ElementDbAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/CmdAction/ElementDbAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "config.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char CommandLineElementDbAction::NAME[] = "element-db";
 …
 {}
+void CommandElementDb(std::string &databasepath) {
+  ValueStorage::getInstance().setCurrentValue(CommandLineElementDbAction::NAME, databasepath);
+  ActionRegistry::getInstance().getActionByName(CommandLineElementDbAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineElementDbAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr CommandLineElementDbAction::performCall() {
   ostringstream usage;
   string databasepath;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   // get the path
   // TODO: Make databasepath a std::string
   config *configuration = World::getInstance().getConfig();
+  dialog->queryString(NAME, &databasepath, MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    strcpy(configuration->databasepath, databasepath.c_str());
+    delete dialog;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  ValueStorage::getInstance().queryCurrentValue(NAME, databasepath);
+  strcpy(configuration->databasepath, databasepath.c_str());
   // load table

src/Actions/CmdAction/ElementDbAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void CommandElementDb(std::string &databasepath);
 class CommandLineElementDbAction : public Action {
+  friend void CommandElementDb(std::string &databasepath);
 public:
   CommandLineElementDbAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/CmdAction/FastParsingAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/CmdAction/FastParsingAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "config.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
+// memento to remember the state when undoing
+class CommandLineFastParsingState : public ActionState {
+public:
+  CommandLineFastParsingState(bool _bool) :
+    boolean(_bool)
+  {}
+  bool boolean;
+};
 const char CommandLineFastParsingAction::NAME[] = "fastparsing";
 …
 {}
+void CommandFastParsing(bool fastparsing) {
+  ValueStorage::getInstance().setCurrentValue(CommandLineFastParsingAction::NAME, fastparsing);
+  ActionRegistry::getInstance().getActionByName(CommandLineFastParsingAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineFastParsingAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryBoolean(NAME, MapOfActions::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr CommandLineFastParsingAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   config *configuration = World::getInstance().getConfig();
+  dialog->queryBoolean(NAME, &configuration->FastParsing, MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    if (configuration->FastParsing)
+      DoLog(0) && (Log() << Verbose(0) << "I won't parse trajectories." << endl);
+    else
+      DoLog(0) && (Log() << Verbose(0) << "I will parse trajectories." << endl);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  ValueStorage::getInstance().queryCurrentValue(NAME, configuration->FastParsing);
+  if (configuration->FastParsing)
+    DoLog(0) && (Log() << Verbose(0) << "I won't parse trajectories." << endl);
+  else
+    DoLog(0) && (Log() << Verbose(0) << "I will parse trajectories." << endl);
+  return Action::success;
+}
 Action::state_ptr CommandLineFastParsingAction::performUndo(Action::state_ptr _state) {
 //  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  CommandLineFastParsingState *state = assert_cast<CommandLineFastParsingState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  config *configuration = World::getInstance().getConfig();
+  configuration->FastParsing = state->boolean;
+  return Action::state_ptr(new CommandLineFastParsingState(!state->boolean));
+}
 Action::state_ptr CommandLineFastParsingAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return performUndo(_state);
+}
 bool CommandLineFastParsingAction::canUndo() {
   return false;
+  return true;
+}
 bool CommandLineFastParsingAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/CmdAction/FastParsingAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void CommandFastParsing(bool fastparsing);
 class CommandLineFastParsingAction : public Action {
+  friend void CommandFastParsing(bool fastparsing);
 public:
   CommandLineFastParsingAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/CmdAction/HelpAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/CmdAction/HelpAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "CommandLineParser.hpp"
 …
 {}
+Action::state_ptr CommandLineHelpAction::performCall() {
+void CommandHelp() {
+  ActionRegistry::getInstance().getActionByName(CommandLineHelpAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineHelpAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
   ostringstream usage;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   usage << CommandLineParser::getInstance().visible << endl;
   dialog->queryEmpty(NAME, usage.str());
+  if(dialog->display()) {
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  return dialog;
+}
+Action::state_ptr CommandLineHelpAction::performCall() {
+  return Action::success;
+}
 Action::state_ptr CommandLineHelpAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr CommandLineHelpAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool CommandLineHelpAction::canUndo() {
   return false;
+  return true;
+}
 bool CommandLineHelpAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/CmdAction/HelpAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void CommandHelp();
 class CommandLineHelpAction : public Action {
+  friend void CommandHelp();
 public:
   CommandLineHelpAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/CmdAction/VerboseAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/CmdAction/VerboseAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "log.hpp"
 #include "verbose.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
+// memento to remember the state when undoing
+class CommandLineVerboseState : public ActionState {
+public:
+  CommandLineVerboseState(int _verbosity) :
+    verbosity(_verbosity)
+  {}
+  int verbosity;
+};
 const char CommandLineVerboseAction::NAME[] = "verbose";
 …
 {}
+void CommandVerbose(int verbosity) {
+  ValueStorage::getInstance().setCurrentValue(CommandLineVerboseAction::NAME, verbosity);
+  ActionRegistry::getInstance().getActionByName(CommandLineVerboseAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineVerboseAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryInt(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr CommandLineVerboseAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   int verbosity = 2;
   dialog->queryInt(NAME, &verbosity, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, verbosity);
+  if(dialog->display()) {
+    setVerbosity(verbosity);
+    DoLog(0) && (Log() << Verbose(0) << "Setting verbosity to " << verbosity << "." << endl);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  setVerbosity(verbosity);
+  DoLog(0) && (Log() << Verbose(0) << "Setting verbosity to " << verbosity << "." << endl);
+  return Action::success;
+}
 Action::state_ptr CommandLineVerboseAction::performUndo(Action::state_ptr _state) {
 //  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  CommandLineVerboseState *state = assert_cast<CommandLineVerboseState*>(_state.get());
   return Action::failure;
 //  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
 //  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  int verbosity = 2;
+  ValueStorage::getInstance().queryCurrentValue(NAME, verbosity);
+  setVerbosity(state->verbosity);
+  return Action::state_ptr(new CommandLineVerboseState(verbosity));
+}
 Action::state_ptr CommandLineVerboseAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return performUndo(_state);
+}
 bool CommandLineVerboseAction::canUndo() {
   return false;
+  return true;
+}
 bool CommandLineVerboseAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/CmdAction/VerboseAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void CommandVerbose(int verbosity);
 class CommandLineVerboseAction : public Action {
+  friend void CommandVerbose(int verbosity);
 public:
   CommandLineVerboseAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/CmdAction/VersionAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/CmdAction/VersionAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char CommandLineVersionAction::NAME[] = "version";
 …
 {}
+Action::state_ptr CommandLineVersionAction::performCall() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+void CommandVersion() {
+  ActionRegistry::getInstance().getActionByName(CommandLineVersionAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* CommandLineVersionAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
   dialog->queryEmpty(NAME, ESPACKVersion);
+  if(dialog->display()) {
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  return dialog;
+}
+Action::state_ptr CommandLineVersionAction::performCall() {
+  return Action::success;
+}
 Action::state_ptr CommandLineVersionAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr CommandLineVersionAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool CommandLineVersionAction::canUndo() {
   return false;
+  return true;
+}
 bool CommandLineVersionAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/CmdAction/VersionAction.hpp

-              r06f4ef6
+              rb6da28
 #include "version.h"
+void CommandVersion();
 class CommandLineVersionAction : public Action {
+  friend void CommandVersion();
 public:
   CommandLineVersionAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/ErrorAction.cpp

-              r06f4ef6
+              rb6da28
+}
+Dialog* ErrorAction::createDialog() {
+  return NULL;
+}
 Action::state_ptr ErrorAction::performCall() {
   Log() << Verbose(0) << errorMsg << endl;

src/Actions/ErrorAction.hpp

r06f4ef6	rb6da28
22	22
23	23	private:
24
	24	virtual Dialog * createDialog();
25	25	virtual Action::state_ptr performCall();
26	26	virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/FragmentationAction/DepthFirstSearchAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/FragmentationAction/DepthFirstSearchAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
+#include "bondgraph.hpp"
 #include "config.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char FragmentationDepthFirstSearchAction::NAME[] = "depth-first-search";
 …
 {}
+void FragmentationDepthFirstSearch(double distance) {
+  ValueStorage::getInstance().setCurrentValue(FragmentationDepthFirstSearchAction::NAME, distance);
+  ActionRegistry::getInstance().getActionByName(FragmentationDepthFirstSearchAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* FragmentationDepthFirstSearchAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryDouble(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr FragmentationDepthFirstSearchAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   double distance;
   dialog->queryDouble(NAME, &distance, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, distance);
+  if(dialog->display()) {
+    DoLog(1) && (Log() << Verbose(1) << "Depth-First-Search Analysis." << endl);
+    molecule * const mol = World::getInstance().getMolecule(MoleculeById(0));
+    MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
+    int *MinimumRingSize = new int[mol->getAtomCount()];
+    atom ***ListOfLocalAtoms = NULL;
+    class StackClass<bond *> *BackEdgeStack = NULL;
+    class StackClass<bond *> *LocalBackEdgeStack = NULL;
+    mol->CreateAdjacencyList(distance, World::getInstance().getConfig()->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
+    Subgraphs = mol->DepthFirstSearchAnalysis(BackEdgeStack);
+    if (Subgraphs != NULL) {
+      int FragmentCounter = 0;
+      while (Subgraphs->next != NULL) {
+        Subgraphs = Subgraphs->next;
+        Subgraphs->FillBondStructureFromReference(mol, FragmentCounter, ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
+        LocalBackEdgeStack = new StackClass<bond *> (Subgraphs->Leaf->BondCount);
+        Subgraphs->Leaf->PickLocalBackEdges(ListOfLocalAtoms[FragmentCounter], BackEdgeStack, LocalBackEdgeStack);
+        Subgraphs->Leaf->CyclicStructureAnalysis(LocalBackEdgeStack, MinimumRingSize);
+        delete(LocalBackEdgeStack);
+        delete(Subgraphs->previous);
+        FragmentCounter++;
+      }
+      delete(Subgraphs);
+      for (int i=0;i<FragmentCounter;i++)
+        delete[](ListOfLocalAtoms[i]);
+      delete[](ListOfLocalAtoms);
+  DoLog(1) && (Log() << Verbose(1) << "Depth-First-Search Analysis." << endl);
+  molecule * const mol = World::getInstance().getMolecule(MoleculeById(0));
+  MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
+  int *MinimumRingSize = new int[mol->getAtomCount()];
+  atom **ListOfAtoms = NULL;
+  class StackClass<bond *> *BackEdgeStack = NULL;
+  class StackClass<bond *> *LocalBackEdgeStack = NULL;
+  mol->CreateAdjacencyList(distance, World::getInstance().getConfig()->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
+  Subgraphs = mol->DepthFirstSearchAnalysis(BackEdgeStack);
+  if (Subgraphs != NULL) {
+    int FragmentCounter = 0;
+    while (Subgraphs->next != NULL) {
+      Subgraphs = Subgraphs->next;
+      ListOfAtoms = NULL;
+      Subgraphs->FillBondStructureFromReference(mol, ListOfAtoms, false);  // we want to keep the created ListOfLocalAtoms
+      LocalBackEdgeStack = new StackClass<bond *> (Subgraphs->Leaf->BondCount);
+      Subgraphs->Leaf->PickLocalBackEdges(ListOfAtoms, BackEdgeStack, LocalBackEdgeStack);
+      Subgraphs->Leaf->CyclicStructureAnalysis(LocalBackEdgeStack, MinimumRingSize);
+      delete(LocalBackEdgeStack);
+      delete(Subgraphs->previous);
+      delete[](ListOfAtoms);  // and here we remove it
+      FragmentCounter++;
+    }
+    delete(BackEdgeStack);
+    delete[](MinimumRingSize);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+    delete(Subgraphs);
+  }
+  delete(BackEdgeStack);
+  delete[](MinimumRingSize);
+  return Action::success;
+}
 Action::state_ptr FragmentationDepthFirstSearchAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr FragmentationDepthFirstSearchAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool FragmentationDepthFirstSearchAction::canUndo() {
   return false;
+  return true;
+}
 bool FragmentationDepthFirstSearchAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/FragmentationAction/DepthFirstSearchAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void FragmentationDepthFirstSearch(double distance);
 class FragmentationDepthFirstSearchAction : public Action {
+  friend void FragmentationDepthFirstSearch(double distance);
 public:
   FragmentationDepthFirstSearchAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/FragmentationAction/FragmentationAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/FragmentationAction/FragmentationAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
+#include "bondgraph.hpp"
 #include "config.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char FragmentationFragmentationAction::NAME[] = "fragment-mol";
 …
 {}
+void FragmentationFragmentation(std::string &path, double distance, int order) {
+  ValueStorage::getInstance().setCurrentValue(FragmentationFragmentationAction::NAME, path);
+  ValueStorage::getInstance().setCurrentValue("distance", distance);
+  ValueStorage::getInstance().setCurrentValue("order", order);
+  ActionRegistry::getInstance().getActionByName(FragmentationFragmentationAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* FragmentationFragmentationAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryDouble("distance", ValueStorage::getInstance().getDescription("distance"));
+  dialog->queryInt("order", ValueStorage::getInstance().getDescription("order"));
+  return dialog;
+}
 Action::state_ptr FragmentationFragmentationAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   clock_t start,end;
   molecule *mol = NULL;
   double distance = -1.;
   int order = 0;
+  std::string path;
   config *configuration = World::getInstance().getConfig();
   int ExitFlag = 0;
+  cout << "pre-dialog"<< endl;
+  dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryDouble("distance", &distance, MapOfActions::getInstance().getDescription("distance"));
+  dialog->queryInt("order", &order, MapOfActions::getInstance().getDescription("order"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, path);
+  ValueStorage::getInstance().queryCurrentValue("distance", distance);
+  ValueStorage::getInstance().queryCurrentValue("order", order);
   if(dialog->display()) {
     cout << "POST-dialog"<< endl;
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     ASSERT(mol != NULL, "No molecule has been picked for fragmentation.");
     DoLog(0) && (Log() << Verbose(0) << "Fragmenting molecule with bond distance " << distance << " angstroem, order of " << order << "." << endl);
 …
     DoLog(0) && (Log() << Verbose(0) << "Fragmenting molecule with current connection matrix ..." << endl);
     if (mol->hasBondStructure()) {
       ExitFlag = mol->FragmentMolecule(order, configuration);
+      ExitFlag = mol->FragmentMolecule(order, path);
+    }
     World::getInstance().setExitFlag(ExitFlag);
     end = clock();
     DoLog(0) && (Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl);
-    delete dialog;
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}
 Action::state_ptr FragmentationFragmentationAction::performUndo(Action::state_ptr _state) {
+//  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  return Action::success;
+}
 Action::state_ptr FragmentationFragmentationAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return Action::success;
+}
 bool FragmentationFragmentationAction::canUndo() {
   return false;
+  return true;
+}
 bool FragmentationFragmentationAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/FragmentationAction/FragmentationAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void FragmentationFragmentation(std::string &path, double distance, int order);
 class FragmentationFragmentationAction : public Action {
+  friend void FragmentationFragmentation(std::string &path, double distance, int order);
 public:
   FragmentationFragmentationAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/FragmentationAction/SubgraphDissectionAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/FragmentationAction/SubgraphDissectionAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "config.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char FragmentationSubgraphDissectionAction::NAME[] = "subgraph-dissect";
 …
 {}
+Action::state_ptr FragmentationSubgraphDissectionAction::performCall() {
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
+void FragmentationSubgraphDissection() {
+  ActionRegistry::getInstance().getActionByName(FragmentationSubgraphDissectionAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* FragmentationSubgraphDissectionAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
   dialog->queryEmpty(NAME, MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    DoLog(1) && (Log() << Verbose(1) << "Dissecting molecular system into a set of disconnected subgraphs ... " << endl);
+    // @TODO rather do the dissection afterwards
+    MoleculeListClass *molecules = World::getInstance().getMolecules();
+    molecules->DissectMoleculeIntoConnectedSubgraphs(World::getInstance().getPeriode(), World::getInstance().getConfig());
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  return dialog;
+}
+Action::state_ptr FragmentationSubgraphDissectionAction::performCall() {
+  DoLog(1) && (Log() << Verbose(1) << "Dissecting molecular system into a set of disconnected subgraphs ... " << endl);
+  // @TODO rather do the dissection afterwards
+  MoleculeListClass *molecules = World::getInstance().getMolecules();
+  molecules->DissectMoleculeIntoConnectedSubgraphs(World::getInstance().getPeriode(), World::getInstance().getConfig());
+  return Action::success;
+}

src/Actions/FragmentationAction/SubgraphDissectionAction.hpp

-              r06f4ef6
+              rb6da28
 #ifndef SUBGRAPHDISSECTIONACTION_HPP_
 #define SUBGRAPHDISSECTIONACTION_HPP_f
+#define SUBGRAPHDISSECTIONACTION_HPP_
 #include "Actions/Action.hpp"
+void FragmentationSubgraphDissection();
 class FragmentationSubgraphDissectionAction : public Action {
+  friend void FragmentationSubgraphDissection();
 public:
   FragmentationSubgraphDissectionAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/Makefile.am

-              r06f4ef6
+              rb6da28
   ${MOLECULEACTIONSOURCE} \
   ${PARSERACTIONSOURCE} \
+  ${SELECTIONACTIONSOURCE} \
   ${TESSELATIONACTIONSOURCE} \
   ${WORLDACTIONSOURCE} \
 …
   ${MOLECULEACTIONHEADER} \
   ${PARSERACTIONHEADER} \
+  ${SELECTIONACTIONHEADER} \
   ${TESSELATIONACTIONHEADER} \
   ${WORLDACTIONHEADER} \
 …
   AnalysisAction/MolecularVolumeAction.cpp \
   AnalysisAction/PairCorrelationAction.cpp \
+  AnalysisAction/PrincipalAxisSystemAction.cpp
+  AnalysisAction/PointCorrelationAction.cpp \
+  AnalysisAction/PrincipalAxisSystemAction.cpp \
+  AnalysisAction/SurfaceCorrelationAction.cpp
 ANALYSISACTIONHEADER = \
   AnalysisAction/MolecularVolumeAction.hpp \
   AnalysisAction/PairCorrelationAction.hpp \
+  AnalysisAction/PrincipalAxisSystemAction.hpp
+  AnalysisAction/PointCorrelationAction.hpp \
+  AnalysisAction/PrincipalAxisSystemAction.hpp \
+  AnalysisAction/SurfaceCorrelationAction.hpp
 ATOMACTIONSOURCE = \
 …
   ParserAction/SaveXyzAction.hpp
+SELECTIONACTIONSOURCE = \
+        SelectionAction/AllAtomsAction.cpp \
+        SelectionAction/AllMoleculesAction.cpp \
+        SelectionAction/AtomByIdAction.cpp \
+        SelectionAction/MoleculeByIdAction.cpp \
+        SelectionAction/NotAllAtomsAction.cpp \
+        SelectionAction/NotAllMoleculesAction.cpp \
+        SelectionAction/NotAtomByIdAction.cpp \
+        SelectionAction/NotMoleculeByIdAction.cpp
+SELECTIONACTIONHEADER = \
+        SelectionAction/AllAtomsAction.hpp \
+        SelectionAction/AllMoleculesAction.hpp \
+        SelectionAction/AtomByIdAction.hpp \
+        SelectionAction/MoleculeByIdAction.hpp \
+        SelectionAction/NotAllAtomsAction.hpp \
+        SelectionAction/NotAllMoleculesAction.hpp \
+        SelectionAction/NotAtomByIdAction.hpp \
+        SelectionAction/NotMoleculeByIdAction.hpp
 TESSELATIONACTIONSOURCE = \
   TesselationAction/ConvexEnvelopeAction.cpp \
 …
   WorldAction/CenterOnEdgeAction.cpp \
   WorldAction/ChangeBoxAction.cpp \
+  WorldAction/InputAction.cpp \
+  WorldAction/OutputAction.cpp \
   WorldAction/RemoveSphereOfAtomsAction.cpp \
   WorldAction/RepeatBoxAction.cpp \
   WorldAction/ScaleBoxAction.cpp \
   WorldAction/SetDefaultNameAction.cpp \
+  WorldAction/SetGaussianBasisAction.cpp
+  WorldAction/SetGaussianBasisAction.cpp \
+  WorldAction/SetOutputFormatsAction.cpp
 WORLDACTIONHEADER = \
   WorldAction/AddEmptyBoundaryAction.hpp \
 …
   WorldAction/CenterOnEdgeAction.hpp \
   WorldAction/ChangeBoxAction.hpp \
+  WorldAction/InputAction.hpp \
+  WorldAction/OutputAction.hpp \
   WorldAction/RemoveSphereOfAtomsAction.hpp \
   WorldAction/RepeatBoxAction.hpp \
   WorldAction/ScaleBoxAction.hpp \
   WorldAction/SetDefaultNameAction.hpp \
+  WorldAction/SetGaussianBasisAction.hpp
+  WorldAction/SetGaussianBasisAction.hpp \
+  WorldAction/SetOutputFormatsAction.hpp
+unity.cpp:
+        echo "" >  unity.cpp; \
+        list='$(ACTIONSSOURCE)'; for file in $$list; do \
+          echo "#include \"$(srcdir)/$$file\"" >> unity.cpp; \
+        done;
+MOSTLYCLEANFILES = unity.cpp

src/Actions/MakroAction.cpp

-              r06f4ef6
+              rb6da28
+}
+Dialog* MakroAction::fillDialog(Dialog *dialog) {
+  return actions->fillAllDialogs(dialog);
+}
 Action::state_ptr MakroAction::performCall(){

src/Actions/MakroAction.hpp

r06f4ef6	rb6da28
29	29	bool shouldUndo();
30	30
	31	protected:
	32	virtual Dialog fillDialog(Dialog dialog);
31	33	private:
32	34	virtual Action::state_ptr performCall();

src/Actions/ManipulateAtomsProcess.cpp

-              r06f4ef6
+              rb6da28
 {}
+Dialog* ManipulateAtomsProcess::fillDialog(Dialog *dialog){
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  return dialog;
+}
 Action::state_ptr ManipulateAtomsProcess::performCall(){
   World::getInstance().doManipulate(this);
 …
   setMaxSteps(world->numAtoms());
   start();
+  for(World::AtomIterator iter=world->getAtomIter(descr);iter!=world->atomEnd();++iter){
+  for(World::internal_AtomIterator
+      iter=world->getAtomIter_internal(descr);
+      iter!=world->atomEnd_internal();
+      ++iter){
     setCurrStep(iter.getCount());
     operation(*iter);

src/Actions/ManipulateAtomsProcess.hpp

-              r06f4ef6
+              rb6da28
   virtual void doManipulate(World *);
+protected:
+  virtual Dialog * fillDialog(Dialog*);
 private:
   virtual Action::state_ptr performCall();
   virtual Action::state_ptr performUndo(Action::state_ptr);

src/Actions/MapOfActions.cpp

-              r06f4ef6
+              rb6da28
 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>
 …
 #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"
 …
+{
   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));
+}
 …
+{
   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));
+}
 …
   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";
 …
   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";
 …
   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, ...";
 …
   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";
 …
   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";
 …
   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";
 …
   ShortFormMap["scale-box"] = "s";
   ShortFormMap["set-basis"] = "M";
+  ShortFormMap["set-output"] = "o";
   ShortFormMap["subgraph-dissect"] = "I";
   ShortFormMap["suspend-in-water"] = "u";
 …
   // 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");
 …
   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");
 …
   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");
 …
     // 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");
+}
 …
+}
+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.
+ *
 …
     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:
 …
             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())
 …
             ListRunner->second->add_options()
               (getKeyAndShortForm(*OptionRunner).c_str(),
                   po::value<BoxValue>()->multitoken(),
+                  po::value<BoxValue>(),
                   getDescription(*OptionRunner).c_str())
+              ;
 …
             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(),
 …
             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())
 …
             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(),
 …
+              ;
             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())
+              ;
 …
+        }
       } 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())
 …
+    }
+  }
-  // 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;
+}
 …
  * \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();
+}

src/Actions/MapOfActions.hpp

-              r06f4ef6
+              rb6da28
 #define MAPOFACTIONS_HPP_
-#include "Helpers/Assert.hpp"
 #include <boost/program_options.hpp>
+#include <boost/lexical_cast.hpp>
 #include <map>
 #include <set>
+#include <vector>
+#include <typeinfo>
+#include "Exceptions/IllegalTypeException.hpp"
+#include "Exceptions/MissingValueException.hpp"
+#include "Helpers/Assert.hpp"
+#include "Patterns/Singleton.hpp"
 class MapOfActionsTest;
+#include "Patterns/Singleton.hpp"
+class Box;
+class atom;
+class element;
+class molecule;
+class Vector;
 namespace po = boost::program_options;
+using boost::lexical_cast;
+/** Central class for adding functionality to the code.
+ *
+ * In Molecuilder everything that can be done - such as adding atoms,
+ * translating molecules, saving bind information - is an Action.
+ *
+ * In order to reference Action's with what the user sees, this class is the
+ * mediator.
+ *
+ * An Action is described to the user by:
+ * -# a name (this is the most important information)
+ * -# a description
+ * -# a shortform (single letter for use on the command line)
+ * -# a text menu it resides in
+ * -# the type of its argument
+ * -# the command line category
+ *
+ * The Action::NAME is the most important information because every Action
+ * registers itself automatically with the ActionRegistry and can be retrieved
+ * therefrom and from this MapOfActions simply by knowing its name alone.
+ *
+ * In the constructor of MapOfActions all this is set.
+ *
+ * Note that Action will require input from the user. This is done via class
+ * Query.
+ *
+ * And note also that MapOfActions actually contains more than just all
+ * Actions: There are a number of names that actually are just arguments to
+ * actions (e.g. "output-file").
+ *
+ * <h1> Howto add an Action</h1>
+ *
+ * Let us assume your new action (class) is called SuperDuperAction, consisting
+ * of two files SuperDuperAction.cpp and SuperDuperAction.hpp.
+ *
+ * Furthermore, let's say you Action needs two values: a double value as a
+ * upper threshold and a string which is the name of the output file.
+ *
+ * <h2> Command Line preliminaries </h2>
+ *
+ * You have to decide whether (for the command line) it makes sense to have an
+ * extra argument requesting the arguments, or one should be the argument of
+ * your action. I.e. your action name is "super-duper", then the use may
+ * call your action like this:
+ *
+ * ./molecuilder --super-duper 4 --output-file test.dat
+ *
+ * Here, we have picked the threshold as the value for your action and the
+ * name of the output file is given by an additional argument. Of course,
+ * it can be the other way round or by two arguments such as here:
+ *
+ * ./molecuilder --super-duper --threshold 4 --output-file test.dat
+ *
+ * It depends on what possible arguments are already there (don't make up
+ * new ones if present ones actually make sense for your action) and which
+ * argument is more natural or closer to what your action does.
+ *
+ * <h2> Menu preliminaries </h2>
+ *
+ * Whatever you decide, your action will need some Query dialogs to request
+ * the necessary information from the user, either via a command line
+ * argument (--output-file) via a text dialog (referenced by "output-file")
+ * or via a graphical dialog (same reference). And therein, the names
+ * of the arguments have to re-appear.
+ *
+ * Then, the following steps have to be done to incorporate your Action:
+ * -# create a unique name for your action (no capital letters) to reference
+ *    it, this name has to appear in the file SuperDuperAction.cpp, e.g.
+ *    "super-duper"
+ * -# pick names the other required arguments, best if they are already
+ *    present in the MapOfActions. They have to appear in Query's in the
+ *    code of your Action.
+ * -# With this name create entries in the following maps for the action
+ *    name and for each names of a desired addtional argument if not present:
+ *   -# DescriptionMap, a catchy description of what your action does
+ *   -# TypeMap, see MapOfActions::OptionTypes for possible types of the single
+ *      argument it takes.
+ *   -# MenuContainsActionMap, in which menu should your action appear
+ *   -# ShortFormMap (optional), single letter for command line call
+ *   -# DefaultValueMap (optional), the default value (always a string)
+ * -# add to one of the command line sets by the following categories
+ *   -# generic - generic options (i.e. not one of the others)
+ *   -# config - action/argument only considers internal bevahior, user
+ *      does not have to see it while still having full functionality
+ *   -# hidden - this should be hidden from the user
+ *   -# visible - this should be visible to the user
+ *   -# inputfile - this should only be parsed from an input file, not
+ *      from command line
+ * -# add to a menu, i.e. make an entry in MenuContainsActionMap.
+ * -# add header file SuperDuperAction.hpp to MapOfActions.cpp and instantiate
+ *    your action in populateMenu() (mind the sorting: 1. menu,
+ *    2. alphabetical)
+ *
+ *  And that's.
+ *
+ *  Now, your action can be called from the command line, within the text
+ *  menu and the graphical user interface.
+ *
+ */
 class MapOfActions : public Singleton<MapOfActions> {
   friend class Singleton<MapOfActions>;
   friend class MapOfActionsTest;
 public:
   enum OptionTypes { None, Boolean, Integer, ListOfInts, Double, ListOfDoubles, String, Axis, Vector, Box, Molecule, ListOfMolecules, Atom, ListOfAtoms, Element, ListOfElements };
+  enum OptionTypes { None, Boolean, Integer, ListOfIntegers, Double, ListOfDoubles, String, ListOfStrings, Vector, ListOfVectors, Box, Molecule, ListOfMolecules, Atom, ListOfAtoms, Element, ListOfElements };
   // getter for the action descriptions and short forms
   std::string getDescription(string actionname);
   std::string getKeyAndShortForm(string actionname);
   std::string getShortForm(string actionname);
   map <std::string, std::string> getShortFormToActionMap();
+  std::string getDescription(std::string actionname);
+  std::string getKeyAndShortForm(std::string actionname);
+  std::string getShortForm(std::string actionname);
+  std::map <std::string, std::string> getShortFormToActionMap();
   void AddOptionsToParser();
   // check presence and getter for action type
+  bool hasValue(string actionname);
+  bool isShortFormPresent(string shortform);
+  enum OptionTypes getValueType(string actionname);
+  set<string> generic;
+  set<string> config;
+  set<string> hidden;
+  set<string> visible;
+  set<string> inputfile;
+  bool hasValue(std::string actionname);
+  bool isShortFormPresent(std::string shortform);
+  std::string  getValueType(std::string actionname);
+  std::set<std::string> generic;
+  std::set<std::string> config;
+  std::set<std::string> hidden;
+  std::set<std::string> visible;
+  std::set<std::string> inputfile;
+  std::multimap <std::string, std::string> MenuContainsActionMap;
+  std::map <std::string, std::pair<std::string,std::string> > MenuDescription;
+  // instantiates and puts all known actions into the ActionRegistry
+  void populateActions();
+  void queryCurrentValue(const char * name, class atom * &_T);
+  void queryCurrentValue(const char * name, class element * &_T);
+  void queryCurrentValue(const char * name, class molecule * &_T);
+  void queryCurrentValue(const char * name, class Box &_T);
+  void queryCurrentValue(const char * name, class Vector &_T);
+  void queryCurrentValue(const char * name, std::vector<atom *>&_T);
+  void queryCurrentValue(const char * name, std::vector<element *>&_T);
+  void queryCurrentValue(const char * name, std::vector<molecule *>&_T);
+  template<typename T> void queryCurrentValue(const char * name, T &_T)
+  {
+    if (typeid( T ) == *TypeMap[name]) { // constructor of type_info is private, hence can only store by ref or ptr
+      if (CurrentValue.find(name) == CurrentValue.end())
+        throw MissingValueException(__FILE__, __LINE__);
+      _T = lexical_cast<T>(CurrentValue[name].c_str());
+      CurrentValue.erase(name);
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
+  }
+  template<typename T> void queryCurrentValue(const char * name, std::vector<T> &_T)
+  {
+    T temp;
+    if (typeid( std::vector<T> ) == *TypeMap[name]) { // constructor of type_info is private, hence can only store by ref or ptr
+      if (CurrentValue.find(name) == CurrentValue.end())
+        throw MissingValueException(__FILE__, __LINE__);
+      std::istringstream stream(CurrentValue[name]);
+      CurrentValue.erase(name);
+      while (!stream.fail()) {
+        stream >> temp >> std::ws;
+        _T.push_back(temp);
+      }
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
+  }
+  void setCurrentValue(const char * name, class atom * &_T);
+  void setCurrentValue(const char * name, class element * &_T);
+  void setCurrentValue(const char * name, class molecule * &_T);
+  void setCurrentValue(const char * name, class Box &_T);
+  void setCurrentValue(const char * name, class Vector &_T);
+  void setCurrentValue(const char * name, std::vector<atom *>&_T);
+  void setCurrentValue(const char * name, std::vector<element *>&_T);
+  void setCurrentValue(const char * name, std::vector<molecule *>&_T);
+  template<class T> void setCurrentValue(const char * name, T &_T)
+  {
+    std::ostringstream stream;
+    if (typeid( T ) == *TypeMap[name]) {  // constructor of type_info is private, hence can only store by ref or ptr
+      stream << _T;
+      CurrentValue[name] = stream.str();
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
+  }
+  template<class T> void setCurrentValue(const char * name, std::vector<T> &_T)
+  {
+    std::ostringstream stream;
+    if (typeid( std::vector<T> ) == *TypeMap[name]) {  // constructor of type_info is private, hence can only store by ref or ptr
+      std::ostringstream stream;
+      for (typename std::vector<T>::iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+        stream << (*iter) << " ";
+      }
+      CurrentValue[name] = stream.str();
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
+  }
 private:
 …
   // lookup list from our configs to the ones of CommandLineParser
   map< set<std::string> *, po::options_description *> CmdParserLookup;
+  std::map< std::set<std::string> *, po::options_description *> CmdParserLookup;
   // map of the action names and their description
+  map<std::string, std::string> DefaultValue;
+  map<std::string, std::string> DescriptionMap;
+  map<std::string, std::string> ShortFormMap;
+  map<std::string, enum OptionTypes > TypeMap;
+  std::map<std::string, std::string> CurrentValue;
+  std::map<std::string, std::string> DescriptionMap;
+  std::map<std::string, std::string> ShortFormMap;
+  std::map<std::string, const std::type_info * > TypeMap;
+  std::map<const std::type_info *, enum OptionTypes > TypeEnumMap;
 };

src/Actions/MethodAction.cpp

-              r06f4ef6
+              rb6da28
 {}
+Dialog* MethodAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  return dialog;
+}
 Action::state_ptr MethodAction::performCall() {

src/Actions/MethodAction.hpp

r06f4ef6	rb6da28
25	25	virtual bool shouldUndo();
26	26
	27	protected:
	28	virtual Dialog * fillDialog(Dialog *dialog);
27	29	private:
28	30	virtual Action::state_ptr performCall();

src/Actions/MoleculeAction/BondFileAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/MoleculeAction/BondFileAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
-#include "atom.hpp"
-#include "bondgraph.hpp"
-#include "config.hpp"
-#include "defs.hpp"
-#include "log.hpp"
-#include "molecule.hpp"
-#include "vector.hpp"
-#include "World.hpp"
 /****** MoleculeBondFileAction *****/
 …
 {}
+void MoleculeBondFile(std::string &bondfile) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeBondFileAction::NAME, bondfile);
+  ActionRegistry::getInstance().getActionByName(MoleculeBondFileAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeBondFileAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, MapOfActions::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeBondFileAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  if(World::getInstance().countSelectedMolecules() == 1) {
+    mol = World::getInstance().beginMoleculeSelection()->second;
     DoLog(0) && (Log() << Verbose(0) << "Parsing bonds from " << filename << "." << endl);
     ifstream input(filename.c_str());
     mol->CreateAdjacencyListFromDbondFile(&input);
     input.close();
-    delete dialog;
     return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  } else
+    return Action::failure;
+}

src/Actions/MoleculeAction/BondFileAction.hpp

-              r06f4ef6
+              rb6da28
 class MoleculeListClass;
+void MoleculeBondFile(std::string &bondfile);
 class MoleculeBondFileAction : public Action {
+  friend void MoleculeBondFile(std::string &bondfile);
 public:
   MoleculeBondFileAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/MoleculeAction/ChangeNameAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/MoleculeAction/ChangeNameAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "atom.hpp"
+#include "molecule.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "molecule.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeChangeNameAction *****/
 …
 };
 const char MoleculeChangeNameAction::NAME[] = "Change filename of Molecule";
+const char MoleculeChangeNameAction::NAME[] = "change-molname";
 MoleculeChangeNameAction::MoleculeChangeNameAction() :
 …
 {}
+void MoleculeChangeName(std::string &name) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeChangeNameAction::NAME, name);
+  ActionRegistry::getInstance().getActionByName(MoleculeChangeNameAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeChangeNameAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeChangeNameAction::performCall() {
   string filename;
   molecule *mol = NULL;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryString("Enter name: ",&filename);
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  if (World::getInstance().countSelectedMolecules() == 1) {
+    mol = World::getInstance().beginMoleculeSelection()->second;
     string oldName = mol->getName();
     mol->setName(filename);
-    delete dialog;
     return Action::state_ptr(new MoleculeChangeNameState(mol,oldName));
+  }
+  delete dialog;
+  return Action::failure;
+  } else
+    return Action::failure;
+}

src/Actions/MoleculeAction/ChangeNameAction.hpp

-              r06f4ef6
+              rb6da28
 class MoleculeListClass;
+void MoleculeChangeName(std::string &name);
 class MoleculeChangeNameAction : public Action {
+  friend void MoleculeChangeName(std::string &name);
 public:
   MoleculeChangeNameAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/MoleculeAction/FillWithMoleculeAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/MoleculeAction/FillWithMoleculeAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "atom.hpp"
+#include "bondgraph.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "bondgraph.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "defs.hpp"
+#include "molecule.hpp"
+#include "periodentafel.hpp"
+#include "vector.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeFillWithMoleculeAction *****/
 …
 {}
+void MoleculeFillWithMolecule(std::string &fillername, Vector &distances, Vector &lengths, double MaxDistance, bool DoRotate) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeFillWithMoleculeAction::NAME, fillername);
+  ValueStorage::getInstance().setCurrentValue("distances", distances);
+  ValueStorage::getInstance().setCurrentValue("lengths", lengths);
+  ValueStorage::getInstance().setCurrentValue("DoRotate", MaxDistance);
+  ValueStorage::getInstance().setCurrentValue("MaxDistance", DoRotate);
+  ActionRegistry::getInstance().getActionByName(MoleculeFillWithMoleculeAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeFillWithMoleculeAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryVector("distances", false, ValueStorage::getInstance().getDescription("distances"));
+  dialog->queryVector("lengths", false, ValueStorage::getInstance().getDescription("lengths"));
+  dialog->queryBoolean("DoRotate", ValueStorage::getInstance().getDescription("DoRotate"));
+  dialog->queryDouble("MaxDistance", ValueStorage::getInstance().getDescription("MaxDistance"));
+  return dialog;
+}
 Action::state_ptr MoleculeFillWithMoleculeAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   Vector distances;
   Vector lengths;
 …
   bool DoRotate = false;
   dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
   dialog->queryVector("distances", &distances, World::getInstance().getDomain(), false, MapOfActions::getInstance().getDescription("distances"));
   dialog->queryVector("lengths", &lengths, World::getInstance().getDomain(), false, MapOfActions::getInstance().getDescription("lengths"));
   dialog->queryBoolean("DoRotate", &DoRotate, MapOfActions::getInstance().getDescription("DoRotate"));
   dialog->queryDouble("MaxDistance", &MaxDistance, MapOfActions::getInstance().getDescription("MaxDistance"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  ValueStorage::getInstance().queryCurrentValue("distances", distances);
+  ValueStorage::getInstance().queryCurrentValue("lengths", lengths);
+  ValueStorage::getInstance().queryCurrentValue("DoRotate", DoRotate);
+  ValueStorage::getInstance().queryCurrentValue("MaxDistance", MaxDistance);
+  if(dialog->display()) {
+    DoLog(1) && (Log() << Verbose(1) << "Filling Box with water molecules, lengths(" << lengths[0] << "," << lengths[1] << "," << lengths[2] << "), distances (" << distances[0] << "," << distances[1] << "," << distances[2] << "), MaxDistance " << MaxDistance << ", DoRotate " << DoRotate << "." << endl);
+    // construct water molecule
+    molecule *filler = World::getInstance().createMolecule();
+    if (!filler->AddXYZFile(filename)) {
+      DoeLog(0) && (eLog()<< Verbose(0) << "Could not parse filler molecule from " << filename << "." << endl);
+    }
+    filler->SetNameFromFilename(filename.c_str());
+    molecule *Filling = NULL;
+  DoLog(1) && (Log() << Verbose(1) << "Filling Box with water molecules, lengths(" << lengths[0] << "," << lengths[1] << "," << lengths[2] << "), distances (" << distances[0] << "," << distances[1] << "," << distances[2] << "), MaxDistance " << MaxDistance << ", DoRotate " << DoRotate << "." << endl);
+  // construct water molecule
+  molecule *filler = World::getInstance().createMolecule();
+  if (!filler->AddXYZFile(filename)) {
+    DoeLog(0) && (eLog()<< Verbose(0) << "Could not parse filler molecule from " << filename << "." << endl);
+  }
+  filler->SetNameFromFilename(filename.c_str());
+  molecule *Filling = NULL;
 //    atom *first = NULL, *second = NULL, *third = NULL;
 //    first = World::getInstance().createAtom();
 …
 //    filler->AddBond(first, third, 1);
 //    filler->AddBond(second, third, 1);
     World::getInstance().getConfig()->BG->ConstructBondGraph(filler);
+  World::getInstance().getConfig()->BG->ConstructBondGraph(filler);
 //    filler->SetNameFromFilename("water");
+    // call routine
+    double distance[NDIM];
+    for (int i=0;i<NDIM;i++)
+      distance[i] = distances[i];
+    Filling = FillBoxWithMolecule(World::getInstance().getMolecules(), filler, *(World::getInstance().getConfig()), MaxDistance, distance, lengths[0], lengths[1], lengths[2], DoRotate);
+    if (Filling != NULL) {
+      Filling->ActiveFlag = false;
+      World::getInstance().getMolecules()->insert(Filling);
+    }
+    World::getInstance().destroyMolecule(filler);
+  // call routine
+  double distance[NDIM];
+  for (int i=0;i<NDIM;i++)
+    distance[i] = distances[i];
+  Filling = FillBoxWithMolecule(World::getInstance().getMolecules(), filler, *(World::getInstance().getConfig()), MaxDistance, distance, lengths[0], lengths[1], lengths[2], DoRotate);
+  if (Filling != NULL) {
+    Filling->ActiveFlag = false;
+    World::getInstance().getMolecules()->insert(Filling);
+  }
+  for (molecule::iterator iter = filler->begin(); !filler->empty(); iter = filler->begin()) {
+    atom *Walker = *iter;
+    filler->erase(iter);
+    World::getInstance().destroyAtom(Walker);
+  }
+  World::getInstance().destroyMolecule(filler);
+    delete dialog;
+    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/FillWithMoleculeAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
 #include "Actions/Process.hpp"
+#include "vector.hpp"
 class MoleculeListClass;
+void MoleculeFillWithMolecule(std::string &fillername, Vector &distances, Vector &lengths, double MaxDistance, bool DoRotate);
 class MoleculeFillWithMoleculeAction : public Action {
+  friend void MoleculeFillWithMolecule(std::string &fillername, Vector &distances, Vector &lengths, double MaxDistance, bool DoRotate);
 public:
   MoleculeFillWithMoleculeAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/MoleculeAction/LinearInterpolationofTrajectoriesAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/MoleculeAction/LinearInterpolationofTrajectoriesAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "atom.hpp"
+#include "defs.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
-#include "atom.hpp"
-#include "defs.hpp"
-#include "log.hpp"
-#include "molecule.hpp"
-#include "verbose.hpp"
-#include "World.hpp"
 /****** MoleculeLinearInterpolationofTrajectoriesAction *****/
 …
 {}
+void MoleculeLinearInterpolationofTrajectories(std::string &filename, int start, int end, bool IdMapping) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeLinearInterpolationofTrajectoriesAction::NAME, filename);
+  ValueStorage::getInstance().setCurrentValue("start-step", start);
+  ValueStorage::getInstance().setCurrentValue("end-step", end);
+  ValueStorage::getInstance().setCurrentValue("id-mapping", IdMapping);
+  ActionRegistry::getInstance().getActionByName(MoleculeLinearInterpolationofTrajectoriesAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeLinearInterpolationofTrajectoriesAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryInt("start-step", MapOfActions::getInstance().getDescription("start-step"));
+  dialog->queryInt("end-step", MapOfActions::getInstance().getDescription("end-step"));
+  dialog->queryBoolean("id-mapping", MapOfActions::getInstance().getDescription("id-mapping"));
+  return dialog;
+}
 Action::state_ptr MoleculeLinearInterpolationofTrajectoriesAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
   int start = -1;
 …
   bool IdMapping = true;
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  ValueStorage::getInstance().queryCurrentValue("start-step", start);
+  ValueStorage::getInstance().queryCurrentValue("end-step", end);
+  ValueStorage::getInstance().queryCurrentValue("id-mapping", IdMapping);
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryInt("start-step", &start, MapOfActions::getInstance().getDescription("start-step"));
+  dialog->queryInt("end-step", &end, MapOfActions::getInstance().getDescription("end-step"));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  dialog->queryBoolean("id-mapping", &IdMapping, MapOfActions::getInstance().getDescription("id-mapping"));
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Linear interpolation between configuration " << start << " and " << end << "." << endl);
     if (IdMapping)
       DoLog(1) && (Log() << Verbose(1) << "Using Identity for the permutation map." << endl);
+    char outputname[MAXSTRINGSIZE];
+    strcpy(outputname, filename.c_str());
+    // TODO: LinearInterpolationBetweenConfiguration should use stream, not the filename directly! (better for unit test)
+    if (!mol->LinearInterpolationBetweenConfiguration(start, end, outputname, *(World::getInstance().getConfig()), IdMapping))
+      DoLog(2) && (Log() << Verbose(2) << "Could not store " << outputname << " files." << endl);
+    if (!mol->LinearInterpolationBetweenConfiguration(start, end, filename, *(World::getInstance().getConfig()), IdMapping))
+      DoLog(2) && (Log() << Verbose(2) << "Could not store " << filename << " files." << endl);
     else
       DoLog(2) && (Log() << Verbose(2) << "Steps created and " << filename << " files stored." << endl);
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/LinearInterpolationofTrajectoriesAction.hpp

-              r06f4ef6
+              rb6da28
 class MoleculeListClass;
+void MoleculeLinearInterpolationofTrajectories(std::string &filename, int start, int end, bool IdMapping);
 class MoleculeLinearInterpolationofTrajectoriesAction : public Action {
+  friend void MoleculeLinearInterpolationofTrajectories(std::string &filename, int start, int end, bool IdMapping);
 public:
   MoleculeLinearInterpolationofTrajectoriesAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/MoleculeAction/RotateToPrincipalAxisSystemAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/MoleculeAction/RotateToPrincipalAxisSystemAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeRotateToPrincipalAxisSystemAction *****/
 …
 {}
+void MoleculeRotateToPrincipalAxisSystem() {
+  ActionRegistry::getInstance().getActionByName(MoleculeRotateToPrincipalAxisSystemAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeRotateToPrincipalAxisSystemAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryEmpty(NAME, MapOfActions::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeRotateToPrincipalAxisSystemAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(0) && (Log() << Verbose(0) << "Converting to prinicipal axis system." << endl);
     mol->PrincipalAxisSystem(true);
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/RotateToPrincipalAxisSystemAction.hpp

-              r06f4ef6
+              rb6da28
 class MoleculeListClass;
+void MoleculeRotateToPrincipalAxisSystem();
 class MoleculeRotateToPrincipalAxisSystemAction : public Action {
+  friend void MoleculeRotateToPrincipalAxisSystem();
 public:
   MoleculeRotateToPrincipalAxisSystemAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/MoleculeAction/SaveAdjacencyAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/MoleculeAction/SaveAdjacencyAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "bondgraph.hpp"
+#include "config.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "bondgraph.hpp"
+#include "config.hpp"
+#include "defs.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "vector.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeSaveAdjacencyAction *****/
 …
 {}
+void MoleculeSaveAdjacency(std::string &adjacencyfile) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeSaveAdjacencyAction::NAME, adjacencyfile);
+  ActionRegistry::getInstance().getActionByName(MoleculeSaveAdjacencyAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeSaveAdjacencyAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeSaveAdjacencyAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(0) && (Log() << Verbose(0) << "Storing adjacency to path " << filename << "." << endl);
     World::getInstance().getConfig()->BG->ConstructBondGraph(mol);
     // TODO: sollte stream nicht filename benutzen, besser fuer unit test
+    char outputname[MAXSTRINGSIZE];
+    strcpy(outputname, filename.c_str());
+    mol->StoreAdjacencyToFile(NULL, outputname);
+    delete dialog;
+    return Action::success;
+    mol->StoreAdjacencyToFile(filename);
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/SaveAdjacencyAction.hpp

-              r06f4ef6
+              rb6da28
 class MoleculeListClass;
+void MoleculeSaveAdjacency(std::string &adjacencyfile);
 class MoleculeSaveAdjacencyAction : public Action {
+  friend void MoleculeSaveAdjacency(std::string &adjacencyfile);
 public:
   MoleculeSaveAdjacencyAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/MoleculeAction/SaveBondsAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/MoleculeAction/SaveBondsAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "bondgraph.hpp"
+#include "config.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "bondgraph.hpp"
+#include "config.hpp"
+#include "defs.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "vector.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeSaveBondsAction *****/
 …
 {}
+void MoleculeSaveBonds(std::string &bondsfile) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeSaveBondsAction::NAME, bondsfile);
+  ActionRegistry::getInstance().getActionByName(MoleculeSaveBondsAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeSaveBondsAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeSaveBondsAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(0) && (Log() << Verbose(0) << "Storing bonds to path " << filename << "." << endl);
     World::getInstance().getConfig()->BG->ConstructBondGraph(mol);
+    // TODO: sollte stream, nicht filenamen direkt nutzen, beser fuer unit tests
+    char outputname[MAXSTRINGSIZE];
+    strcpy(outputname, filename.c_str());
+    mol->StoreBondsToFile(NULL, outputname);
+    delete dialog;
+    return Action::success;
+    // TODO: sollte stream, nicht filenamen direkt nutzen, besser fuer unit tests
+    mol->StoreBondsToFile(filename);
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/SaveBondsAction.hpp

-              r06f4ef6
+              rb6da28
 class MoleculeListClass;
+void MoleculeSaveBonds(std::string &bondsfile);
 class MoleculeSaveBondsAction : public Action {
+  friend void MoleculeSaveBonds(std::string &bondsfile);
 public:
   MoleculeSaveBondsAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/MoleculeAction/SaveTemperatureAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/MoleculeAction/SaveTemperatureAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeSaveTemperatureAction *****/
 …
 {}
+void MoleculeSaveTemperature(std::string &temperaturefile) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeSaveTemperatureAction::NAME, temperaturefile);
+  ActionRegistry::getInstance().getActionByName(MoleculeSaveTemperatureAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeSaveTemperatureAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeSaveTemperatureAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Storing temperatures in " << filename << "." << endl);
     ofstream output;
 …
       DoLog(2) && (Log() << Verbose(2) << "File stored." << endl);
     output.close();
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/SaveTemperatureAction.hpp

-              r06f4ef6
+              rb6da28
 class MoleculeListClass;
+void MoleculeSaveTemperature(std::string &temperaturefile);
 class MoleculeSaveTemperatureAction : public Action {
+  friend void MoleculeSaveTemperature(std::string &temperaturefile);
 public:
   MoleculeSaveTemperatureAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/MoleculeAction/SuspendInWaterAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/MoleculeAction/SuspendInWaterAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "log.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "log.hpp"
+#include "config.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeSuspendInWaterAction *****/
 …
 {}
+void MoleculeSuspendInWater(double density) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeSuspendInWaterAction::NAME, density);
+  ActionRegistry::getInstance().getActionByName(MoleculeSuspendInWaterAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeSuspendInWaterAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryDouble(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeSuspendInWaterAction::performCall() {
   molecule *mol = NULL;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   double density;
   double volume = 0.;
+  dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryDouble("density", &density, MapOfActions::getInstance().getDescription("density"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, density);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(0) && (Log() << Verbose(0) << "Evaluating necessary cell volume for a cluster suspended in water.");
     if (density < 1.0) {
 …
     } else {
       PrepareClustersinWater(World::getInstance().getConfig(), mol, volume, density);  // if volume == 0, will calculate from ConvexEnvelope
-      delete dialog;
-      return Action::success;
+    }
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/SuspendInWaterAction.hpp

-              r06f4ef6
+              rb6da28
 class MoleculeListClass;
+void MoleculeSuspendInWater(double density);
 class MoleculeSuspendInWaterAction : public Action {
+  friend void MoleculeSuspendInWater(double density);
 public:
   MoleculeSuspendInWaterAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/MoleculeAction/TranslateAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/MoleculeAction/TranslateAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "vector.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeTranslateAction *****/
 …
 {}
+void MoleculeTranslate(Vector &x, bool periodic) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeTranslateAction::NAME, x);
+  ValueStorage::getInstance().setCurrentValue("periodic", periodic);
+  ActionRegistry::getInstance().getActionByName(MoleculeTranslateAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeTranslateAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryBoolean("periodic", ValueStorage::getInstance().getDescription("periodic"));
+  return dialog;
+}
 Action::state_ptr MoleculeTranslateAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
   Vector x;
   bool periodic = false;
+  dialog->queryVector(NAME, &x, World::getInstance().getDomain(), false, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  dialog->queryBoolean("periodic", &periodic, MapOfActions::getInstance().getDescription("periodic"));
+  cout << "pre-dialog" << endl;
+  ValueStorage::getInstance().queryCurrentValue(NAME, x);
+  ValueStorage::getInstance().queryCurrentValue("periodic", periodic);
   if(dialog->display()) {
     cout << "post-dialog" << endl;
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Translating all ions by given vector." << endl);
     if (periodic)
 …
     else
       mol->Translate((const Vector *)&x);
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/TranslateAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
 #include "Actions/Process.hpp"
+#include "vector.hpp"
 class MoleculeListClass;
+void MoleculeTranslate(Vector &x, bool periodic);
 class MoleculeTranslateAction : public Action {
+  friend void MoleculeTranslate(Vector &x, bool periodic);
 public:
   MoleculeTranslateAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/MoleculeAction/VerletIntegrationAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/MoleculeAction/VerletIntegrationAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** MoleculeVerletIntegrationAction *****/
 …
 {}
+void MoleculeVerletIntegration(std::string &forcesfile) {
+  ValueStorage::getInstance().setCurrentValue(MoleculeVerletIntegrationAction::NAME, forcesfile);
+  ActionRegistry::getInstance().getActionByName(MoleculeVerletIntegrationAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* MoleculeVerletIntegrationAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr MoleculeVerletIntegrationAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule *mol = NULL;
+  dialog->queryString(NAME, &filename, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryMolecule("molecule-by-id", &mol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     DoLog(1) && (Log() << Verbose(1) << "Parsing forces file and Verlet integrating." << endl);
     // TODO: sollte besser stream nutzen, nicht filename direkt (es sei denn, ist prefix), besser fuer unit test
     char outputname[MAXSTRINGSIZE];
     strcpy(outputname, filename.c_str());
     if (!mol->VerletForceIntegration(outputname, *(World::getInstance().getConfig())))
+    if (!mol->VerletForceIntegration(outputname, *(World::getInstance().getConfig()), 0))
       DoLog(2) && (Log() << Verbose(2) << "File not found." << endl);
     else
       DoLog(2) && (Log() << Verbose(2) << "File found and parsed." << endl);
-    delete dialog;
-    return Action::success;
+  }
+  delete dialog;
+  return Action::failure;
+  return Action::success;
+}

src/Actions/MoleculeAction/VerletIntegrationAction.hpp

-              r06f4ef6
+              rb6da28
 class MoleculeListClass;
+void MoleculeVerletIntegration(std::string &forcesfile);
 class MoleculeVerletIntegrationAction : public Action {
+  friend void MoleculeVerletIntegration(std::string &forcesfile);
 public:
   MoleculeVerletIntegrationAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/ParserAction/LoadXyzAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Helpers/MemDebug.hpp"
+using namespace std;
 #include "Actions/ParserAction/LoadXyzAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "Parser/XyzParser.hpp"
+#include "atom.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
+#include <set>
 #include <string>
+using namespace std;
+#include <vector>
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "molecule.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** ParserLoadXyzAction *****/
 …
 //};
 const char ParserLoadXyzAction::NAME[] = "LoadXyz";
+const char ParserLoadXyzAction::NAME[] = "parse-xyz";
 ParserLoadXyzAction::ParserLoadXyzAction() :
 …
 {}
+void ParserLoadXyz(std::string &filename) {
+  ValueStorage::getInstance().setCurrentValue(ParserLoadXyzAction::NAME, filename);
+  ActionRegistry::getInstance().getActionByName(ParserLoadXyzAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* ParserLoadXyzAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr ParserLoadXyzAction::performCall() {
   string filename;
-  XyzParser parser;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryString("filename",&filename, "Filename of the xyz file");
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+    // parse xyz file
+    ifstream input;
+    input.open(filename.c_str());
+    if (!input.fail())
+      parser.load(&input);
+    input.close();
+  DoLog(1) && (Log() << Verbose(1) << "Parsing xyz file for new atoms." << endl);
+  // parse xyz file
+  ifstream input;
+  input.open(filename.c_str());
+  if (!input.fail()) {
+    // TODO: Remove the insertion into molecule when saving does not depend on them anymore. Also, remove molecule.hpp include
+    set <atom*> UniqueList;
+    {
+      vector<atom *> ListBefore = World::getInstance().getAllAtoms();
+      for (vector<atom *>::iterator runner = ListBefore.begin();runner != ListBefore.end(); ++runner)
+        UniqueList.insert(*runner);
+    }
+    XyzParser parser; // briefly instantiate a parser which is removed at end of focus
+    parser.load(&input);
+    {
+      vector<atom *> ListAfter = World::getInstance().getAllAtoms();
+      pair< set<atom *>::iterator, bool > Inserter;
+      if (UniqueList.size() != ListAfter.size()) { // only create if new atoms have been parsed
+        MoleculeListClass *molecules = World::getInstance().getMolecules();
+        molecule *mol = World::getInstance().createMolecule();
+        molecules->insert(mol);
+        for (vector<atom *>::iterator runner = ListAfter.begin(); runner != ListAfter.end(); ++runner) {
+          Inserter = UniqueList.insert(*runner);
+          if (Inserter.second) { // if not present, then new (just parsed) atom, add ...
+            cout << "Adding new atom " << **runner << " to new mol." << endl;
+            mol->AddAtom(*runner);
+          }
+        }
+        mol->doCountAtoms();
+      } else {
+        cout << "No atoms parsed?" << endl;
+      }
+    }
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "Could not open file " << filename << "." << endl);
+  }
   delete dialog;
   return Action::failure;
+  input.close();
+  return Action::success;
+}

src/Actions/ParserAction/LoadXyzAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Process.hpp"
+void ParserLoadXyz(std::string &filename);
 class ParserLoadXyzAction : public Action {
+  friend void ParserLoadXyz(std::string &filename);
 public:
   ParserLoadXyzAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/ParserAction/SaveXyzAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/ParserAction/SaveXyzAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "Parser/XyzParser.hpp"
+#include "atom.hpp"
+#include "molecule.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
-#include "atom.hpp"
-#include "molecule.hpp"
 /****** ParserSaveXyzAction *****/
 …
 {}
+void ParserSaveXyz(std::string &filename) {
+  ValueStorage::getInstance().setCurrentValue(ParserSaveXyzAction::NAME, filename);
+  ActionRegistry::getInstance().getActionByName(ParserSaveXyzAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* ParserSaveXyzAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr ParserSaveXyzAction::performCall() {
   string filename;
   XyzParser parser;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryString("filename",&filename, "Filename of the xyz file");
+  ValueStorage::getInstance().queryCurrentValue(NAME, filename);
+  if(dialog->display()) {
+    // store xyz file
+    ofstream output;
+    output.open(filename.c_str());
+    if (!output.fail())
+      parser.save(&output);
+    output.close();
+  }
+  delete dialog;
+  // store xyz file
+  ofstream output;
+  output.open(filename.c_str());
+  if (!output.fail())
+    parser.save(&output);
+  output.close();
   return Action::failure;
+}

src/Actions/ParserAction/SaveXyzAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Process.hpp"
+void ParserSaveXyz(std::string &filename);
 class ParserSaveXyzAction : public Action {
+  friend void ParserSaveXyz(std::string &filename);
 public:
   ParserSaveXyzAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/Process.cpp

-              r06f4ef6
+              rb6da28
 Process::Process(int _maxSteps, std::string _name, bool _doRegister) :
+  Action(_name,_doRegister),
   Observable("Process"),
-  Action(_name,_doRegister),
   maxSteps(_maxSteps),
   active(false),
 …
 int Process::getCurrStep(){
-  OBSERVE;
   return currStep;
+}
 void Process::setCurrStep(int _currStep){
+  OBSERVE;
   currStep = _currStep;
+}
 …
     return 0;
+}
 int Process::getMaxSteps(){
   return maxSteps;

src/Actions/TesselationAction/ConvexEnvelopeAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/TesselationAction/ConvexEnvelopeAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "linkedcell.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "boundary.hpp"
+#include "config.hpp"
+#include "linkedcell.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** TesselationConvexEnvelopeAction *****/
 …
 {}
+void TesselationConvexEnvelope(std::string &filenameConvex, std::string &filenameNonConvex) {
+  ValueStorage::getInstance().setCurrentValue("convex-file", filenameConvex);
+  ValueStorage::getInstance().setCurrentValue("nonconvex-file", filenameConvex);
+  ActionRegistry::getInstance().getActionByName(TesselationConvexEnvelopeAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* TesselationConvexEnvelopeAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryString("convex-file", ValueStorage::getInstance().getDescription("convex-file"));
+  dialog->queryString("nonconvex-file", ValueStorage::getInstance().getDescription("nonconvex-file"));
+  return dialog;
+}
 Action::state_ptr TesselationConvexEnvelopeAction::performCall() {
   string filenameConvex;
   string filenameNonConvex;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule * mol = NULL;
   bool Success = false;
+  bool Success = true;
   config *configuration = World::getInstance().getConfig();
+  dialog->queryMolecule(NAME, &mol, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryString("convex-file", &filenameConvex, MapOfActions::getInstance().getDescription("convex-file"));
+  dialog->queryString("nonconvex-file", &filenameNonConvex, MapOfActions::getInstance().getDescription("nonconvex-file"));
+  ValueStorage::getInstance().queryCurrentValue("convex-file", filenameConvex);
+  ValueStorage::getInstance().queryCurrentValue("nonconvex-file", filenameNonConvex);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    mol = iter->second;
     class Tesselation *TesselStruct = NULL;
     const LinkedCell *LCList = NULL;
 …
     DoLog(1) && (Log() << Verbose(1) << "Storing tecplot non-convex data in " << filenameNonConvex << "." << endl);
     LCList = new LinkedCell(mol, 100.);
+    //FindConvexBorder(mol, LCList, argv[argptr]);
+    Boundaries *BoundaryPoints = NULL;
+    //FindConvexBorder(mol, BoundaryPoints, TesselStruct, LCList, argv[argptr]);
     // TODO: Beide Funktionen sollten streams anstelle des Filenamen benutzen, besser fuer unit tests
     FindNonConvexBorder(mol, TesselStruct, LCList, 50., filenameNonConvex.c_str());
 …
     delete(TesselStruct);
     delete(LCList);
-    delete dialog;
-    if (Success)
-      return Action::success;
-    else
-      return Action::failure;
+  }
+  delete dialog;
+  return Action::failure;
+  if (Success)
+    return Action::success;
+  else
+    return Action::failure;
+}

src/Actions/TesselationAction/ConvexEnvelopeAction.hpp

-              r06f4ef6
+              rb6da28
 class TesselationListClass;
+void TesselationConvexEnvelope(std::string &filenameConvex, std::string &filenameNonConvex);
 class TesselationConvexEnvelopeAction : public Action {
+  friend void TesselationConvexEnvelope(std::string &filenameConvex, std::string &filenameNonConvex);
 public:
   TesselationConvexEnvelopeAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();
 …
 };
 #endif // CONVEXENVELOPEACTION_HPP

src/Actions/TesselationAction/NonConvexEnvelopeAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/TesselationAction/NonConvexEnvelopeAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "boundary.hpp"
+#include "linkedcell.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "atom.hpp"
+#include "boundary.hpp"
+#include "linkedcell.hpp"
+#include "log.hpp"
+#include "molecule.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "UIElements/ValueStorage.hpp"
 /****** TesselationNonConvexEnvelopeAction *****/
 …
 {}
+void TesselationNonConvexEnvelope(double radius, std::string &filename) {
+  ValueStorage::getInstance().setCurrentValue(TesselationNonConvexEnvelopeAction::NAME, radius);
+  ValueStorage::getInstance().setCurrentValue("nonconvex-file", filename);
+  ActionRegistry::getInstance().getActionByName(TesselationNonConvexEnvelopeAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* TesselationNonConvexEnvelopeAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryDouble(NAME, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryString("nonconvex-file", MapOfActions::getInstance().getDescription("nonconvex-file"));
+  return dialog;
+}
 Action::state_ptr TesselationNonConvexEnvelopeAction::performCall() {
   string filename;
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   molecule * Boundary = NULL;
   double SphereRadius = 0;
 …
   clock_t start,end;
+  dialog->queryMolecule(NAME, &Boundary, MapOfActions::getInstance().getDescription(NAME));
+  dialog->queryString("nonconvex-file", &filename, MapOfActions::getInstance().getDescription("nonconvex-file"));
+  dialog->queryDouble("sphere-radius", &SphereRadius, MapOfActions::getInstance().getDescription("sphere-radius"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, SphereRadius);
+  ValueStorage::getInstance().queryCurrentValue("nonconvex-file", filename);
+  if(dialog->display()) {
+  for (World::MoleculeSelectionIterator iter = World::getInstance().beginMoleculeSelection(); iter != World::getInstance().endMoleculeSelection(); ++iter) {
+    Boundary = iter->second;
     class Tesselation *T = NULL;
     const LinkedCell *LCList = NULL;
 …
     delete(LCList);
     delete(T);
-    delete dialog;
-    if (Success)
-      return Action::success;
-    else
-      return Action::failure;
+  }
+  delete dialog;
+  return Action::failure;
+  if (Success)
+    return Action::success;
+  else
+    return Action::failure;
+}

src/Actions/TesselationAction/NonConvexEnvelopeAction.hpp

-              r06f4ef6
+              rb6da28
 class TesselationListClass;
+void TesselationNonConvexEnvelope(double radius, std::string &filename);
 class TesselationNonConvexEnvelopeAction : public Action {
+  friend void TesselationNonConvexEnvelope(double radius, std::string &filename);
 public:
   TesselationNonConvexEnvelopeAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/Values.hpp

-              r06f4ef6
+              rb6da28
+{
   double xx;
+  double xy;
+  double xz;
+  double yx;
   double yy;
+  double yz;
+  double zx;
+  double zy;
   double zz;
 };

src/Actions/WorldAction/AddEmptyBoundaryAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/WorldAction/AddEmptyBoundaryAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 #include "Helpers/Assert.hpp"
 …
 {}
+void WorldAddEmptyBoundary(Vector &boundary) {
+  ValueStorage::getInstance().setCurrentValue(WorldAddEmptyBoundaryAction::NAME, boundary);
+  ActionRegistry::getInstance().getActionByName(WorldAddEmptyBoundaryAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldAddEmptyBoundaryAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldAddEmptyBoundaryAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   Vector boundary;
   Vector Min;
 …
   int j=0;
   dialog->queryVector(NAME, &boundary, World::getInstance().getDomain(), false, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, boundary);
+  if(dialog->display()) {
+    // get maximum and minimum
+    vector<atom *> AllAtoms = World::getInstance().getAllAtoms();
+    ASSERT(AllAtoms.size() > 0, "There must be atoms present for AddingEmptyBoundary.");
+    vector<atom *>::iterator AtomRunner = AllAtoms.begin();
+    Min = (*AtomRunner)->x;
+    Max = (*AtomRunner)->x;
+    for (; AtomRunner != AllAtoms.end(); ++AtomRunner) {
+      for (int i=0;i<NDIM;i++) {
+        if ((*AtomRunner)->x[i] > Max[i])
+          Max[i] = (*AtomRunner)->x[i];
+        if ((*AtomRunner)->x[i] < Min[i])
+          Min[i] = (*AtomRunner)->x[i];
+      }
+  // get maximum and minimum
+  vector<atom *> AllAtoms = World::getInstance().getAllAtoms();
+  ASSERT(AllAtoms.size() > 0, "There must be atoms present for AddingEmptyBoundary.");
+  vector<atom *>::iterator AtomRunner = AllAtoms.begin();
+  Min = (*AtomRunner)->x;
+  Max = (*AtomRunner)->x;
+  for (; AtomRunner != AllAtoms.end(); ++AtomRunner) {
+    for (int i=0;i<NDIM;i++) {
+      if ((*AtomRunner)->x[i] > Max[i])
+        Max[i] = (*AtomRunner)->x[i];
+      if ((*AtomRunner)->x[i] < Min[i])
+        Min[i] = (*AtomRunner)->x[i];
+    }
-    // set new box size
-    double * const cell_size = World::getInstance().getDomain();
-    for (j=0;j<6;j++)
-      cell_size[j] = 0.;
-    j=-1;
-    for (int i=0;i<NDIM;i++) {
-      j += i+1;
-      cell_size[j] = (Max[i]-Min[i]+2.*boundary[i]);
+    }
-    // translate all atoms, such that Min is aty (0,0,0)
-    AtomRunner = AllAtoms.begin();
-    for (; AtomRunner != AllAtoms.end(); ++AtomRunner)
-      (*AtomRunner)->x -= Min - boundary;
-    delete dialog;
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  // set new box size
+  double * const cell_size = new double[6];
+  for (j=0;j<6;j++)
+    cell_size[j] = 0.;
+  j=-1;
+  for (int i=0;i<NDIM;i++) {
+    j += i+1;
+    cell_size[j] = (Max[i]-Min[i]+2.*boundary[i]);
+  }
+  World::getInstance().setDomain(cell_size);
+  delete[] cell_size;
+  // translate all atoms, such that Min is aty (0,0,0)
+  AtomRunner = AllAtoms.begin();
+  for (; AtomRunner != AllAtoms.end(); ++AtomRunner)
+    (*AtomRunner)->x -= Min - boundary;
+  return Action::success;
+}

src/Actions/WorldAction/AddEmptyBoundaryAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+#include "vector.hpp"
+void WorldAddEmptyBoundary(Vector &boundary);
 class WorldAddEmptyBoundaryAction : public Action {
+  friend void WorldAddEmptyBoundary(Vector &boundary);
 public:
   WorldAddEmptyBoundaryAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/WorldAction/BoundInBoxAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/WorldAction/BoundInBoxAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldBoundInBoxAction::NAME[] = "bound-in-box";
 …
 {}
+void WorldBoundInBox() {
+  ActionRegistry::getInstance().getActionByName(WorldBoundInBoxAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldBoundInBoxAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldBoundInBoxAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  dialog->queryEmpty(NAME, MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    // center
+    vector<molecule*> AllMolecules = World::getInstance().getAllMolecules();
+    for (vector<molecule*>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+      (*MolRunner)->BoundInBox();
+    }
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  // center
+  vector<molecule*> AllMolecules = World::getInstance().getAllMolecules();
+  for (vector<molecule*>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+    (*MolRunner)->BoundInBox();
+  }
+  return Action::success;
+}

src/Actions/WorldAction/BoundInBoxAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void WorldBoundInBox();
 class WorldBoundInBoxAction : public Action {
+  friend void WorldBoundInBox();
 public:
   WorldBoundInBoxAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/WorldAction/CenterInBoxAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/WorldAction/CenterInBoxAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "Box.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldCenterInBoxAction::NAME[] = "center-in-box";
 …
 {}
+void WorldCenterInBox(Box &_box) {
+  ValueStorage::getInstance().setCurrentValue(WorldCenterInBoxAction::NAME, _box);
+  ActionRegistry::getInstance().getActionByName(WorldCenterInBoxAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldCenterInBoxAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryBox(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldCenterInBoxAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  double * cell_size = World::getInstance().getDomain();
+  dialog->queryBox(NAME, &cell_size, MapOfActions::getInstance().getDescription(NAME));
+  Box& cell_size = World::getInstance().getDomain();
+  ValueStorage::getInstance().queryCurrentValue(NAME, cell_size);
+  World::getInstance().setDomain(cell_size.getM());
+  if(dialog->display()) {
+    // center
+    vector<molecule *> AllMolecules = World::getInstance().getAllMolecules();
+    for (vector<molecule*>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+      (*MolRunner)->CenterInBox();
+    }
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  // center
+  vector<molecule *> AllMolecules = World::getInstance().getAllMolecules();
+  for (vector<molecule*>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+    (*MolRunner)->CenterInBox();
+  }
+  return Action::success;
+}

src/Actions/WorldAction/CenterInBoxAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+#include "Box.hpp"
+void WorldCenterInBox(Box &_box);
 class WorldCenterInBoxAction : public Action {
+  friend void WorldCenterInBox(Box &_box);
 public:
   WorldCenterInBoxAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/WorldAction/CenterOnEdgeAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/WorldAction/CenterOnEdgeAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "log.hpp"
 #include "vector.hpp"
 #include "World.hpp"
+#include "Matrix.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 #include "Helpers/Assert.hpp"
 …
 {}
+void WorldCenterOnEdge() {
+  ActionRegistry::getInstance().getActionByName(WorldCenterOnEdgeAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldCenterOnEdgeAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryEmpty(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldCenterOnEdgeAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   Vector Min;
   Vector Max;
-  int j=0;
+  dialog->queryEmpty(NAME, MapOfActions::getInstance().getDescription(NAME));
+  // get maximum and minimum
+  vector<atom *> AllAtoms = World::getInstance().getAllAtoms();
+  ASSERT(AllAtoms.size() > 0, "For CenteronEdge atoms must be present.");
+  vector<atom *>::iterator AtomRunner = AllAtoms.begin();
+  Min = (*AtomRunner)->x;
+  Max = (*AtomRunner)->x;
+  for (; AtomRunner != AllAtoms.end(); ++AtomRunner) {
+    for (int i=0;i<NDIM;i++) {
+      if ((*AtomRunner)->x[i] > Max[i])
+        Max[i] = (*AtomRunner)->x[i];
+      if ((*AtomRunner)->x[i] < Min[i])
+        Min[i] = (*AtomRunner)->x[i];
+    }
+  }
+  // set new box size
+  Matrix domain;
+  for (int i=0;i<NDIM;i++) {
+    double tmp = Max[i]-Min[i];
+    tmp = fabs(tmp)>=1. ? tmp : 1.0;
+    domain.at(i,i) = tmp;
+  }
+  World::getInstance().setDomain(domain);
+  // translate all atoms, such that Min is aty (0,0,0)
+  for (vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner)
+    (*AtomRunner)->x -= Min;
+  if(dialog->display()) {
+    // get maximum and minimum
+    vector<atom *> AllAtoms = World::getInstance().getAllAtoms();
+    ASSERT(AllAtoms.size() > 0, "For CenteronEdge atoms must be present.");
+    vector<atom *>::iterator AtomRunner = AllAtoms.begin();
+    Min = (*AtomRunner)->x;
+    Max = (*AtomRunner)->x;
+    for (; AtomRunner != AllAtoms.end(); ++AtomRunner) {
+      for (int i=0;i<NDIM;i++) {
+        if ((*AtomRunner)->x[i] > Max[i])
+          Max[i] = (*AtomRunner)->x[i];
+        if ((*AtomRunner)->x[i] < Min[i])
+          Min[i] = (*AtomRunner)->x[i];
+      }
+    }
+    // set new box size
+    double * const cell_size = World::getInstance().getDomain();
+    for (j=0;j<6;j++)
+      cell_size[j] = 0.;
+    j=-1;
+    for (int i=0;i<NDIM;i++) {
+      j += i+1;
+      cell_size[j] = (Max[i]-Min[i]);
+    }
+    // translate all atoms, such that Min is aty (0,0,0)
+    for (vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner)
+      (*AtomRunner)->x -= Min;
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  return Action::success;
+}

src/Actions/WorldAction/CenterOnEdgeAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void WorldCenterOnEdge();
 class WorldCenterOnEdgeAction : public Action {
+  friend void WorldCenterOnEdge();
 public:
   WorldCenterOnEdgeAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/WorldAction/ChangeBoxAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/WorldAction/ChangeBoxAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "log.hpp"
 #include "verbose.hpp"
 #include "World.hpp"
+#include "Box.hpp"
+#include "Matrix.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldChangeBoxAction::NAME[] = "change-box";
 …
 {}
+void WorldChangeBox(Box &_box) {
+  ValueStorage::getInstance().setCurrentValue(WorldChangeBoxAction::NAME, _box);
+  ActionRegistry::getInstance().getActionByName(WorldChangeBoxAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldChangeBoxAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryBox(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldChangeBoxAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
+  double * cell_size = World::getInstance().getDomain();
+  dialog->queryBox(NAME, &cell_size, MapOfActions::getInstance().getDescription(NAME));
+  Box cell_size;
+  ValueStorage::getInstance().queryCurrentValue(NAME, cell_size);
+  World::getInstance().setDomain(cell_size.getM()); // this is needed as only this function is OBSERVEd.
+  if(dialog->display()) {
+    DoLog(0) && (Log() << Verbose(0) << "Setting box domain to " << cell_size[0] << "," << cell_size[1] << "," << cell_size[2] << "," << cell_size[3] << "," << cell_size[4] << "," << cell_size[5] << "," << endl);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  DoLog(0) && (Log() << Verbose(0) << "Setting box domain to " << World::getInstance().getDomain().getM() << endl);
+  return Action::success;
+}

src/Actions/WorldAction/ChangeBoxAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+#include "Box.hpp"
+void WorldChangeBox(Box &_box);
 class WorldChangeBoxAction : public Action {
+  friend void WorldChangeBox(Box &_box);
 public:
   WorldChangeBoxAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/WorldAction/RemoveSphereOfAtomsAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/WorldAction/RemoveSphereOfAtomsAction.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "Descriptors/AtomDescriptor.hpp"
 #include "atom.hpp"
-#include "Descriptors/AtomDescriptor.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldRemoveSphereOfAtomsAction::NAME[] = "remove-sphere";
 …
 {}
+void WorldRemoveSphereOfAtoms(double radius, Vector &point) {
+  ValueStorage::getInstance().setCurrentValue(WorldRemoveSphereOfAtomsAction::NAME, radius);
+  ValueStorage::getInstance().setCurrentValue("position", point);
+  ActionRegistry::getInstance().getActionByName(WorldRemoveSphereOfAtomsAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldRemoveSphereOfAtomsAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryDouble(NAME, ValueStorage::getInstance().getDescription(NAME));
+  dialog->queryVector("position", false, ValueStorage::getInstance().getDescription("position"));
+  return dialog;
+}
 Action::state_ptr WorldRemoveSphereOfAtomsAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   double radius = 0.;
   Vector point;
   dialog->queryDouble(NAME, &radius, MapOfActions::getInstance().getDescription(NAME));
   dialog->queryVector("position", &point, World::getInstance().getDomain(), false, MapOfActions::getInstance().getDescription("position"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, radius);
+  ValueStorage::getInstance().queryCurrentValue("position", point);
+  if(dialog->display()) {
+    delete dialog;
+    DoLog(1) && (Log() << Verbose(1) << "Removing atoms around " << point << " with radius " << radius << "." << endl);
+    vector<atom*> AllAtoms = World::getInstance().getAllAtoms();
+    vector<molecule *> molecules = World::getInstance().getAllMolecules();
+    for (vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner) {
+      if (point.DistanceSquared((*AtomRunner)->x) > radius*radius) { // distance to first above radius ...
+        // TODO: This is not necessary anymore when atoms are completely handled by World (create/destroy and load/save)
+        for (vector<molecule *>::iterator iter = molecules.begin();iter != molecules.end();++iter)
+          (*iter)->erase(*AtomRunner);
+        World::getInstance().destroyAtom(*AtomRunner);
+      }
+  DoLog(1) && (Log() << Verbose(1) << "Removing atoms around " << point << " with radius " << radius << "." << endl);
+  vector<atom*> AllAtoms = World::getInstance().getAllAtoms();
+  vector<molecule *> molecules = World::getInstance().getAllMolecules();
+  for (vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner) {
+    if (point.DistanceSquared((*AtomRunner)->x) > radius*radius) { // distance to first above radius ...
+      // TODO: This is not necessary anymore when atoms are completely handled by World (create/destroy and load/save)
+      for (vector<molecule *>::iterator iter = molecules.begin();iter != molecules.end();++iter)
+        (*iter)->erase(*AtomRunner);
+      World::getInstance().destroyAtom(*AtomRunner);
+    }
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}

src/Actions/WorldAction/RemoveSphereOfAtomsAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+#include "vector.hpp"
+void WorldRemoveSphereOfAtoms(double radius, Vector &point);
 class WorldRemoveSphereOfAtomsAction : public Action {
+  friend void WorldRemoveSphereOfAtoms(double radius, Vector &point);
 public:
   WorldRemoveSphereOfAtomsAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/WorldAction/RepeatBoxAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/WorldAction/RepeatBoxAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 #include "vector.hpp"
+#include "Matrix.hpp"
 #include "verbose.hpp"
 #include "World.hpp"
+#include "Box.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 #include "Descriptors/MoleculeDescriptor.hpp"
 #include "Descriptors/MoleculePtrDescriptor.hpp"
 …
 {}
+void WorldRepeatBox(Vector &Repeater) {
+  ValueStorage::getInstance().setCurrentValue(WorldRepeatBoxAction::NAME, Repeater);
+  ActionRegistry::getInstance().getActionByName(WorldRepeatBoxAction::NAME)->call(Action::NonInteractive);
+};
+Dialog * WorldRepeatBoxAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldRepeatBoxAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   Vector Repeater;
   int count;
 …
   MoleculeListClass *molecules = World::getInstance().getMolecules();
   dialog->queryVector(NAME, &Repeater, World::getInstance().getDomain(), false, MapOfActions::getInstance().getDescription(NAME));
+  //dialog->queryMolecule("molecule-by-id", &mol,MapOfActions::getInstance().getDescription("molecule-by-id"));
+  ValueStorage::getInstance().queryCurrentValue(NAME, Repeater);
   vector<molecule *> AllMolecules;
   if (mol != NULL) {
 …
+  }
+  if(dialog->display()) {
+    (cout << "Repeating box " << Repeater << " times for (x,y,z) axis." << endl);
+    double * const cell_size = World::getInstance().getDomain();
+    double *M = ReturnFullMatrixforSymmetric(cell_size);
+    Vector x,y;
+    int n[NDIM];
+    for (int axis = 0; axis < NDIM; axis++) {
+      Repeater[axis] = floor(Repeater[axis]);
+      if (Repeater[axis] < 1) {
+        DoeLog(1) && (eLog()<< Verbose(1) << "Repetition factor must be greater than 1!" << endl);
+        Repeater[axis] = 1;
+      }
+      cell_size[(abs(axis+1) == 2) ? 2 : ((abs(axis+2) == 3) ? 5 : 0)] *= Repeater[axis];
+  (cout << "Repeating box " << Repeater << " times for (x,y,z) axis." << endl);
+  Matrix M = World::getInstance().getDomain().getM();
+  Matrix newM = M;
+  Vector x,y;
+  int n[NDIM];
+  Matrix repMat;
+  for (int axis = 0; axis < NDIM; axis++) {
+    Repeater[axis] = floor(Repeater[axis]);
+    if (Repeater[axis] < 1) {
+      DoeLog(1) && (eLog()<< Verbose(1) << "Repetition factor must be greater than 1!" << endl);
+      Repeater[axis] = 1;
+    }
+    repMat.at(axis,axis) = Repeater[axis];
+  }
+  newM *= repMat;
+  World::getInstance().setDomain(newM);
+    molecule *newmol = NULL;
+    Vector ** vectors = NULL;
+    for (n[0] = 0; n[0] < Repeater[0]; n[0]++) {
+      y[0] = n[0];
+      for (n[1] = 0; n[1] < Repeater[1]; n[1]++) {
+        y[1] = n[1];
+        for (n[2] = 0; n[2] < Repeater[2]; n[2]++) {
+          y[2] = n[2];
+          if (n[0] == n[1] == n[2] == 0)
+            continue;
+          for (vector<molecule *>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+            mol = *MolRunner;
+            DoLog(1) && (Log() << Verbose(1) << "Current mol is " << mol->name << "." << endl);
+            count = mol->getAtomCount();   // is changed becausing of adding, thus has to be stored away beforehand
+            if (count != 0) {  // if there is more than none
+              Elements = new const element *[count];
+              vectors = new Vector *[count];
+              j = 0;
+              for(molecule::iterator AtomRunner = mol->begin(); AtomRunner != mol->end(); ++AtomRunner) {
+                Elements[j] = (*AtomRunner)->type;
+                vectors[j] = &(*AtomRunner)->x;
+                j++;
+              }
+              if (count != j)
+                DoeLog(1) && (eLog()<< Verbose(1) << "AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl);
+              x = y;
+              x.MatrixMultiplication(M);
+              newmol = World::getInstance().createMolecule();
+              molecules->insert(newmol);
+              for (int k=count;k--;) { // go through every atom of the original cell
+                Walker = World::getInstance().createAtom(); // create a new body
+                Walker->x = (*vectors[k]) + x;
+                Walker->type = Elements[k];  // insert original element
+                cout << "new atom is " << *Walker << endl;
+                newmol->AddAtom(Walker);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
+              }
+              // free memory
+              delete[](Elements);
+              delete[](vectors);
+            } else {
+              DoLog(1) && (Log() << Verbose(1) << "\t ... is empty." << endl);
+  molecule *newmol = NULL;
+  Vector ** vectors = NULL;
+  for (n[0] = 0; n[0] < Repeater[0]; n[0]++) {
+    y[0] = n[0];
+    for (n[1] = 0; n[1] < Repeater[1]; n[1]++) {
+      y[1] = n[1];
+      for (n[2] = 0; n[2] < Repeater[2]; n[2]++) {
+        y[2] = n[2];
+        if ((n[0] == 0) && (n[1] == 0) && (n[2] == 0))
+          continue;
+        for (vector<molecule *>::iterator MolRunner = AllMolecules.begin(); MolRunner != AllMolecules.end(); ++MolRunner) {
+          mol = *MolRunner;
+          DoLog(1) && (Log() << Verbose(1) << "Current mol is " << mol->name << "." << endl);
+          count = mol->getAtomCount();   // is changed becausing of adding, thus has to be stored away beforehand
+          if (count != 0) {  // if there is more than none
+            Elements = new const element *[count];
+            vectors = new Vector *[count];
+            j = 0;
+            for(molecule::iterator AtomRunner = mol->begin(); AtomRunner != mol->end(); ++AtomRunner) {
+              Elements[j] = (*AtomRunner)->type;
+              vectors[j] = &(*AtomRunner)->x;
+              j++;
+            }
+            if (count != j)
+              DoeLog(1) && (eLog()<< Verbose(1) << "AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl);
+            x = y;
+            x *= M;
+            newmol = World::getInstance().createMolecule();
+            molecules->insert(newmol);
+            for (int k=count;k--;) { // go through every atom of the original cell
+              Walker = World::getInstance().createAtom(); // create a new body
+              Walker->x = (*vectors[k]) + x;
+              Walker->type = Elements[k];  // insert original element
+              cout << "new atom is " << *Walker << endl;
+              newmol->AddAtom(Walker);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
+            }
+            // free memory
+            delete[](Elements);
+            delete[](vectors);
+          } else {
+            DoLog(1) && (Log() << Verbose(1) << "\t ... is empty." << endl);
+          }
+        }
+      }
+    }
-    delete(M);
-    delete dialog;
-    return Action::success;
-  } else {
-    delete dialog;
-    return Action::failure;
+  }
+  return Action::success;
+}

src/Actions/WorldAction/RepeatBoxAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+#include "vector.hpp"
+void WorldRepeatBox(Vector &Repeater);
 class WorldRepeatBoxAction : public Action {
+  friend void WorldRepeatBox(Vector &Repeater);
 public:
   WorldRepeatBoxAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/WorldAction/ScaleBoxAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/WorldAction/ScaleBoxAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "atom.hpp"
 #include "log.hpp"
 …
 #include "verbose.hpp"
 #include "World.hpp"
+#include "Box.hpp"
+#include "Matrix.hpp"
 #include <iostream>
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
 #include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
 const char WorldScaleBoxAction::NAME[] = "scale-box";
 …
 {}
+void WorldScaleBox(Vector &Scaler) {
+  ValueStorage::getInstance().setCurrentValue(WorldScaleBoxAction::NAME, Scaler);
+  ActionRegistry::getInstance().getActionByName(WorldScaleBoxAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldScaleBoxAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryVector(NAME, false, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldScaleBoxAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   Vector Scaler;
   double x[NDIM];
-  int j=0;
   dialog->queryVector(NAME, &Scaler, World::getInstance().getDomain(), false, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, Scaler);
+  if(dialog->display()) {
+    DoLog(1) && (Log() << Verbose(1) << "Scaling all atomic positions by factor." << endl);
+    for (int i=0;i<NDIM;i++)
+      x[i] = Scaler[i];
+    vector<atom*> AllAtoms = World::getInstance().getAllAtoms();
+    for(vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner) {
+      (*AtomRunner)->x.ScaleAll(x);
+    }
+    j = -1;
+    double * const cell_size = World::getInstance().getDomain();
+    for (int i=0;i<NDIM;i++) {
+      j += i+1;
+      cell_size[j]*=x[i];
+    }
+  DoLog(1) && (Log() << Verbose(1) << "Scaling all atomic positions by factor." << endl);
+  for (int i=0;i<NDIM;i++)
+    x[i] = Scaler[i];
+  vector<atom*> AllAtoms = World::getInstance().getAllAtoms();
+  for(vector<atom*>::iterator AtomRunner = AllAtoms.begin(); AtomRunner != AllAtoms.end(); ++AtomRunner) {
+    (*AtomRunner)->x.ScaleAll(x);
+  }
     delete dialog;
     return Action::success;
+  } else {
     delete dialog;
     return Action::failure;
+  Matrix M = World::getInstance().getDomain().getM();
+  Matrix scale;
+  for (int i=0;i<NDIM;i++) {
+    scale.at(i,i) = x[i];
+  }
+  M *= scale;
+  World::getInstance().setDomain(M);
+  return Action::success;
+}

src/Actions/WorldAction/ScaleBoxAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+#include "vector.hpp"
+void WorldScaleBox(Vector &Scaler);
 class WorldScaleBoxAction : public Action {
+  friend void WorldScaleBox(Vector &Scaler);
 public:
   WorldScaleBoxAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/WorldAction/SetDefaultNameAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/WorldAction/SetDefaultNameAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "log.hpp"
 #include "verbose.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
+// memento to remember the state when undoing
+class WorldSetDefaultNameState : public ActionState {
+public:
+  WorldSetDefaultNameState(std::string _lastName) :
+    lastName(_lastName)
+  {}
+  std::string lastName;
+};
 const char WorldSetDefaultNameAction::NAME[] = "default-molname";
 …
 {}
+void WorldSetDefaultName(std::string &defaultname) {
+  ValueStorage::getInstance().setCurrentValue(WorldSetDefaultNameAction::NAME, defaultname);
+  ActionRegistry::getInstance().getActionByName(WorldSetDefaultNameAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldSetDefaultNameAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  string defaultname = World::getInstance().getDefaultName();
+  ValueStorage::getInstance().setCurrentValue(NAME, defaultname);
+  dialog->queryString(NAME, MapOfActions::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldSetDefaultNameAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   string defaultname;
   defaultname = World::getInstance().getDefaultName();
   dialog->queryString(NAME, &defaultname, MapOfActions::getInstance().getDescription(NAME));
+  ValueStorage::getInstance().queryCurrentValue(NAME, defaultname);
+  if(dialog->display()) {
+    World::getInstance().setDefaultName(defaultname);
+    DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << World::getInstance().getDefaultName() << "." << endl);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  World::getInstance().setDefaultName(defaultname);
+  DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << World::getInstance().getDefaultName() << "." << endl);
+  return Action::success;
+}
 Action::state_ptr WorldSetDefaultNameAction::performUndo(Action::state_ptr _state) {
 //  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  WorldSetDefaultNameState *state = assert_cast<WorldSetDefaultNameState*>(_state.get());
+  return Action::failure;
+//  string newName = state->mol->getName();
+//  state->mol->setName(state->lastName);
+//
+//  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  string newName = World::getInstance().getDefaultName();
+  World::getInstance().setDefaultName(state->lastName);
+  return Action::state_ptr(new WorldSetDefaultNameState(newName));
+}
 Action::state_ptr WorldSetDefaultNameAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return performUndo(_state);
+}
 bool WorldSetDefaultNameAction::canUndo() {
   return false;
+  return true;
+}
 bool WorldSetDefaultNameAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/WorldAction/SetDefaultNameAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void WorldSetDefaultName(std::string &defaultname);
 class WorldSetDefaultNameAction : public Action {
+  friend void WorldSetDefaultName(std::string &defaultname);
 public:
   WorldSetDefaultNameAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/Actions/WorldAction/SetGaussianBasisAction.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/WorldAction/SetGaussianBasisAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "config.hpp"
 #include "log.hpp"
 …
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "UIElements/ValueStorage.hpp"
+// memento to remember the state when undoing
+class WorldSetGaussianBasisState : public ActionState {
+public:
+  WorldSetGaussianBasisState(std::string _lastName) :
+    lastName(_lastName)
+  {}
+  std::string lastName;
+};
 const char WorldSetGaussianBasisAction::NAME[] = "set-basis";
 …
 {}
+void WorldSetGaussianBasis(std::string &basisname) {
+  ValueStorage::getInstance().setCurrentValue(WorldSetGaussianBasisAction::NAME, basisname);
+  ActionRegistry::getInstance().getActionByName(WorldSetGaussianBasisAction::NAME)->call(Action::NonInteractive);
+};
+Dialog* WorldSetGaussianBasisAction::fillDialog(Dialog *dialog) {
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  dialog->queryString(NAME, ValueStorage::getInstance().getDescription(NAME));
+  return dialog;
+}
 Action::state_ptr WorldSetGaussianBasisAction::performCall() {
-  Dialog *dialog = UIFactory::getInstance().makeDialog();
   config *configuration = World::getInstance().getConfig();
-  dialog->queryString(NAME, &(configuration->basis), MapOfActions::getInstance().getDescription(NAME));
+  if(dialog->display()) {
+    DoLog(1) && (Log() << Verbose(1) << "Setting MPQC basis to " << configuration->basis << "." << endl);
+    delete dialog;
+    return Action::success;
+  } else {
+    delete dialog;
+    return Action::failure;
+  }
+  string lastname = configuration->basis;
+  ValueStorage::getInstance().queryCurrentValue(NAME, configuration->basis);
+  DoLog(1) && (Log() << Verbose(1) << "Setting MPQC basis to " << configuration->basis << "." << endl);
+  return Action::success;
+}
 Action::state_ptr WorldSetGaussianBasisAction::performUndo(Action::state_ptr _state) {
 //  ParserLoadXyzState *state = assert_cast<ParserLoadXyzState*>(_state.get());
+  WorldSetGaussianBasisState *state = assert_cast<WorldSetGaussianBasisState*>(_state.get());
   return Action::failure;
 //  string newName = state->mol->getName();
 //  state->mol->setName(state->lastName);
+//
 //  return Action::state_ptr(new ParserLoadXyzState(state->mol,newName));
+  config *configuration = World::getInstance().getConfig();
+  string newName = configuration->basis;
+  configuration->basis = state->lastName;
+  return Action::state_ptr(new WorldSetGaussianBasisState(newName));
+}
 Action::state_ptr WorldSetGaussianBasisAction::performRedo(Action::state_ptr _state){
   return Action::failure;
+  return performUndo(_state);
+}
 bool WorldSetGaussianBasisAction::canUndo() {
   return false;
+  return true;
+}
 bool WorldSetGaussianBasisAction::shouldUndo() {
   return false;
+  return true;
+}

src/Actions/WorldAction/SetGaussianBasisAction.hpp

-              r06f4ef6
+              rb6da28
 #include "Actions/Action.hpp"
+void WorldSetGaussianBasis(std::string &basisname);
 class WorldSetGaussianBasisAction : public Action {
+  friend void WorldSetGaussianBasis(std::string &basisname);
 public:
   WorldSetGaussianBasisAction();
 …
   virtual const std::string getName();
+protected:
+  virtual Dialog * fillDialog(Dialog *dialog);
 private:
   virtual Action::state_ptr performCall();

src/CommandLineParser.cpp

r06f4ef6	rb6da28
41	41	void CommandLineParser::Parse()
42	42	{
43		po::store(po::command_line_parser(argc,argv).options(cmdline_options).~~options(visible).positional(inputfile).~~run(), vm);
	43	po::store(po::command_line_parser(argc,argv).options(cmdline_options).run(), vm);
44	44	ifstream input;
45	45	input.open("example.cfg");

src/CommandLineParser.hpp

-              r06f4ef6
+              rb6da28
 #include <list>
+/** This class is a wrapper for boost::program_options.
+ *
+ * <h1> CommandLine Howto </h1>
+ * <h2> Introduction </h2>
+ *
+ * The UIFactory is a base class for the User Interaction. There are three UI specializations:
+ * Text, GUI and CommandLine. Accessing functionality via the CommandLine UI is explained here.
+ *
+ * First, an Action has to be written for the specific functionality. This Action should
+ * be added in Actions/...Action in the respective subdirectory of the following types:
+ *  -# Analysis: Analysis actions like evaluating pair correlation, bonds, ...
+ *  -# Atom: adding, removing, manipulating atoms
+ *  -# Cmd: specifying data bases, verbosity, ...
+ *  -# Fragmentation: fragmenting a system, performing graph analysis, ...
+ *  -# Molecule: adding, removing, manipulating molecules
+ *  -# Parser: Parsing files (loading, saving)
+ *  -# Tesselation: obtaining (non)convex surface of a molecule, embedding, ...
+ *  -# World: Setting Box dimensions, default name of new molecules, ...
+ *
+ *  The CommandLineUIFactory is a specialization of the UIFactory for parsing command
+ *  line parameters, generating and executing actions there from.
+ *
+ *  The idea of the CommandLineFactory is explained elsewhere, here we would like to give a
+ *  receipe for creating new actions.
+ *
+ * <h3>Introducing new actions</h3>
+ *
+ * Let us now introduce what to do if a new action is to be implemented. Here, we use the
+ * CommandLineVersionAction as an example.
+ * This consists if basically three parts:
+ * 1. Create the files, write the classes and make them compilable
+ *   - Create new source and header files in one of the above subfolders in the Actions folder,
+ *     e.g. create VersionAction.cpp and VersionAction.hpp in Actions/Cmd/
+ *   - Give it a sensible class name, the convention is <type><what it does>Action,
+ *     where <type> is basically the naming (written out) of the subdirectory,
+ *     e.g. class CommandLineVersionAction.
+ *   - Add the source and header file to the respective variables in molecuilder/src/Makefile.am,
+ *     e.g. if you add a Cmd action the variables are CMDACTIONSOURCE and CMDACTIONHEADER,
+ *     such that they get compiled.
+ * 2. Add an instance to the CommandLineUIFactory, such that they are known to the UI.
+ *   - Add the header file as an include to UIElements/CommandLineWindow.cpp, e.g.
+ *     #include "Actions/Cmd/VersionAction.hpp"
+ *   - Add an instance of your class to the specific populater-function in
+ *     UIElements/CommandLineWindow.cpp, e.g. for the above Cmd action, add to populateCmdActions()
+ *     add new CommandLineVersionAction().
+ *     This will automatically register in the ActionRegistry.
+ * 3. Give them an option name, short hand an description, such that they can be referenced from
+ *    the command line.
+ *   - think of a new key name, e.g. "version", which is the long form of the command parameter,
+ *     i.e. --version).
+ *   - add this key to every map of MapofActions, i.e. to
+ *     - MapofActions::DescriptionMap: the description which appears as help and tooltip
+ *     - MapofActions::ShortFormMap: the short form of the command parameter (e.g. -v)
+ *     - MapofActions::ValueMap: the value the command parameter has (do not create if it does not need one)
+ *   - If your action requires additional parameters, these need to be added in the same manner as in
+ *     the list item above.
+ *
+ *  Don't forget to write the actual code. :)
+ *
+ * <h3>Writing an action</h3>
+ *
+ *  As you write a new action you may think in terms of the command line, i.e. you want to use this
+ *  new functionality you add by calling molecuilder as: ./molecuilder --super-action foobar.txt, where
+ *  the key of your new action would be "super-action". While this is fine, keep in mind, that your action
+ *  should be useable for the other UI specializations as well, i.e. from the menu and the GUI. Therefore,
+ *  -# Don't use cin to ask the user for input: Use Query...()!
+ *  -# Rather don't use cout/cerrs, but either give Log() or eLog() or use QueryEmpty() if you want to give
+ *     the user specific information what you ask of him.
+ *
+ */
 class CommandLineParser : public Singleton<CommandLineParser> {
   friend class Singleton<CommandLineParser>;

src/Descriptors/AtomDescriptor.cpp

-              r06f4ef6
+              rb6da28
 #include "World.hpp"
 #include "atom.hpp"
+#include "Patterns/ObservedContainer_impl.hpp"
 #include <boost/bind.hpp>
+#include <cassert>
 #include <iostream>
 using namespace std;
 typedef World::AtomSet::iterator atoms_iter_t;
+typedef World::AtomSet::internal_iterator atoms_iter_t;
 /************************ Forwarding object **************************************/
 …
 atom* AtomDescriptor_impl::find() {
   World::AtomSet atoms = getAtoms();
   atoms_iter_t res = find_if(atoms.begin(),atoms.end(),boost::bind(&AtomDescriptor_impl::predicate,this,_1));
   return (res!=atoms.end())?((*res).second):0;
+  World::AtomSet &atoms = getAtoms();
+  atoms_iter_t res = find_if(atoms.begin_internal(),atoms.end_internal(),boost::bind(&AtomDescriptor_impl::predicate,this,_1));
+  return (res!=atoms.end_internal())?((*res).second):0;
+}
 …
   vector<atom*> res;
   World::AtomSet atoms = getAtoms();
+  atoms_iter_t iter;
+  for(iter=atoms.begin();iter!=atoms.end();++iter) {
+    if(predicate(*iter)){
+      res.push_back((*iter).second);
+    }
+  for_each(atoms.begin_internal(),
+           atoms.end_internal(),
+           boost::bind(&AtomDescriptor_impl::checkAndAdd,
+                       this,&res,_1));
+  return res;
+}
+void AtomDescriptor_impl::checkAndAdd(std::vector<atom*> *v,std::pair<atomId_t,atom*> p){
+  if(predicate(p)){
+    v->push_back(p.second);
+  }
-  return res;
+}

src/Descriptors/AtomDescriptor.hpp

r06f4ef6	rb6da28
35	35	// close coupling to the world to allow access
36	36	friend atom* World::getAtom(AtomDescriptor descriptor);
37		friend ~~std::vector<atom*>~~ World::getAllAtoms(AtomDescriptor descriptor);
	37	friend World::AtomComposite World::getAllAtoms(AtomDescriptor descriptor);
38	38	template <class,class,class> friend class SelectiveIterator;
39	39

src/Descriptors/AtomDescriptor_impl.hpp

r06f4ef6	rb6da28
50	50	*/
51	51	World::AtomSet& getAtoms();
	52
	53	void checkAndAdd(std::vector<atom>,std::pair<atomId_t,atom*>);
52	54	};
53	55

src/Descriptors/AtomIdDescriptor.cpp

-              r06f4ef6
+              rb6da28
 #include "atom.hpp"
+#include "Patterns/ObservedContainer_impl.hpp"
 using namespace std;
 …
 atom *AtomIdDescriptor_impl::find(){
   World::AtomSet atoms = getAtoms();
+  World::AtomSet &atoms = getAtoms();
   World::AtomSet::iterator res = atoms.find(id);
   return (res!=atoms.end())?((*res).second):0;

src/Descriptors/MoleculeDescriptor.cpp

-              r06f4ef6
+              rb6da28
 #include "World.hpp"
+#include "Patterns/ObservedContainer_impl.hpp"
 #include "molecule.hpp"
 #include <boost/bind.hpp>
-#include <cassert>
 #include <iostream>
 using namespace std;
 typedef World::MoleculeSet::iterator molecules_iter_t;
+typedef World::MoleculeSet::internal_iterator molecules_iter_t;
 /************************ Forwarding object **************************************/
 …
 molecule* MoleculeDescriptor_impl::find() {
   World::MoleculeSet molecules = getMolecules();
   molecules_iter_t res = find_if(molecules.begin(),molecules.end(),boost::bind(&MoleculeDescriptor_impl::predicate,this,_1));
   return (res!=molecules.end())?((*res).second):0;
+  World::MoleculeSet &molecules = getMolecules();
+  molecules_iter_t res = find_if(molecules.begin_internal(),molecules.end_internal(),boost::bind(&MoleculeDescriptor_impl::predicate,this,_1));
+  return (res!=molecules.end_internal())?((*res).second):0;
+}
 vector<molecule*> MoleculeDescriptor_impl::findAll() {
   vector<molecule*> res;
+  World::MoleculeSet molecules = getMolecules();
+  molecules_iter_t iter;
+  for(iter=molecules.begin();iter!=molecules.end();++iter) {
+    if(predicate(*iter)){
+      res.push_back((*iter).second);
+    }
+  World::MoleculeSet &molecules = getMolecules();
+  for_each(molecules.begin_internal(),
+           molecules.end_internal(),
+           boost::bind(&MoleculeDescriptor_impl::checkAndAdd,
+                       this,&res,_1));
+  return res;
+}
+void MoleculeDescriptor_impl::checkAndAdd(std::vector<molecule*> *v,std::pair<moleculeId_t,molecule*> p){
+  if(predicate(p)){
+    v->push_back(p.second);
+  }
-  return res;
+}

src/Descriptors/MoleculeDescriptor_impl.hpp

r06f4ef6	rb6da28
50	50	*/
51	51	World::MoleculeSet& getMolecules();
	52
	53	void checkAndAdd(std::vector<molecule>,std::pair<moleculeId_t,molecule*>);
52	54	};
53	55

src/Descriptors/MoleculeIdDescriptor.cpp

-              r06f4ef6
+              rb6da28
 #include "MoleculeIdDescriptor.hpp"
 #include "MoleculeIdDescriptor_impl.hpp"
+#include "Patterns/ObservedContainer_impl.hpp"
 #include "molecule.hpp"
 …
 molecule *MoleculeIdDescriptor_impl::find(){
   World::MoleculeSet molecules = getMolecules();
+  World::MoleculeSet &molecules = getMolecules();
   World::MoleculeSet::iterator res = molecules.find(id);
   return (res!=molecules.end())?((*res).second):0;

src/Descriptors/MoleculeNameDescriptor.cpp

r06f4ef6	rb6da28
30	30
31	31	molecule *MoleculeNameDescriptor_impl::find(){
32		World::MoleculeSet molecules = getMolecules();
	32	World::MoleculeSet &molecules = getMolecules();
33	33	World::MoleculeSet::iterator res = molecules.begin();
34	34	for (; res != molecules.end(); res++)

src/Descriptors/MoleculePtrDescriptor.cpp

-              r06f4ef6
+              rb6da28
 #include "MoleculePtrDescriptor.hpp"
 #include "MoleculePtrDescriptor_impl.hpp"
+#include "Patterns/ObservedContainer_impl.hpp"
 #include "molecule.hpp"
 …
 molecule *MoleculePtrDescriptor_impl::find(){
   World::MoleculeSet molecules = getMolecules();
+  World::MoleculeSet &molecules = getMolecules();
   World::MoleculeSet::iterator res = molecules.find(ptr->getId());
   return (res!=molecules.end())?((*res).second):0;

src/Exceptions/CustomException.cpp

r06f4ef6	rb6da28
9	9
10	10	#include "CustomException.hpp"
	11	#include <iostream>
11	12
12	13	using namespace std;

src/Exceptions/CustomException.hpp

-              r06f4ef6
+              rb6da28
 #include <exception>
+#include <iostream>
+#include <iosfwd>
+#include <string>
 /**

src/Hbondangle.db

r06f4ef6	rb6da28
	1	# atomicnumber angles for single, double and triple bond (-1 no angle)
1	2	1 180 -1 -1
2	3	5 180 131.0 109.2

src/Hbonddistance.db

r06f4ef6	rb6da28
	1	#atomic number bond distances for single, double and triple bond (-1 no bond)
1	2	1 0.74 -1 -1
2	3	2 0.77429209 -1 -1

src/Helpers/Assert.cpp

-              r06f4ef6
+              rb6da28
  *      Author: crueger
  */
-#include "Helpers/MemDebug.hpp"
 #include "Helpers/Assert.hpp"
 …
+}
-using namespace Assert;
 #ifndef NDEBUG
+Action _my_assert::defaultAction = Ask;
+std::vector<Assert::hook_t> _my_assert::hooks;
+#ifdef __GNUC__
+#include <cstdlib>
+#include <execinfo.h>
+#include <cxxabi.h>
+#endif
+std::map<std::string,bool> _wrapper::ignores;
+const char* _wrapper::message_ptr = "source pointer did not point to object of desired type";
+const char* _wrapper::message_ref = "source reference did not contain object of desired type";
+Assert::Action Assert::_my_assert::defaultAction = Ask;
+std::vector<Assert::hook_t> Assert::_my_assert::hooks;
+std::map<std::string,bool> Assert::_wrapper::ignores;
+const char* Assert::_wrapper::message_ptr = "source pointer did not point to object of desired type";
+const char* Assert::_wrapper::message_ref = "source reference did not contain object of desired type";
+bool _my_assert::check(const bool res,
+                       const char* condition,
+                       const char* message,
+                       const char* filename,
+                       const int line,
+                       bool& ignore)
+bool Assert::_my_assert::check(const char* condition,
+                               const char* message,
+                               const char* filename,
+                               const int line,
+                               bool& ignore)
+{
+  if(!res){
+    cout << "Assertion \"" << condition << "\" failed in file " << filename << " at line " << line << endl;
+    cout << "Assertion Message: " << message << std::endl;
+    while(true){
+      char choice;
+      if(defaultAction==Ask) {
+        cout << "Please choose: (a)bort, (t)hrow execption, (i)gnore, al(w)ays ignore" << endl;
+        cin >> choice;
+      }
+      else{
+        choice = ActionKeys[defaultAction];
+      }
+      switch(choice){
+        case 'a':
+          return true;
+          break;
+        case 't':
+          throw AssertionFailure(condition,filename,line,message);
+          break;
+        case 'w':
+          ignore = true;
+          // fallthrough
+        case 'i':
+          return false;
+          break;
+      }
+  cout << "Assertion \"" << condition << "\" failed in file " << filename << " at line " << line << endl;
+  cout << "Assertion Message: " << message << std::endl;
+  while(true){
+    char choice;
+    if(defaultAction==Assert::Ask) {
+#ifdef __GNUC__
+      cout << "Please choose: (a)bort, (t)hrow execption, show (b)actrace, (i)gnore, al(w)ays ignore" << endl;
+#else
+      cout << "Please choose: (a)bort, (t)hrow execption, (i)gnore, al(w)ays ignore" << endl;
+#endif /* __GNUC__ */
+      cin >> choice;
+    }
+    else{
+      choice = ActionKeys[defaultAction];
+    }
+    switch(choice){
+      case 'a':
+        return true;
+        break;
+      case 't':
+        throw AssertionFailure(condition,filename,line,message);
+        break;
+#ifdef __GNUC__
+      case 'b':
+        Assert::_my_assert::backtrace(filename,line);
+       break;
+#endif /* __GNUC__ */
+      case 'w':
+        ignore = true;
+        // fallthrough
+      case 'i':
+        return false;
+        break;
+    }
+  }
 …
+}
+void _my_assert::doHooks(){
+#ifdef __GNUC__
+void Assert::_my_assert::backtrace(const char *file, int line){
+  const size_t max_depth = 100;
+  void* stack_addrs[max_depth];
+  size_t stack_depth;
+  char **stack_strings=0;
+  const char *func_name=0;
+  size_t sz = 64;
+  // get the backtrace
+  stack_depth   = ::backtrace(stack_addrs,max_depth);
+  stack_strings = backtrace_symbols(stack_addrs, stack_depth);
+  // used later for demangling
+  // reserved here, so we can free it unconditionally
+  char *dm_function = static_cast<char*>(malloc(sz));
+  if(!dm_function){
+    // malloc failed... we are out of luck
+    cout << "cannot provide stack trace due to exhausted memory" << endl;
+    return;
+  }
+  cout << "Backtrace from  " << file << "@" << line << ":" << endl;
+  // i=2 because we don't want this function, nor the assertion handler
+  for(unsigned int i=2;i<stack_depth-2;++i){
+    // find the mangled function name
+    char *begin = stack_strings[i];
+    // function name starts with a (
+    while(*begin && *begin!='(') ++begin;
+    char *end=begin;
+    while(*end && *end!='+') ++end;
+    // see if we found our function name
+    if(*begin && *end){
+      *begin++ = 0;
+      *end = 0;
+      // use the C++ demangler
+      int status;
+      char *func_ret = abi::__cxa_demangle(begin, dm_function, &sz, &status);
+      if(func_ret){
+        // abi might have realloced...
+        dm_function = func_ret;
+        func_name = dm_function;
+      }
+      else{
+        // demangling failed... get the function name without demangling
+        func_name = begin;
+      }
+    }
+    else{
+      // function name not found... get the whole line
+      func_name = stack_strings[i];
+    }
+    cout << func_name << endl;
+  }
+  free(dm_function);
+  free(stack_strings); // malloc()ed by backtrace_symbols
+}
+#endif /* __GNUC__ */
+void Assert::_my_assert::doHooks(){
   for(vector<hook_t>::reverse_iterator iter = hooks.rbegin(); iter!=hooks.rend(); ++iter ){
     (*iter)();
 …
+}
 void _my_assert::addHook(hook_t hook){
+void Assert::_my_assert::addHook(hook_t hook){
   hooks.push_back(hook);
+}
 void _my_assert::removeHook(Assert::hook_t hook){
+void Assert::_my_assert::removeHook(Assert::hook_t hook){
   for(vector<hook_t>::iterator iter = hooks.begin(); iter!=hooks.end();){
     if((*iter)==hook){
 …
+}
 void _my_assert::setDefault(Assert::Action action){
+void Assert::_my_assert::setDefault(Assert::Action action){
   defaultAction = action;
+}
 Assert::Action _my_assert::getDefault(){
+Assert::Action Assert::_my_assert::getDefault(){
   return defaultAction;
+}
 std::string _my_assert::printDefault(){
+std::string Assert::_my_assert::printDefault(){
   return ActionNames[defaultAction];
+}

src/Helpers/Assert.hpp

-              r06f4ef6
+              rb6da28
 #include<sstream>
 #include<string>
 #include<iostream>
+#include<iosfwd>
 #include<vector>
 #include<map>
 …
       static bool ignore = false;\
       if(!ignore){\
         if(Assert::_my_assert::check((condition),STRINGIFY(condition),(message),\
                                      __FILE__,__LINE__,ignore)){\
+        if(!(condition) && Assert::_my_assert::check(STRINGIFY(condition),(message),\
+                                                     __FILE__,__LINE__,ignore)){\
           Assert::_my_assert::doHooks();\
           DEBUG_BREAK;\
 …
                   static bool ignore = false; \
                   if(!ignore){\
                           if(Assert::_my_assert::check(false,"Exception caught",(message),__FILE__,__LINE__,ignore)){\
+                          if(Assert::_my_assert::check("Exception caught",(message),__FILE__,__LINE__,ignore)){\
                             Assert::_my_assert::doHooks();\
           DEBUG_BREAK;\
+                            DEBUG_BREAK;\
                           }\
                   }\
 …
     class _my_assert{
     public:
+      static bool check(const bool res,
+                        const char* condition,
+      static bool check(const char* condition,
                         const char* message,
                         const char* filename,
                         const int line,
                         bool& ignore);
+#ifdef __GNUC__
+      static void backtrace(const char *file, int line);
+#endif /* __GNUC__ */
       static void addHook(Assert::hook_t hook);
       static void removeHook(Assert::hook_t hook);
 …
       if(!ignore){
         if(_my_assert::check(dynamic_cast<target>(src)==static_cast<target>(src),"type-safe typecast",
                                        message_ptr,file,line,ignore)){
+        bool res = dynamic_cast<target>(src)==static_cast<target>(src);
+        if(!res && _my_assert::check("type-safe typecast",message_ptr,file,line,ignore)){
           _my_assert::doHooks();
           DEBUG_BREAK;
 …
       catch(...){
         if(!ignore){
           if(_my_assert::check(0,"type-safe typecast",message_ref,file,line,ignore)){
+          if(_my_assert::check("type-safe typecast",message_ref,file,line,ignore)){
             _my_assert::doHooks();
             DEBUG_BREAK;

src/Helpers/MemDebug.cpp

-              r06f4ef6
+              rb6da28
  */
+#ifndef NDBEGUG
+#ifndef NO_MEMDEBUG
+// NDEBUG implies NO_MEMDEBUG
+#ifdef NDEBUG
+# ifndef NO_MEMDEBUG
+#   define NO_MEMDEBUG
+# endif
+#endif
+// NO_MEMDEBUG and MEMDEBUG are mutually exclusive, but at least one must be set
+#ifdef NO_MEMDEBUG
+# ifdef MEMDEBUG
+#   undef MEMDEBUG
+# endif
+#else
+# ifndef MEMDEBUG
+#   define MEMDEBUG
+# endif
+#endif
+#ifdef MEMDEBUG
 #include <iostream>
 …
   // all allocated memory blocks
   struct entry_t {
+    typedef unsigned int checksum_t;
     // we seperate the tracking info from the rest
     // A checksum will be calculated for this part of
 …
     } info;
     bool isIgnored;
     char checksum;
+    checksum_t checksum;
     entry_t *prev;
     entry_t *next;
 …
   // calculates a simple checksum for the info block
   // the checksum is used to find memory corruptions
   inline char calcChecksum(entry_t::info_t *info){
+  inline entry_t::checksum_t calcChecksum(entry_t::info_t *info){
     char *buffer = (char*)info;
     char checksum =0;
+    entry_t::checksum_t checksum =0;
     for(size_t i=0;i<sizeof(entry_t::info_t);i++){
       checksum+=buffer[i];
 …
       cout << "Chunk reserved at: " << pos->info.file << ":" << pos->info.line << endl;
 #endif
+    }
+  }
+  void dumpMemory(std::ostream &ost){
+    ost << "Maximum allocated Memory: " << max << " bytes" << endl;
+    ost << "Maximum allocated Memory: " << max << " bytes" << endl;
+    ost << "Currently allocated Memory: " << state <<" bytes" << endl;
+    ost << allocs << " allocated chunks total" << endl;
+    bool corrupted=false;
+    for(entry_t *pos=begin;pos;pos=pos->next){
+      ost << "\nChunk of " << pos->info.nbytes << " bytes" << " still available" << endl;
+#     ifdef __GNUC__
+        ost << "Chunk reserved at: " << pos->info.function
+             << " (" << pos->info.file << ":" << pos->info.line  << ")" << endl;
+#     else
+        ost << "Chunk reserved at: " << pos->info.file << ":" << pos->info.line << endl;
+#     endif
+        ost << "Chunk address: " << pos->info.location << endl;
+        entry_t::checksum_t checksum = calcChecksum(&pos->info);
+        ost << "Checksum of chunk: " << checksum << endl;
+        ost << "Checksum at allocation time: " << pos->checksum << endl;
+        if(checksum!=pos->checksum){
+          ost << "!!!Chunk was corrupted!!!" << endl;
+          corrupted=true;
+        }
+    }
+    if(corrupted){
+      ost << "\n!!!Memory corruption detected!!!" << endl;
+    }
+  }
 …
+}
 #endif
-#endif

src/Helpers/MemDebug.hpp

-              r06f4ef6
+              rb6da28
  * your sourcefiles.
  */
-#ifndef NDEBUG
-#ifndef NO_MEMDEBUG
+#ifndef MEMDEBUG
+#define MEMDEBUG
+// Set all flags in a way that makes sense
+// NDEBUG implies NO_MEMDEBUG
+#ifdef NDEBUG
+# ifndef NO_MEMDEBUG
+#   define NO_MEMDEBUG
+# endif
 #endif
+// NO_MEMDEBUG and MEMDEBUG are mutually exclusive, but at least one must be set
+#ifdef NO_MEMDEBUG
+# ifdef MEMDEBUG
+#   undef MEMDEBUG
+# endif
+#else
+# ifndef MEMDEBUG
+#   define MEMDEBUG
+# endif
+#endif
+#ifdef MEMDEBUG
 #include <new>
 …
    */
   void getState();
+  void dumpMemory(std::ostream&);
   void _ignore(void*);
 …
 #endif
+#endif
+#endif
+#ifdef NDEBUG
+#undef MEMDEBUG
+#endif
+#ifndef MEMDEBUG
+#else
 // memory debugging was disabled
 namespace Memory {
   inline void getState(){}
+  inline void dumpMemory(std::ostream&){};
   template <typename T>
 …
 #endif
 #endif /* MEMDEBUG_HPP_ */

src/Legacy/oldmenu.cpp

-              r06f4ef6
+              rb6da28
 #include "Legacy/oldmenu.hpp"
+#include "analysis_bonds.hpp"
 #include "analysis_correlation.hpp"
 #include "World.hpp"
 …
   Log() << Verbose(0) << " f - calculate temperature from current velocity" << endl;
   Log() << Verbose(0) << " g - output all temperatures per step from velocities" << endl;
+  Log() << Verbose(0) << " h - count the number of hydrogen bonds" << endl;
   Log() << Verbose(0) << "all else - go back" << endl;
   Log() << Verbose(0) << "===============================================" << endl;
 …
         const LinkedCell *LCList = NULL;
         LCList = new LinkedCell(mol, 10.);
+        FindConvexBorder(mol, TesselStruct, LCList, NULL);
+        Boundaries *BoundaryPoints = NULL;
+        FindConvexBorder(mol, BoundaryPoints TesselStruct, LCList, NULL);
         double clustervolume = VolumeOfConvexEnvelope(TesselStruct, configuration);
         Log() << Verbose(0) << "The tesselated surface area is " << clustervolume << "." << endl;\
 …
+      }
       break;
+    case 'h':
+      {
+        int Z1;
+        cout << "Please enter first interface element: ";
+        cin >> Z1;
+        const element * InterfaceElement = World::getInstance().getPeriode()->FindElement(Z1);
+        int Z2;
+        cout << "Please enter second interface element: ";
+        cin >> Z2;
+        const element * InterfaceElement2 = World::getInstance().getPeriode()->FindElement(Z2);
+        cout << endl << "There are " << CountHydrogenBridgeBonds(World::getInstance().getMolecules(), InterfaceElement, InterfaceElement2) << " hydrogen bridges with connections to " << (InterfaceElement != 0 ? InterfaceElement->name : "None") << " and " << (InterfaceElement2 != 0 ? InterfaceElement2->name : "None") << "." << endl;
+      }
+      break;
+  }
 };
 …
+{
   int Order1;
+  std::string path;
   clock_t start, end;
 …
   Log() << Verbose(0) << "What's the desired bond order: ";
   cin >> Order1;
+  DoLog(0) && (Log() << Verbose(0) << "What's the output path and prefix [e.g. /home/foo/BondFragment]: ");
+  cin >> path;
   if (mol->hasBondStructure()) {
     start = clock();
     mol->FragmentMolecule(Order1, configuration);
+    mol->FragmentMolecule(Order1, path);
     end = clock();
     Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;

src/Line.cpp

-              r06f4ef6
+              rb6da28
+}
+std::vector<Vector> Line::getSphereIntersections() const{
+  std::vector<Vector> res;
+  // line is kept in normalized form, so we can skip a lot of calculations
+  double discriminant = 1-origin->NormSquared();
+  // we might have 2, 1 or 0 solutions, depending on discriminant
+  if(discriminant>=0){
+    if(discriminant==0){
+      res.push_back(*origin);
+    }
+    else{
+      Vector helper = sqrt(discriminant)*(*direction);
+      res.push_back(*origin+helper);
+      res.push_back(*origin-helper);
+    }
+  }
+  return res;
+}
 Line makeLineThrough(const Vector &x1, const Vector &x2){
   if(x1==x2){

src/Line.hpp

r06f4ef6	rb6da28
38	38	Plane getOrthogonalPlane(const Vector &origin) const;
39	39
	40	std::vector<Vector> getSphereIntersections() const;
	41
40	42	private:
41	43	std::auto_ptr<Vector> origin;

src/Makefile.am

-              r06f4ef6
+              rb6da28
   Helpers/Assert.cpp \
   Helpers/MemDebug.cpp
+BASESOURCE = \
+  ${HELPERSOURCE} \
+  Space.cpp \
+  vector.cpp
+BASEHEADER = \
+  ${HELPERHEADER} \
+  Space.hpp \
+  vector.hpp
 ATOMSOURCE = \
 …
 LINALGSOURCE = \
-  ${HELPERSOURCE} \
   gslmatrix.cpp \
   gslvector.cpp \
+  linearsystemofequations.cpp \
+  Space.cpp \
+  vector.cpp
+  linearsystemofequations.cpp
+LINALGHEADER = gslmatrix.hpp \
+LINALGHEADER = \
+  gslmatrix.hpp \
   gslvector.hpp \
+  linearsystemofequations.hpp \
+  Space.hpp \
+  vector.hpp
+  linearsystemofequations.hpp
 ANALYSISSOURCE = \
 …
 ACTIONSHEADER = \
-  ${ANALYSISACTIONHEADER} \
-  ${ATOMACTIONHEADER} \
-  ${CMDACTIONHEADER} \
-  ${FRAGMENTATIONACTIONHEADER} \
-  ${MOLECULEACTIONHEADER} \
-  ${PARSERACTIONHEADER} \
-  ${TESSELATIONACTIONHEADER} \
-  ${WORLDACTIONHEADER} \
   Actions/Action.hpp \
   Actions/ActionHistory.hpp \
 …
   Actions/MethodAction.hpp \
   Actions/Process.hpp
+EXCEPTIONSOURCE = \
+  Exceptions/CustomException.cpp \
+  Exceptions/IllegalTypeException.cpp \
+  Exceptions/LinearDependenceException.cpp \
+  Exceptions/MathException.cpp \
+  Exceptions/MissingValueException.cpp \
+  Exceptions/NotInvertibleException.cpp \
+  Exceptions/ParseError.cpp \
+  Exceptions/SkewException.cpp \
+  Exceptions/ZeroVectorException.cpp
+EXCEPTIONHEADER = \
+  Exceptions/CustomException.hpp \
+  Exceptions/IllegalTypeException.hpp \
+  Exceptions/LinearDependenceException.hpp \
+  Exceptions/MathException.hpp \
+  Exceptions/MissingValueException.hpp \
+  Exceptions/NotInvertibleException.hpp \
+  Exceptions/ParseError.hpp \
+  Exceptions/SkewException.hpp \
+  Exceptions/ZeroVectorException.hpp
 PARSERSOURCE = \
   Parser/ChangeTracker.cpp \
   Parser/FormatParser.cpp \
+  Parser/FormatParserStorage.cpp \
+  Parser/MpqcParser.cpp \
+  Parser/PcpParser.cpp \
   Parser/TremoloParser.cpp \
   Parser/XyzParser.cpp
 PARSERHEADER = \
   Parser/ChangeTracker.hpp \
   Parser/FormatParser.hpp \
+  Parser/FormatParserStorage.hpp \
+  Parser/MpqcParser.hpp \
+  Parser/PcpParser.hpp \
   Parser/TremoloParser.hpp \
   Parser/XyzParser.hpp
 …
 SHAPESOURCE = \
+  Shapes/Shape.cpp
+  Shapes/BaseShapes.cpp \
+  Shapes/Shape.cpp \
+  Shapes/ShapeOps.cpp
 SHAPEHEADER = \
+  Shapes/Shape.hpp
+  Shapes/BaseShapes.hpp \
+  Shapes/Shape.hpp \
+  Shapes/ShapeOps.hpp
-# all these files are only used for legacy reasons while the transition is in progress
-# they are only needed to keep the program usable at any point of the transition and will be
-# deleted once everything is fully refactored
-LEGACYSOURCE = Legacy/oldmenu.cpp
-LEGACYHEADER = Legacy/oldmenu.hpp
 DESCRIPTORSOURCE = Descriptors/AtomDescriptor.cpp \
   Descriptors/AtomIdDescriptor.cpp \
+  Descriptors/AtomSelectionDescriptor.cpp \
   Descriptors/AtomTypeDescriptor.cpp \
   Descriptors/MoleculeDescriptor.cpp \
+  Descriptors/MoleculeFormulaDescriptor.cpp \
   Descriptors/MoleculeIdDescriptor.cpp \
   Descriptors/MoleculeNameDescriptor.cpp \
+  Descriptors/MoleculePtrDescriptor.cpp
+  Descriptors/MoleculePtrDescriptor.cpp \
+  Descriptors/MoleculeSelectionDescriptor.cpp
 DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp \
   Descriptors/AtomIdDescriptor.hpp \
+  Descriptors/AtomSelectionDescriptor.hpp \
   Descriptors/AtomTypeDescriptor.hpp \
   Descriptors/MoleculeDescriptor.hpp \
+  Descriptors/MoleculeFormulaDescriptor.hpp \
   Descriptors/MoleculeIdDescriptor.hpp \
   Descriptors/MoleculeNameDescriptor.hpp \
+  Descriptors/MoleculePtrDescriptor.hpp
+EXCEPTIONSOURCE = Exceptions/CustomException.cpp \
+                                  Exceptions/LinearDependenceException.cpp \
+                                  Exceptions/MathException.cpp \
+                                  Exceptions/SkewException.cpp \
+                                  Exceptions/ZeroVectorException.cpp
+  Descriptors/MoleculePtrDescriptor.hpp \
+  Descriptors/MoleculeSelectionDescriptor.cpp
+QTUIMOC_HEADER = UIElements/QT4/QTDialog.hpp \
+        UIElements/QT4/QTMainWindow.hpp \
+        UIElements/Menu/QT4/QTMenu.hpp \
+        UIElements/Views/QT4/QTWorldView.hpp \
+        UIElements/Views/QT4/GLMoleculeView.hpp \
+        UIElements/Views/QT4/QTMoleculeView.hpp \
+        UIElements/Views/QT4/QTStatusBar.hpp
+EXCEPTIONHEADER = Exceptions/CustomException.hpp \
+                                  Exceptions/LinearDependenceException.hpp \
+                                  Exceptions/MathException.hpp \
+                                  Exceptions/SkewException.hpp \
+                                  Exceptions/ZeroVectorException.hpp
+QTUISOURCE = allmocs.moc.cpp \
+        UIElements/QT4/QTMainWindow.cpp \
+        UIElements/QT4/QTDialog.cpp \
+        UIElements/QT4/QTUIFactory.cpp \
+        UIElements/Menu/QT4/QTMenu.cpp \
+        UIElements/Views/QT4/QTWorldView.cpp \
+        UIElements/Views/QT4/GLMoleculeView.cpp \
+        UIElements/Views/QT4/QTMoleculeView.cpp \
+        UIElements/Views/QT4/QTStatusBar.cpp
+QTUIHEADER = ${QTUIMOC_HEADER} UIElements/QT4/QTUIFactory.hpp
+QTUI_DEFS =
 SOURCE = \
 …
   ${ACTIONSSOURCE} \
   ${ATOMSOURCE} \
+  ${EXCEPTIONSOURCE} \
   ${PATTERNSOURCE} \
   ${PARSERSOURCE} \
   ${SHAPESOURCE} \
   ${DESCRIPTORSOURCE} \
-  ${HELPERSOURCE} \
-  ${LEGACYSOURCE} \
-  ${EXCEPTIONSOURCE} \
   bond.cpp \
   bondgraph.cpp \
   boundary.cpp \
+  Box.cpp \
   CommandLineParser.cpp \
   config.cpp \
+  ConfigFileBuffer.cpp \
   element.cpp \
   elements_db.cpp \
   ellipsoid.cpp \
   errorlogger.cpp \
+  Formula.cpp \
   graph.cpp \
   helpers.cpp \
 …
   log.cpp \
   logger.cpp \
+  Matrix.cpp \
   moleculelist.cpp \
   molecule.cpp \
 …
   periodentafel.cpp \
   Plane.cpp \
-  Space.cpp \
   tesselation.cpp \
   tesselationhelpers.cpp \
+  ThermoStatContainer.cpp \
   triangleintersectionlist.cpp \
   vector.cpp \
+  UIElements/UIFactory.cpp \
   vector_ops.cpp \
   verbose.cpp \
 …
   ${ACTIONSHEADER} \
   ${ATOMHEADER} \
+  ${EXCEPTIONHEADER} \
   ${PARSERHEADER} \
   ${PATTERNHEADER} \
   ${SHAPEHEADER} \
   ${DESCRIPTORHEADER} \
-  ${EXCEPTIONHEADER} \
-  ${LEGACYHEADER} \
   bond.hpp \
   bondgraph.hpp \
   boundary.hpp \
+  Box.hpp \
   CommandLineParser.hpp \
   config.hpp \
+  ConfigFileBuffer.hpp \
   defs.hpp \
   element.hpp \
 …
   ellipsoid.hpp \
   errorlogger.hpp \
+  Formula.hpp \
   graph.hpp \
   helpers.hpp \
 …
   log.hpp \
   logger.hpp \
+  Matrix.hpp \
   molecule.hpp \
   molecule_template.hpp \
 …
   tesselation.hpp \
   tesselationhelpers.hpp \
+  ThermoStatContainer.hpp \
   triangleintersectionlist.hpp \
+  UIElements/UIFactory.hpp \
   verbose.hpp \
   vector_ops.hpp \
 …
 BOOST_LIB = $(BOOST_LDFLAGS) $(BOOST_MPL_LIB)
+GUI_LIBS = ${QT_LDADD} ${QT_LIB_GUI} -lQtOpenGL ${GLU_LIBS}
 INCLUDES = -I$(top_srcdir)/src/unittests -I$(top_srcdir)/src/Actions -I$(top_srcdir)/src/UIElements
+noinst_LIBRARIES = libmolecuilder.a libgslwrapper.a
+bin_PROGRAMS = molecuilder joiner analyzer
+noinst_LIBRARIES = libmolecuilderbase.a libmolecuilder.a libgslwrapper.a libmenu.a libparser.a
+bin_PROGRAMS = molecuilder molecuildergui joiner analyzer
+EXTRA_PROGRAMS = unity
 molecuilderdir = ${bindir}
+libmolecuilderbase_a_SOURCES = ${BASESOURCE} ${BASEHEADER}
 libmolecuilder_a_SOURCES = ${SOURCE} ${HEADER}
+libmenu_a_SOURCES = ${UISOURCE} ${UIHEADER}
+libparser_a_SOURCES = ${PARSERSOURCE} ${PARSERHEADER}
 libgslwrapper_a_SOURCES = ${LINALGSOURCE} ${LINALGHEADER}
 molecuilder_DATA = elements.db valence.db orbitals.db Hbonddistance.db Hbondangle.db
+molecuilder_LDFLAGS = $(BOOST_LDFLAGS)
+molecuilder_SOURCES = builder.cpp
+molecuilder_LDADD =  UIElements/libMolecuilderUI.a Actions/libMolecuilderActions.a libmolecuilder.a libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_LIB} ${BOOST_PROGRAM_OPTIONS_LIB}
+molecuilder_CXXFLAGS = $(BOOST_CPPFLAGS)
+#molecuilder_CXXFLAGS += -DNO_CACHING
+molecuilder_LDFLAGS = $(BOOST_LIB)
+molecuilder_SOURCES = ${LEGACYSOURCE} builder.cpp
+molecuilder_SOURCES += $(srcdir)/version.c
+molecuilder_LDADD = UIElements/libMolecuilderUI.a Actions/libMolecuilderActions.a libmolecuilderbase.a libmolecuilder.a libparser.a libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_LIB} ${BOOST_PROGRAM_OPTIONS_LIB}
+#Stuff for building the GUI using QT
+molecuildergui_SOURCES = ${QTUISOURCE} ${LEGACYSOURCE} builder.cpp
+molecuildergui_SOURCES += $(srcdir)/version.c
+molecuildergui_CXXFLAGS = ${QT_CXXFLAGS} ${GLU_CXXFLAGS} -DUSE_GUI_QT
+molecuildergui_LDFLAGS = $(BOOST_LIB) ${QT_LDFLAGS} ${GLU_LDFLAGS}
+molecuildergui_LDADD = UIElements/libMolecuilderUI.a Actions/libMolecuilderActions.a libmolecuilderbase.a libmolecuilder.a libparser.a libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_LIB} ${BOOST_PROGRAM_OPTIONS_LIB}  ${GUI_LIBS}
 joiner_SOURCES = joiner.cpp datacreator.cpp parser.cpp datacreator.hpp helpers.hpp parser.hpp periodentafel.hpp
+joiner_LDADD = libmolecuilder.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
+joiner_LDADD = libmolecuilder.a libmolecuilderbase.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
 analyzer_SOURCES = analyzer.cpp datacreator.cpp parser.cpp helpers.hpp periodentafel.hpp parser.hpp datacreator.hpp
+analyzer_LDADD = libmolecuilder.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
+analyzer_LDADD = libmolecuilder.a libmolecuilderbase.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
+unity_SOURCES = unity.cpp $(srcdir)/version.c
+unity_LDADD = $(BOOST_LIB) ${BOOST_THREAD_LIB} ${BOOST_PROGRAM_OPTIONS_LIB}
+#Rules needed for QT4
+# UI-Files are scattered throughout several subdirectories
+# Therfore `%'-rules do not seem to work
+#Quick fix to get it done otherwise
+allmocs.moc.cpp: ${QTUIMOC_HEADER}
+        echo "" > allmocs.moc.cpp;\
+        list='$(QTUIMOC_HEADER)'; for header in $$list; do \
+        echo "Making mocfile for $$header"; \
+        target=`basename $$header | sed "s/\(.*\)\..*/\1.moc.cpp/"`;\
+        $(MOC) $(srcdir)/$$header -o $$target \
+        || eval $$failcom; \
+        echo "#include \"$$target\"" >> allmocs.moc.cpp; \
+        done;
+unity.cpp: ${LINALGSOURCE} ${LINALGHEADER} ${SOURCE} ${HEADER}
+        echo "" >  unity.cpp; \
+        list='$(BASESOURCE)'; for file in $$list; do \
+          echo "#include \"$(srcdir)/$$file\"" >> unity.cpp; \
+        done; \
+        list='$(LINALGSOURCE)'; for file in $$list; do \
+          echo "#include \"$(srcdir)/$$file\"" >> unity.cpp; \
+        done; \
+        list='$(SOURCE)'; for file in $$list; do \
+          echo "#include \"$(srcdir)/$$file\"" >> unity.cpp; \
+        done; \
+        subdirs='$(SUBDIRS)';for directory in $$subdirs; do\
+                olddir=$$PWD;\
+                cd $$directory && make unity.cpp;\
+                cd $$olddir;\
+                echo "#include \"$$directory/unity.cpp\"" >> unity.cpp;\
+        done;\
+        echo "#include \"$(srcdir)/builder.cpp\"" >> unity.cpp;
+MOSTLYCLEANFILES = allmocs.moc.cpp unity.cpp
+#EXTRA_DIST = ${molecuilder_DATA}
 FORCE:
 $(srcdir)/.git-version: FORCE
+        @if (test -d $(top_srcdir)/../.git && cd $(srcdir) && git describe HEAD) > .git-version-t 2>/dev/null \
+        @if (test -d $(top_srcdir)/.git && cd $(srcdir) \
+             && { git describe --dirty --always || git describe; } ) > .git-version-t 2>/dev/null \
           && ! diff .git-version-t $(srcdir)/.git-version >/dev/null 2>&1; then \
           mv -f .git-version-t $(srcdir)/.git-version; \
 …
         echo "const char *ESPACKVersion = \"$(PACKAGE_NAME) -- git version: "`cat $(srcdir)/.git-version`"\";" > $@
+molecuilder_SOURCES += $(srcdir)/version.c

src/Parser/ChangeTracker.cpp

-              r06f4ef6
+              rb6da28
 #include "Helpers/MemDebug.hpp"
+#include "Parser/ChangeTracker.hpp"
+#include "Patterns/Singleton_impl.hpp"
-#include "ChangeTracker.hpp"
-ChangeTracker* ChangeTracker::instance = NULL;
 /**
 …
 ChangeTracker::~ChangeTracker() {
   World::getInstance().signOff(this);
+}
-/**
- * Returns the change tracker instance.
+ *
- * \return this
- */
-ChangeTracker* ChangeTracker::get() {
-  if (instance == NULL) {
-    instance = new ChangeTracker();
+  }
-  return instance;
+}
-/**
- * Destroys the change tracker instance. Be careful, the change tracker is a
- * singleton and destruction might lead to a loss of consistency.
- */
-void ChangeTracker::destroy() {
-  delete instance;
-  instance = NULL;
+}
 …
+  }
+}
+CONSTRUCT_SINGLETON(ChangeTracker)

src/Parser/ChangeTracker.hpp

-              r06f4ef6
+              rb6da28
  * changes to it.
  */
+class ChangeTracker : public Observable {
+class ChangeTracker : public Singleton<ChangeTracker>, public Observable {
+  friend class Singleton<ChangeTracker>;
 public:
   void saveStatus();
 …
   bool isConsistent;
   static ChangeTracker* instance;
+  // private constructor and destructor due to singleton
   ChangeTracker();
   ~ChangeTracker();

src/Parser/FormatParser.cpp

r06f4ef6	rb6da28
19	19	Observer("FormatParser")
20	20	{
21		ChangeTracker::get~~()->~~signOn(this);
	21	ChangeTracker::getInstance().signOn(this);
22	22	saveStream = NULL;
23	23	}
…	…
27	27	*/
28	28	FormatParser::~FormatParser() {
29		ChangeTracker::get~~()->~~signOff(this);
	29	ChangeTracker::getInstance().signOff(this);
30	30	}
31	31

src/Parser/TremoloParser.cpp

-              r06f4ef6
+              rb6da28
 using namespace std;
-using namespace boost;
 /**
 …
   knownKeys["GrpTypeNo"] = TremoloKey::GrpTypeNo;
   knownKeys["torsion"] = TremoloKey::torsion;
+  // default behavior: use all possible keys on output
+  for (std::map<std::string, TremoloKey::atomDataKey>::iterator iter = knownKeys.begin(); iter != knownKeys.end(); ++iter)
+    usedFields.push_back(iter->first);
+}
 …
   lineStream << line.substr(offset);
+  usedFields.clear();
   while (lineStream.good()) {
     lineStream >> keyword;

src/Parser/TremoloParser.hpp

r06f4ef6	rb6da28
10	10
11	11	#include <string>
12		#include "FormatParser.hpp"
	12	#include "Parser/FormatParser.hpp"
13	13
14	14	/**

src/Parser/XyzParser.cpp

-              r06f4ef6
+              rb6da28
  */
 XyzParser::~XyzParser() {
-  delete(&comment);
+}
 …
  */
 void XyzParser::save(ostream* file) {
+  *file << World::getInstance().numAtoms() << endl << comment << endl;
+  if (comment == "") {
+    time_t now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
+    comment = "Created by molecuilder on ";
+    // ctime ends in \n\0, we have to cut away the newline
+    std::string time(ctime(&now));
+    size_t pos = time.find('\n');
+    if (pos != 0)
+      comment += time.substr(0,pos);
+    else
+      comment += time;
+  }
+  *file << World::getInstance().numAtoms() << endl << "\t" << comment << endl;
   vector<atom*> atoms = World::getInstance().getAllAtoms();
   for(vector<atom*>::iterator it = atoms.begin(); it != atoms.end(); it++) {
     *file << fixed << (*it)->getType()->symbol << "\t" << (*it)->x[0] << "\t" << (*it)->x[1] << "\t" << (*it)->x[2] << endl;
+    *file << noshowpoint << (*it)->getType()->symbol << "\t" << (*it)->x[0] << "\t" << (*it)->x[1] << "\t" << (*it)->x[2] << endl;
+  }
+}

src/Parser/XyzParser.hpp

r06f4ef6	rb6da28
10	10
11	11	#include <string>
12		#include "FormatParser.hpp"
	12	#include "Parser/FormatParser.hpp"
13	13
14	14	/**

src/Patterns/Cacheable.hpp

r06f4ef6	rb6da28
12	12	#include <boost/function.hpp>
13	13	#include <boost/shared_ptr.hpp>
14		~~#include <iostream>~~
15	14
16	15	#include "Helpers/Assert.hpp"

src/Patterns/ObservedIterator.hpp

r06f4ef6	rb6da28
84	84	{
85	85	--iter;
	86	return *this;
86	87	}
87	88
…	…
105	106	acquireLock();
106	107	return (*iter);
	108	}
	109
	110	value_type *operator->(){
	111	acquireLock();
	112	return &(*iter);
107	113	}
108	114

src/Patterns/Observer.hpp

-              r06f4ef6
+              rb6da28
   //! @cond
   // Structure for RAII-Style notification
 protected:
+public:
   /**
    * This structure implements the Observer-mechanism RAII-Idiom.
 …
 #define OBSERVE Observable::_Observable_protector PASTE(_scope_obs_protector_,__LINE__)(this)
 #define NOTIFY(notification) do{Observable::enque_notification_internal(this,notification);}while(0)
+#define LOCK_OBSERVABLE(observable) Observable::_Observable_protector PASTE(_scope_obs_protector_,__LINE__)(&(observable))
 #endif /* OBSERVER_HPP_ */

src/Patterns/Singleton.hpp

-              r06f4ef6
+              rb6da28
 #define SINGLETON_HPP_
-#include <cassert>
 #include <boost/thread.hpp>
+#include "Helpers/Assert.hpp"
 #include "defs.hpp"
 …
     inline static void set(creator_T*&,creator_T*){
       assert(0 && "Cannot set the Instance for a singleton of this type");
+      ASSERT(0, "Cannot set the Instance for a singleton of this type");
+    }
   };
 …
   struct creator_t<creator_T,false>{
     inline static creator_T* make(){
+      assert(0 && "Cannot create a singleton of this type directly");
+      ASSERT(0, "Cannot create a singleton of this type directly");
+      return 0;
+    }
     inline static void set(ptr_t& dest,creator_T* src){

src/Patterns/Singleton_impl.hpp

-              r06f4ef6
+              rb6da28
 template <class T,bool _may_create>
 void Singleton<T,_may_create>::setInstance(T* newInstance){
   assert(!theInstance.get() && "Trying to set the instance of an already created singleton");
+  ASSERT(!theInstance.get(), "Trying to set the instance of an already created singleton");
   boost::recursive_mutex::scoped_lock guard(instanceLock);
   theInstance.reset(newInstance);
 …
 template <class T, bool _may_create>
 Singleton<T,_may_create>::Singleton(const Singleton<T,_may_create>&){
   assert(0 && "Copy constructor of singleton template called");
+  ASSERT(0, "Copy constructor of singleton template called");
+}

src/Plane.hpp

r06f4ef6	rb6da28
11	11	#include <memory>
12	12	#include <vector>
13		#include <ios~~tream~~>
	13	#include <iosfwd>
14	14	#include "Space.hpp"
15	15	#include "Exceptions/LinearDependenceException.hpp"

src/Shapes/Shape.cpp

-              r06f4ef6
+              rb6da28
 Shape::~Shape(){}
 bool Shape::isInside(const Vector &point){
+bool Shape::isInside(const Vector &point) const{
   return impl->isInside(point);
+}
 …
 Shape::impl_ptr Shape::getImpl() const{
   return impl;
+}
+// allows arbitrary friendship, but only if implementation is known
+Shape::impl_ptr getShapeImpl(const Shape &shape){
+  return shape.getImpl();
+}
 …
 Shape operator&&(const Shape &lhs,const Shape &rhs){
   Shape::impl_ptr newImpl = Shape::impl_ptr(new AndShape_impl(lhs.getImpl(),rhs.getImpl()));
+  Shape::impl_ptr newImpl = Shape::impl_ptr(new AndShape_impl(getShapeImpl(lhs),getShapeImpl(rhs)));
   return Shape(newImpl);
+}
 …
 Shape operator||(const Shape &lhs,const Shape &rhs){
   Shape::impl_ptr newImpl = Shape::impl_ptr(new OrShape_impl(lhs.getImpl(),rhs.getImpl()));
+  Shape::impl_ptr newImpl = Shape::impl_ptr(new OrShape_impl(getShapeImpl(lhs),getShapeImpl(rhs)));
   return Shape(newImpl);
+}
 …
 Shape operator!(const Shape &arg){
   Shape::impl_ptr newImpl = Shape::impl_ptr(new NotShape_impl(arg.getImpl()));
+  Shape::impl_ptr newImpl = Shape::impl_ptr(new NotShape_impl(getShapeImpl(arg)));
   return Shape(newImpl);
+}

src/Shapes/Shape.hpp

-              r06f4ef6
+              rb6da28
 class Shape
+{
-friend Shape operator&&(const Shape&,const Shape&);
-friend Shape operator||(const Shape&,const Shape&);
-friend Shape operator!(const Shape&);
 public:
   typedef boost::shared_ptr<Shape_impl> impl_ptr;
+  friend impl_ptr getShapeImpl(const Shape&);
   Shape(impl_ptr);
 …
   virtual ~Shape();
   bool isInside(const Vector &point);
+  bool isInside(const Vector &point) const;
   Shape &operator=(const Shape& rhs);

src/Shapes/Shape_impl.hpp

-              r06f4ef6
+              rb6da28
 class Shape_impl {
 public:
+  Shape_impl(){};
+  virtual ~Shape_impl(){};
   virtual bool isInside(const Vector &point)=0;
 };
 …
 };
+Shape::impl_ptr getShapeImpl(const Shape&);
 #endif /* SHAPE_IMPL_HPP_ */

src/UIElements/CommandLineUI/CommandLineDialog.cpp

-              r06f4ef6
+              rb6da28
 #include "defs.hpp"
 #include "log.hpp"
+#include "Matrix.hpp"
 #include "periodentafel.hpp"
 #include "verbose.hpp"
 #include "World.hpp"
+#include "Box.hpp"
 #include "atom.hpp"
 …
+}
+void CommandLineDialog::queryInt(const char* title, int* target, string _description){
+  registerQuery(new IntCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryBoolean(const char* title, bool* target, string _description){
+  registerQuery(new BooleanCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryDouble(const char* title, double* target, string _description){
+  registerQuery(new DoubleCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryString(const char* title, string* target, string _description){
+  registerQuery(new StringCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryAtom(const char* title, atom **target, string _description) {
+  registerQuery(new AtomCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryMolecule(const char* title, molecule **target, string _description) {
+  registerQuery(new MoleculeCommandLineQuery(title,target, _description));
+}
+void CommandLineDialog::queryVector(const char* title, Vector *target,const double *const cellSize, bool check, string _description) {
+  registerQuery(new VectorCommandLineQuery(title,target,cellSize,check, _description));
+}
+void CommandLineDialog::queryBox(const char* title, double ** const cellSize, string _description) {
+  registerQuery(new BoxCommandLineQuery(title,cellSize,_description));
+}
+void CommandLineDialog::queryElement(const char* title, std::vector<element *> *target, string _description){
+  registerQuery(new ElementCommandLineQuery(title,target, _description));
+void CommandLineDialog::queryInt(const char* title, string _description){
+  registerQuery(new IntCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryInts(const char* title, string _description){
+  registerQuery(new IntsCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryBoolean(const char* title, string _description){
+  registerQuery(new BooleanCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryDouble(const char* title, string _description){
+  registerQuery(new DoubleCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryDoubles(const char* title, string _description){
+  registerQuery(new DoublesCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryString(const char* title, string _description){
+  registerQuery(new StringCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryStrings(const char* title, string _description){
+  registerQuery(new StringsCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryAtom(const char* title, string _description) {
+  registerQuery(new AtomCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryAtoms(const char* title, string _description) {
+  registerQuery(new AtomsCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryMolecule(const char* title, string _description) {
+  registerQuery(new MoleculeCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryMolecules(const char* title, string _description) {
+  registerQuery(new MoleculesCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryVector(const char* title, bool check, string _description) {
+  registerQuery(new VectorCommandLineQuery(title,check, _description));
+}
+void CommandLineDialog::queryVectors(const char* title, bool check, string _description) {
+  registerQuery(new VectorsCommandLineQuery(title,check, _description));
+}
+void CommandLineDialog::queryBox(const char* title, string _description) {
+  registerQuery(new BoxCommandLineQuery(title,_description));
+}
+void CommandLineDialog::queryElement(const char* title, string _description){
+  registerQuery(new ElementCommandLineQuery(title, _description));
+}
+void CommandLineDialog::queryElements(const char* title, string _description){
+  registerQuery(new ElementsCommandLineQuery(title, _description));
+}
 …
+}
 CommandLineDialog::IntCommandLineQuery::IntCommandLineQuery(string title,int *_target, string _description) :
     Dialog::IntQuery(title,_target, _description)
+CommandLineDialog::IntCommandLineQuery::IntCommandLineQuery(string title, string _description) :
+    Dialog::IntQuery(title, _description)
 {}
 …
+}
+CommandLineDialog::BooleanCommandLineQuery::BooleanCommandLineQuery(string title,bool *_target, string _description) :
+    Dialog::BooleanQuery(title,_target, _description)
+CommandLineDialog::IntsCommandLineQuery::IntsCommandLineQuery(string title, string _description) :
+    Dialog::IntsQuery(title, _description)
+{}
+CommandLineDialog::IntsCommandLineQuery::~IntsCommandLineQuery() {}
+bool CommandLineDialog::IntsCommandLineQuery::handle() {
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    tmp = CommandLineParser::getInstance().vm[getTitle()].as< std::vector<int> >();
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing integers for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::BooleanCommandLineQuery::BooleanCommandLineQuery(string title, string _description) :
+    Dialog::BooleanQuery(title, _description)
 {}
 …
+}
 CommandLineDialog::StringCommandLineQuery::StringCommandLineQuery(string title,string *_target, string _description) :
     Dialog::StringQuery(title,_target, _description)
+CommandLineDialog::StringCommandLineQuery::StringCommandLineQuery(string title, string _description) :
+    Dialog::StringQuery(title, _description)
 {}
 …
+}
+CommandLineDialog::DoubleCommandLineQuery::DoubleCommandLineQuery(string title,double *_target, string _description) :
+    Dialog::DoubleQuery(title,_target, _description)
+CommandLineDialog::StringsCommandLineQuery::StringsCommandLineQuery(string title, string _description) :
+    Dialog::StringsQuery(title, _description)
+{}
+CommandLineDialog::StringsCommandLineQuery::~StringsCommandLineQuery() {}
+bool CommandLineDialog::StringsCommandLineQuery::handle() {
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    tmp = CommandLineParser::getInstance().vm[getTitle()].as< vector<string> >();
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing strings for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::DoubleCommandLineQuery::DoubleCommandLineQuery(string title, string _description) :
+    Dialog::DoubleQuery(title, _description)
 {}
 …
+}
+CommandLineDialog::AtomCommandLineQuery::AtomCommandLineQuery(string title, atom **_target, string _description) :
+    Dialog::AtomQuery(title,_target, _description)
+CommandLineDialog::DoublesCommandLineQuery::DoublesCommandLineQuery(string title, string _description) :
+    Dialog::DoublesQuery(title, _description)
+{}
+CommandLineDialog::DoublesCommandLineQuery::~DoublesCommandLineQuery() {}
+bool CommandLineDialog::DoublesCommandLineQuery::handle() {
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    tmp = CommandLineParser::getInstance().vm[getTitle()].as< std::vector<double> >();
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing doubles for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::AtomCommandLineQuery::AtomCommandLineQuery(string title, string _description) :
+    Dialog::AtomQuery(title, _description)
 {}
 …
+}
+CommandLineDialog::MoleculeCommandLineQuery::MoleculeCommandLineQuery(string title, molecule **_target, string _description) :
+    Dialog::MoleculeQuery(title,_target, _description)
+CommandLineDialog::AtomsCommandLineQuery::AtomsCommandLineQuery(string title, string _description) :
+    Dialog::AtomsQuery(title, _description)
+{}
+CommandLineDialog::AtomsCommandLineQuery::~AtomsCommandLineQuery() {}
+bool CommandLineDialog::AtomsCommandLineQuery::handle() {
+  std::vector<int> IdxOfAtom;
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    IdxOfAtom = CommandLineParser::getInstance().vm[getTitle()].as< std::vector<int> >();
+    for (std::vector<int>::iterator iter = IdxOfAtom.begin(); iter != IdxOfAtom.end(); ++iter) {
+      temp = World::getInstance().getAtom(AtomById(*iter));
+      if (temp)
+        tmp.push_back(temp);
+    }
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing atoms for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::MoleculeCommandLineQuery::MoleculeCommandLineQuery(string title, string _description) :
+    Dialog::MoleculeQuery(title, _description)
 {}
 …
   if (CommandLineParser::getInstance().vm.count(getTitle())) {
     IdxOfMol = CommandLineParser::getInstance().vm[getTitle()].as<int>();
+    cout << "IdxOfMol " << IdxOfMol << endl;
+    if (IdxOfMol >= 0)
+      tmp = World::getInstance().getMolecule(MoleculeById(IdxOfMol));
+    else
+      tmp = NULL;
+    tmp = World::getInstance().getMolecule(MoleculeById(IdxOfMol));
     return true;
   } else {
 …
+}
+CommandLineDialog::VectorCommandLineQuery::VectorCommandLineQuery(string title, Vector *_target, const double *const _cellSize, bool _check, string _description) :
+    Dialog::VectorQuery(title,_target,_cellSize,_check, _description)
+CommandLineDialog::MoleculesCommandLineQuery::MoleculesCommandLineQuery(string title, string _description) :
+    Dialog::MoleculesQuery(title, _description)
+{}
+CommandLineDialog::MoleculesCommandLineQuery::~MoleculesCommandLineQuery() {}
+bool CommandLineDialog::MoleculesCommandLineQuery::handle() {
+  std::vector<int> IdxOfMol;
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    IdxOfMol = CommandLineParser::getInstance().vm[getTitle()].as< std::vector<int> >();
+    for (std::vector<int>::iterator iter = IdxOfMol.begin(); iter != IdxOfMol.end(); ++iter) {
+      temp = World::getInstance().getMolecule(MoleculeById(*iter));
+      if (temp)
+        tmp.push_back(temp);
+    }
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing molecules for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::VectorCommandLineQuery::VectorCommandLineQuery(string title, bool _check, string _description) :
+    Dialog::VectorQuery(title,_check, _description)
 {}
 …
   if (CommandLineParser::getInstance().vm.count(getTitle())) {
     temp = CommandLineParser::getInstance().vm[getTitle()].as< VectorValue >();
+    tmp->at(0) = temp.x;
+    tmp->at(1) = temp.y;
+    tmp->at(2) = temp.z;
+    tmp[0] = temp.x;
+    tmp[1] = temp.y;
+    tmp[2] = temp.z;
+    if ((check) && (!World::getInstance().getDomain().isInside(tmp))) {
+      DoeLog(1) && (eLog() << Verbose(1) << "Vector " << tmp << " would be outside of box domain." << endl);
+      return false;
+    }
     return true;
   } else {
 …
+}
+CommandLineDialog::BoxCommandLineQuery::BoxCommandLineQuery(string title, double ** const _cellSize, string _description) :
+    Dialog::BoxQuery(title,_cellSize, _description)
+CommandLineDialog::VectorsCommandLineQuery::VectorsCommandLineQuery(string title, bool _check, string _description) :
+    Dialog::VectorsQuery(title,_check, _description)
+{}
+CommandLineDialog::VectorsCommandLineQuery::~VectorsCommandLineQuery()
+{}
+bool CommandLineDialog::VectorsCommandLineQuery::handle() {
+  std::vector<VectorValue> temporary;
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    temporary = CommandLineParser::getInstance().vm[getTitle()].as< std::vector<VectorValue> >();
+    for(std::vector<VectorValue>::iterator iter = temporary.begin(); iter != temporary.end(); ++iter) {
+      temp[0] = (*iter).x;
+      temp[1] = (*iter).y;
+      temp[2] = (*iter).z;
+      if ((!check) || (World::getInstance().getDomain().isInside(temp)))
+        tmp.push_back(temp);
+      else
+        DoeLog(1) && (eLog() << Verbose(1) << "Vector " << temp << " would be outside of box domain." << endl);
+    }
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing vectors for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::BoxCommandLineQuery::BoxCommandLineQuery(string title, string _description) :
+    Dialog::BoxQuery(title, _description)
 {}
 …
   if (CommandLineParser::getInstance().vm.count(getTitle())) {
     temp = CommandLineParser::getInstance().vm[getTitle()].as< BoxValue >();
+    tmp[0] = temp.xx;
+    tmp[1] = temp.xy;
+    tmp[2] = temp.xz;
+    tmp[3] = temp.yy;
+    tmp[4] = temp.yz;
+    tmp[5] = temp.zz;
+    Matrix M;
+    M.set(0,0, temp.xx);
+    M.set(0,1, temp.yx);
+    M.set(0,2, temp.zx);
+    M.set(1,0, temp.yx);
+    M.set(1,1, temp.yy);
+    M.set(1,2, temp.zy);
+    M.set(2,0, temp.zx);
+    M.set(2,1, temp.zy);
+    M.set(2,2, temp.zz);
+    tmp.setM(M);
     return true;
   } else {
 …
+}
 CommandLineDialog::ElementCommandLineQuery::ElementCommandLineQuery(string title, std::vector<element *> *target, string _description) :
     Dialog::ElementQuery(title,target, _description)
+CommandLineDialog::ElementCommandLineQuery::ElementCommandLineQuery(string title, string _description) :
+    Dialog::ElementQuery(title, _description)
 {}
 …
   // TODO: vector of ints and removing first is not correctly implemented yet. How to remove from a vector?
   periodentafel *periode = World::getInstance().getPeriode();
+  element *elemental = NULL;
+  if (CommandLineParser::getInstance().vm.count(getTitle())) {
+    int Z = CommandLineParser::getInstance().vm[getTitle()].as< int >();
+    tmp = periode->FindElement(Z);
+    ASSERT(tmp != NULL, "Invalid element specified in ElementCommandLineQuery");
+    return true;
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing element for " << getTitle() << "." << endl);
+    return false;
+  }
+}
+CommandLineDialog::ElementsCommandLineQuery::ElementsCommandLineQuery(string title, string _description) :
+    Dialog::ElementsQuery(title, _description)
+{}
+CommandLineDialog::ElementsCommandLineQuery::~ElementsCommandLineQuery()
+{}
+bool CommandLineDialog::ElementsCommandLineQuery::handle() {
+  // TODO: vector of ints and removing first is not correctly implemented yet. How to remove from a vector?
+  periodentafel *periode = World::getInstance().getPeriode();
   if (CommandLineParser::getInstance().vm.count(getTitle())) {
     vector<int> AllElements = CommandLineParser::getInstance().vm[getTitle()].as< vector<int> >();
     for (vector<int>::iterator ZRunner = AllElements.begin(); ZRunner != AllElements.end(); ++ZRunner) {
       elemental = periode->FindElement(*ZRunner);
       ASSERT(elemental != NULL, "Invalid element specified in ElementCommandLineQuery");
       elements.push_back(elemental);
+      temp = periode->FindElement(*ZRunner);
+      ASSERT(temp != NULL, "Invalid element specified in ElementCommandLineQuery");
+      tmp.push_back(temp);
+    }
     return true;
   } else {
     DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing element for " << getTitle() << "." << endl);
     return false;
+  }
+}
+    DoeLog(1) && (eLog() << Verbose(1) << "CommandLineUI parsing error: Missing elements for " << getTitle() << "." << endl);
+    return false;
+  }
+}

src/UIElements/CommandLineUI/CommandLineDialog.hpp

-              r06f4ef6
+              rb6da28
   virtual void queryEmpty(const char *, std::string = "");
+  virtual void queryInt(const char *, int *, std::string = "");
+  virtual void queryBoolean(const char *, bool *, std::string = "");
+  virtual void queryString(const char*, std::string *, std::string = "");
+  virtual void queryDouble(const char*, double*, std::string = "");
+  virtual void queryAtom(const char*,atom**, std::string = "");
+  virtual void queryMolecule(const char*,molecule**,std::string = "");
+  virtual void queryVector(const char*,Vector *,const double * const,bool, std::string = "");
+  virtual void queryBox(const char*,double ** const, std::string = "");
+  virtual void queryElement(const char*, std::vector<element *> *, std::string = "");
+  virtual void queryInt(const char *, std::string = "");
+  virtual void queryInts(const char *, std::string = "");
+  virtual void queryBoolean(const char *, std::string = "");
+  virtual void queryString(const char*, std::string = "");
+  virtual void queryStrings(const char*, std::string = "");
+  virtual void queryDouble(const char*, std::string = "");
+  virtual void queryDoubles(const char*, std::string = "");
+  virtual void queryAtom(const char*, std::string = "");
+  virtual void queryAtoms(const char*, std::string = "");
+  virtual void queryMolecule(const char*, std::string = "");
+  virtual void queryMolecules(const char*, std::string = "");
+  virtual void queryVector(const char*, bool, std::string = "");
+  virtual void queryVectors(const char*, bool, std::string = "");
+  virtual void queryBox(const char*, std::string = "");
+  virtual void queryElement(const char*, std::string = "");
+  virtual void queryElements(const char*, std::string = "");
 protected:
 …
   class IntCommandLineQuery : public Dialog::IntQuery {
   public:
     IntCommandLineQuery(std::string title, int *_target, std::string _description = "");
+    IntCommandLineQuery(std::string title, std::string _description = "");
     virtual ~IntCommandLineQuery();
+    virtual bool handle();
+  };
+  class IntsCommandLineQuery : public Dialog::IntsQuery {
+  public:
+    IntsCommandLineQuery(std::string title, std::string _description = "");
+    virtual ~IntsCommandLineQuery();
     virtual bool handle();
   };
 …
   class BooleanCommandLineQuery : public Dialog::BooleanQuery {
   public:
     BooleanCommandLineQuery(std::string title, bool *_target, std::string _description = "");
+    BooleanCommandLineQuery(std::string title, std::string _description = "");
     virtual ~BooleanCommandLineQuery();
     virtual bool handle();
 …
   class DoubleCommandLineQuery : public Dialog::DoubleQuery {
   public:
     DoubleCommandLineQuery(std::string title, double *_target, std::string _description = "");
+    DoubleCommandLineQuery(std::string title, std::string _description = "");
     virtual ~DoubleCommandLineQuery();
+    virtual bool handle();
+  };
+  class DoublesCommandLineQuery : public Dialog::DoublesQuery {
+  public:
+    DoublesCommandLineQuery(std::string title, std::string _description = "");
+    virtual ~DoublesCommandLineQuery();
     virtual bool handle();
   };
 …
   class StringCommandLineQuery : public Dialog::StringQuery {
   public:
     StringCommandLineQuery(std::string title, std::string *_target, std::string _description = "");
+    StringCommandLineQuery(std::string title, std::string _description = "");
     virtual ~StringCommandLineQuery();
+    virtual bool handle();
+  };
+  class StringsCommandLineQuery : public Dialog::StringsQuery {
+  public:
+    StringsCommandLineQuery(std::string title, std::string _description = "");
+    virtual ~StringsCommandLineQuery();
     virtual bool handle();
   };
 …
   class AtomCommandLineQuery : public Dialog::AtomQuery {
   public:
     AtomCommandLineQuery(std::string title, atom **_target, std::string _description = "");
+    AtomCommandLineQuery(std::string title, std::string _description = "");
     virtual ~AtomCommandLineQuery();
+    virtual bool handle();
+  };
+  class AtomsCommandLineQuery : public Dialog::AtomsQuery {
+  public:
+    AtomsCommandLineQuery(std::string title, std::string _description = "");
+    virtual ~AtomsCommandLineQuery();
     virtual bool handle();
   };
 …
   class MoleculeCommandLineQuery : public Dialog::MoleculeQuery {
   public:
     MoleculeCommandLineQuery(std::string title, molecule **_target, std::string _description = "");
+    MoleculeCommandLineQuery(std::string title, std::string _description = "");
     virtual ~MoleculeCommandLineQuery();
+    virtual bool handle();
+  };
+  class MoleculesCommandLineQuery : public Dialog::MoleculesQuery {
+  public:
+    MoleculesCommandLineQuery(std::string title, std::string _description = "");
+    virtual ~MoleculesCommandLineQuery();
     virtual bool handle();
   };
 …
   class VectorCommandLineQuery : public Dialog::VectorQuery {
   public:
     VectorCommandLineQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check, std::string _description = "");
+    VectorCommandLineQuery(std::string title,bool _check, std::string _description = "");
     virtual ~VectorCommandLineQuery();
+    virtual bool handle();
+  };
+  class VectorsCommandLineQuery : public Dialog::VectorsQuery {
+  public:
+    VectorsCommandLineQuery(std::string title,bool _check, std::string _description = "");
+    virtual ~VectorsCommandLineQuery();
     virtual bool handle();
   };
 …
   class BoxCommandLineQuery : public Dialog::BoxQuery {
   public:
     BoxCommandLineQuery(std::string title,double ** const _cellSize, std::string _description = "");
+    BoxCommandLineQuery(std::string title, std::string _description = "");
     virtual ~BoxCommandLineQuery();
     virtual bool handle();
 …
   class ElementCommandLineQuery : public Dialog::ElementQuery {
   public:
     ElementCommandLineQuery(std::string title, std::vector<element *> *_target, std::string _description = "");
+    ElementCommandLineQuery(std::string title, std::string _description = "");
     virtual ~ElementCommandLineQuery();
+    virtual bool handle();
+  };
+  class ElementsCommandLineQuery : public Dialog::ElementsQuery {
+  public:
+    ElementsCommandLineQuery(std::string title, std::string _description = "");
+    virtual ~ElementsCommandLineQuery();
     virtual bool handle();
   };

src/UIElements/CommandLineUI/CommandLineUIFactory.hpp

-              r06f4ef6
+              rb6da28
 #include "UIFactory.hpp"
+/** This class is a specialization of the UIFactory.
+ *
+ * <h2> Introduction </h2>
+ *
+ * The UIFactory is a base class for the User Interaction. There are three UI specializations:
+ * Text, GUI and CommandLine.
+ *
+ * The idea of the command line part is as follows:
+ *
+ * All actions that can be called from the command line are instantiated via populater-functions.
+ * In the constructor of an action it is automatically registered with the ActionRegistry and can
+ * henceforth be looked up there.
+ *
+ * There is a CommandLineParser which parses the command line parameters and puts all found values
+ * into a map. Then, MainWindow::Display of the CommandLineUIFactory is called, which goes through
+ * every action (by the ActionRegistry) and looks through the parsed commands whether the action is
+ * desired.
+ *
+ * In the action itself, Query's ask for user input. In the CommandLine case, we don't want direct
+ * user interaction, but the user has to have those values already delivered along with the desired
+ * action. Hence, the Query implementations just look up the desired values in the CommandLineParser
+ * vaults. When they are not found, an exception is thrown. When all are found, the action is performed.
+ *
+ */
 class CommandLineUIFactory : public UIFactory
+{

src/UIElements/CommandLineUI/CommandLineWindow.cpp

-              r06f4ef6
+              rb6da28
 #include "CommandLineUI/CommandLineStatusIndicator.hpp"
+#include "Actions/Action.hpp"
+#include "Actions/MapOfActions.hpp"
 #include "Actions/ActionRegistry.hpp"
+#include "Actions/AnalysisAction/MolecularVolumeAction.hpp"
+#include "Actions/AnalysisAction/PairCorrelationAction.hpp"
+#include "Actions/AnalysisAction/PrincipalAxisSystemAction.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/SaveAdjacencyAction.hpp"
+#include "Actions/MoleculeAction/SaveBondsAction.hpp"
+#include "Actions/MoleculeAction/SaveTemperatureAction.hpp"
+#include "Actions/MoleculeAction/TranslateAction.hpp"
+#include "Actions/MoleculeAction/VerletIntegrationAction.hpp"
+#include "Actions/ParserAction/LoadXyzAction.hpp"
+#include "Actions/ParserAction/SaveXyzAction.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/RemoveSphereOfAtomsAction.hpp"
+#include "Actions/WorldAction/RepeatBoxAction.hpp"
+#include "Actions/WorldAction/ScaleBoxAction.hpp"
+#include "Actions/WorldAction/SetDefaultNameAction.hpp"
+#include "Actions/WorldAction/SetGaussianBasisAction.hpp"
 #include "CommandLineParser.hpp"
 …
+{
   // create and register all command line callable actions
+  populateAnalysisActions();
+  populateAtomActions();
+  populateCmdActions();
+  populateFragmentationActions();
+  populateMoleculeActions();
+  populateParserActions();
+  populateTesselationActions();
+  populateWorldActions();
+  MapOfActions::getInstance().populateActions();
   // Add status indicators etc...
 …
 void CommandLineWindow::display() {
+  //cout << ActionRegistry::getInstance();
   // go through all possible actions
   for (std::list<std::string>::iterator CommandRunner = CommandLineParser::getInstance().SequenceOfActions.begin(); CommandRunner != CommandLineParser::getInstance().SequenceOfActions.end(); ++CommandRunner) {
+    cout << "Checking presence of " << *CommandRunner << endl;
+    if (ActionRegistry::getInstance().isActionByNamePresent(*CommandRunner))
+    cout << "Checking presence of " << *CommandRunner << ": ";
+    if (ActionRegistry::getInstance().isActionPresentByName(*CommandRunner)) {
+      cout << "calling " << *CommandRunner << endl;
       ActionRegistry::getInstance().getActionByName(*CommandRunner)->call();
+    } else {
+      cout << "absent." << endl;
+    }
+  }
+}
-void CommandLineWindow::populateAnalysisActions()
+{
-  new AnalysisMolecularVolumeAction();
-  new AnalysisPairCorrelationAction();
-  new AnalysisPrincipalAxisSystemAction();
+}
-void CommandLineWindow::populateAtomActions()
+{
-  new AtomAddAction();
-  new AtomChangeElementAction();
-  new AtomRemoveAction();
+}
-void CommandLineWindow::populateCmdActions()
+{
-  new CommandLineBondLengthTableAction();
-  new CommandLineElementDbAction();
-  new CommandLineFastParsingAction();
-  new CommandLineHelpAction();
-  new CommandLineVerboseAction();
-  new CommandLineVersionAction();
+}
-void CommandLineWindow::populateFragmentationActions()
+{
-  new FragmentationDepthFirstSearchAction();
-  new FragmentationFragmentationAction();
-  new FragmentationSubgraphDissectionAction();
+}
-void CommandLineWindow::populateMoleculeActions()
+{
-  new MoleculeBondFileAction();
-  new MoleculeChangeNameAction();
-  new MoleculeFillWithMoleculeAction();
-  new MoleculeLinearInterpolationofTrajectoriesAction();
-  new MoleculeSaveAdjacencyAction();
-  new MoleculeSaveBondsAction();
-  new MoleculeSaveTemperatureAction();
-  new MoleculeTranslateAction();
-  new MoleculeVerletIntegrationAction();
+}
-void CommandLineWindow::populateParserActions()
+{
-  new ParserLoadXyzAction();
-  new ParserSaveXyzAction();
+}
-void CommandLineWindow::populateTesselationActions()
+{
-  new TesselationConvexEnvelopeAction();
-  new TesselationNonConvexEnvelopeAction();
+}
-void CommandLineWindow::populateWorldActions()
+{
-  new WorldAddEmptyBoundaryAction();
-  new WorldBoundInBoxAction();
-  new WorldCenterInBoxAction();
-  new WorldCenterOnEdgeAction();
-  new WorldChangeBoxAction();
-  new WorldRemoveSphereOfAtomsAction();
-  new WorldRepeatBoxAction();
-  new WorldScaleBoxAction();
-  new WorldSetDefaultNameAction();
-  new WorldSetGaussianBasisAction();
+}

src/UIElements/Dialog.cpp

-              r06f4ef6
+              rb6da28
 #include "Helpers/MemDebug.hpp"
-#include <cassert>
 #include "Dialog.hpp"
+#include "ValueStorage.hpp"
+#include "verbose.hpp"
 #include "atom.hpp"
 #include "element.hpp"
 #include "molecule.hpp"
 #include "vector.hpp"
+#include "Matrix.hpp"
+#include "Box.hpp"
 using namespace std;
 …
 bool Dialog::display(){
+  if(checkAll()){
+    setAll();
+    return true;
+  }
+  else{
+    return false;
+  }
+}
+bool Dialog::checkAll(){
   list<Query*>::iterator iter;
   bool retval = true;
 …
+    }
+  }
-  if (retval){
-    // if all queries succeeded we can set the targets to appropriate values
-    for(iter=queries.begin(); iter!=queries.end(); iter++) {
-      (*iter)->setResult();
+    }
+  }
   return retval;
+}
+void Dialog::setAll(){
+  list<Query*>::iterator iter;
+  for(iter=queries.begin(); iter!=queries.end(); iter++) {
+    (*iter)->setResult();
+  }
+}
+bool Dialog::hasQueries(){
+  return queries.size();
+}
 …
 // Int Queries
 Dialog::IntQuery::IntQuery(string title,int *_target, std::string description) :
     Query(title, description), target(_target)
+Dialog::IntQuery::IntQuery(string title, std::string description) :
+    Query(title, description)
 {}
 …
 void Dialog::IntQuery::setResult() {
+  *target = tmp;
+}
+// Int Queries
+Dialog::BooleanQuery::BooleanQuery(string title,bool *_target, std::string description) :
+    Query(title, description), target(_target)
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Ints Queries
+Dialog::IntsQuery::IntsQuery(string title, std::string description) :
+    Query(title, description)
+{}
+Dialog::IntsQuery::~IntsQuery() {}
+void Dialog::IntsQuery::setResult() {
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Bool Queries
+Dialog::BooleanQuery::BooleanQuery(string title,std::string description) :
+    Query(title, description)
 {}
 …
 void Dialog::BooleanQuery::setResult() {
   *target = tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // String Queries
 Dialog::StringQuery::StringQuery(string title,string *_target, std::string _description) :
     Query(title, _description), target(_target)
+Dialog::StringQuery::StringQuery(string title,std::string _description) :
+    Query(title, _description)
 {}
 …
 void Dialog::StringQuery::setResult() {
+  *target = tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Strings Queries
+Dialog::StringsQuery::StringsQuery(string title,std::string _description) :
+    Query(title, _description)
+{}
+Dialog::StringsQuery::~StringsQuery() {};
+void Dialog::StringsQuery::setResult() {
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // Double Queries
 Dialog::DoubleQuery::DoubleQuery(string title,double *_target, std::string _description) :
     Query(title, _description), target(_target)
+Dialog::DoubleQuery::DoubleQuery(string title, std::string _description) :
+    Query(title, _description)
 {}
 …
 void Dialog::DoubleQuery::setResult() {
+  *target = tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Doubles Queries
+Dialog::DoublesQuery::DoublesQuery(string title, std::string _description) :
+    Query(title, _description)
+{}
+Dialog::DoublesQuery::~DoublesQuery() {};
+void Dialog::DoublesQuery::setResult() {
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 …
 // Atom Queries
 Dialog::AtomQuery::AtomQuery(string title, atom **_target, std::string _description) :
+Dialog::AtomQuery::AtomQuery(string title, std::string _description) :
     Query(title, _description),
+    tmp(0),
+    target(_target)
+    tmp(0)
 {}
 …
 void Dialog::AtomQuery::setResult() {
+  *target = tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Atoms Queries
+Dialog::AtomsQuery::AtomsQuery(string title, std::string _description) :
+    Query(title, _description),
+    tmp(0)
+{}
+Dialog::AtomsQuery::~AtomsQuery() {}
+void Dialog::AtomsQuery::setResult() {
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // Molecule Queries
 Dialog::MoleculeQuery::MoleculeQuery(string title, molecule **_target, std::string _description) :
+Dialog::MoleculeQuery::MoleculeQuery(string title, std::string _description) :
     Query(title, _description),
+    tmp(0),
+    target(_target)
+    tmp(0)
 {}
 …
 void Dialog::MoleculeQuery::setResult() {
+  *target = tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Molecules Queries
+Dialog::MoleculesQuery::MoleculesQuery(string title, std::string _description) :
+    Query(title, _description),
+    tmp(0)
+{}
+Dialog::MoleculesQuery::~MoleculesQuery() {}
+void Dialog::MoleculesQuery::setResult() {
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // Vector Queries
 Dialog::VectorQuery::VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check, std::string _description) :
+Dialog::VectorQuery::VectorQuery(std::string title,bool _check, std::string _description) :
   Query(title, _description),
+  cellSize(_cellSize),
+  check(_check),
+  target(_target)
+{
+  tmp = new Vector();
+}
+  check(_check)
+{}
 Dialog::VectorQuery::~VectorQuery()
+{
+  delete tmp;
+}
+{}
 void Dialog::VectorQuery::setResult() {
+  *target = *tmp;
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Vectors Queries
+Dialog::VectorsQuery::VectorsQuery(std::string title,bool _check, std::string _description) :
+  Query(title, _description),
+  check(_check)
+{}
+Dialog::VectorsQuery::~VectorsQuery()
+{}
+void Dialog::VectorsQuery::setResult() {
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // Box Queries
+Dialog::BoxQuery::BoxQuery(std::string title, double ** const _cellSize, std::string _description) :
+  Query(title, _description),
+  target(_cellSize)
+{
+    tmp = new double[6];
+}
+Dialog::BoxQuery::BoxQuery(std::string title, std::string _description) :
+  Query(title, _description)
+{}
 Dialog::BoxQuery::~BoxQuery()
+{
+  delete[] tmp;
+}
+{}
 void Dialog::BoxQuery::setResult() {
+  for (int i=0;i<6;i++) {
+    (*target)[i] = tmp[i];
+  }
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
 // Element Queries
+Dialog::ElementQuery::ElementQuery(std::string title, std::vector<element *> *_target, std::string _description) :
+  Query(title, _description),
+  target(_target)
+Dialog::ElementQuery::ElementQuery(std::string title, std::string _description) :
+  Query(title, _description)
   {}
 …
 void Dialog::ElementQuery::setResult(){
+  *target=elements;
+}
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}
+// Elements Queries
+Dialog::ElementsQuery::ElementsQuery(std::string title, std::string _description) :
+  Query(title, _description)
+  {}
+Dialog::ElementsQuery::~ElementsQuery(){}
+void Dialog::ElementsQuery::setResult(){
+  ValueStorage::getInstance().setCurrentValue(title.c_str(), tmp);
+}

src/UIElements/Dialog.hpp

-              r06f4ef6
+              rb6da28
 #include<vector>
+#include "Box.hpp"
+#include "vector.hpp"
 class atom;
+class Box;
 class element;
 class molecule;
+class Vector;
+/** Dialog is one of the two main classes of the UIFactory base class.
+ *
+ * The Dialog is meant for asking the user for information needed to perform actions he
+ * desires, such as asking for a position in space or a length.
+ *
+ * For this purpose there is the base class Query and numerous specializations for each
+ * of the types to be asked. There are primitives integer, doubles and string, but also
+ * advanced types such as element, molecule or Vector. There is also an empty query for
+ * displaying text.
+ */
 class Dialog
+{
 …
   virtual void queryEmpty(const char *, std::string = "")=0;
+  virtual void queryBoolean(const char *, bool *, std::string = "")=0;
+  virtual void queryInt(const char *, int *, std::string = "")=0;
+  virtual void queryDouble(const char*,double *, std::string = "")=0;
+  virtual void queryString(const char*, std::string *, std::string = "")=0;
+  virtual void queryAtom(const char*,atom**,std::string = "")=0;
+  virtual void queryMolecule(const char*,molecule**, std::string = "")=0;
+  virtual void queryVector(const char*,Vector *,const double *const,bool, std::string = "")=0;
+  virtual void queryBox(const char*,double ** const, std::string = "")=0;
+  virtual void queryElement(const char*, std::vector<element *> *, std::string = "")=0;
+  virtual void queryBoolean(const char *, std::string = "")=0;
+  virtual void queryInt(const char *, std::string = "")=0;
+  virtual void queryInts(const char *, std::string = "")=0;
+  virtual void queryDouble(const char*, std::string = "")=0;
+  virtual void queryDoubles(const char*, std::string = "")=0;
+  virtual void queryString(const char*, std::string = "")=0;
+  virtual void queryStrings(const char*, std::string = "")=0;
+  virtual void queryAtom(const char*,std::string = "")=0;
+  virtual void queryAtoms(const char*,std::string = "")=0;
+  virtual void queryMolecule(const char*, std::string = "")=0;
+  virtual void queryMolecules(const char*, std::string = "")=0;
+  virtual void queryVector(const char*,bool, std::string = "")=0;
+  virtual void queryVectors(const char*,bool, std::string = "")=0;
+  virtual void queryBox(const char*, std::string = "")=0;
+  virtual void queryElement(const char*, std::string = "")=0;
+  virtual void queryElements(const char*, std::string = "")=0;
   virtual bool display();
+  virtual bool checkAll();
+  virtual void setAll();
+  virtual bool hasQueries();
 protected:
 …
   class BooleanQuery : public Query {
   public:
     BooleanQuery(std::string title,bool *_target, std::string _description = "");
+    BooleanQuery(std::string title, std::string _description = "");
     virtual ~BooleanQuery();
     virtual bool handle()=0;
 …
   protected:
     bool tmp;
-  private:
-    bool *target;
   };
   class IntQuery : public Query {
   public:
     IntQuery(std::string title,int *_target, std::string _description = "");
+    IntQuery(std::string title, std::string _description = "");
     virtual ~IntQuery();
     virtual bool handle()=0;
 …
   protected:
     int tmp;
+  private:
+    int *target;
+  };
+  class IntsQuery : public Query {
+  public:
+    IntsQuery(std::string title, std::string _description = "");
+    virtual ~IntsQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    int temp;
+    std::vector<int> tmp;
   };
   class DoubleQuery : public Query {
   public:
     DoubleQuery(std::string title,double *_target, std::string _description = "");
+    DoubleQuery(std::string title, std::string _description = "");
     virtual ~DoubleQuery();
     virtual bool handle()=0;
 …
   protected:
     double tmp;
+  private:
+    double *target;
+  };
+  class DoublesQuery : public Query {
+  public:
+    DoublesQuery(std::string title, std::string _description = "");
+    virtual ~DoublesQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    double temp;
+    std::vector<double> tmp;
   };
   class StringQuery : public Query {
   public:
     StringQuery(std::string title,std::string *_target, std::string _description = "");
+    StringQuery(std::string title, std::string _description = "");
     virtual ~StringQuery();
     virtual bool handle()=0;
 …
   protected:
     std::string tmp;
+  private:
+    std::string *target;
+  };
+  class StringsQuery : public Query {
+  public:
+    StringsQuery(std::string title, std::string _description = "");
+    virtual ~StringsQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    std::string temp;
+    std::vector<std::string> tmp;
   };
   class MoleculeQuery : public Query {
   public:
     MoleculeQuery(std::string title, molecule **_target, std::string _description = "");
+    MoleculeQuery(std::string title, std::string _description = "");
     virtual ~MoleculeQuery();
     virtual bool handle()=0;
 …
   protected:
     molecule *tmp;
+  private:
+    molecule **target;
+  };
+  class MoleculesQuery : public Query {
+  public:
+    MoleculesQuery(std::string title, std::string _description = "");
+    virtual ~MoleculesQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    molecule * temp;
+    std::vector<molecule *> tmp;
   };
   class AtomQuery : public Query {
   public:
     AtomQuery(std::string title, atom **_target, std::string _description = "");
+    AtomQuery(std::string title, std::string _description = "");
     virtual ~AtomQuery();
     virtual bool handle()=0;
 …
   protected:
     atom *tmp;
+  private:
+    atom **target;
+  };
+  class AtomsQuery : public Query {
+  public:
+    AtomsQuery(std::string title, std::string _description = "");
+    virtual ~AtomsQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    atom *temp;
+    std::vector<atom *> tmp;
   };
   class VectorQuery : public Query {
   public:
       VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check, std::string _description = "");
+      VectorQuery(std::string title,bool _check, std::string _description = "");
       virtual ~VectorQuery();
       virtual bool handle()=0;
       virtual void setResult();
     protected:
+      Vector *tmp;
+      const double *const cellSize;
+      Vector tmp;
       bool check;
+    private:
+      Vector *target;
+  };
+  class VectorsQuery : public Query {
+  public:
+      VectorsQuery(std::string title,bool _check, std::string _description = "");
+      virtual ~VectorsQuery();
+      virtual bool handle()=0;
+      virtual void setResult();
+    protected:
+      Vector temp;
+      std::vector<Vector> tmp;
+      bool check;
   };
   class BoxQuery : public Query {
   public:
       BoxQuery(std::string title,double ** const _cellSize, std::string _description = "");
+      BoxQuery(std::string title, std::string _description = "");
       virtual ~BoxQuery();
       virtual bool handle()=0;
       virtual void setResult();
     protected:
+      double *tmp;
+    private:
+      double **target;
+      Box tmp;
   };
   class ElementQuery : public Query {
   public:
     ElementQuery(std::string title, std::vector<element *> *_target, std::string _description = "");
+    ElementQuery(std::string title, std::string _description = "");
     virtual ~ElementQuery();
     virtual bool handle()=0;
     virtual void setResult();
   protected:
+    std::vector<element *> elements;
+  private:
+    std::vector<element *> * const target;
+    element * tmp;
+  };
+  class ElementsQuery : public Query {
+  public:
+    ElementsQuery(std::string title, std::string _description = "");
+    virtual ~ElementsQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    element *temp;
+    std::vector<element *> tmp;
   };

src/UIElements/MainWindow.cpp

-              r06f4ef6
+              rb6da28
 MainWindow::MainWindow()
+{
+  // TODO Auto-generated constructor stub
+}
+{}
 MainWindow::~MainWindow()
+{
+  // TODO Auto-generated destructor stub
+}
+{}

src/UIElements/Makefile.am

-              r06f4ef6
+              rb6da28
   Dialog.cpp \
   MainWindow.cpp \
   UIFactory.cpp
+  ValueStorage.cpp
 UIHEADER = \
 …
   Dialog.hpp \
   MainWindow.hpp \
   UIFactory.hpp
+  ValueStorage.hpp
 TEXTUISOURCE = \
 …
   CommandLineUI/CommandLineWindow.hpp
+unity.cpp:
+        echo "" >  unity.cpp; \
+        list='$(UISOURCE)'; for file in $$list; do \
+          echo "#include \"$(srcdir)/$$file\"" >> unity.cpp; \
+        done;
+MOSTLYCLEANFILES = unity.cpp

src/UIElements/Menu/TextMenu.cpp

-              r06f4ef6
+              rb6da28
+}
+Dialog* TextMenu::LeaveAction::fillDialog(Dialog *dialog){
+  ASSERT(dialog,"No Dialog given when filling action dialog");
+  return dialog;
+}
 Action::state_ptr TextMenu::LeaveAction::performCall(){
   menu->doQuit();

src/UIElements/Menu/TextMenu.hpp

r06f4ef6	rb6da28
35	35	bool shouldUndo();
36	36
	37	protected:
	38	virtual Dialog* fillDialog(Dialog *dialog);
37	39	private:
38	40	virtual Action::state_ptr performCall();

src/UIElements/TextUI/TextDialog.cpp

-              r06f4ef6
+              rb6da28
 #include <Descriptors/MoleculeDescriptor.hpp>
 #include <Descriptors/MoleculeIdDescriptor.hpp>
+#include <boost/lexical_cast.hpp>
 #include "TextUI/TextDialog.hpp"
 …
 #include "molecule.hpp"
 #include "vector.hpp"
+#include "Matrix.hpp"
+#include "Box.hpp"
+#include <boost/lexical_cast.hpp>
 using namespace std;
+using boost::lexical_cast;
+using boost::bad_lexical_cast;
 …
+}
+void TextDialog::queryBoolean(const char* title, bool* target, string description){
+  registerQuery(new BooleanTextQuery(title,target,description));
+}
+void TextDialog::queryInt(const char* title, int* target, string description){
+  registerQuery(new IntTextQuery(title,target,description));
+}
+void TextDialog::queryDouble(const char* title, double* target, string description){
+  registerQuery(new DoubleTextQuery(title,target,description));
+}
+void TextDialog::queryString(const char* title, string* target, string description){
+  registerQuery(new StringTextQuery(title,target,description));
+}
+void TextDialog::queryAtom(const char* title, atom **target, string description) {
+  registerQuery(new AtomTextQuery(title,target,description));
+}
+void TextDialog::queryMolecule(const char* title, molecule **target, string description) {
+  registerQuery(new MoleculeTextQuery(title,target,description));
+}
+void TextDialog::queryVector(const char* title, Vector *target,const double *const cellSize, bool check, string description) {
+  registerQuery(new VectorTextQuery(title,target,cellSize,check,description));
+}
+void TextDialog::queryBox(const char* title,double ** const cellSize, string description) {
+  registerQuery(new BoxTextQuery(title,cellSize,description));
+}
+void TextDialog::queryElement(const char* title, std::vector<element *> *target, string description){
+  registerQuery(new ElementTextQuery(title,target,description));
+void TextDialog::queryBoolean(const char* title, string description){
+  registerQuery(new BooleanTextQuery(title,description));
+}
+void TextDialog::queryInt(const char* title, string description){
+  registerQuery(new IntTextQuery(title,description));
+}
+void TextDialog::queryInts(const char* title, string description){
+  registerQuery(new IntsTextQuery(title,description));
+}
+void TextDialog::queryDouble(const char* title, string description){
+  registerQuery(new DoubleTextQuery(title,description));
+}
+void TextDialog::queryDoubles(const char* title, string description){
+  registerQuery(new DoublesTextQuery(title,description));
+}
+void TextDialog::queryString(const char* title, string description){
+  registerQuery(new StringTextQuery(title,description));
+}
+void TextDialog::queryStrings(const char* title, string description){
+  registerQuery(new StringsTextQuery(title,description));
+}
+void TextDialog::queryAtom(const char* title, string description) {
+  registerQuery(new AtomTextQuery(title,description));
+}
+void TextDialog::queryAtoms(const char* title, string description) {
+  registerQuery(new AtomsTextQuery(title,description));
+}
+void TextDialog::queryMolecule(const char* title, string description) {
+  registerQuery(new MoleculeTextQuery(title,description));
+}
+void TextDialog::queryMolecules(const char* title, string description) {
+  registerQuery(new MoleculesTextQuery(title,description));
+}
+void TextDialog::queryVector(const char* title, bool check, string description) {
+  registerQuery(new VectorTextQuery(title,check,description));
+}
+void TextDialog::queryVectors(const char* title, bool check, string description) {
+  registerQuery(new VectorsTextQuery(title,check,description));
+}
+void TextDialog::queryBox(const char* title, string description) {
+  registerQuery(new BoxTextQuery(title,description));
+}
+void TextDialog::queryElement(const char* title, string description){
+  registerQuery(new ElementTextQuery(title,description));
+}
+void TextDialog::queryElements(const char* title, string description){
+  registerQuery(new ElementsTextQuery(title,description));
+}
 …
+}
 TextDialog::IntTextQuery::IntTextQuery(string title, int * _target, std::string _description) :
     Dialog::IntQuery(title,_target,_description)
+TextDialog::IntTextQuery::IntTextQuery(string title, std::string _description) :
+    Dialog::IntQuery(title,_description)
 {}
 …
+}
+TextDialog::BooleanTextQuery::BooleanTextQuery(string title, bool * _target, std::string _description) :
+    Dialog::BooleanQuery(title,_target,_description)
+TextDialog::IntsTextQuery::IntsTextQuery(string title, std::string _description) :
+    Dialog::IntsQuery(title,_description)
+{}
+TextDialog::IntsTextQuery::~IntsTextQuery() {}
+bool TextDialog::IntsTextQuery::handle() {
+  Log() << Verbose(0) << getTitle();
+  std::string line;
+  getline(cin,line);
+  // dissect by " "
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); iter != line.end(); ++iter) {
+    if (*iter == ' ') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> temp;
+      tmp.push_back(temp);
+      olditer = iter;
+    }
+  }
+  if (olditer != line.begin()) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> temp;
+    tmp.push_back(temp);
+  }
+  return true;
+}
+TextDialog::BooleanTextQuery::BooleanTextQuery(string title, std::string _description) :
+    Dialog::BooleanQuery(title,_description)
 {}
 …
+}
 TextDialog::StringTextQuery::StringTextQuery(string title,string *_target, std::string _description) :
     Dialog::StringQuery(title,_target,_description)
+TextDialog::StringTextQuery::StringTextQuery(string title, std::string _description) :
+    Dialog::StringQuery(title,_description)
 {}
 …
+}
+TextDialog::DoubleTextQuery::DoubleTextQuery(string title,double *_target, std::string _description) :
+    Dialog::DoubleQuery(title,_target,_description)
+TextDialog::StringsTextQuery::StringsTextQuery(string title, std::string _description) :
+    Dialog::StringsQuery(title,_description)
+{}
+TextDialog::StringsTextQuery::~StringsTextQuery() {}
+bool TextDialog::StringsTextQuery::handle() {
+  Log() << Verbose(0) << getTitle();
+  getline(cin,temp);
+  // dissect by " "
+  string::iterator olditer = temp.begin();
+  for(string::iterator iter = temp.begin(); iter != temp.end(); ++iter) {
+    if (*iter == ' ') {
+      tmp.push_back(string(iter, olditer));
+      olditer = iter;
+    }
+  }
+  if (olditer != temp.begin())  // insert last part also
+    tmp.push_back(string(olditer, temp.end()));
+  return true;
+}
+TextDialog::DoubleTextQuery::DoubleTextQuery(string title, std::string _description) :
+    Dialog::DoubleQuery(title,_description)
 {}
 …
+}
+TextDialog::AtomTextQuery::AtomTextQuery(string title, atom **_target, std::string _description) :
+    Dialog::AtomQuery(title,_target,_description)
+TextDialog::DoublesTextQuery::DoublesTextQuery(string title, std::string _description) :
+    Dialog::DoublesQuery(title,_description)
+{}
+TextDialog::DoublesTextQuery::~DoublesTextQuery() {}
+bool TextDialog::DoublesTextQuery::handle() {
+  Log() << Verbose(0) << getTitle();
+  std::string line;
+  getline(cin,line);
+  // dissect by " "
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); iter != line.end(); ++iter) {
+    if (*iter == ' ') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> temp;
+      tmp.push_back(temp);
+      olditer = iter;
+    }
+  }
+  if (olditer != line.begin()) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> temp;
+    tmp.push_back(temp);
+  }
+  return true;
+}
+TextDialog::AtomTextQuery::AtomTextQuery(string title, std::string _description) :
+    Dialog::AtomQuery(title,_description)
 {}
 …
 bool TextDialog::AtomTextQuery::handle() {
   int idxOfAtom=0;
+  int idxOfAtom=-1;
   bool badInput = false;
   do{
 …
     tmp = World::getInstance().getAtom(AtomById(idxOfAtom));
     if(!tmp && idxOfAtom!=-1){
       Log() << Verbose(0) << "Invalid Atom Index" << endl;
+      Log() << Verbose(0) << "Invalid Atom Index" << idxOfAtom << endl;
       badInput = true;
+    }
 …
+}
+TextDialog::MoleculeTextQuery::MoleculeTextQuery(string title, molecule **_target, std::string _description) :
+    Dialog::MoleculeQuery(title,_target,_description)
+TextDialog::AtomsTextQuery::AtomsTextQuery(string title, std::string _description) :
+    Dialog::AtomsQuery(title,_description)
+{}
+TextDialog::AtomsTextQuery::~AtomsTextQuery() {}
+bool TextDialog::AtomsTextQuery::handle() {
+  int idxOfAtom=-1;
+  Log() << Verbose(0) << getTitle();
+  std::string line;
+  getline(cin,line);
+  // dissect by " "
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); iter != line.end(); ++iter) {
+    if (*iter == ' ') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> idxOfAtom;
+      temp = World::getInstance().getAtom(AtomById(idxOfAtom));
+      if(!temp && idxOfAtom!=-1){
+        Log() << Verbose(0) << "Invalid Atom Index" << idxOfAtom << endl;
+        break;
+      }
+      tmp.push_back(temp);
+      olditer = iter;
+    }
+  }
+  if (olditer != line.begin()) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> idxOfAtom;
+    temp = World::getInstance().getAtom(AtomById(idxOfAtom));
+    if(!temp && idxOfAtom!=-1) {
+      Log() << Verbose(0) << "Invalid Atom Index" << idxOfAtom << endl;
+      tmp.push_back(temp);
+    }
+  }
+  return (idxOfAtom!=-1);
+}
+TextDialog::MoleculeTextQuery::MoleculeTextQuery(string title, std::string _description) :
+    Dialog::MoleculeQuery(title,_description)
 {}
 …
+}
+TextDialog::VectorTextQuery::VectorTextQuery(std::string title, Vector *_target, const double *const _cellSize, bool _check, std::string _description) :
+    Dialog::VectorQuery(title,_target,_cellSize,_check,_description)
+TextDialog::MoleculesTextQuery::MoleculesTextQuery(string title, std::string _description) :
+    Dialog::MoleculesQuery(title,_description)
+{}
+TextDialog::MoleculesTextQuery::~MoleculesTextQuery() {}
+bool TextDialog::MoleculesTextQuery::handle() {
+  int idxOfMol=-1;
+  Log() << Verbose(0) << getTitle();
+  std::string line;
+  getline(cin,line);
+  // dissect by " "
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); iter != line.end(); ++iter) {
+    if (*iter == ' ') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> idxOfMol;
+      temp = World::getInstance().getMolecule(MoleculeById(idxOfMol));
+      if(!temp && idxOfMol!=-1){
+        Log() << Verbose(0) << "Invalid Molecule Index" << idxOfMol << endl;
+        break;
+      }
+      tmp.push_back(temp);
+      olditer = iter;
+    }
+  }
+  if (olditer != line.begin()) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> idxOfMol;
+    temp = World::getInstance().getMolecule(MoleculeById(idxOfMol));
+    if(!temp && idxOfMol!=-1){
+      Log() << Verbose(0) << "Invalid Molecule Index" << idxOfMol << endl;
+      tmp.push_back(temp);
+    }
+  }
+  return (idxOfMol!=-1);
+}
+TextDialog::VectorTextQuery::VectorTextQuery(std::string title, bool _check, std::string _description) :
+    Dialog::VectorQuery(title,_check,_description)
 {}
 …
 bool TextDialog::VectorTextQuery::handle() {
+  Log() << Verbose(0) << getTitle();
+  char coords[3] = {'x','y','z'};
+  int j = -1;
+  for (int i=0;i<3;i++) {
+    j += i+1;
+    do {
+      Log() << Verbose(0) << coords[i] << "[0.." << cellSize[j] << "]: ";
+      cin >> (*tmp)[i];
+    } while ((((*tmp)[i] < 0) || ((*tmp)[i] >= cellSize[j])) && (check));
+  }
+  return true;
+}
+TextDialog::BoxTextQuery::BoxTextQuery(std::string title, double ** const _cellSize, std::string _description) :
+    Dialog::BoxQuery(title,_cellSize,_description)
+  std::cout << getTitle();
+  const Matrix &M = World::getInstance().getDomain().getM();
+  char coords[3] = {'x', 'y', 'z'};
+  for (int i=0;i<3;i++)
+    std::cout << coords[i] << "[0.." << M.at(i,i) << ( (i!=2) ? "], " : "]: ");
+  std::string line;
+  getline(cin,line);
+  // dissect by ","
+  double coord = 0.;
+  int counter = 0;
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); (iter != line.end()) && (counter != 3); ++iter) {
+    if (*iter == ',') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> coord;
+      tmp[counter++] = coord;
+      olditer = iter;
+    }
+  }
+  if ((olditer != line.begin()) && (counter != 3)) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> coord;
+    tmp[counter++] = coord;
+  }
+  // check vector
+  return World::getInstance().getDomain().isInside(tmp);
+}
+TextDialog::VectorsTextQuery::VectorsTextQuery(std::string title, bool _check, std::string _description) :
+    Dialog::VectorsQuery(title,_check,_description)
+{}
+TextDialog::VectorsTextQuery::~VectorsTextQuery()
+{}
+bool TextDialog::VectorsTextQuery::handle() {
+  std::cout << getTitle();
+  char coords[3] = {'x', 'y', 'z'};
+  const Matrix &M = World::getInstance().getDomain().getM();
+  for (int i=0;i<3;i++)
+    std::cout << coords[i] << "[0.." << M.at(i,i) << ( (i!=2) ? "], " : "]: ");
+  std::string line;
+  getline(cin,line);
+  // dissect by ","
+  double coord = 0.;
+  string::iterator olditerspace = line.begin();
+  string::iterator olditercomma = line.begin();
+  int counter = 0;
+  for(string::iterator vectoriter = line.begin(); vectoriter != line.end(); ++vectoriter) {
+    if (*vectoriter == ',')
+      counter++;
+    if ((*vectoriter == ' ') && (counter == 2)) {
+      counter = 0;
+      for(string::iterator componentiter = olditerspace; (componentiter != vectoriter) && (counter !=3); ++componentiter) {
+        if (*componentiter == ',') {
+          std::istringstream stream(string(componentiter, olditercomma));
+          stream >> coord;
+          temp[counter++] = coord;
+          olditercomma = componentiter;
+        }
+      }
+      if ((olditercomma != line.begin()) && (counter != 3)) { // insert last part also
+        std::istringstream stream(string(olditercomma, vectoriter));
+        stream >> coord;
+        temp[counter++] = coord;
+      }
+      if (World::getInstance().getDomain().isInside(temp))
+        tmp.push_back(temp);
+      olditerspace = vectoriter;
+    }
+  }
+  return true;
+}
+TextDialog::BoxTextQuery::BoxTextQuery(std::string title, std::string _description) :
+    Dialog::BoxQuery(title,_description)
 {}
 …
   Log() << Verbose(0) << getTitle();
+  std::string coords[6] = {"xx","xy","xz", "yy", "yz", "zz"};
+  double temp[6];
+  std::string coords[6] = {"xx","yx","yy", "zx", "zy", "zz"};
   for (int i=0;i<6;i++) {
     Log() << Verbose(0) << coords[i] << ": ";
+    cin >> tmp[i];
+  }
+  return true;
+}
+TextDialog::ElementTextQuery::ElementTextQuery(std::string title, std::vector<element *> *_target, std::string _description) :
+    Dialog::ElementQuery(title,_target,_description)
+    cin >> temp[i];
+  }
+  Matrix M;
+  M.set(0,0, temp[0]);
+  M.set(0,1, temp[1]);
+  M.set(0,2, temp[2]);
+  M.set(1,0, temp[1]);
+  M.set(1,1, temp[3]);
+  M.set(1,2, temp[4]);
+  M.set(2,0, temp[2]);
+  M.set(2,1, temp[4]);
+  M.set(2,2, temp[5]);
+  tmp.setM(M);
+  return true;
+}
+TextDialog::ElementTextQuery::ElementTextQuery(std::string title, std::string _description) :
+    Dialog::ElementQuery(title,_description)
 {}
 …
   bool badInput=false;
   bool aborted = false;
   element * tmp = NULL;
+  element * temp = NULL;
   do{
     badInput = false;
 …
+      }
       else{
         tmp = World::getInstance().getPeriode()->FindElement(Z);
         if(!tmp){
+        temp = World::getInstance().getPeriode()->FindElement(Z);
+        if(!temp){
           Log() << Verbose(0) << "No element with this atomic number!" << endl;
           badInput = true;
-        } else {
-          elements.push_back(tmp);
+        }
+      }
 …
+      }
       else{
         tmp = World::getInstance().getPeriode()->FindElement(shorthand.c_str());
         if(!tmp){
+        temp = World::getInstance().getPeriode()->FindElement(shorthand.c_str());
+        if(!temp){
           Log() << Verbose(0) << "No element with this shorthand!" << endl;
           badInput = true;
-        } else {
-          elements.push_back(tmp);
+        }
+      }
 …
   return !aborted;
+}
+TextDialog::ElementsTextQuery::ElementsTextQuery(std::string title, std::string _description) :
+    Dialog::ElementsQuery(title,_description)
+{}
+TextDialog::ElementsTextQuery::~ElementsTextQuery()
+{}
+bool TextDialog::ElementsTextQuery::handle() {
+  std::string shorthand;
+  int Z=-1;
+  Log() << Verbose(0) << getTitle();
+  std::string line;
+  getline(cin,line);
+  // dissect by " "
+  string::iterator olditer = line.begin();
+  for(string::iterator iter = line.begin(); iter != line.end(); ++iter) {
+    if (*iter == ' ') {
+      std::istringstream stream(string(iter, olditer));
+      stream >> shorthand;
+      try {
+        Z = lexical_cast<int>(shorthand);
+        temp = World::getInstance().getPeriode()->FindElement(Z);
+      } catch (bad_lexical_cast) {
+        temp = World::getInstance().getPeriode()->FindElement(shorthand.c_str());
+      };
+      if(!temp && Z!=-1){
+        Log() << Verbose(0) << "Invalid Element" << shorthand << endl;
+        break;
+      }
+      tmp.push_back(temp);
+      olditer = iter;
+    }
+  }
+  if (olditer != line.begin()) { // insert last part also
+    std::istringstream stream(string(olditer, line.end()));
+    stream >> shorthand;
+    try {
+      Z = lexical_cast<int>(shorthand);
+      temp = World::getInstance().getPeriode()->FindElement(Z);
+    } catch (bad_lexical_cast) {
+      temp = World::getInstance().getPeriode()->FindElement(shorthand.c_str());
+    };
+    if(!temp && Z!=-1) {
+      Log() << Verbose(0) << "Invalid Element" << shorthand << endl;
+      tmp.push_back(temp);
+    }
+  }
+  return (Z!=-1);
+}

src/UIElements/TextUI/TextDialog.hpp

-              r06f4ef6
+              rb6da28
   virtual void queryEmpty(const char *, std::string = "");
+  virtual void queryBoolean(const char *, bool *, std::string = "");
+  virtual void queryInt(const char *, int *, std::string = "");
+  virtual void queryString(const char*, std::string *, std::string = "");
+  virtual void queryDouble(const char*, double*, std::string = "");
+  virtual void queryAtom(const char*,atom**,std::string = "");
+  virtual void queryMolecule(const char*,molecule**,std::string = "");
+  virtual void queryVector(const char*,Vector *,const double * const,bool, std::string = "");
+  virtual void queryBox(const char*,double ** const, std::string = "");
+  virtual void queryElement(const char*, std::vector<element *> *, std::string = "");
+  virtual void queryBoolean(const char *, std::string = "");
+  virtual void queryInt(const char *, std::string = "");
+  virtual void queryInts(const char *, std::string = "");
+  virtual void queryString(const char*, std::string = "");
+  virtual void queryStrings(const char*, std::string = "");
+  virtual void queryDouble(const char*, std::string = "");
+  virtual void queryDoubles(const char*, std::string = "");
+  virtual void queryAtom(const char*,std::string = "");
+  virtual void queryAtoms(const char*,std::string = "");
+  virtual void queryMolecule(const char*,std::string = "");
+  virtual void queryMolecules(const char*,std::string = "");
+  virtual void queryVector(const char*,bool, std::string = "");
+  virtual void queryVectors(const char*,bool, std::string = "");
+  virtual void queryBox(const char*, std::string = "");
+  virtual void queryElement(const char*, std::string = "");
+  virtual void queryElements(const char*, std::string = "");
 protected:
 …
   class BooleanTextQuery : public Dialog::BooleanQuery {
   public:
     BooleanTextQuery(std::string title, bool *_target, std::string _description = NULL);
+    BooleanTextQuery(std::string title, std::string _description = NULL);
     virtual ~BooleanTextQuery();
     virtual bool handle();
 …
   class IntTextQuery : public Dialog::IntQuery {
   public:
     IntTextQuery(std::string title, int *_target, std::string _description = NULL);
+    IntTextQuery(std::string title, std::string _description = NULL);
     virtual ~IntTextQuery();
+    virtual bool handle();
+  };
+  class IntsTextQuery : public Dialog::IntsQuery {
+  public:
+    IntsTextQuery(std::string title, std::string _description = NULL);
+    virtual ~IntsTextQuery();
     virtual bool handle();
   };
 …
   class DoubleTextQuery : public Dialog::DoubleQuery {
   public:
     DoubleTextQuery(std::string title, double *_target, std::string _description = NULL);
+    DoubleTextQuery(std::string title, std::string _description = NULL);
     virtual ~DoubleTextQuery();
+    virtual bool handle();
+  };
+  class DoublesTextQuery : public Dialog::DoublesQuery {
+  public:
+    DoublesTextQuery(std::string title, std::string _description = NULL);
+    virtual ~DoublesTextQuery();
     virtual bool handle();
   };
 …
   class StringTextQuery : public Dialog::StringQuery {
   public:
     StringTextQuery(std::string title, std::string *_target, std::string _description = NULL);
+    StringTextQuery(std::string title, std::string _description = NULL);
     virtual ~StringTextQuery();
+    virtual bool handle();
+  };
+  class StringsTextQuery : public Dialog::StringsQuery {
+  public:
+    StringsTextQuery(std::string title, std::string _description = NULL);
+    virtual ~StringsTextQuery();
     virtual bool handle();
   };
 …
   class AtomTextQuery : public Dialog::AtomQuery {
   public:
     AtomTextQuery(std::string title, atom **_target, std::string _description = NULL);
+    AtomTextQuery(std::string title, std::string _description = NULL);
     virtual ~AtomTextQuery();
+    virtual bool handle();
+  };
+  class AtomsTextQuery : public Dialog::AtomsQuery {
+  public:
+    AtomsTextQuery(std::string title, std::string _description = NULL);
+    virtual ~AtomsTextQuery();
     virtual bool handle();
   };
 …
   class MoleculeTextQuery : public Dialog::MoleculeQuery {
   public:
     MoleculeTextQuery(std::string title, molecule **_target, std::string _description = NULL);
+    MoleculeTextQuery(std::string title, std::string _description = NULL);
     virtual ~MoleculeTextQuery();
+    virtual bool handle();
+  };
+  class MoleculesTextQuery : public Dialog::MoleculesQuery {
+  public:
+    MoleculesTextQuery(std::string title, std::string _description = NULL);
+    virtual ~MoleculesTextQuery();
     virtual bool handle();
   };
 …
   class VectorTextQuery : public Dialog::VectorQuery {
   public:
     VectorTextQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check, std::string _description = NULL);
+    VectorTextQuery(std::string title,bool _check, std::string _description = NULL);
     virtual ~VectorTextQuery();
+    virtual bool handle();
+  };
+  class VectorsTextQuery : public Dialog::VectorsQuery {
+  public:
+    VectorsTextQuery(std::string title,bool _check, std::string _description = NULL);
+    virtual ~VectorsTextQuery();
     virtual bool handle();
   };
 …
   class BoxTextQuery : public Dialog::BoxQuery {
   public:
     BoxTextQuery(std::string title,double ** const _cellSize, std::string _description = NULL);
+    BoxTextQuery(std::string title, std::string _description = NULL);
     virtual ~BoxTextQuery();
     virtual bool handle();
 …
   class ElementTextQuery : public Dialog::ElementQuery {
   public:
     ElementTextQuery(std::string title, std::vector<element *> *_target, std::string _description = NULL);
+    ElementTextQuery(std::string title, std::string _description = NULL);
     virtual ~ElementTextQuery();
+    virtual bool handle();
+  };
+  class ElementsTextQuery : public Dialog::ElementsQuery {
+  public:
+    ElementsTextQuery(std::string title, std::string _description = NULL);
+    virtual ~ElementsTextQuery();
     virtual bool handle();
   };

src/UIElements/TextUI/TextUIFactory.cpp

r06f4ef6	rb6da28
9	9	#include "UIElements/TextUI/TextWindow.hpp"
10	10	#include "UIElements/TextUI/TextDialog.hpp"
11
12	11
13	12	TextUIFactory::TextUIFactory()

src/UIElements/TextUI/TextUIFactory.hpp

r06f4ef6	rb6da28
13	13	class TextUIFactory : public UIFactory
14	14	{
15		friend class UIFactory;
	15	friend class UIFactory;
16	16
17	17	public:

src/UIElements/TextUI/TextWindow.cpp

-              r06f4ef6
+              rb6da28
 #include "Helpers/MemDebug.hpp"
-#include "TextUI/TextWindow.hpp"
 #include <boost/bind.hpp>
-// TODO: When done with refactoring most of these wont be needed anymore
-#include "analysis_correlation.hpp"
-#include "atom.hpp"
-#include "bond.hpp"
-#include "bondgraph.hpp"
-#include "boundary.hpp"
-#include "config.hpp"
-#include "element.hpp"
-#include "ellipsoid.hpp"
-#include "helpers.hpp"
-#include "leastsquaremin.hpp"
-#include "linkedcell.hpp"
-#include "log.hpp"
-#include "memoryusageobserver.hpp"
-#include "molecule.hpp"
-#include "periodentafel.hpp"
-#include "World.hpp"
-#include "Legacy/oldmenu.hpp"
 #include "Menu/Menu.hpp"
 …
 #include "Menu/SubMenuItem.hpp"
 #include "TextUI/TextStatusIndicator.hpp"
+#include "TextUI/TextWindow.hpp"
+#include "Actions/MapOfActions.hpp"
 #include "Actions/MethodAction.hpp"
-#include "Actions/MoleculeAction/ChangeNameAction.hpp"
 #include "Actions/ErrorAction.hpp"
 #include "Actions/ActionRegistry.hpp"
+#include "Parser/ChangeTracker.hpp"
 #include "Views/StreamStringView.hpp"
 #include "Views/MethodStringView.hpp"
+#include "defs.hpp"
+#include "log.hpp"
+#include "verbose.hpp"
+// all needed due to config::SaveAll()
+#include "config.hpp"
+#include "periodentafel.hpp"
+// config::SaveAll() and enumerate()
+#include "molecule.hpp"
 #include <iostream>
+using namespace std;
+#include <map>
 // TODO: see what code can be moved to a base class for Graphic and Text Windows
 TextWindow::TextWindow()
+{
+  MoleculeListClass *molecules = World::getInstance().getMolecules();
+  config *configuration = World::getInstance().getConfig();
+  periodentafel *periode = World::getInstance().getPeriode();
+  char *ConfigFileName = NULL;
+  old_menu = new oldmenu;
+  map <std::string, TextMenu *> NametoTextMenuMap;
+  // populate all actions
+  MapOfActions::getInstance().populateActions();
   // build the main menu
   main_menu = new TextMenu(Log() << Verbose(0), "Main Menu");
   moleculeView = new StreamStringView(boost::bind(&MoleculeListClass::Enumerate,molecules,_1));
+  moleculeView = new StreamStringView(boost::bind(&MoleculeListClass::Enumerate,World::getInstance().getMolecules(),_1));
   new DisplayMenuItem(main_menu,moleculeView,"Molecule List");
 …
   new SeperatorItem(main_menu);
   Action *setMoleculeAction = new MethodAction("setMoleculeAction",boost::bind(&MoleculeListClass::flipChosen,molecules));
+  Action *setMoleculeAction = new MethodAction("setMoleculeAction",boost::bind(&MoleculeListClass::flipChosen,World::getInstance().getMolecules()));
   new ActionMenuItem('a',"set molecule (in)active",main_menu,setMoleculeAction);
+  TextMenu *editMoleculesMenu = new TextMenu(Log() << Verbose(0), "Edit Molecules");
+  new SubMenuItem('e',"edit molecules (load, parse, save)",main_menu,editMoleculesMenu);
+  Action *manipulateMoleculeAction = new MethodAction("manipulateMoleculeAction",boost::bind(&oldmenu::ManipulateMolecules,old_menu,periode, molecules, configuration));
+  new ActionMenuItem('g',"globally manipulate atoms in molecule",main_menu,manipulateMoleculeAction);
+  Action *mergeMoleculeAction = new MethodAction("mergeMoleculeAction",boost::bind(&oldmenu::MergeMolecules,old_menu,periode, molecules));
+  new ActionMenuItem('M',"Merge molecules",main_menu,mergeMoleculeAction);
+  Action *manipulateAtomsAction = new MethodAction("manipulateAtomsAction",boost::bind(&oldmenu::ManipulateAtoms,old_menu,periode, molecules, configuration));
+  new ActionMenuItem('m',"manipulate atoms",main_menu,manipulateAtomsAction);
+  TextMenu *Menu = NULL;
+  std::set <char> ShortcutList;
+  for(map<std::string, pair<std::string,std::string> >::iterator iter = MapOfActions::getInstance().MenuDescription.begin(); iter != MapOfActions::getInstance().MenuDescription.end(); ++iter) {
+    Menu = new TextMenu(Log() << Verbose(0), iter->second.second);
+    NametoTextMenuMap.insert( pair <std::string, TextMenu *> (iter->first, Menu) );
+    new SubMenuItem(getSuitableShortForm(ShortcutList,iter->first),iter->second.first.c_str(),main_menu,Menu);
+  }
   new SeperatorItem(main_menu);
+  Action *editConfigAction = new MethodAction("editConfigAction",boost::bind(&config::Edit,configuration));
+  new ActionMenuItem('c',"edit the current configuration",main_menu,editConfigAction);
+  new SeperatorItem(main_menu);
+  Action *saveConfigAction = new MethodAction("saveConfigAction",boost::bind(&config::SaveAll,configuration, ConfigFileName, periode, molecules));
+  new ActionMenuItem('s',"save current setup to config file",main_menu,saveConfigAction);
+  Action *doTestAction = new MethodAction("doTestAction",boost::bind(&oldmenu::testroutine,old_menu,molecules));
+  new ActionMenuItem('T',"call the current test routine",main_menu,doTestAction);
+  Action *saveConfigAction = ActionRegistry::getInstance().getActionByName("output");
+  new ActionMenuItem('s',"save current setup to config files",main_menu,saveConfigAction);
   quitAction = new MethodAction("quitAction",boost::bind(&TextMenu::doQuit,main_menu),false);
   new ActionMenuItem('q',"quit",main_menu,quitAction);
+  // call all functions used to build the submenus
+  populateEditMoleculesMenu(editMoleculesMenu);
+  Action *returnFromEditMoleculeAction = new TextMenu::LeaveAction(editMoleculesMenu);
+  MenuItem *returnItem = new ActionMenuItem('q',"return to Main menu",editMoleculesMenu,returnFromEditMoleculeAction);
+  editMoleculesMenu->addDefault(returnItem);
+  // go through all menus and create them
+  for (map <std::string, TextMenu *>::iterator MenuRunner = NametoTextMenuMap.begin(); MenuRunner != NametoTextMenuMap.end(); ++MenuRunner) {
+    cout << "Creating Menu " << MenuRunner->first << "." << endl;
+    populateMenu(MenuRunner->second, MenuRunner->first);
+  }
   // Add status indicators etc...
 …
 TextWindow::~TextWindow()
+{
-  delete old_menu;
   delete quitAction;
   delete moleculeView;
 …
+}
+void TextWindow::populateEditMoleculesMenu(Menu* editMoleculesMenu)
+char TextWindow::getSuitableShortForm(std::set <char> &ShortcutList, const std::string name) const
+{
+  MoleculeListClass *molecules = World::getInstance().getMolecules();
+  periodentafel *periode = World::getInstance().getPeriode();
+  for (std::string::const_iterator CharRunner = name.begin(); CharRunner != name.end(); ++CharRunner) {
+    if (ShortcutList.find(*CharRunner) == ShortcutList.end())
+      return *CharRunner;
+  }
+  DoeLog(1) && (eLog() << Verbose(1) << "Could not find a suitable shortform for TextWindow::getSuitableShortForm()." << endl);
+  return ((char)(ShortcutList.size() % 10) + '0');
+}
+  // build the EditMoleculesMenu
+  Action *createMoleculeAction = new MethodAction("createMoleculeAction",boost::bind(&MoleculeListClass::createNewMolecule,molecules,periode));
+  new ActionMenuItem('c',"create new molecule",editMoleculesMenu,createMoleculeAction);
+  Action *loadMoleculeAction = new MethodAction("loadMoleculeAction",boost::bind(&MoleculeListClass::loadFromXYZ,molecules,periode));
+  new ActionMenuItem('l',"load molecule from xyz file",editMoleculesMenu,loadMoleculeAction);
+  Action *changeFilenameAction = new MoleculeChangeNameAction();
+  new ActionMenuItem('n',"change molecule's name",editMoleculesMenu,changeFilenameAction);
+  Action *giveFilenameAction = new MethodAction("giveFilenameAction",boost::bind(&MoleculeListClass::setMoleculeFilename,molecules));
+  new ActionMenuItem('N',"give molecules filename",editMoleculesMenu,giveFilenameAction);
+  Action *parseAtomsAction = new MethodAction("parseAtomsAction",boost::bind(&MoleculeListClass::parseXYZIntoMolecule,molecules));
+  new ActionMenuItem('p',"parse atoms in xyz file into molecule",editMoleculesMenu,parseAtomsAction);
+  Action *eraseMoleculeAction = new MethodAction("eraseMoleculeAction",boost::bind(&MoleculeListClass::eraseMolecule,molecules));
+  new ActionMenuItem('r',"remove a molecule",editMoleculesMenu,eraseMoleculeAction);
+void TextWindow::populateMenu(TextMenu* Menu, const  std::string &MenuName)
+{
+  Action *ActionItem = NULL;
+  set <char> ShortcutList;
+  // through all actions for this menu
+  pair < multimap <std::string, std::string>::iterator, multimap <std::string, std::string>::iterator > MenuActions = MapOfActions::getInstance().MenuContainsActionMap.equal_range(MenuName);
+  for (multimap <std::string, std::string>::const_iterator MenuRunner = MenuActions.first; MenuRunner != MenuActions.second; ++MenuRunner) {
+    cout << " Adding " << MenuRunner->second << " to submenu " << MenuName << endl;
+    ActionItem = ActionRegistry::getInstance().getActionByName(MenuRunner->second);
+    new ActionMenuItem(getSuitableShortForm(ShortcutList, MenuRunner->second),MapOfActions::getInstance().getDescription(MenuRunner->second).c_str(),Menu,ActionItem);
+  }
+  // finally add default quit item
+  Action *returnFromAction = new TextMenu::LeaveAction(Menu);
+  MenuItem *returnFromItem = new ActionMenuItem('q',"return to Main menu",Menu,returnFromAction);
+  Menu->addDefault(returnFromItem);
+}

src/UIElements/TextUI/TextWindow.hpp

-              r06f4ef6
+              rb6da28
 #include "MainWindow.hpp"
+#include <string>
+#include <set>
 class TextMenu;
 class Action;
-class oldmenu;
 class StringView;
 class TextStatusIndicator;
 …
   virtual void display();
 private:
   // populaters
+  void populateEditMoleculesMenu(Menu* editMoleculesMenu);
+  char getSuitableShortForm(std::set <char> &ShortcutList, const std::string name) const;
+  void populateMenu(TextMenu* Menu, const std::string &name);
   TextMenu *main_menu;
 …
   StringView *moleculeView;
   TextStatusIndicator *statusIndicator;
-  // This class still contains a lot of scattered functionality
-  oldmenu *old_menu;
 };

src/UIElements/UIFactory.cpp

r06f4ef6	rb6da28
12	12	#include "UIElements/UIFactory.hpp"
13	13	#include "Helpers/Assert.hpp"
	14	#include "Helpers/MemDebug.hpp"
14	15
15	16	using namespace std;

src/UIElements/UIFactory.hpp

-              r06f4ef6
+              rb6da28
  * only create UIelements of that certain type, so that all UIElements match. This way different
  * UIs can be handled in a concise abstract way.
+ *
+ * The main functionality is the MainWindow and the Dialog.
+ *
+ * MainWindow basically is the framework if the UI. The MainWindow has a run function which is
+ * called MainWindow::Display(), which will listen for user input and react to it via actions for
+ * as long as the user desires or tells the MainWindow to quit.
+ *
+ * Within the MainWindow Dialog classes may be instantiated which ask the user for input to
+ * certain actions he wants to perform.
+ *
  */
 class UIFactory : public Singleton<UIFactory,false>
 …
   friend class Singleton<UIFactory,false>;
 public:
   /**
    * Produce some kind of main window, of whichever type was chosen when the factory was created

src/UIElements/Views/StreamStringView.hpp

r06f4ef6	rb6da28
10	10
11	11	#include <boost/function.hpp>
12		#include <ios~~tream~~>
	12	#include <iosfwd>
13	13
14	14	#include "Views/StringView.hpp"

src/VectorSet.hpp

-              r06f4ef6
+              rb6da28
 #include <functional>
 #include <algorithm>
+#include <limits>
 /**
 …
  */
+class Vector;
+#include "vector.hpp"
+#include <list>
 // this tests, whether we actually have a Vector
 …
   void translate(const Vector &translater){
     // this is needed to allow template lookup
+    transform(this->begin(),this->end(),this->begin(),bind1st(plus<Vector>(),translater));
+    transform(this->begin(),this->end(),this->begin(),std::bind1st(std::plus<Vector>(),translater));
+  }
+  double minDistSquared(const Vector &point){
+    if(!this->size())
+      return std::numeric_limits<double>::infinity();
+    std::list<double> helper;
+    helper.resize(this->size());
+    transform(this->begin(),this->end(),
+              helper.begin(),
+              std::bind2nd(std::mem_fun_ref(&Vector::DistanceSquared),point));
+    return *min_element(helper.begin(),helper.end());
+  }
 };
+// allows simpler definition of VectorSets
+#define VECTORSET(container_type) VectorSet<container_type<Vector> >
 #endif /* VECTORSET_HPP_ */

src/World.cpp

-              r06f4ef6
+              rb6da28
 #include "World.hpp"
+#include <functional>
 #include "atom.hpp"
 #include "config.hpp"
 #include "molecule.hpp"
 #include "periodentafel.hpp"
+#include "ThermoStatContainer.hpp"
 #include "Descriptors/AtomDescriptor.hpp"
 #include "Descriptors/AtomDescriptor_impl.hpp"
 …
 #include "Descriptors/SelectiveIterator_impl.hpp"
 #include "Actions/ManipulateAtomsProcess.hpp"
+#include "Helpers/Assert.hpp"
+#include "Box.hpp"
+#include "Matrix.hpp"
+#include "defs.hpp"
 #include "Patterns/Singleton_impl.hpp"
+#include "Patterns/ObservedContainer_impl.hpp"
 using namespace std;
+const unsigned int MAX_POOL_FRAGMENTATION=20;
+const unsigned int MAX_FRAGMENTATION_SKIPS=100;
 /******************************* getter and setter ************************/
 …
+}
 vector<atom*> World::getAllAtoms(AtomDescriptor descriptor){
+World::AtomComposite World::getAllAtoms(AtomDescriptor descriptor){
   return descriptor.findAll();
+}
 vector<atom*> World::getAllAtoms(){
+World::AtomComposite World::getAllAtoms(){
   return getAllAtoms(AllAtoms());
+}
 …
 // system
+double * World::getDomain() {
+  return cell_size;
+Box& World::getDomain() {
+  return *cell_size;
+}
+void World::setDomain(const Matrix &mat){
+  OBSERVE;
+  *cell_size = mat;
+}
 void World::setDomain(double * matrix)
+{
+  OBSERVE;
+  Matrix M = ReturnFullMatrixforSymmetric(matrix);
+  cell_size->setM(M);
+}
 …
 void World::setDefaultName(std::string name)
+{
+  OBSERVE;
   defaultName = name;
 };
+class ThermoStatContainer * World::getThermostats()
+{
+  return Thermostats;
+}
 int World::getExitFlag() {
 …
   molecule *mol = NULL;
   mol = NewMolecule();
+  assert(!molecules.count(currMoleculeId));
+  mol->setId(currMoleculeId++);
+  moleculeId_t id = getNextMoleculeId();
+  ASSERT(!molecules.count(id),"proposed id did not specify an unused ID");
+  mol->setId(id);
   // store the molecule by ID
   molecules[mol->getId()] = mol;
 …
   OBSERVE;
   molecule *mol = molecules[id];
   assert(mol);
+  ASSERT(mol,"Molecule id that was meant to be destroyed did not exist");
   DeleteMolecule(mol);
   molecules.erase(id);
+}
+double *World::cell_size = NULL;
+  releaseMoleculeId(id);
+}
 atom *World::createAtom(){
   OBSERVE;
   atomId_t id = getNextAtomId();
+  ASSERT(!atoms.count(id),"proposed id did not specify an unused ID");
   atom *res = NewAtom(id);
   res->setWorld(this);
 …
   OBSERVE;
   atom *atom = atoms[id];
   assert(atom);
+  ASSERT(atom,"Atom ID that was meant to be destroyed did not exist");
   DeleteAtom(atom);
   atoms.erase(id);
 …
   if(!target){
     target = atoms[oldId];
     assert(target && "Atom with that ID not found");
+    ASSERT(target,"Atom with that ID not found");
     return target->changeId(newId);
+  }
 …
 atomId_t World::getNextAtomId(){
+  // see if we can reuse some Id
+  if(atomIdPool.empty()){
+    return currAtomId++;
+  }
+  else{
+    // we give out the first ID from the pool
+    atomId_t id = *(atomIdPool.begin());
+    atomIdPool.erase(id);
+  // try to find an Id in the pool;
+  if(!atomIdPool.empty()){
+    atomIdPool_t::iterator iter=atomIdPool.begin();
+    atomId_t id = iter->first;
+    range<atomId_t> newRange = makeRange(id+1,iter->last);
+    // we wont use this iterator anymore, so we don't care about invalidating
+    atomIdPool.erase(iter);
+    if(newRange.first<newRange.last){
+      atomIdPool.insert(newRange);
+    }
     return id;
+  }
+  // Nothing in the pool... we are out of luck
+  return currAtomId++;
+}
 void World::releaseAtomId(atomId_t id){
+  atomIdPool.insert(id);
+  // defragmentation of the pool
+  set<atomId_t>::reverse_iterator iter;
+  // go through all Ids in the pool that lie immediately below the border
+  while(!atomIdPool.empty() && *(atomIdPool.rbegin())==(currAtomId-1)){
+    atomIdPool.erase(--currAtomId);
+  }
+  atomIdPool.insert(makeRange(id,id+1));
+  defragAtomIdPool();
+}
 bool World::reserveAtomId(atomId_t id){
   if(id>=currAtomId ){
     // add all ids between the new one and current border as available
     for(atomId_t pos=currAtomId; pos<id; ++pos){
       atomIdPool.insert(pos);
+    range<atomId_t> newRange = makeRange(currAtomId,id);
+    if(newRange.first<newRange.last){
+      atomIdPool.insert(newRange);
+    }
     currAtomId=id+1;
+    defragAtomIdPool();
     return true;
+  }
+  else if(atomIdPool.count(id)){
+    atomIdPool.erase(id);
+  // look for a range that matches the request
+  for(atomIdPool_t::iterator iter=atomIdPool.begin();iter!=atomIdPool.end();++iter){
+    if(iter->isBefore(id)){
+      // we have covered all available ranges... nothing to be found here
+      break;
+    }
+    // no need to check first, since it has to be <=id, since otherwise we would have broken out
+    if(!iter->isBeyond(id)){
+      // we found a matching range... get the id from this range
+      // split up this range at the point of id
+      range<atomId_t> bottomRange = makeRange(iter->first,id);
+      range<atomId_t> topRange = makeRange(id+1,iter->last);
+      // remove this range
+      atomIdPool.erase(iter);
+      if(bottomRange.first<bottomRange.last){
+        atomIdPool.insert(bottomRange);
+      }
+      if(topRange.first<topRange.last){
+        atomIdPool.insert(topRange);
+      }
+      defragAtomIdPool();
+      return true;
+    }
+  }
+  // this ID could not be reserved
+  return false;
+}
+void World::defragAtomIdPool(){
+  // check if the situation is bad enough to make defragging neccessary
+  if((numAtomDefragSkips<MAX_FRAGMENTATION_SKIPS) &&
+     (atomIdPool.size()<lastAtomPoolSize+MAX_POOL_FRAGMENTATION)){
+    ++numAtomDefragSkips;
+    return;
+  }
+  for(atomIdPool_t::iterator iter = atomIdPool.begin();iter!=atomIdPool.end();){
+    // see if this range is adjacent to the next one
+    atomIdPool_t::iterator next = iter;
+    next++;
+    if(next!=atomIdPool.end() && (next->first==iter->last)){
+      // merge the two ranges
+      range<atomId_t> newRange = makeRange(iter->first,next->last);
+      atomIdPool.erase(iter);
+      atomIdPool.erase(next);
+      pair<atomIdPool_t::iterator,bool> res = atomIdPool.insert(newRange);
+      ASSERT(res.second,"Id-Pool was confused");
+      iter=res.first;
+      continue;
+    }
+    ++iter;
+  }
+  if(!atomIdPool.empty()){
+    // check if the last range is at the border
+    atomIdPool_t::iterator iter = atomIdPool.end();
+    iter--;
+    if(iter->last==currAtomId){
+      currAtomId=iter->first;
+      atomIdPool.erase(iter);
+    }
+  }
+  lastAtomPoolSize=atomIdPool.size();
+  numAtomDefragSkips=0;
+}
+// Molecules
+moleculeId_t World::getNextMoleculeId(){
+  // try to find an Id in the pool;
+  if(!moleculeIdPool.empty()){
+    moleculeIdPool_t::iterator iter=moleculeIdPool.begin();
+    moleculeId_t id = iter->first;
+    range<moleculeId_t> newRange = makeRange(id+1,iter->last);
+    // we wont use this iterator anymore, so we don't care about invalidating
+    moleculeIdPool.erase(iter);
+    if(newRange.first<newRange.last){
+      moleculeIdPool.insert(newRange);
+    }
+    return id;
+  }
+  // Nothing in the pool... we are out of luck
+  return currMoleculeId++;
+}
+void World::releaseMoleculeId(moleculeId_t id){
+  moleculeIdPool.insert(makeRange(id,id+1));
+  defragMoleculeIdPool();
+}
+bool World::reserveMoleculeId(moleculeId_t id){
+  if(id>=currMoleculeId ){
+    range<moleculeId_t> newRange = makeRange(currMoleculeId,id);
+    if(newRange.first<newRange.last){
+      moleculeIdPool.insert(newRange);
+    }
+    currMoleculeId=id+1;
+    defragMoleculeIdPool();
     return true;
+  }
+  else{
+    // this ID could not be reserved
+    return false;
+  }
+}
+  // look for a range that matches the request
+  for(moleculeIdPool_t::iterator iter=moleculeIdPool.begin();iter!=moleculeIdPool.end();++iter){
+    if(iter->isBefore(id)){
+      // we have coverd all available ranges... nothing to be found here
+      break;
+    }
+    // no need to check first, since it has to be <=id, since otherwise we would have broken out
+    if(!iter->isBeyond(id)){
+      // we found a matching range... get the id from this range
+      // split up this range at the point of id
+      range<moleculeId_t> bottomRange = makeRange(iter->first,id);
+      range<moleculeId_t> topRange = makeRange(id+1,iter->last);
+      // remove this range
+      moleculeIdPool.erase(iter);
+      if(bottomRange.first<bottomRange.last){
+        moleculeIdPool.insert(bottomRange);
+      }
+      if(topRange.first<topRange.last){
+        moleculeIdPool.insert(topRange);
+      }
+      defragMoleculeIdPool();
+      return true;
+    }
+  }
+  // this ID could not be reserved
+  return false;
+}
+void World::defragMoleculeIdPool(){
+  // check if the situation is bad enough to make defragging neccessary
+  if((numMoleculeDefragSkips<MAX_FRAGMENTATION_SKIPS) &&
+     (moleculeIdPool.size()<lastMoleculePoolSize+MAX_POOL_FRAGMENTATION)){
+    ++numMoleculeDefragSkips;
+    return;
+  }
+  for(moleculeIdPool_t::iterator iter = moleculeIdPool.begin();iter!=moleculeIdPool.end();){
+    // see if this range is adjacent to the next one
+    moleculeIdPool_t::iterator next = iter;
+    next++;
+    if(next!=moleculeIdPool.end() && (next->first==iter->last)){
+      // merge the two ranges
+      range<moleculeId_t> newRange = makeRange(iter->first,next->last);
+      moleculeIdPool.erase(iter);
+      moleculeIdPool.erase(next);
+      pair<moleculeIdPool_t::iterator,bool> res = moleculeIdPool.insert(newRange);
+      ASSERT(res.second,"Id-Pool was confused");
+      iter=res.first;
+      continue;
+    }
+    ++iter;
+  }
+  if(!moleculeIdPool.empty()){
+    // check if the last range is at the border
+    moleculeIdPool_t::iterator iter = moleculeIdPool.end();
+    iter--;
+    if(iter->last==currMoleculeId){
+      currMoleculeId=iter->first;
+      moleculeIdPool.erase(iter);
+    }
+  }
+  lastMoleculePoolSize=moleculeIdPool.size();
+  numMoleculeDefragSkips=0;
+}
+/******************************* Iterators ********************************/
+// external parts with observers
+CONSTRUCT_SELECTIVE_ITERATOR(atom*,World::AtomSet,AtomDescriptor);
+World::AtomIterator
+World::getAtomIter(AtomDescriptor descr){
+    return AtomIterator(descr,atoms);
+}
+World::AtomIterator
+World::getAtomIter(){
+    return AtomIterator(AllAtoms(),atoms);
+}
+World::AtomIterator
+World::atomEnd(){
+  return AtomIterator(AllAtoms(),atoms,atoms.end());
+}
+CONSTRUCT_SELECTIVE_ITERATOR(molecule*,World::MoleculeSet,MoleculeDescriptor);
+World::MoleculeIterator
+World::getMoleculeIter(MoleculeDescriptor descr){
+    return MoleculeIterator(descr,molecules);
+}
+World::MoleculeIterator
+World::getMoleculeIter(){
+    return MoleculeIterator(AllMolecules(),molecules);
+}
+World::MoleculeIterator
+World::moleculeEnd(){
+  return MoleculeIterator(AllMolecules(),molecules,molecules.end());
+}
+// Internal parts, without observers
+// Build the AtomIterator from template
+CONSTRUCT_SELECTIVE_ITERATOR(atom*,World::AtomSet::set_t,AtomDescriptor);
+World::internal_AtomIterator
+World::getAtomIter_internal(AtomDescriptor descr){
+  return internal_AtomIterator(descr,atoms.getContent());
+}
+World::internal_AtomIterator
+World::atomEnd_internal(){
+  return internal_AtomIterator(AllAtoms(),atoms.getContent(),atoms.end_internal());
+}
+// build the MoleculeIterator from template
+CONSTRUCT_SELECTIVE_ITERATOR(molecule*,World::MoleculeSet::set_t,MoleculeDescriptor);
+World::internal_MoleculeIterator World::getMoleculeIter_internal(MoleculeDescriptor descr){
+  return internal_MoleculeIterator(descr,molecules.getContent());
+}
+World::internal_MoleculeIterator World::moleculeEnd_internal(){
+  return internal_MoleculeIterator(AllMolecules(),molecules.getContent(),molecules.end_internal());
+}
+/************************** Selection of Atoms and molecules ******************/
+// Atoms
+void World::clearAtomSelection(){
+  selectedAtoms.clear();
+}
+void World::selectAtom(atom *atom){
+  ASSERT(atom,"Invalid pointer in selection of atom");
+  selectedAtoms[atom->getId()]=atom;
+}
+void World::selectAtom(atomId_t id){
+  ASSERT(atoms.count(id),"Atom Id selected that was not in the world");
+  selectedAtoms[id]=atoms[id];
+}
+void World::selectAllAtoms(AtomDescriptor descr){
+  internal_AtomIterator begin = getAtomIter_internal(descr);
+  internal_AtomIterator end = atomEnd_internal();
+  void (World::*func)(atom*) = &World::selectAtom; // needed for type resolution of overloaded function
+  for_each(begin,end,bind1st(mem_fun(func),this)); // func is select... see above
+}
+void World::selectAtomsOfMolecule(molecule *_mol){
+  ASSERT(_mol,"Invalid pointer to molecule in selection of Atoms of Molecule");
+  // need to make it const to get the fast iterators
+  const molecule *mol = _mol;
+  void (World::*func)(atom*) = &World::selectAtom; // needed for type resolution of overloaded function
+  for_each(mol->begin(),mol->end(),bind1st(mem_fun(func),this)); // func is select... see above
+}
+void World::selectAtomsOfMolecule(moleculeId_t id){
+  ASSERT(molecules.count(id),"No molecule with the given id upon Selection of atoms from molecule");
+  selectAtomsOfMolecule(molecules[id]);
+}
+void World::unselectAtom(atom *atom){
+  ASSERT(atom,"Invalid pointer in unselection of atom");
+  unselectAtom(atom->getId());
+}
+void World::unselectAtom(atomId_t id){
+  ASSERT(atoms.count(id),"Atom Id unselected that was not in the world");
+  selectedAtoms.erase(id);
+}
+void World::unselectAllAtoms(AtomDescriptor descr){
+  internal_AtomIterator begin = getAtomIter_internal(descr);
+  internal_AtomIterator end = atomEnd_internal();
+  void (World::*func)(atom*) = &World::unselectAtom; // needed for type resolution of overloaded function
+  for_each(begin,end,bind1st(mem_fun(func),this)); // func is unselect... see above
+}
+void World::unselectAtomsOfMolecule(molecule *_mol){
+  ASSERT(_mol,"Invalid pointer to molecule in selection of Atoms of Molecule");
+  // need to make it const to get the fast iterators
+  const molecule *mol = _mol;
+  void (World::*func)(atom*) = &World::unselectAtom; // needed for type resolution of overloaded function
+  for_each(mol->begin(),mol->end(),bind1st(mem_fun(func),this)); // func is unsselect... see above
+}
+void World::unselectAtomsOfMolecule(moleculeId_t id){
+  ASSERT(molecules.count(id),"No molecule with the given id upon Selection of atoms from molecule");
+  unselectAtomsOfMolecule(molecules[id]);
+}
+size_t World::countSelectedAtoms() const {
+  size_t count = 0;
+  for (AtomSet::const_iterator iter = selectedAtoms.begin(); iter != selectedAtoms.end(); ++iter)
+    count++;
+  return count;
+}
+bool World::isSelected(atom *atom) const {
+  return selectedAtoms.find(atom->getId()) != selectedAtoms.end();
+}
+const std::vector<atom *> World::getSelectedAtoms() const {
+  std::vector<atom *> returnAtoms;
+  returnAtoms.resize(countSelectedAtoms());
+  int count = 0;
+  for (AtomSet::const_iterator iter = selectedAtoms.begin(); iter != selectedAtoms.end(); ++iter)
+    returnAtoms[count++] = iter->second;
+  return returnAtoms;
+}
 // Molecules
+/******************************* Iterators ********************************/
+// Build the AtomIterator from template
+CONSTRUCT_SELECTIVE_ITERATOR(atom*,World::AtomSet,AtomDescriptor);
+World::AtomIterator World::getAtomIter(AtomDescriptor descr){
+  return AtomIterator(descr,atoms);
+}
+World::AtomIterator World::atomEnd(){
+  return AtomIterator(AllAtoms(),atoms,atoms.end());
+}
+// build the MoleculeIterator from template
+CONSTRUCT_SELECTIVE_ITERATOR(molecule*,World::MoleculeSet,MoleculeDescriptor);
+World::MoleculeIterator World::getMoleculeIter(MoleculeDescriptor descr){
+  return MoleculeIterator(descr,molecules);
+}
+World::MoleculeIterator World::moleculeEnd(){
+  return MoleculeIterator(AllMolecules(),molecules,molecules.end());
+void World::clearMoleculeSelection(){
+  selectedMolecules.clear();
+}
+void World::selectMolecule(molecule *mol){
+  ASSERT(mol,"Invalid pointer to molecule in selection");
+  selectedMolecules[mol->getId()]=mol;
+}
+void World::selectMolecule(moleculeId_t id){
+  ASSERT(molecules.count(id),"Molecule Id selected that was not in the world");
+  selectedMolecules[id]=molecules[id];
+}
+void World::selectAllMolecules(MoleculeDescriptor descr){
+  internal_MoleculeIterator begin = getMoleculeIter_internal(descr);
+  internal_MoleculeIterator end = moleculeEnd_internal();
+  void (World::*func)(molecule*) = &World::selectMolecule; // needed for type resolution of overloaded function
+  for_each(begin,end,bind1st(mem_fun(func),this)); // func is select... see above
+}
+void World::selectMoleculeOfAtom(atom *atom){
+  ASSERT(atom,"Invalid atom pointer in selection of MoleculeOfAtom");
+  molecule *mol=atom->getMolecule();
+  // the atom might not be part of a molecule
+  if(mol){
+    selectMolecule(mol);
+  }
+}
+void World::selectMoleculeOfAtom(atomId_t id){
+  ASSERT(atoms.count(id),"No such atom with given ID in selection of Molecules of Atom");\
+  selectMoleculeOfAtom(atoms[id]);
+}
+void World::unselectMolecule(molecule *mol){
+  ASSERT(mol,"invalid pointer in unselection of molecule");
+  unselectMolecule(mol->getId());
+}
+void World::unselectMolecule(moleculeId_t id){
+  ASSERT(molecules.count(id),"No such molecule with ID in unselection");
+  selectedMolecules.erase(id);
+}
+void World::unselectAllMolecules(MoleculeDescriptor descr){
+  internal_MoleculeIterator begin = getMoleculeIter_internal(descr);
+  internal_MoleculeIterator end = moleculeEnd_internal();
+  void (World::*func)(molecule*) = &World::unselectMolecule; // needed for type resolution of overloaded function
+  for_each(begin,end,bind1st(mem_fun(func),this)); // func is unselect... see above
+}
+void World::unselectMoleculeOfAtom(atom *atom){
+  ASSERT(atom,"Invalid atom pointer in selection of MoleculeOfAtom");
+  molecule *mol=atom->getMolecule();
+  // the atom might not be part of a molecule
+  if(mol){
+    unselectMolecule(mol);
+  }
+}
+void World::unselectMoleculeOfAtom(atomId_t id){
+  ASSERT(atoms.count(id),"No such atom with given ID in selection of Molecules of Atom");\
+  unselectMoleculeOfAtom(atoms[id]);
+}
+size_t World::countSelectedMolecules() const {
+  size_t count = 0;
+  for (MoleculeSet::const_iterator iter = selectedMolecules.begin(); iter != selectedMolecules.end(); ++iter)
+    count++;
+  return count;
+}
+bool World::isSelected(molecule *mol) const {
+  return selectedMolecules.find(mol->getId()) != selectedMolecules.end();
+}
+const std::vector<molecule *> World::getSelectedMolecules() const {
+  std::vector<molecule *> returnMolecules;
+  returnMolecules.resize(countSelectedMolecules());
+  int count = 0;
+  for (MoleculeSet::const_iterator iter = selectedMolecules.begin(); iter != selectedMolecules.end(); ++iter)
+    returnMolecules[count++] = iter->second;
+  return returnMolecules;
+}
+/******************* Iterators over Selection *****************************/
+World::AtomSelectionIterator World::beginAtomSelection(){
+  return selectedAtoms.begin();
+}
+World::AtomSelectionIterator World::endAtomSelection(){
+  return selectedAtoms.end();
+}
+World::MoleculeSelectionIterator World::beginMoleculeSelection(){
+  return selectedMolecules.begin();
+}
+World::MoleculeSelectionIterator World::endMoleculeSelection(){
+  return selectedMolecules.end();
+}
 …
     periode(new periodentafel),
     configuration(new config),
+    Thermostats(new ThermoStatContainer),
     ExitFlag(0),
+    atoms(),
+    atoms(this),
+    selectedAtoms(this),
     currAtomId(0),
+    molecules(),
+    lastAtomPoolSize(0),
+    numAtomDefragSkips(0),
+    molecules(this),
+    selectedMolecules(this),
     currMoleculeId(0),
     molecules_deprecated(new MoleculeListClass(this))
+{
+  cell_size = new double[6];
+  cell_size[0] = 20.;
+  cell_size[1] = 0.;
+  cell_size[2] = 20.;
+  cell_size[3] = 0.;
+  cell_size[4] = 0.;
+  cell_size[5] = 20.;
+  cell_size = new Box;
+  Matrix domain;
+  domain.at(0,0) = 20;
+  domain.at(1,1) = 20;
+  domain.at(2,2) = 20;
+  cell_size->setM(domain);
   defaultName = "none";
   molecules_deprecated->signOn(this);
 …
+{
   molecules_deprecated->signOff(this);
   delete[] cell_size;
+  delete cell_size;
   delete molecules_deprecated;
-  delete periode;
-  delete configuration;
   MoleculeSet::iterator molIter;
   for(molIter=molecules.begin();molIter!=molecules.end();++molIter){
 …
+  }
   atoms.clear();
+  delete periode;
+  delete configuration;
+  delete Thermostats;
+}

src/World.hpp

-              r06f4ef6
+              rb6da28
 #include "Patterns/Cacheable.hpp"
 #include "Patterns/Singleton.hpp"
+#include "Patterns/ObservedContainer.hpp"
+#include "Helpers/Range.hpp"
+#include "AtomSet.hpp"
 // include config.h
 …
 // forward declarations
-class config;
-class periodentafel;
-class MoleculeListClass;
 class atom;
-class molecule;
 class AtomDescriptor;
 class AtomDescriptor_impl;
+template<typename T> class AtomsCalculation;
+class Box;
+class config;
+class ManipulateAtomsProcess;
+class Matrix;
+class molecule;
 class MoleculeDescriptor;
 class MoleculeDescriptor_impl;
+class ManipulateAtomsProcess;
+template<typename T>
+class AtomsCalculation;
+class MoleculeListClass;
+class periodentafel;
+class ThermoStatContainer;
 /****************************************** forward declarations *****************************/
 …
 friend class MoleculeDescriptor_impl;
 friend class MoleculeDescriptor;
+// coupling with descriptors over selection
+friend class AtomSelectionDescriptor_impl;
+friend class MoleculeSelectionDescriptor_impl;
 // Actions, calculations etc associated with the World
 …
   // Types for Atom and Molecule structures
+  typedef std::map<atomId_t,atom*> AtomSet;
+  typedef std::map<moleculeId_t,molecule*> MoleculeSet;
+  typedef ObservedContainer<std::map<atomId_t,atom*> > AtomSet;
+  typedef ObservedContainer<std::map<moleculeId_t,molecule*> > MoleculeSet;
+  typedef ATOMSET(std::vector) AtomComposite;
   /***** getter and setter *****/
 …
    * returns a vector containing all atoms that match a given descriptor
    */
   std::vector<atom*> getAllAtoms(AtomDescriptor descriptor);
   std::vector<atom*> getAllAtoms();
+  AtomComposite getAllAtoms(AtomDescriptor descriptor);
+  AtomComposite getAllAtoms();
   /**
 …
    * get the domain size as a symmetric matrix (6 components)
    */
+  double * getDomain();
+  Box& getDomain();
+  /**
+   * Set the domain size from a matrix object
+   *
+   * Matrix needs to be symmetric
+   */
+  void setDomain(const Matrix &mat);
   /**
 …
    */
   void setDefaultName(std::string name);
+  /**
+   * get pointer to World's ThermoStatContainer
+   */
+  ThermoStatContainer * getThermostats();
   /*
 …
   ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string);
+  /****
+   * Iterators to use internal data structures
+   * All these iterators are observed to track changes.
+   * There is a corresponding protected section with unobserved iterators,
+   * which can be used internally when the extra speed is needed
+   */
+  typedef SelectiveIterator<atom*,AtomSet,AtomDescriptor>       AtomIterator;
+  /**
+   * returns an iterator over all Atoms matching a given descriptor.
+   * This iterator is observed, so don't keep it around unnecessary to
+   * avoid unintended blocking.
+   */
+  AtomIterator getAtomIter(AtomDescriptor descr);
+  AtomIterator getAtomIter();
+  AtomIterator atomEnd();
+  typedef SelectiveIterator<molecule*,MoleculeSet,MoleculeDescriptor>   MoleculeIterator;
+  /**
+   * returns an iterator over all Molecules matching a given descriptor.
+   * This iterator is observed, so don't keep it around unnecessary to
+   * avoid unintended blocking.
+   */
+  MoleculeIterator getMoleculeIter(MoleculeDescriptor descr);
+  MoleculeIterator getMoleculeIter();
+  MoleculeIterator moleculeEnd();
+  /******** Selections of molecules and Atoms *************/
+  void clearAtomSelection();
+  void selectAtom(atom*);
+  void selectAtom(atomId_t);
+  void selectAllAtoms(AtomDescriptor);
+  void selectAtomsOfMolecule(molecule*);
+  void selectAtomsOfMolecule(moleculeId_t);
+  void unselectAtom(atom*);
+  void unselectAtom(atomId_t);
+  void unselectAllAtoms(AtomDescriptor);
+  void unselectAtomsOfMolecule(molecule*);
+  void unselectAtomsOfMolecule(moleculeId_t);
+  size_t countSelectedAtoms() const;
+  bool isSelected(atom *_atom) const;
+  const std::vector<atom *> getSelectedAtoms() const;
+  void clearMoleculeSelection();
+  void selectMolecule(molecule*);
+  void selectMolecule(moleculeId_t);
+  void selectAllMolecules(MoleculeDescriptor);
+  void selectMoleculeOfAtom(atom*);
+  void selectMoleculeOfAtom(atomId_t);
+  void unselectMolecule(molecule*);
+  void unselectMolecule(moleculeId_t);
+  void unselectAllMolecules(MoleculeDescriptor);
+  void unselectMoleculeOfAtom(atom*);
+  void unselectMoleculeOfAtom(atomId_t);
+  size_t countSelectedMolecules() const;
+  bool isSelected(molecule *_mol) const;
+  const std::vector<molecule *> getSelectedMolecules() const;
+  /******************** Iterators to selections *****************/
+  typedef AtomSet::iterator AtomSelectionIterator;
+  AtomSelectionIterator beginAtomSelection();
+  AtomSelectionIterator endAtomSelection();
+  typedef MoleculeSet::iterator MoleculeSelectionIterator;
+  MoleculeSelectionIterator beginMoleculeSelection();
+  MoleculeSelectionIterator endMoleculeSelection();
 protected:
+  /**** Iterators to use internal data structures */
+  /****
+   * Iterators to use internal data structures
+   * All these iterators are unobserved for speed reasons.
+   * There is a corresponding public section to these methods,
+   * which produce observed iterators.*/
   // Atoms
   typedef SelectiveIterator<atom*,AtomSet,AtomDescriptor> AtomIterator;
+  typedef SelectiveIterator<atom*,AtomSet::set_t,AtomDescriptor>        internal_AtomIterator;
   /**
 …
    * used for internal purposes, like AtomProcesses and AtomCalculations.
    */
   AtomIterator getAtomIter(AtomDescriptor descr);
+  internal_AtomIterator getAtomIter_internal(AtomDescriptor descr);
   /**
 …
    * used for internal purposes, like AtomProcesses and AtomCalculations.
    */
   AtomIterator atomEnd();
+  internal_AtomIterator atomEnd_internal();
   // Molecules
+  typedef SelectiveIterator<molecule*,MoleculeSet,MoleculeDescriptor> MoleculeIterator;
+  typedef SelectiveIterator<molecule*,MoleculeSet::set_t,MoleculeDescriptor>   internal_MoleculeIterator;
   /**
 …
    * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
    */
   MoleculeIterator getMoleculeIter(MoleculeDescriptor descr);
+  internal_MoleculeIterator getMoleculeIter_internal(MoleculeDescriptor descr);
   /**
 …
    * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
    */
   MoleculeIterator moleculeEnd();
+  internal_MoleculeIterator moleculeEnd_internal();
 …
   void releaseAtomId(atomId_t);
   bool reserveAtomId(atomId_t);
+  void defragAtomIdPool();
+  moleculeId_t getNextMoleculeId();
+  void releaseMoleculeId(moleculeId_t);
+  bool reserveMoleculeId(moleculeId_t);
+  void defragMoleculeIdPool();
   periodentafel *periode;
   config *configuration;
   static double *cell_size;
+  Box *cell_size;
   std::string defaultName;
+  class ThermoStatContainer *Thermostats;
   int ExitFlag;
+public:
+private:
   AtomSet atoms;
+private:
+  std::set<atomId_t> atomIdPool; //<!stores the pool for all available AtomIds below currAtomId
+  AtomSet selectedAtoms;
+  typedef std::set<range<atomId_t> > atomIdPool_t;
+  /**
+   * stores the pool for all available AtomIds below currAtomId
+   *
+   * The pool contains ranges of free ids in the form [bottom,top).
+   */
+  atomIdPool_t atomIdPool;
   atomId_t currAtomId; //!< stores the next available Id for atoms
+  size_t lastAtomPoolSize; //!< size of the pool after last defrag, to skip some defrags
+  unsigned int numAtomDefragSkips;
   MoleculeSet molecules;
+  MoleculeSet selectedMolecules;
+  typedef std::set<range<atomId_t> > moleculeIdPool_t;
+  /**
+   * stores the pool for all available AtomIds below currAtomId
+   *
+   * The pool contains ranges of free ids in the form [bottom,top).
+   */
+  moleculeIdPool_t moleculeIdPool;
   moleculeId_t currMoleculeId;
+  size_t lastMoleculePoolSize; //!< size of the pool after last defrag, to skip some defrags
+  unsigned int numMoleculeDefragSkips;
 private:
   /**

src/analysis_bonds.cpp

-              r06f4ef6
+              rb6da28
 #include "element.hpp"
 #include "info.hpp"
+#include "verbose.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 …
  * \param *molecules molecules to count bonds
  * \param *InterfaceElement or NULL
+ */
+int CountHydrogenBridgeBonds(MoleculeListClass *molecules, const element * InterfaceElement = NULL)
+ * \param *Interface2Element or NULL
+ */
+int CountHydrogenBridgeBonds(MoleculeListClass *molecules, const element * InterfaceElement = NULL, const element * Interface2Element = NULL)
+{
   int count = 0;
 …
   double Otherangle = 0.;
   bool InterfaceFlag = false;
+  bool Interface2Flag = false;
   bool OtherHydrogenFlag = true;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); ++MolWalker) {
 …
               OtherHydrogens = 0;
               InterfaceFlag = (InterfaceElement == NULL);
+              Interface2Flag = (Interface2Element == NULL);
               for (BondList::const_iterator BondRunner = (*Runner)->ListOfBonds.begin(); BondRunner != (*Runner)->ListOfBonds.end(); BondRunner++) {
                 atom * const OtherAtom = (*BondRunner)->GetOtherAtom(*Runner);
 …
+                }
                 InterfaceFlag = InterfaceFlag || (OtherAtom->type == InterfaceElement);
+                Interface2Flag = Interface2Flag || (OtherAtom->type == Interface2Element);
+              }
               DoLog(1) && (Log() << Verbose(1) << "Otherangle is " << Otherangle << " for " << OtherHydrogens << " hydrogens." << endl);
 …
                   break;
+              }
               if (InterfaceFlag && OtherHydrogenFlag) {
+              if (InterfaceFlag && Interface2Flag && OtherHydrogenFlag) {
                 // on this element (Walker) we check for bond to hydrogen, i.e. part of water molecule
                 for (BondList::const_iterator BondRunner = (*Walker)->ListOfBonds.begin(); BondRunner != (*Walker)->ListOfBonds.end(); BondRunner++) {

src/analysis_bonds.hpp

r06f4ef6	rb6da28
33	33	void MinMeanMaxBondDistanceBetweenElements(const molecule mol, const element type1, const element *type2, double &Min, double &Mean, double &Max);
34	34
35		int CountHydrogenBridgeBonds(MoleculeListClass * const molecules, const element * InterfaceElement);
	35	int CountHydrogenBridgeBonds(MoleculeListClass * const molecules, const element * InterfaceElement, const element * Interface2Element);
36	36	int CountBondsOfTwo(MoleculeListClass * const molecules, const element * const first, const element * const second);
37	37	int CountBondsOfThree(MoleculeListClass * const molecules, const element * const first, const element * const second, const element * const third);

src/analysis_correlation.cpp

-              r06f4ef6
+              rb6da28
 #include <iostream>
+#include <iomanip>
 #include "analysis_correlation.hpp"
 …
 #include "triangleintersectionlist.hpp"
 #include "vector.hpp"
+#include "Matrix.hpp"
 #include "verbose.hpp"
 #include "World.hpp"
+#include "Box.hpp"
 /** Calculates the pair correlation between given elements.
  * Note given element order is unimportant (i.e. g(Si, O) === g(O, Si))
  * \param *molecules list of molecules structure
+ * \param *molecules vector of molecules
  * \param &elements vector of elements to correlate
  * \return Map of doubles with values the pair of the two atoms.
  */
 PairCorrelationMap *PairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements)
+PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements)
+{
   Info FunctionInfo(__func__);
   PairCorrelationMap *outmap = NULL;
   double distance = 0.;
   double *domain = World::getInstance().getDomain();
   if (molecules->ListOfMolecules.empty()) {
+  Box &domain = World::getInstance().getDomain();
+  if (molecules.empty()) {
     DoeLog(1) && (eLog()<< Verbose(1) <<"No molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
 …
   outmap = new PairCorrelationMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++){
+    if ((*MolWalker)->ActiveFlag) {
+      DoeLog(2) && (eLog()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      eLog() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++){
+          if ((*MolOtherWalker)->ActiveFlag) {
+            DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+            for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+              DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+              if ((*iter)->getId() < (*runner)->getId()){
+                for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+                  if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
+                    distance = (*iter)->node->PeriodicDistance(*(*runner)->node,  domain);
+                    //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                    outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+                  }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++){
+    DoLog(2) && (Log()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+      for (std::vector<molecule *>::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules.end(); MolOtherWalker++){
+        DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+        for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+          DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+          if ((*iter)->getId() < (*runner)->getId()){
+            for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+              if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
+                distance = domain.periodicDistance(*(*iter)->node,*(*runner)->node);
+                //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+              }
+            }
+          }
+        }
 …
  * \return Map of doubles with values the pair of the two atoms.
  */
 PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const int ranges[NDIM] )
+PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
   Vector periodicOtherX;
   if (molecules->ListOfMolecules.empty()) {
+  if (molecules.empty()) {
     DoeLog(1) && (eLog()<< Verbose(1) <<"No molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
 …
   outmap = new PairCorrelationMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++){
+    if ((*MolWalker)->ActiveFlag) {
+      double * FullMatrix = ReturnFullMatrixforSymmetric(World::getInstance().getDomain());
+      double * FullInverseMatrix = InverseMatrix(FullMatrix);
+      DoeLog(2) && (eLog()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      eLog() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl;
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        periodicX = *(*iter)->node;
+        periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+        // go through every range in xyz and get distance
+        for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+          for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+            for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+              checkX = Vector(n[0], n[1], n[2]) + periodicX;
+              checkX.MatrixMultiplication(FullMatrix);
+              for (MoleculeList::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules->ListOfMolecules.end(); MolOtherWalker++){
+                if ((*MolOtherWalker)->ActiveFlag) {
+                  DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+                  for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+                    DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+                    if ((*iter)->getId() < (*runner)->getId()){
+                      for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+                        if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
+                          periodicOtherX = *(*runner)->node;
+                          periodicOtherX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+                          // go through every range in xyz and get distance
+                          for (Othern[0]=-ranges[0]; Othern[0] <= ranges[0]; Othern[0]++)
+                            for (Othern[1]=-ranges[1]; Othern[1] <= ranges[1]; Othern[1]++)
+                              for (Othern[2]=-ranges[2]; Othern[2] <= ranges[2]; Othern[2]++) {
+                                checkOtherX = Vector(Othern[0], Othern[1], Othern[2]) + periodicOtherX;
+                                checkOtherX.MatrixMultiplication(FullMatrix);
+                                distance = checkX.distance(checkOtherX);
+                                //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+                              }
+                        }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++){
+    Matrix FullMatrix = World::getInstance().getDomain().getM();
+    Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
+    DoLog(2) && (Log()<< Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+      periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
+      // go through every range in xyz and get distance
+      for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+        for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+          for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+            checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
+            for (std::vector<molecule *>::const_iterator MolOtherWalker = MolWalker; MolOtherWalker != molecules.end(); MolOtherWalker++){
+                DoLog(2) && (Log() << Verbose(2) << "Current other molecule is " << *MolOtherWalker << "." << endl);
+                for (molecule::const_iterator runner = (*MolOtherWalker)->begin(); runner != (*MolOtherWalker)->end(); ++runner) {
+                  DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << **runner << "." << endl);
+                  if ((*iter)->getId() < (*runner)->getId()){
+                    for (set <pair<element *, element *> >::iterator PairRunner = PairsOfElements.begin(); PairRunner != PairsOfElements.end(); ++PairRunner)
+                      if ((PairRunner->first == (**iter).type) && (PairRunner->second == (**runner).type)) {
+                        periodicOtherX = FullInverseMatrix * (*(*runner)->node); // x now in [0,1)^3
+                        // go through every range in xyz and get distance
+                        for (Othern[0]=-ranges[0]; Othern[0] <= ranges[0]; Othern[0]++)
+                          for (Othern[1]=-ranges[1]; Othern[1] <= ranges[1]; Othern[1]++)
+                            for (Othern[2]=-ranges[2]; Othern[2] <= ranges[2]; Othern[2]++) {
+                              checkOtherX = FullMatrix * (Vector(Othern[0], Othern[1], Othern[2]) + periodicOtherX);
+                              distance = checkX.distance(checkOtherX);
+                              //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                              outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+                            }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+      }
-      delete[](FullMatrix);
-      delete[](FullInverseMatrix);
+    }
+  }
 …
  * \return Map of dobules with values as pairs of atom and the vector
  */
 CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point )
+CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point )
+{
   Info FunctionInfo(__func__);
   CorrelationToPointMap *outmap = NULL;
   double distance = 0.;
   double *cell_size = World::getInstance().getDomain();
   if (molecules->ListOfMolecules.empty()) {
+  Box &domain = World::getInstance().getDomain();
+  if (molecules.empty()) {
     DoLog(1) && (Log() << Verbose(1) <<"No molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToPointMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            distance = (*iter)->node->PeriodicDistance(*point, cell_size);
+            DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+            outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> ((*iter), point) ) );
+          }
+      }
+    }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++) {
+    DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+      for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+        if ((*type == NULL) || ((*iter)->type == *type)) {
+          distance = domain.periodicDistance(*(*iter)->node,*point);
+          DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+          outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> ((*iter), point) ) );
+        }
+    }
+  }
   return outmap;
 …
  * \return Map of dobules with values as pairs of atom and the vector
  */
 CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] )
+CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
   Vector checkX;
   if (molecules->ListOfMolecules.empty()) {
+  if (molecules.empty()) {
     DoLog(1) && (Log() << Verbose(1) <<"No molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToPointMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      double * FullMatrix = ReturnFullMatrixforSymmetric(World::getInstance().getDomain());
+      double * FullInverseMatrix = InverseMatrix(FullMatrix);
+      DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            periodicX = *(*iter)->node;
+            periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+            // go through every range in xyz and get distance
+            for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+              for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+                for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                  checkX = Vector(n[0], n[1], n[2]) + periodicX;
+                  checkX.MatrixMultiplication(FullMatrix);
+                  distance = checkX.distance(*point);
+                  DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+                  outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (*iter, point) ) );
+                }
+          }
+      }
+      delete[](FullMatrix);
+      delete[](FullInverseMatrix);
+    }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++) {
+    Matrix FullMatrix = World::getInstance().getDomain().getM();
+    Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
+    DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+      for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+        if ((*type == NULL) || ((*iter)->type == *type)) {
+          periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
+          // go through every range in xyz and get distance
+          for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+            for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+              for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
+                distance = checkX.distance(*point);
+                DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+                outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (*iter, point) ) );
+              }
+        }
+    }
+  }
   return outmap;
 …
  * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
  */
 CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
+CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
+{
   Info FunctionInfo(__func__);
 …
   Vector centroid;
   if ((Surface == NULL) || (LC == NULL) || (molecules->ListOfMolecules.empty())) {
+  if ((Surface == NULL) || (LC == NULL) || (molecules.empty())) {
     DoeLog(1) && (eLog()<< Verbose(1) <<"No Tesselation, no LinkedCell or no molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToSurfaceMap;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      DoLog(1) && (Log() << Verbose(1) << "Current molecule is " << (*MolWalker)->name << "." << endl);
+      if ((*MolWalker)->empty())
+        DoLog(1) && (1) && (Log() << Verbose(1) << "\t is empty." << endl);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(1) && (Log() << Verbose(1) << "\tCurrent atom is " << *(*iter) << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            TriangleIntersectionList Intersections((*iter)->node,Surface,LC);
+            distance = Intersections.GetSmallestDistance();
+            triangle = Intersections.GetClosestTriangle();
+            outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> ((*iter), triangle) ) );
+          }
+      }
+    } else {
+      DoLog(1) && (Log() << Verbose(1) << "molecule " << (*MolWalker)->name << " is not active." << endl);
+    }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++) {
+    DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << (*MolWalker)->name << "." << endl);
+    if ((*MolWalker)->empty())
+      DoLog(2) && (2) && (Log() << Verbose(2) << "\t is empty." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "\tCurrent atom is " << *(*iter) << "." << endl);
+      for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+        if ((*type == NULL) || ((*iter)->type == *type)) {
+          TriangleIntersectionList Intersections((*iter)->node,Surface,LC);
+          distance = Intersections.GetSmallestDistance();
+          triangle = Intersections.GetClosestTriangle();
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> ((*iter), triangle) ) );
+        }
+    }
+  }
   return outmap;
 …
  * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
  */
 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
+CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
   Vector checkX;
   if ((Surface == NULL) || (LC == NULL) || (molecules->ListOfMolecules.empty())) {
+  if ((Surface == NULL) || (LC == NULL) || (molecules.empty())) {
     DoLog(1) && (Log() << Verbose(1) <<"No Tesselation, no LinkedCell or no molecule given." << endl);
     return outmap;
+  }
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++)
     (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToSurfaceMap;
   double ShortestDistance = 0.;
   BoundaryTriangleSet *ShortestTriangle = NULL;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    if ((*MolWalker)->ActiveFlag) {
+      double * FullMatrix = ReturnFullMatrixforSymmetric(World::getInstance().getDomain());
+      double * FullInverseMatrix = InverseMatrix(FullMatrix);
+      DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+        for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+          if ((*type == NULL) || ((*iter)->type == *type)) {
+            periodicX = *(*iter)->node;
+            periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
+            // go through every range in xyz and get distance
+            ShortestDistance = -1.;
+            for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+              for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+                for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                  checkX = Vector(n[0], n[1], n[2]) + periodicX;
+                  checkX.MatrixMultiplication(FullMatrix);
+                  TriangleIntersectionList Intersections(&checkX,Surface,LC);
+                  distance = Intersections.GetSmallestDistance();
+                  triangle = Intersections.GetClosestTriangle();
+                  if ((ShortestDistance == -1.) || (distance < ShortestDistance)) {
+                    ShortestDistance = distance;
+                    ShortestTriangle = triangle;
+                  }
+  for (std::vector<molecule *>::const_iterator MolWalker = molecules.begin(); MolWalker != molecules.end(); MolWalker++) {
+    Matrix FullMatrix = World::getInstance().getDomain().getM();
+    Matrix FullInverseMatrix = World::getInstance().getDomain().getMinv();
+    DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      DoLog(3) && (Log() << Verbose(3) << "Current atom is " << **iter << "." << endl);
+      for (vector<element *>::const_iterator type = elements.begin(); type != elements.end(); ++type)
+        if ((*type == NULL) || ((*iter)->type == *type)) {
+          periodicX = FullInverseMatrix * (*(*iter)->node); // x now in [0,1)^3
+          // go through every range in xyz and get distance
+          ShortestDistance = -1.;
+          for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
+            for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
+              for (n[2]=-ranges[2]; n[2] <= ranges[2]; n[2]++) {
+                checkX = FullMatrix * (Vector(n[0], n[1], n[2]) + periodicX);
+                TriangleIntersectionList Intersections(&checkX,Surface,LC);
+                distance = Intersections.GetSmallestDistance();
+                triangle = Intersections.GetClosestTriangle();
+                if ((ShortestDistance == -1.) || (distance < ShortestDistance)) {
+                  ShortestDistance = distance;
+                  ShortestTriangle = triangle;
+                }
+            // insert
+            outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (*iter, ShortestTriangle) ) );
+            //Log() << Verbose(1) << "INFO: Inserting " << Walker << " with distance " << ShortestDistance << " to " << *ShortestTriangle << "." << endl;
+          }
+      }
+      delete[](FullMatrix);
+      delete[](FullInverseMatrix);
+    }
+              }
+          // insert
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (*iter, ShortestTriangle) ) );
+          //Log() << Verbose(1) << "INFO: Inserting " << Walker << " with distance " << ShortestDistance << " to " << *ShortestTriangle << "." << endl;
+        }
+    }
+  }
   return outmap;

src/analysis_correlation.hpp

-              r06f4ef6
+              rb6da28
 // STL headers
 #include <map>
+#include <vector>
 #include "defs.hpp"
 #include "atom.hpp"
+#include "verbose.hpp"
 /****************************************** forward declarations *****************************/
 …
 class element;
 class LinkedCell;
-class MoleculeListClass;
 class Tesselation;
 class Vector;
 …
 /********************************************** declarations *******************************/
 PairCorrelationMap *PairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements);
 CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point );
 CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC );
 PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const int ranges[NDIM] );
 CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] );
 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
+PairCorrelationMap *PairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements);
+CorrelationToPointMap *CorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point );
+CorrelationToSurfaceMap *CorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC );
+PairCorrelationMap *PeriodicPairCorrelation(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const int ranges[NDIM] );
+CorrelationToPointMap *PeriodicCorrelationToPoint(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] );
+CorrelationToSurfaceMap *PeriodicCorrelationToSurface(std::vector<molecule *> &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
 int GetBin ( const double value, const double BinWidth, const double BinStart );
 void OutputCorrelation( ofstream * const file, const BinPairMap * const map );

src/analyzer.cpp

-              r06f4ef6
+              rb6da28
 #include "datacreator.hpp"
 #include "helpers.hpp"
-#include "memoryallocator.hpp"
 #include "parser.hpp"
 #include "periodentafel.hpp"
+#include "verbose.hpp"
 // include config.h

src/atom.cpp

-              r06f4ef6
+              rb6da28
 #include "element.hpp"
 #include "lists.hpp"
-#include "memoryallocator.hpp"
 #include "parser.hpp"
 #include "vector.hpp"
 #include "World.hpp"
 #include "molecule.hpp"
+#include "Shapes/Shape.hpp"
+#include <iomanip>
+#include <iostream>
 /************************************* Functions for class atom *************************************/
 …
 };
+bool atom::isFather(const atom *ptr){
+  return ptr==father;
+}
 /** Checks whether atom is within the given box.
  * \param offset offset to box origin
 …
  * \return true - is inside, false - is not
  */
 bool atom::IsInParallelepiped(const Vector offset, const double *parallelepiped) const
+{
   return (node->IsInParallelepiped(offset, parallelepiped));
+bool atom::IsInShape(const Shape& shape) const
+{
+  return shape.isInside(*node);
 };
 …
   * \return true - \a *out present, false - \a *out is NULL
  */
 bool atom::OutputArrayIndexed(ofstream * const out, const int *ElementNo, int *AtomNo, const char *comment) const
+bool atom::OutputArrayIndexed(ostream * const out,const enumeration<const element*> &elementLookup, int *AtomNo, const char *comment) const
+{
   AtomNo[type->Z]++;  // increment number
   if (out != NULL) {
+    *out << "Ion_Type" << ElementNo[type->Z] << "_" << AtomNo[type->Z] << "\t"  << fixed << setprecision(9) << showpoint;
+    cout << "Looking for atom with element " << *type << endl;
+    ASSERT(elementLookup.there.find(type)!=elementLookup.there.end(),"Type of this atom was not in the formula upon enumeration");
+    *out << "Ion_Type" << elementLookup.there.find(type)->second << "_" << AtomNo[type->Z] << "\t"  << fixed << setprecision(9) << showpoint;
     *out << x[0] << "\t" << x[1] << "\t" << x[2];
     *out << "\t" << FixedIon;
 …
  * \param *AtomNo pointer to atom counter that is increased by one
  */
 void atom::OutputMPQCLine(ofstream * const out, const Vector *center, int *AtomNo = NULL) const
+void atom::OutputMPQCLine(ostream * const out, const Vector *center, int *AtomNo = NULL) const
+{
   *out << "\t\t" << type->symbol << " [ " << x[0]-center->at(0) << "\t" << x[1]-center->at(1) << "\t" << x[2]-center->at(2) << " ]" << endl;
 …
+}
 atomId_t atom::getId() {
+atomId_t atom::getId() const {
   return id;
+}
 …
+}
+molecule* atom::getMolecule(){
+  return mol;
+}
 void atom::removeFromMolecule(){
   if(mol){

src/atom.hpp

-              r06f4ef6
+              rb6da28
 #endif
 #include <iostream>
+#include <iosfwd>
 #include <list>
 #include <vector>
 …
 class World;
 class molecule;
+class Shape;
 /********************************************** declarations *******************************/
 …
   bool OutputIndexed(ofstream * const out, const int ElementNo, const int AtomNo, const char *comment = NULL) const;
   bool OutputArrayIndexed(ofstream * const out, const int *ElementNo, int *AtomNo, const char *comment = NULL) const;
+  bool OutputArrayIndexed(ostream * const out,const enumeration<const element*>&, int *AtomNo, const char *comment = NULL) const;
   bool OutputXYZLine(ofstream *out) const;
   bool OutputTrajectory(ofstream * const out, const int *ElementNo, int *AtomNo, const int step) const;
   bool OutputTrajectoryXYZ(ofstream * const out, const int step) const;
   void OutputMPQCLine(ofstream * const out, const Vector *center, int *AtomNo) const;
+  void OutputMPQCLine(ostream * const out, const Vector *center, int *AtomNo) const;
   void InitComponentNr();
   void EqualsFather ( const atom *ptr, const atom **res ) const;
+  bool isFather(const atom *ptr);
   void CorrectFather();
   atom *GetTrueFather();
 …
   double DistanceToVector(const Vector &origin) const;
   double DistanceSquaredToVector(const Vector &origin) const;
   bool IsInParallelepiped(const Vector offset, const double *parallelepiped) const;
+  bool IsInShape(const Shape&) const;
   // getter and setter
 …
   void setWorld(World*);
   virtual atomId_t getId();
+  virtual atomId_t getId() const;
   virtual bool changeId(atomId_t newId);
 …
    void setMolecule(molecule*);
+   molecule* getMolecule();
    void removeFromMolecule();

src/atom_graphnodeinfo.cpp

-              r06f4ef6
+              rb6da28
 #include "atom_graphnodeinfo.hpp"
-#include "memoryallocator.hpp"
 /** Constructor of class GraphNodeInfo.
  */
 GraphNodeInfo::GraphNodeInfo() : GraphNr(-1), ComponentNr(NULL), LowpointNr(-1), SeparationVertex(false), IsCyclic(false), Ancestor(NULL) {};
+GraphNodeInfo::GraphNodeInfo() : GraphNr(-1), ComponentNr(0), LowpointNr(-1), SeparationVertex(false), IsCyclic(false), Ancestor(0) {};
 /** Destructor of class GraphNodeInfo.

src/atom_particleinfo.cpp

-              r06f4ef6
+              rb6da28
 #include "atom_particleinfo.hpp"
+#include "memoryallocator.hpp"
+#include <iostream>
 /** Constructor of ParticleInfo.

src/atom_particleinfo.hpp

-              r06f4ef6
+              rb6da28
 #endif
+#include <iostream>
+#include <iosfwd>
+#include <string>
 /****************************************** forward declarations *****************************/

src/atom_trajectoryparticle.cpp

-              r06f4ef6
+              rb6da28
 #include "log.hpp"
 #include "parser.hpp"
+#include "ThermoStatContainer.hpp"
 #include "verbose.hpp"
 …
  * \param *Force matrix with forces
  */
 void TrajectoryParticle::VelocityVerletUpdate(int NextStep, config *configuration, ForceMatrix *Force)
+void TrajectoryParticle::VelocityVerletUpdate(int NextStep, config *configuration, ForceMatrix *Force, const size_t offset)
+{
   //a = configuration.Deltat*0.5/walker->type->mass;        // (F+F_old)/2m = a and thus: v = (F+F_old)/2m * t = (F + F_old) * a
   for (int d=0; d<NDIM; d++) {
     Trajectory.F.at(NextStep)[d] = -Force->Matrix[0][nr][d+5]*(configuration->GetIsAngstroem() ? AtomicLengthToAngstroem : 1.);
+    Trajectory.F.at(NextStep)[d] = -Force->Matrix[0][nr][d+offset]*(configuration->GetIsAngstroem() ? AtomicLengthToAngstroem : 1.);
     Trajectory.R.at(NextStep)[d] = Trajectory.R.at(NextStep-1)[d];
     Trajectory.R.at(NextStep)[d] += configuration->Deltat*(Trajectory.U.at(NextStep-1)[d]);     // s(t) = s(0) + v * deltat + 1/2 a * deltat^2
 …
 void TrajectoryParticle::Thermostat_Langevin(int Step, gsl_rng * r, double *ekin, config *configuration)
+{
   double sigma  = sqrt(configuration->TargetTemp/type->mass); // sigma = (k_b T)/m (Hartree/atomicmass = atomiclength/atomictime)
+  double sigma  = sqrt(configuration->Thermostats->TargetTemp/type->mass); // sigma = (k_b T)/m (Hartree/atomicmass = atomiclength/atomictime)
   Vector &U = Trajectory.U.at(Step);
   if (FixedIon == 0) { // even FixedIon moves, only not by other's forces
     // throw a dice to determine whether it gets hit by a heat bath particle
     if (((((rand()/(double)RAND_MAX))*configuration->TempFrequency) < 1.)) {
+    if (((((rand()/(double)RAND_MAX))*configuration->Thermostats->TempFrequency) < 1.)) {
       DoLog(3) && (Log() << Verbose(3) << "Particle " << *this << " was hit (sigma " << sigma << "): " << sqrt(U[0]*U[0]+U[1]*U[1]+U[2]*U[2]) << " -> ");
       // pick three random numbers from a Boltzmann distribution around the desired temperature T for each momenta axis
 …
   if (FixedIon == 0) { // even FixedIon moves, only not by other's forces
     for (int d=0; d<NDIM; d++) {
       U[d] *= sqrt(1+(configuration->Deltat/configuration->TempFrequency)*(ScaleTempFactor-1));
+      U[d] *= sqrt(1+(configuration->Deltat/configuration->Thermostats->TempFrequency)*(ScaleTempFactor-1));
       *ekin += 0.5*type->mass * U[d]*U[d];
+    }
 …
   if (FixedIon == 0) { // even FixedIon moves, only not by other's forces
     for (int d=0; d<NDIM; d++) {
         U[d] += configuration->Deltat/type->mass * (configuration->alpha * (U[d] * type->mass));
+        U[d] += configuration->Deltat/type->mass * (configuration->Thermostats->alpha * (U[d] * type->mass));
         *ekin += (0.5*type->mass) * U[d]*U[d];
+      }

src/atom_trajectoryparticle.hpp

-              r06f4ef6
+              rb6da28
 #include <fstream>
+#include <gsl/gsl_inline.h>
 #include <gsl/gsl_randist.h>
 …
   void ResizeTrajectory(int MaxSteps);
   void CopyStepOnStep(int dest, int src);
   void VelocityVerletUpdate(int MDSteps, config *configuration, ForceMatrix *Force);
+  void VelocityVerletUpdate(int MDSteps, config *configuration, ForceMatrix *Force, const size_t offset);
   void SumUpKineticEnergy( int Step, double *TotalMass, Vector *TotalVelocity ) const;

src/bond.cpp

r06f4ef6	rb6da28
7	7	#include "Helpers/MemDebug.hpp"
8	8
	9	#include "verbose.hpp"
9	10	#include "atom.hpp"
10	11	#include "bond.hpp"

src/bondgraph.cpp

r06f4ef6	rb6da28
15	15	#include "element.hpp"
16	16	#include "info.hpp"
	17	#include "verbose.hpp"
17	18	#include "log.hpp"
18	19	#include "molecule.hpp"

src/bondgraph.hpp

r06f4ef6	rb6da28
18	18	#endif
19	19
20		#include <ios~~tream~~>
	20	#include <iosfwd>
21	21
22	22	/********************************************* defines *********************************/

src/boundary.cpp

-              r06f4ef6
+              rb6da28
 #include "info.hpp"
 #include "linkedcell.hpp"
+#include "verbose.hpp"
 #include "log.hpp"
-#include "memoryallocator.hpp"
 #include "molecule.hpp"
 #include "tesselation.hpp"
 …
 #include "World.hpp"
 #include "Plane.hpp"
+#include "Matrix.hpp"
+#include "Box.hpp"
+#include <iostream>
+#include <iomanip>
 #include<gsl/gsl_poly.h>
 …
  * \param *out output stream for debugging
  * \param *mol molecule structure with Atom's and Bond's.
+ * \param *BoundaryPts set of boundary points to use or NULL
  * \param *TesselStruct Tesselation filled with points, lines and triangles on boundary on return
  * \param *LCList atoms in LinkedCell list
 …
  * \return *TesselStruct is filled with convex boundary and tesselation is stored under \a *filename.
  */
 void FindConvexBorder(const molecule* mol, Tesselation *&TesselStruct, const LinkedCell *LCList, const char *filename)
+void FindConvexBorder(const molecule* mol, Boundaries *BoundaryPts, Tesselation *&TesselStruct, const LinkedCell *LCList, const char *filename)
+{
         Info FunctionInfo(__func__);
 …
   // 1. Find all points on the boundary
   if (BoundaryPoints == NULL) {
       BoundaryFreeFlag = true;
       BoundaryPoints = GetBoundaryPoints(mol, TesselStruct);
+  if (BoundaryPts == NULL) {
+    BoundaryFreeFlag = true;
+    BoundaryPoints = GetBoundaryPoints(mol, TesselStruct);
   } else {
+      DoLog(0) && (Log() << Verbose(0) << "Using given boundary points set." << endl);
+    BoundaryPoints = BoundaryPts;
+    DoLog(0) && (Log() << Verbose(0) << "Using given boundary points set." << endl);
+  }
 // printing all inserted for debugging
+  for (int axis=0; axis < NDIM; axis++)
+    {
+      DoLog(1) && (Log() << Verbose(1) << "Printing list of candidates for axis " << axis << " which we have inserted so far." << endl);
+      int i=0;
+      for(Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
+        if (runner != BoundaryPoints[axis].begin())
+          DoLog(0) && (Log() << Verbose(0) << ", " << i << ": " << *runner->second.second);
+        else
+          DoLog(0) && (Log() << Verbose(0) << i << ": " << *runner->second.second);
+        i++;
+      }
+      DoLog(0) && (Log() << Verbose(0) << endl);
+    }
+  for (int axis=0; axis < NDIM; axis++) {
+    DoLog(1) && (Log() << Verbose(1) << "Printing list of candidates for axis " << axis << " which we have inserted so far." << endl);
+    int i=0;
+    for(Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
+      if (runner != BoundaryPoints[axis].begin())
+        DoLog(0) && (Log() << Verbose(0) << ", " << i << ": " << *runner->second.second);
+      else
+        DoLog(0) && (Log() << Verbose(0) << i << ": " << *runner->second.second);
+      i++;
+    }
+    DoLog(0) && (Log() << Verbose(0) << endl);
+  }
   // 2. fill the boundary point list
 …
     for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++)
         if (!TesselStruct->AddBoundaryPoint(runner->second.second, 0))
           DoeLog(2) && (eLog()<< Verbose(2) << "Point " << *(runner->second.second) << " is already present!" << endl);
+          DoLog(2) && (Log()<< Verbose(2) << "Point " << *(runner->second.second) << " is already present." << endl);
   DoLog(0) && (Log() << Verbose(0) << "I found " << TesselStruct->PointsOnBoundaryCount << " points on the convex boundary." << endl);
 …
   IsAngstroem = configuration->GetIsAngstroem();
+  BoundaryPoints = GetBoundaryPoints(mol, TesselStruct);
   GreatestDiameter = GetDiametersOfCluster(BoundaryPoints, mol, TesselStruct, IsAngstroem);
-  BoundaryPoints = GetBoundaryPoints(mol, TesselStruct);
   LinkedCell *LCList = new LinkedCell(mol, 10.);
   FindConvexBorder(mol, TesselStruct, (const LinkedCell *&)LCList, NULL);
+  FindConvexBorder(mol, BoundaryPoints, TesselStruct, (const LinkedCell *&)LCList, NULL);
   delete (LCList);
+  delete[] BoundaryPoints;
 …
   else
     clustervolume = ClusterVolume;
+  delete TesselStruct;
   for (int i = 0; i < NDIM; i++)
 …
     mol->CenterInBox();
+  }
+  delete GreatestDiameter;
   // update Box of atoms by boundary
   mol->SetBoxDimension(&BoxLengths);
 …
   int N[NDIM];
   int n[NDIM];
   double *M =  ReturnFullMatrixforSymmetric(World::getInstance().getDomain());
   double Rotations[NDIM*NDIM];
   double *MInverse = InverseMatrix(M);
+  const Matrix &M = World::getInstance().getDomain().getM();
+  Matrix Rotations;
+  const Matrix &MInverse = World::getInstance().getDomain().getMinv();
   Vector AtomTranslations;
   Vector FillerTranslations;
 …
   // calculate filler grid in [0,1]^3
+  FillerDistance = Vector(distance[0], distance[1], distance[2]);
+  FillerDistance.InverseMatrixMultiplication(M);
+  FillerDistance = MInverse * Vector(distance[0], distance[1], distance[2]);
   for(int i=0;i<NDIM;i++)
     N[i] = (int) ceil(1./FillerDistance[i]);
 …
       for (n[2] = 0; n[2] < N[2]; n[2]++) {
         // calculate position of current grid vector in untransformed box
+        CurrentPosition = Vector((double)n[0]/(double)N[0], (double)n[1]/(double)N[1], (double)n[2]/(double)N[2]);
+        CurrentPosition.MatrixMultiplication(M);
+        CurrentPosition = M * Vector((double)n[0]/(double)N[0], (double)n[1]/(double)N[1], (double)n[2]/(double)N[2]);
         // create molecule random translation vector ...
         for (int i=0;i<NDIM;i++)
 …
+            }
             Rotations[0] =   cos(phi[0])            *cos(phi[2]) + (sin(phi[0])*sin(phi[1])*sin(phi[2]));
             Rotations[3] =   sin(phi[0])            *cos(phi[2]) - (cos(phi[0])*sin(phi[1])*sin(phi[2]));
             Rotations[6] =               cos(phi[1])*sin(phi[2])                                     ;
             Rotations[1] = - sin(phi[0])*cos(phi[1])                                                ;
             Rotations[4] =   cos(phi[0])*cos(phi[1])                                                ;
             Rotations[7] =               sin(phi[1])                                                ;
             Rotations[3] = - cos(phi[0])            *sin(phi[2]) + (sin(phi[0])*sin(phi[1])*cos(phi[2]));
             Rotations[5] = - sin(phi[0])            *sin(phi[2]) - (cos(phi[0])*sin(phi[1])*cos(phi[2]));
             Rotations[8] =               cos(phi[1])*cos(phi[2])                                     ;
+            Rotations.set(0,0,  cos(phi[0])            *cos(phi[2]) + (sin(phi[0])*sin(phi[1])*sin(phi[2])));
+            Rotations.set(0,1,  sin(phi[0])            *cos(phi[2]) - (cos(phi[0])*sin(phi[1])*sin(phi[2])));
+            Rotations.set(0,2,              cos(phi[1])*sin(phi[2])                                        );
+            Rotations.set(1,0, -sin(phi[0])*cos(phi[1])                                                    );
+            Rotations.set(1,1,  cos(phi[0])*cos(phi[1])                                                    );
+            Rotations.set(1,2,              sin(phi[1])                                                    );
+            Rotations.set(2,0, -cos(phi[0])            *sin(phi[2]) + (sin(phi[0])*sin(phi[1])*cos(phi[2])));
+            Rotations.set(2,1, -sin(phi[0])            *sin(phi[2]) - (cos(phi[0])*sin(phi[1])*cos(phi[2])));
+            Rotations.set(2,2,              cos(phi[1])*cos(phi[2])                                        );
+          }
 …
           Inserter = (*iter)->x;
           if (DoRandomRotation)
             Inserter.MatrixMultiplication(Rotations);
+            Inserter *= Rotations;
           Inserter += AtomTranslations + FillerTranslations + CurrentPosition;
           // check whether inserter is inside box
           Inserter.MatrixMultiplication(MInverse);
+          Inserter *= MInverse;
           FillIt = true;
           for (int i=0;i<NDIM;i++)
             FillIt = FillIt && (Inserter[i] >= -MYEPSILON) && ((Inserter[i]-1.) <= MYEPSILON);
           Inserter.MatrixMultiplication(M);
+          Inserter *= M;
           // Check whether point is in- or outside
 …
+            }
+      }
+  delete[](M);
+  delete[](MInverse);
+  for (MoleculeList::iterator ListRunner = List->ListOfMolecules.begin(); ListRunner != List->ListOfMolecules.end(); ListRunner++) {
+    delete LCList[*ListRunner];
+    delete TesselStruct[(*ListRunner)];
+  }
   return Filling;
 …
 //  // Purges surplus triangles.
 //  TesselStruct->RemoveDegeneratedTriangles();
   // check envelope for consistency
   status = CheckListOfBaselines(TesselStruct);
+//
+//  // check envelope for consistency
+//  status = CheckListOfBaselines(TesselStruct);
   cout << "before correction" << endl;

src/boundary.hpp

-              r06f4ef6
+              rb6da28
 #include <fstream>
 #include <iostream>
+#include <iosfwd>
 // STL headers
 …
 double ConvexizeNonconvexEnvelope(class Tesselation *&TesselStruct, const molecule * const mol, const char * const filename);
 molecule * FillBoxWithMolecule(MoleculeListClass *List, molecule *filler, config &configuration, const double MaxDistance, const double distance[NDIM], const double boundary, const double RandomAtomDisplacement, const double RandomMolDisplacement, const bool DoRandomRotation);
 void FindConvexBorder(const molecule* const mol, Tesselation *&TesselStruct, const LinkedCell *LCList, const char *filename);
+void FindConvexBorder(const molecule* const mol, Boundaries *BoundaryPts, Tesselation *&TesselStruct, const LinkedCell *LCList, const char *filename);
 Vector* FindEmbeddingHole(MoleculeListClass *mols, molecule *srcmol);
 void FindNextSuitablePoint(class BoundaryTriangleSet *BaseTriangle, class BoundaryLineSet *BaseLine, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC);

src/builder.cpp

-              r06f4ef6
+              rb6da28
 /** \file builder.cpp
+ *
+ * By stating absolute positions or binding angles and distances atomic positions of a molecule can be constructed.
+ * The output is the complete configuration file for PCP for direct use.
+ * Features:
+ * -# Atomic data is retrieved from a file, if not found requested and stored there for later re-use
+ * -# step-by-step construction of the molecule beginning either at a centre of with a certain atom
+ *  date: Jan 1, 2007
+ *  author: heber
+ *
  */
 /*! \mainpage Molecuilder - a molecular set builder
+/*! \mainpage MoleCuilder - a molecular set builder
+ *
  * This introductory shall briefly make aquainted with the program, helping in installing and a first run.
+ * This introductory shall briefly make acquainted with the program, helping in installing and a first run.
+ *
  * \section about About the Program
+ *
+ *  Molecuilder is a short program, written in C++, that enables the construction of a coordinate set for the
+ *  atoms making up an molecule by the successive statement of binding angles and distances and referencing to
+ *  already constructed atoms.
+ *  MoleCuilder is a program, written entirely in C++, that enables the construction of a coordinate set for the
+ *  atoms making up an molecule. It allows for both building of simple molecules by adding atom-wise giving bond
+ *  angles and distances or absolute coordinates, but also using them as templates. Regions can be specified and
+ *  ordered to be filled with a molecule in a certain manner. Greater conglomerations of molecules can be tesselated
+ *  and recognized as a region themselves to be subsequently surrounded by other (surface solvated) molecules.
+ *  In the end, MoleCuilder allows the construction of arbitrary nano structures, whether they be crystalline or
+ *  amorphic in nature.
+ *
- *  A configuration file may be written that is compatible to the format used by PCP - a parallel Car-Parrinello
- *  molecular dynamics implementation.
+ *
  * \section install Installation
 …
  *  -# make clean uninstall: deletes .o-files and removes executable from the given binary directory\n
  *  -# make doxygen-doc: Creates these html pages out of the documented source
+ *  -# make check: Runs an extensive set of unit tests and a testsuite which also gives a good overview on the set of
+ *                 functions.
+ *
  * \section run Running
 …
  *  The program can be executed by running: ./molecuilder
+ *
+ *  Note, that it uses a database, called "elements.db", in the executable's directory. If the file is not found,
+ *  it is created and any given data on elements of the periodic table will be stored therein and re-used on
+ *  later re-execution.
+ *  MoleCuilder has three interfaces at your disposal:
+ *  -# Textmenu: A simple interactive console-based menu, where awaits your choices and inputs in order to set atoms
+ *               as you like
+ *  -# CommandLineUI: Every command can also be chained up as a sequence of actions on the command line to be executed
+ *               with any user interaction.
+ *  -# GraphicalUI: A graphical user interface that also display the molecular structure being built and lots of other
+ *               informations to ease the construction of bigger geometries.
+ *
+ * \section ref References
+ *
+ *  For the special configuration file format, see the documentation of pcp.
+ *  The supported output formats right now are:
+ *  -# mpqc: Configuration files of the Massively Parallel Quantum Chemistry package (Sandia labs)
+ *  -# pcp: Configuration files of the Parallel Car-Parrinello program (Institute for Numerical Simulation)
+ *  -# tremolo: Configuration files of TREMOLO (Institute for Numerical Simulation)
+ *  -# xyz: the most basic format for the 3d arrangement of atoms consisting of a list of element and 3 coordinates.
+ *
  */
 …
 #include "Helpers/MemDebug.hpp"
-#include <boost/bind.hpp>
-using namespace std;
-#include <cstring>
-#include <cstdlib>
-#include "analysis_bonds.hpp"
-#include "analysis_correlation.hpp"
-#include "atom.hpp"
-#include "bond.hpp"
 #include "bondgraph.hpp"
-#include "boundary.hpp"
 #include "CommandLineParser.hpp"
 #include "config.hpp"
-#include "element.hpp"
-#include "ellipsoid.hpp"
-#include "helpers.hpp"
-#include "leastsquaremin.hpp"
-#include "linkedcell.hpp"
 #include "log.hpp"
-#include "memoryusageobserver.hpp"
 #include "molecule.hpp"
 #include "periodentafel.hpp"
+#include "tesselationhelpers.hpp"
+#include "UIElements/UIFactory.hpp"
+#include "UIElements/TextUI/TextUIFactory.hpp"
+#include "UIElements/CommandLineUI/CommandLineUIFactory.hpp"
+#ifdef USE_GUI_QT
+#include "UIElements/QT4/QTUIFactory.hpp"
+#endif
+#include "UIElements/MainWindow.hpp"
+#include "UIElements/Dialog.hpp"
+#include "Menu/ActionMenuItem.hpp"
+#include "verbose.hpp"
+#include "World.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "Actions/ActionHistory.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "Parser/ChangeTracker.hpp"
+#include "Parser/FormatParserStorage.hpp"
 #include "UIElements/UIFactory.hpp"
 #include "UIElements/TextUI/TextUIFactory.hpp"
 …
 #include "UIElements/MainWindow.hpp"
 #include "UIElements/Dialog.hpp"
+#include "Menu/ActionMenuItem.hpp"
+#include "Actions/ActionRegistry.hpp"
+#include "Actions/ActionHistory.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "Actions/MethodAction.hpp"
+#include "Actions/MoleculeAction/ChangeNameAction.hpp"
+#include "World.hpp"
 #include "version.h"
-#include "World.hpp"
-/********************************************* Subsubmenu routine ************************************/
-#if 0
-/** Submenu for adding atoms to the molecule.
- * \param *periode periodentafel
- * \param *molecule molecules with atoms
- */
-static void AddAtoms(periodentafel *periode, molecule *mol)
+{
-  atom *first, *second, *third, *fourth;
-  Vector **atoms;
-  Vector x,y,z,n;  // coordinates for absolute point in cell volume
-  double a,b,c;
-  char choice;  // menu choice char
-  bool valid;
-  cout << Verbose(0) << "===========ADD ATOM============================" << endl;
-  cout << Verbose(0) << " a - state absolute coordinates of atom" << endl;
-  cout << Verbose(0) << " b - state relative coordinates of atom wrt to reference point" << endl;
-  cout << Verbose(0) << " c - state relative coordinates of atom wrt to already placed atom" << endl;
-  cout << Verbose(0) << " d - state two atoms, two angles and a distance" << endl;
-  cout << Verbose(0) << " e - least square distance position to a set of atoms" << endl;
-  cout << Verbose(0) << "all else - go back" << endl;
-  cout << Verbose(0) << "===============================================" << endl;
-  cout << Verbose(0) << "Note: Specifiy angles in degrees not multiples of Pi!" << endl;
-  cout << Verbose(0) << "INPUT: ";
-  cin >> choice;
-  switch (choice) {
-    default:
-      DoeLog(2) && (eLog()<< Verbose(2) << "Not a valid choice." << endl);
-      break;
-      case 'a': // absolute coordinates of atom
-        cout << Verbose(0) << "Enter absolute coordinates." << endl;
-        first = new atom;
-        first->x.AskPosition(World::getInstance().getDomain(), false);
-        first->type = periode->AskElement();  // give type
-        mol->AddAtom(first);  // add to molecule
-        break;
-      case 'b': // relative coordinates of atom wrt to reference point
-        first = new atom;
-        valid = true;
-        do {
-          if (!valid) DoeLog(2) && (eLog()<< Verbose(2) << "Resulting position out of cell." << endl);
-          cout << Verbose(0) << "Enter reference coordinates." << endl;
-          x.AskPosition(World::getInstance().getDomain(), true);
-          cout << Verbose(0) << "Enter relative coordinates." << endl;
-          first->x.AskPosition(World::getInstance().getDomain(), false);
-          first->x.AddVector((const Vector *)&x);
-          cout << Verbose(0) << "\n";
-        } while (!(valid = mol->CheckBounds((const Vector *)&first->x)));
-        first->type = periode->AskElement();  // give type
-        mol->AddAtom(first);  // add to molecule
-        break;
-      case 'c': // relative coordinates of atom wrt to already placed atom
-        first = new atom;
-        valid = true;
-        do {
-          if (!valid) DoeLog(2) && (eLog()<< Verbose(2) << "Resulting position out of cell." << endl);
-          second = mol->AskAtom("Enter atom number: ");
-          DoLog(0) && (Log() << Verbose(0) << "Enter relative coordinates." << endl);
-          first->x.AskPosition(World::getInstance().getDomain(), false);
-          for (int i=NDIM;i--;) {
-            first->x.x[i] += second->x.x[i];
+          }
-        } while (!(valid = mol->CheckBounds((const Vector *)&first->x)));
-        first->type = periode->AskElement();  // give type
-        mol->AddAtom(first);  // add to molecule
-        break;
-    case 'd': // two atoms, two angles and a distance
-        first = new atom;
-        valid = true;
-        do {
-          if (!valid) {
-            DoeLog(2) && (eLog()<< Verbose(2) << "Resulting coordinates out of cell - " << first->x << endl);
+          }
-          cout << Verbose(0) << "First, we need two atoms, the first atom is the central, while the second is the outer one." << endl;
-          second = mol->AskAtom("Enter central atom: ");
-          third = mol->AskAtom("Enter second atom (specifying the axis for first angle): ");
-          fourth = mol->AskAtom("Enter third atom (specifying a plane for second angle): ");
-          a = ask_value("Enter distance between central (first) and new atom: ");
-          b = ask_value("Enter angle between new, first and second atom (degrees): ");
-          b *= M_PI/180.;
-          bound(&b, 0., 2.*M_PI);
-          c = ask_value("Enter second angle between new and normal vector of plane defined by first, second and third atom (degrees): ");
-          c *= M_PI/180.;
-          bound(&c, -M_PI, M_PI);
-          cout << Verbose(0) << "radius: " << a << "\t phi: " << b*180./M_PI << "\t theta: " << c*180./M_PI << endl;
-/*
-          second->Output(1,1,(ofstream *)&cout);
-          third->Output(1,2,(ofstream *)&cout);
-          fourth->Output(1,3,(ofstream *)&cout);
-          n.MakeNormalvector((const vector *)&second->x, (const vector *)&third->x, (const vector *)&fourth->x);
-          x.Copyvector(&second->x);
-          x.SubtractVector(&third->x);
-          x.Copyvector(&fourth->x);
-          x.SubtractVector(&third->x);
-          if (!z.SolveSystem(&x,&y,&n, b, c, a)) {
-         coutg() << Verbose(0) << "Failure solving self-dependent linear system!" << endl;
-            continue;
+          }
-          DoLog(0) && (Log() << Verbose(0) << "resulting relative coordinates: ");
-          z.Output();
-          DoLog(0) && (Log() << Verbose(0) << endl);
-          */
-          // calc axis vector
-          x.CopyVector(&second->x);
-          x.SubtractVector(&third->x);
-          x.Normalize();
-          Log() << Verbose(0) << "x: ",
-          x.Output();
-          DoLog(0) && (Log() << Verbose(0) << endl);
-          z.MakeNormalVector(&second->x,&third->x,&fourth->x);
-          Log() << Verbose(0) << "z: ",
-          z.Output();
-          DoLog(0) && (Log() << Verbose(0) << endl);
-          y.MakeNormalVector(&x,&z);
-          Log() << Verbose(0) << "y: ",
-          y.Output();
-          DoLog(0) && (Log() << Verbose(0) << endl);
-          // rotate vector around first angle
-          first->x.CopyVector(&x);
-          first->x.RotateVector(&z,b - M_PI);
-          Log() << Verbose(0) << "Rotated vector: ",
-          first->x.Output();
-          DoLog(0) && (Log() << Verbose(0) << endl);
-          // remove the projection onto the rotation plane of the second angle
-          n.CopyVector(&y);
-          n.Scale(first->x.ScalarProduct(&y));
-          Log() << Verbose(0) << "N1: ",
-          n.Output();
-          DoLog(0) && (Log() << Verbose(0) << endl);
-          first->x.SubtractVector(&n);
-          Log() << Verbose(0) << "Subtracted vector: ",
-          first->x.Output();
-          DoLog(0) && (Log() << Verbose(0) << endl);
-          n.CopyVector(&z);
-          n.Scale(first->x.ScalarProduct(&z));
-          Log() << Verbose(0) << "N2: ",
-          n.Output();
-          DoLog(0) && (Log() << Verbose(0) << endl);
-          first->x.SubtractVector(&n);
-          Log() << Verbose(0) << "2nd subtracted vector: ",
-          first->x.Output();
-          DoLog(0) && (Log() << Verbose(0) << endl);
-          // rotate another vector around second angle
-          n.CopyVector(&y);
-          n.RotateVector(&x,c - M_PI);
-          Log() << Verbose(0) << "2nd Rotated vector: ",
-          n.Output();
-          DoLog(0) && (Log() << Verbose(0) << endl);
-          // add the two linear independent vectors
-          first->x.AddVector(&n);
-          first->x.Normalize();
-          first->x.Scale(a);
-          first->x.AddVector(&second->x);
-          DoLog(0) && (Log() << Verbose(0) << "resulting coordinates: ");
-          first->x.Output();
-          DoLog(0) && (Log() << Verbose(0) << endl);
-        } while (!(valid = mol->CheckBounds((const Vector *)&first->x)));
-        first->type = periode->AskElement();  // give type
-        mol->AddAtom(first);  // add to molecule
-        break;
-      case 'e': // least square distance position to a set of atoms
-        first = new atom;
-        atoms = new (Vector*[128]);
-        valid = true;
-        for(int i=128;i--;)
-          atoms[i] = NULL;
-        int i=0, j=0;
-        cout << Verbose(0) << "Now we need at least three molecules.\n";
-        do {
-          cout << Verbose(0) << "Enter " << i+1 << "th atom: ";
-          cin >> j;
-          if (j != -1) {
-            second = mol->FindAtom(j);
-            atoms[i++] = &(second->x);
+          }
-        } while ((j != -1) && (i<128));
-        if (i >= 2) {
-          first->x.LSQdistance((const Vector **)atoms, i);
-          first->x.Output();
-          first->type = periode->AskElement();  // give type
-          mol->AddAtom(first);  // add to molecule
-        } else {
-          delete first;
-          cout << Verbose(0) << "Please enter at least two vectors!\n";
+        }
-        break;
-  };
-};
-/** Submenu for centering the atoms in the molecule.
- * \param *mol molecule with all the atoms
- */
-static void CenterAtoms(molecule *mol)
+{
-  Vector x, y, helper;
-  char choice;  // menu choice char
-  cout << Verbose(0) << "===========CENTER ATOMS=========================" << endl;
-  cout << Verbose(0) << " a - on origin" << endl;
-  cout << Verbose(0) << " b - on center of gravity" << endl;
-  cout << Verbose(0) << " c - within box with additional boundary" << endl;
-  cout << Verbose(0) << " d - within given simulation box" << endl;
-  cout << Verbose(0) << "all else - go back" << endl;
-  cout << Verbose(0) << "===============================================" << endl;
-  cout << Verbose(0) << "INPUT: ";
-  cin >> choice;
-  switch (choice) {
-    default:
-      cout << Verbose(0) << "Not a valid choice." << endl;
-      break;
-    case 'a':
-      cout << Verbose(0) << "Centering atoms in config file on origin." << endl;
-      mol->CenterOrigin();
-      break;
-    case 'b':
-      cout << Verbose(0) << "Centering atoms in config file on center of gravity." << endl;
-      mol->CenterPeriodic();
-      break;
-    case 'c':
-      cout << Verbose(0) << "Centering atoms in config file within given additional boundary." << endl;
-      for (int i=0;i<NDIM;i++) {
-        cout << Verbose(0) << "Enter axis " << i << " boundary: ";
-        cin >> y.x[i];
+      }
-      mol->CenterEdge(&x);  // make every coordinate positive
-      mol->Center.AddVector(&y); // translate by boundary
-      helper.CopyVector(&y);
-      helper.Scale(2.);
-      helper.AddVector(&x);
-      mol->SetBoxDimension(&helper);  // update Box of atoms by boundary
-      break;
-    case 'd':
-      cout << Verbose(1) << "Centering atoms in config file within given simulation box." << endl;
-      for (int i=0;i<NDIM;i++) {
-        cout << Verbose(0) << "Enter axis " << i << " boundary: ";
-        cin >> x.x[i];
+      }
-      // update Box of atoms by boundary
-      mol->SetBoxDimension(&x);
-      // center
-      mol->CenterInBox();
-      break;
+  }
-};
-/** Submenu for aligning the atoms in the molecule.
- * \param *periode periodentafel
- * \param *mol molecule with all the atoms
- */
-static void AlignAtoms(periodentafel *periode, molecule *mol)
+{
-  atom *first, *second, *third;
-  Vector x,n;
-  char choice;  // menu choice char
-  cout << Verbose(0) << "===========ALIGN ATOMS=========================" << endl;
-  cout << Verbose(0) << " a - state three atoms defining align plane" << endl;
-  cout << Verbose(0) << " b - state alignment vector" << endl;
-  cout << Verbose(0) << " c - state two atoms in alignment direction" << endl;
-  cout << Verbose(0) << " d - align automatically by least square fit" << endl;
-  cout << Verbose(0) << "all else - go back" << endl;
-  cout << Verbose(0) << "===============================================" << endl;
-  cout << Verbose(0) << "INPUT: ";
-  cin >> choice;
-  switch (choice) {
-    default:
-    case 'a': // three atoms defining mirror plane
-      first = mol->AskAtom("Enter first atom: ");
-      second = mol->AskAtom("Enter second atom: ");
-      third = mol->AskAtom("Enter third atom: ");
-      n.MakeNormalVector((const Vector *)&first->x,(const Vector *)&second->x,(const Vector *)&third->x);
-      break;
-    case 'b': // normal vector of mirror plane
-      cout << Verbose(0) << "Enter normal vector of mirror plane." << endl;
-      n.AskPosition(World::getInstance().getDomain(),0);
-      n.Normalize();
-      break;
-    case 'c': // three atoms defining mirror plane
-      first = mol->AskAtom("Enter first atom: ");
-      second = mol->AskAtom("Enter second atom: ");
-      n.CopyVector((const Vector *)&first->x);
-      n.SubtractVector((const Vector *)&second->x);
-      n.Normalize();
-      break;
-    case 'd':
-      char shorthand[4];
-      Vector a;
-      struct lsq_params param;
-      do {
-        fprintf(stdout, "Enter the element of atoms to be chosen: ");
-        fscanf(stdin, "%3s", shorthand);
-      } while ((param.type = periode->FindElement(shorthand)) == NULL);
-      cout << Verbose(0) << "Element is " << param.type->name << endl;
-      mol->GetAlignvector(&param);
-      for (int i=NDIM;i--;) {
-        x.x[i] = gsl_vector_get(param.x,i);
-        n.x[i] = gsl_vector_get(param.x,i+NDIM);
+      }
-      gsl_vector_free(param.x);
-      cout << Verbose(0) << "Offset vector: ";
-      x.Output();
-      DoLog(0) && (Log() << Verbose(0) << endl);
-      n.Normalize();
-      break;
-  };
-  DoLog(0) && (Log() << Verbose(0) << "Alignment vector: ");
-  n.Output();
-  DoLog(0) && (Log() << Verbose(0) << endl);
-  mol->Align(&n);
-};
-/** Submenu for mirroring the atoms in the molecule.
- * \param *mol molecule with all the atoms
- */
-static void MirrorAtoms(molecule *mol)
+{
-  atom *first, *second, *third;
-  Vector n;
-  char choice;  // menu choice char
-  DoLog(0) && (Log() << Verbose(0) << "===========MIRROR ATOMS=========================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " a - state three atoms defining mirror plane" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " b - state normal vector of mirror plane" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " c - state two atoms in normal direction" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "all else - go back" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "===============================================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "INPUT: ");
-  cin >> choice;
-  switch (choice) {
-    default:
-    case 'a': // three atoms defining mirror plane
-      first = mol->AskAtom("Enter first atom: ");
-      second = mol->AskAtom("Enter second atom: ");
-      third = mol->AskAtom("Enter third atom: ");
-      n.MakeNormalVector((const Vector *)&first->x,(const Vector *)&second->x,(const Vector *)&third->x);
-      break;
-    case 'b': // normal vector of mirror plane
-      DoLog(0) && (Log() << Verbose(0) << "Enter normal vector of mirror plane." << endl);
-      n.AskPosition(World::getInstance().getDomain(),0);
-      n.Normalize();
-      break;
-    case 'c': // three atoms defining mirror plane
-      first = mol->AskAtom("Enter first atom: ");
-      second = mol->AskAtom("Enter second atom: ");
-      n.CopyVector((const Vector *)&first->x);
-      n.SubtractVector((const Vector *)&second->x);
-      n.Normalize();
-      break;
-  };
-  DoLog(0) && (Log() << Verbose(0) << "Normal vector: ");
-  n.Output();
-  DoLog(0) && (Log() << Verbose(0) << endl);
-  mol->Mirror((const Vector *)&n);
-};
-/** Submenu for removing the atoms from the molecule.
- * \param *mol molecule with all the atoms
- */
-static void RemoveAtoms(molecule *mol)
+{
-  atom *first, *second;
-  int axis;
-  double tmp1, tmp2;
-  char choice;  // menu choice char
-  DoLog(0) && (Log() << Verbose(0) << "===========REMOVE ATOMS=========================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " a - state atom for removal by number" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " b - keep only in radius around atom" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " c - remove this with one axis greater value" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "all else - go back" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "===============================================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "INPUT: ");
-  cin >> choice;
-  switch (choice) {
-    default:
-    case 'a':
-      if (mol->RemoveAtom(mol->AskAtom("Enter number of atom within molecule: ")))
-        DoLog(1) && (Log() << Verbose(1) << "Atom removed." << endl);
-      else
-        DoLog(1) && (Log() << Verbose(1) << "Atom not found." << endl);
-      break;
-    case 'b':
-      second = mol->AskAtom("Enter number of atom as reference point: ");
-      DoLog(0) && (Log() << Verbose(0) << "Enter radius: ");
-      cin >> tmp1;
-      first = mol->start;
-      second = first->next;
-      while(second != mol->end) {
-        first = second;
-        second = first->next;
-        if (first->x.DistanceSquared((const Vector *)&second->x) > tmp1*tmp1) // distance to first above radius ...
-          mol->RemoveAtom(first);
+      }
-      break;
-    case 'c':
-      DoLog(0) && (Log() << Verbose(0) << "Which axis is it: ");
-      cin >> axis;
-      DoLog(0) && (Log() << Verbose(0) << "Lower boundary: ");
-      cin >> tmp1;
-      DoLog(0) && (Log() << Verbose(0) << "Upper boundary: ");
-      cin >> tmp2;
-      first = mol->start;
-      second = first->next;
-      while(second != mol->end) {
-        first = second;
-        second = first->next;
-        if ((first->x.x[axis] < tmp1) || (first->x.x[axis] > tmp2)) {// out of boundary ...
-          //Log() << Verbose(0) << "Atom " << *first << " with " << first->x.x[axis] << " on axis " << axis << " is out of bounds [" << tmp1 << "," << tmp2 << "]." << endl;
-          mol->RemoveAtom(first);
+        }
+      }
-      break;
-  };
-  //mol->Output();
-  choice = 'r';
-};
-/** Submenu for measuring out the atoms in the molecule.
- * \param *periode periodentafel
- * \param *mol molecule with all the atoms
- */
-static void MeasureAtoms(periodentafel *periode, molecule *mol, config *configuration)
+{
-  atom *first, *second, *third;
-  Vector x,y;
-  double min[256], tmp1, tmp2, tmp3;
-  int Z;
-  char choice;  // menu choice char
-  DoLog(0) && (Log() << Verbose(0) << "===========MEASURE ATOMS=========================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " a - calculate bond length between one atom and all others" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " b - calculate bond length between two atoms" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " c - calculate bond angle" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " d - calculate principal axis of the system" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " e - calculate volume of the convex envelope" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " f - calculate temperature from current velocity" << endl);
-  DoLog(0) && (Log() << Verbose(0) << " g - output all temperatures per step from velocities" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "all else - go back" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "===============================================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "INPUT: ");
-  cin >> choice;
-  switch(choice) {
-    default:
-      DoLog(1) && (Log() << Verbose(1) << "Not a valid choice." << endl);
-      break;
-    case 'a':
-      first = mol->AskAtom("Enter first atom: ");
-      for (int i=MAX_ELEMENTS;i--;)
-        min[i] = 0.;
-      second = mol->start;
-      while ((second->next != mol->end)) {
-        second = second->next; // advance
-        Z = second->type->Z;
-        tmp1 = 0.;
-        if (first != second) {
-          x.CopyVector((const Vector *)&first->x);
-          x.SubtractVector((const Vector *)&second->x);
-          tmp1 = x.Norm();
+        }
-        if ((tmp1 != 0.) && ((min[Z] == 0.) || (tmp1 < min[Z]))) min[Z] = tmp1;
-        //Log() << Verbose(0) << "Bond length between Atom " << first->nr << " and " << second->nr << ": " << tmp1 << " a.u." << endl;
+      }
-      for (int i=MAX_ELEMENTS;i--;)
-        if (min[i] != 0.) Log() << Verbose(0) << "Minimum Bond length between " << first->type->name << " Atom " << first->nr << " and next Ion of type " << (periode->FindElement(i))->name << ": " << min[i] << " a.u." << endl;
-      break;
-    case 'b':
-      first = mol->AskAtom("Enter first atom: ");
-      second = mol->AskAtom("Enter second atom: ");
-      for (int i=NDIM;i--;)
-        min[i] = 0.;
-      x.CopyVector((const Vector *)&first->x);
-      x.SubtractVector((const Vector *)&second->x);
-      tmp1 = x.Norm();
-      DoLog(1) && (Log() << Verbose(1) << "Distance vector is ");
-      x.Output();
-      DoLog(0) && (Log() << Verbose(0) << "." << endl << "Norm of distance is " << tmp1 << "." << endl);
-      break;
-    case 'c':
-      DoLog(0) && (Log() << Verbose(0) << "Evaluating bond angle between three - first, central, last - atoms." << endl);
-      first = mol->AskAtom("Enter first atom: ");
-      second = mol->AskAtom("Enter central atom: ");
-      third  = mol->AskAtom("Enter last atom: ");
-      tmp1 = tmp2 = tmp3 = 0.;
-      x.CopyVector((const Vector *)&first->x);
-      x.SubtractVector((const Vector *)&second->x);
-      y.CopyVector((const Vector *)&third->x);
-      y.SubtractVector((const Vector *)&second->x);
-      DoLog(0) && (Log() << Verbose(0) << "Bond angle between first atom Nr." << first->nr << ", central atom Nr." << second->nr << " and last atom Nr." << third->nr << ": ");
-      DoLog(0) && (Log() << Verbose(0) << (acos(x.ScalarProduct((const Vector *)&y)/(y.Norm()*x.Norm()))/M_PI*180.) << " degrees" << endl);
-      break;
-    case 'd':
-      DoLog(0) && (Log() << Verbose(0) << "Evaluating prinicipal axis." << endl);
-      DoLog(0) && (Log() << Verbose(0) << "Shall we rotate? [0/1]: ");
-      cin >> Z;
-      if ((Z >=0) && (Z <=1))
-        mol->PrincipalAxisSystem((bool)Z);
-      else
-        mol->PrincipalAxisSystem(false);
-      break;
-    case 'e':
+      {
-        DoLog(0) && (Log() << Verbose(0) << "Evaluating volume of the convex envelope.");
-        class Tesselation *TesselStruct = NULL;
-        const LinkedCell *LCList = NULL;
-        LCList = new LinkedCell(mol, 10.);
-        FindConvexBorder(mol, TesselStruct, LCList, NULL);
-        double clustervolume = VolumeOfConvexEnvelope(TesselStruct, configuration);
-        DoLog(0) && (Log() << Verbose(0) << "The tesselated surface area is " << clustervolume << "." << endl);\
-        delete(LCList);
-        delete(TesselStruct);
+      }
-      break;
-    case 'f':
-      mol->OutputTemperatureFromTrajectories((ofstream *)&cout, mol->MDSteps-1, mol->MDSteps);
-      break;
-    case 'g':
+      {
-        char filename[255];
-        DoLog(0) && (Log() << Verbose(0) << "Please enter filename: " << endl);
-        cin >> filename;
-        DoLog(1) && (Log() << Verbose(1) << "Storing temperatures in " << filename << "." << endl);
-        ofstream *output = new ofstream(filename, ios::trunc);
-        if (!mol->OutputTemperatureFromTrajectories(output, 0, mol->MDSteps))
-          DoLog(2) && (Log() << Verbose(2) << "File could not be written." << endl);
-        else
-          DoLog(2) && (Log() << Verbose(2) << "File stored." << endl);
-        output->close();
-        delete(output);
+      }
-      break;
+  }
-};
-/** Submenu for measuring out the atoms in the molecule.
- * \param *mol molecule with all the atoms
- * \param *configuration configuration structure for the to be written config files of all fragments
- */
-static void FragmentAtoms(molecule *mol, config *configuration)
+{
-  int Order1;
-  clock_t start, end;
-  DoLog(0) && (Log() << Verbose(0) << "Fragmenting molecule with current connection matrix ..." << endl);
-  DoLog(0) && (Log() << Verbose(0) << "What's the desired bond order: ");
-  cin >> Order1;
-  if (mol->first->next != mol->last) {  // there are bonds
-    start = clock();
-    mol->FragmentMolecule(Order1, configuration);
-    end = clock();
-    DoLog(0) && (Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl);
-  } else
-    DoLog(0) && (Log() << Verbose(0) << "Connection matrix has not yet been generated!" << endl);
-};
-/********************************************** Submenu routine **************************************/
-/** Submenu for manipulating atoms.
- * \param *periode periodentafel
- * \param *molecules list of molecules whose atoms are to be manipulated
- */
-static void ManipulateAtoms(periodentafel *periode, MoleculeListClass *molecules, config *configuration)
+{
-  atom *first, *second, *third;
-  molecule *mol = NULL;
-  Vector x,y,z,n; // coordinates for absolute point in cell volume
-  double *factor; // unit factor if desired
-  double bond, minBond;
-  char choice;  // menu choice char
-  bool valid;
-  DoLog(0) && (Log() << Verbose(0) << "=========MANIPULATE ATOMS======================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "a - add an atom" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "r - remove an atom" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "b - scale a bond between atoms" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "t - turn an atom round another bond" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "u - change an atoms element" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "l - measure lengths, angles, ... for an atom" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "all else - go back" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "===============================================" << endl);
-  if (molecules->NumberOfActiveMolecules() > 1)
-    DoeLog(2) && (eLog()<< Verbose(2) << "There is more than one molecule active! Atoms will be added to each." << endl);
-  DoLog(0) && (Log() << Verbose(0) << "INPUT: ");
-  cin >> choice;
-  switch (choice) {
-    default:
-      DoLog(0) && (Log() << Verbose(0) << "Not a valid choice." << endl);
-      break;
-    case 'a': // add atom
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-        mol = *ListRunner;
-        DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
-        AddAtoms(periode, mol);
+      }
-      break;
-    case 'b': // scale a bond
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-        mol = *ListRunner;
-        DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
-        DoLog(0) && (Log() << Verbose(0) << "Scaling bond length between two atoms." << endl);
-        first = mol->AskAtom("Enter first (fixed) atom: ");
-        second = mol->AskAtom("Enter second (shifting) atom: ");
-        minBond = 0.;
-        for (int i=NDIM;i--;)
-          minBond += (first->x.x[i]-second->x.x[i])*(first->x.x[i] - second->x.x[i]);
-        minBond = sqrt(minBond);
-        DoLog(0) && (Log() << Verbose(0) << "Current Bond length between " << first->type->name << " Atom " << first->nr << " and " << second->type->name << " Atom " << second->nr << ": " << minBond << " a.u." << endl);
-        DoLog(0) && (Log() << Verbose(0) << "Enter new bond length [a.u.]: ");
-        cin >> bond;
-        for (int i=NDIM;i--;) {
-          second->x.x[i] -= (second->x.x[i]-first->x.x[i])/minBond*(minBond-bond);
+        }
-        //Log() << Verbose(0) << "New coordinates of Atom " << second->nr << " are: ";
-        //second->Output(second->type->No, 1);
+      }
-      break;
-    case 'c': // unit scaling of the metric
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-        mol = *ListRunner;
-        DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
-       DoLog(0) && (Log() << Verbose(0) << "Angstroem -> Bohrradius: 1.8897261\t\tBohrradius -> Angstroem: 0.52917721" << endl);
-       DoLog(0) && (Log() << Verbose(0) << "Enter three factors: ");
-       factor = new double[NDIM];
-       cin >> factor[0];
-       cin >> factor[1];
-       cin >> factor[2];
-       valid = true;
-       mol->Scale((const double ** const)&factor);
-       delete[](factor);
+      }
-     break;
-    case 'l': // measure distances or angles
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-        mol = *ListRunner;
-        DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
-        MeasureAtoms(periode, mol, configuration);
+      }
-      break;
-    case 'r': // remove atom
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-        mol = *ListRunner;
-        DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
-        RemoveAtoms(mol);
+      }
-      break;
-    case 't': // turn/rotate atom
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-          mol = *ListRunner;
-          DoLog(0) && (Log() << Verbose(0) << "Turning atom around another bond - first is atom to turn, second (central) and third specify bond" << endl);
-          first = mol->AskAtom("Enter turning atom: ");
-          second = mol->AskAtom("Enter central atom: ");
-          third  = mol->AskAtom("Enter bond atom: ");
-          cout << Verbose(0) << "Enter new angle in degrees: ";
-          double tmp = 0.;
-          cin >> tmp;
-          // calculate old angle
-          x.CopyVector((const Vector *)&first->x);
-          x.SubtractVector((const Vector *)&second->x);
-          y.CopyVector((const Vector *)&third->x);
-          y.SubtractVector((const Vector *)&second->x);
-          double alpha = (acos(x.ScalarProduct((const Vector *)&y)/(y.Norm()*x.Norm()))/M_PI*180.);
-          cout << Verbose(0) << "Bond angle between first atom Nr." << first->nr << ", central atom Nr." << second->nr << " and last atom Nr." << third->nr << ": ";
-          cout << Verbose(0) << alpha << " degrees" << endl;
-          // rotate
-          z.MakeNormalVector(&x,&y);
-          x.RotateVector(&z,(alpha-tmp)*M_PI/180.);
-          x.AddVector(&second->x);
-          first->x.CopyVector(&x);
-          // check new angle
-          x.CopyVector((const Vector *)&first->x);
-          x.SubtractVector((const Vector *)&second->x);
-          alpha = (acos(x.ScalarProduct((const Vector *)&y)/(y.Norm()*x.Norm()))/M_PI*180.);
-          cout << Verbose(0) << "new Bond angle between first atom Nr." << first->nr << ", central atom Nr." << second->nr << " and last atom Nr." << third->nr << ": ";
-          cout << Verbose(0) << alpha << " degrees" << endl;
+        }
-      break;
-    case 'u': // change an atom's element
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-        int Z;
-        mol = *ListRunner;
-        DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
-        first = NULL;
-        do {
-          DoLog(0) && (Log() << Verbose(0) << "Change the element of which atom: ");
-          cin >> Z;
-        } while ((first = mol->FindAtom(Z)) == NULL);
-        DoLog(0) && (Log() << Verbose(0) << "New element by atomic number Z: ");
-        cin >> Z;
-        first->type = periode->FindElement(Z);
-        DoLog(0) && (Log() << Verbose(0) << "Atom " << first->nr << "'s element is " << first->type->name << "." << endl);
+      }
-      break;
+  }
-};
-/** Submenu for manipulating molecules.
- * \param *periode periodentafel
- * \param *molecules list of molecule to manipulate
- */
-static void ManipulateMolecules(periodentafel *periode, MoleculeListClass *molecules, config *configuration)
+{
-  atom *first = NULL;
-  Vector x,y,z,n; // coordinates for absolute point in cell volume
-  int j, axis, count, faktor;
-  char choice;  // menu choice char
-  molecule *mol = NULL;
-  element **Elements;
-  Vector **vectors;
-  MoleculeLeafClass *Subgraphs = NULL;
-  DoLog(0) && (Log() << Verbose(0) << "=========MANIPULATE GLOBALLY===================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "c - scale by unit transformation" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "d - duplicate molecule/periodic cell" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "f - fragment molecule many-body bond order style" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "g - center atoms in box" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "i - realign molecule" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "m - mirror all molecules" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "o - create connection matrix" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "t - translate molecule by vector" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "all else - go back" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "===============================================" << endl);
-  if (molecules->NumberOfActiveMolecules() > 1)
-    DoeLog(2) && (eLog()<< Verbose(2) << "There is more than one molecule active! Atoms will be added to each." << endl);
-  DoLog(0) && (Log() << Verbose(0) << "INPUT: ");
-  cin >> choice;
-  switch (choice) {
-    default:
-      DoLog(0) && (Log() << Verbose(0) << "Not a valid choice." << endl);
-      break;
-    case 'd': // duplicate the periodic cell along a given axis, given times
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-        mol = *ListRunner;
-        DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
-        DoLog(0) && (Log() << Verbose(0) << "State the axis [(+-)123]: ");
-        cin >> axis;
-        DoLog(0) && (Log() << Verbose(0) << "State the factor: ");
-        cin >> faktor;
-        mol->CountAtoms(); // recount atoms
-        if (mol->getAtomCount() != 0) {  // if there is more than none
-          count = mol->getAtomCount();  // is changed becausing of adding, thus has to be stored away beforehand
-          Elements = new element *[count];
-          vectors = new Vector *[count];
-          j = 0;
-          first = mol->start;
-          while (first->next != mol->end) { // make a list of all atoms with coordinates and element
-            first = first->next;
-            Elements[j] = first->type;
-            vectors[j] = &first->x;
-            j++;
+          }
-          if (count != j)
-            DoeLog(1) && (eLog()<< Verbose(1) << "AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl);
-          x.Zero();
-          y.Zero();
-          y.x[abs(axis)-1] = World::getInstance().getDomain()[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] * abs(axis)/axis; // last term is for sign, first is for magnitude
-          for (int i=1;i<faktor;i++) {  // then add this list with respective translation factor times
-            x.AddVector(&y); // per factor one cell width further
-            for (int k=count;k--;) { // go through every atom of the original cell
-              first = new atom(); // create a new body
-              first->x.CopyVector(vectors[k]);  // use coordinate of original atom
-              first->x.AddVector(&x);     // translate the coordinates
-              first->type = Elements[k];  // insert original element
-              mol->AddAtom(first);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
+            }
+          }
-          if (mol->first->next != mol->last) // if connect matrix is present already, redo it
-            mol->CreateAdjacencyList(mol->BondDistance, configuration->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
-          // free memory
-          delete[](Elements);
-          delete[](vectors);
-          // correct cell size
-          if (axis < 0) { // if sign was negative, we have to translate everything
-            x.Zero();
-            x.AddVector(&y);
-            x.Scale(-(faktor-1));
-            mol->Translate(&x);
+          }
-          World::getInstance().getDomain()[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+        }
+      }
-      break;
-    case 'f':
-      FragmentAtoms(mol, configuration);
-      break;
-    case 'g': // center the atoms
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-        mol = *ListRunner;
-        DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
-        CenterAtoms(mol);
+      }
-      break;
-    case 'i': // align all atoms
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-        mol = *ListRunner;
-        DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
-        AlignAtoms(periode, mol);
+      }
-      break;
-    case 'm': // mirror atoms along a given axis
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-        mol = *ListRunner;
-        DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
-        MirrorAtoms(mol);
+      }
-      break;
-    case 'o': // create the connection matrix
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-          mol = *ListRunner;
-          double bonddistance;
-          clock_t start,end;
-          DoLog(0) && (Log() << Verbose(0) << "What's the maximum bond distance: ");
-          cin >> bonddistance;
-          start = clock();
-          mol->CreateAdjacencyList(bonddistance, configuration->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
-          end = clock();
-          DoLog(0) && (Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl);
+        }
-      break;
-    case 't': // translate all atoms
-      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if ((*ListRunner)->ActiveFlag) {
-        mol = *ListRunner;
-        DoLog(0) && (Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl);
-        DoLog(0) && (Log() << Verbose(0) << "Enter translation vector." << endl);
-        x.AskPosition(World::getInstance().getDomain(),0);
-        mol->Center.AddVector((const Vector *)&x);
+     }
-     break;
+  }
-  // Free all
-  if (Subgraphs != NULL) {  // free disconnected subgraph list of DFS analysis was performed
-    while (Subgraphs->next != NULL) {
-      Subgraphs = Subgraphs->next;
-      delete(Subgraphs->previous);
+    }
-    delete(Subgraphs);
+  }
-};
-/** Submenu for creating new molecules.
- * \param *periode periodentafel
- * \param *molecules list of molecules to add to
- */
-static void EditMolecules(periodentafel *periode, MoleculeListClass *molecules)
+{
-  char choice;  // menu choice char
-  Vector center;
-  int nr, count;
-  molecule *mol = NULL;
-  DoLog(0) && (Log() << Verbose(0) << "==========EDIT MOLECULES=====================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "c - create new molecule" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "l - load molecule from xyz file" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "n - change molecule's name" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "N - give molecules filename" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "p - parse atoms in xyz file into molecule" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "r - remove a molecule" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "all else - go back" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "===============================================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "INPUT: ");
-  cin >> choice;
-  switch (choice) {
-    default:
-      DoLog(0) && (Log() << Verbose(0) << "Not a valid choice." << endl);
-      break;
-    case 'c':
-      mol = World::getInstance().createMolecule();
-      molecules->insert(mol);
-      break;
-    case 'l': // load from XYZ file
+      {
-        char filename[MAXSTRINGSIZE];
-        DoLog(0) && (Log() << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl);
-        mol = World::getInstance().createMolecule();
-        do {
-          DoLog(0) && (Log() << Verbose(0) << "Enter file name: ");
-          cin >> filename;
-        } while (!mol->AddXYZFile(filename));
-        mol->SetNameFromFilename(filename);
-        // center at set box dimensions
-        mol->CenterEdge(&center);
-        double * const cell_size = World::getInstance().getDomain();
-        cell_size[0] = center.x[0];
-        cell_size[1] = 0;
-        cell_size[2] = center.x[1];
-        cell_size[3] = 0;
-        cell_size[4] = 0;
-        cell_size[5] = center.x[2];
-        molecules->insert(mol);
+      }
-      break;
-    case 'n':
+      {
-        char filename[MAXSTRINGSIZE];
-        do {
-          DoLog(0) && (Log() << Verbose(0) << "Enter index of molecule: ");
-          cin >> nr;
-          mol = molecules->ReturnIndex(nr);
-        } while (mol == NULL);
-        DoLog(0) && (Log() << Verbose(0) << "Enter name: ");
-        cin >> filename;
-        strcpy(mol->name, filename);
+      }
-      break;
-    case 'N':
+      {
-        char filename[MAXSTRINGSIZE];
-        do {
-          DoLog(0) && (Log() << Verbose(0) << "Enter index of molecule: ");
-          cin >> nr;
-          mol = molecules->ReturnIndex(nr);
-        } while (mol == NULL);
-        DoLog(0) && (Log() << Verbose(0) << "Enter name: ");
-        cin >> filename;
-        mol->SetNameFromFilename(filename);
+      }
-      break;
-    case 'p': // parse XYZ file
+      {
-        char filename[MAXSTRINGSIZE];
-        mol = NULL;
-        do {
-          DoLog(0) && (Log() << Verbose(0) << "Enter index of molecule: ");
-          cin >> nr;
-          mol = molecules->ReturnIndex(nr);
-        } while (mol == NULL);
-        DoLog(0) && (Log() << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl);
-        do {
-          DoLog(0) && (Log() << Verbose(0) << "Enter file name: ");
-          cin >> filename;
-        } while (!mol->AddXYZFile(filename));
-        mol->SetNameFromFilename(filename);
+      }
-      break;
-    case 'r':
-      DoLog(0) && (Log() << Verbose(0) << "Enter index of molecule: ");
-      cin >> nr;
-      count = 1;
-      for(MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-        if (nr == (*ListRunner)->IndexNr) {
-          mol = *ListRunner;
-          molecules->ListOfMolecules.erase(ListRunner);
-          delete(mol);
-          break;
+        }
-      break;
+  }
-};
-/** Submenu for merging molecules.
- * \param *periode periodentafel
- * \param *molecules list of molecules to add to
- */
-static void MergeMolecules(periodentafel *periode, MoleculeListClass *molecules)
+{
-  char choice;  // menu choice char
-  DoLog(0) && (Log() << Verbose(0) << "===========MERGE MOLECULES=====================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "a - simple add of one molecule to another" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "b - count the number of bonds of two elements" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "B - count the number of bonds of three elements " << endl);
-  DoLog(0) && (Log() << Verbose(0) << "e - embedding merge of two molecules" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "h - count the number of hydrogen bonds" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "b - count the number of hydrogen bonds" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "m - multi-merge of all molecules" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "s - scatter merge of two molecules" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "t - simple merge of two molecules" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "all else - go back" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "===============================================" << endl);
-  DoLog(0) && (Log() << Verbose(0) << "INPUT: ");
-  cin >> choice;
-  switch (choice) {
-    default:
-      DoLog(0) && (Log() << Verbose(0) << "Not a valid choice." << endl);
-      break;
-    case 'a':
+      {
-        int src, dest;
-        molecule *srcmol = NULL, *destmol = NULL;
+        {
-          do {
-            DoLog(0) && (Log() << Verbose(0) << "Enter index of destination molecule: ");
-            cin >> dest;
-            destmol = molecules->ReturnIndex(dest);
-          } while ((destmol == NULL) && (dest != -1));
-          do {
-            DoLog(0) && (Log() << Verbose(0) << "Enter index of source molecule to add from: ");
-            cin >> src;
-            srcmol = molecules->ReturnIndex(src);
-          } while ((srcmol == NULL) && (src != -1));
-          if ((src != -1) && (dest != -1))
-            molecules->SimpleAdd(srcmol, destmol);
+        }
+      }
-      break;
-    case 'b':
+      {
-        const int nr = 2;
-        char *names[nr] = {"first", "second"};
-        int Z[nr];
-        element *elements[nr];
-        for (int i=0;i<nr;i++) {
-          Z[i] = 0;
-          do {
-            cout << "Enter " << names[i] << " element: ";
-            cin >> Z[i];
-          } while ((Z[i] <= 0) && (Z[i] > MAX_ELEMENTS));
-          elements[i] = periode->FindElement(Z[i]);
+        }
-        const int count = CountBondsOfTwo(molecules, elements[0], elements[1]);
-        cout << endl << "There are " << count << " ";
-        for (int i=0;i<nr;i++) {
-          if (i==0)
-            cout << elements[i]->symbol;
-          else
-            cout << "-" << elements[i]->symbol;
+        }
-        cout << " bonds." << endl;
+      }
-    break;
-    case 'B':
+      {
-        const int nr = 3;
-        char *names[nr] = {"first", "second", "third"};
-        int Z[nr];
-        element *elements[nr];
-        for (int i=0;i<nr;i++) {
-          Z[i] = 0;
-          do {
-            cout << "Enter " << names[i] << " element: ";
-            cin >> Z[i];
-          } while ((Z[i] <= 0) && (Z[i] > MAX_ELEMENTS));
-          elements[i] = periode->FindElement(Z[i]);
+        }
-        const int count = CountBondsOfThree(molecules, elements[0], elements[1], elements[2]);
-        cout << endl << "There are " << count << " ";
-        for (int i=0;i<nr;i++) {
-          if (i==0)
-            cout << elements[i]->symbol;
-          else
-            cout << "-" << elements[i]->symbol;
+        }
-        cout << " bonds." << endl;
+      }
-    break;
-    case 'e':
+      {
-        int src, dest;
-        molecule *srcmol = NULL, *destmol = NULL;
-        do {
-          DoLog(0) && (Log() << Verbose(0) << "Enter index of matrix molecule (the variable one): ");
-          cin >> src;
-          srcmol = molecules->ReturnIndex(src);
-        } while ((srcmol == NULL) && (src != -1));
-        do {
-          DoLog(0) && (Log() << Verbose(0) << "Enter index of molecule to merge into (the fixed one): ");
-          cin >> dest;
-          destmol = molecules->ReturnIndex(dest);
-        } while ((destmol == NULL) && (dest != -1));
-        if ((src != -1) && (dest != -1))
-          molecules->EmbedMerge(destmol, srcmol);
+      }
-      break;
-    case 'h':
+      {
-        int Z;
-        cout << "Please enter interface element: ";
-        cin >> Z;
-        element * const InterfaceElement = periode->FindElement(Z);
-        cout << endl << "There are " << CountHydrogenBridgeBonds(molecules, InterfaceElement) << " hydrogen bridges with connections to " << (InterfaceElement != 0 ? InterfaceElement->name : "None") << "." << endl;
+      }
-      break;
-    case 'm':
+      {
-        int nr;
-        molecule *mol = NULL;
-        do {
-          DoLog(0) && (Log() << Verbose(0) << "Enter index of molecule to merge into: ");
-          cin >> nr;
-          mol = molecules->ReturnIndex(nr);
-        } while ((mol == NULL) && (nr != -1));
-        if (nr != -1) {
-          int N = molecules->ListOfMolecules.size()-1;
-          int *src = new int(N);
-          for(MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-            if ((*ListRunner)->IndexNr != nr)
-              src[N++] = (*ListRunner)->IndexNr;
-          molecules->SimpleMultiMerge(mol, src, N);
-          delete[](src);
+        }
+      }
-      break;
-    case 's':
-      DoLog(0) && (Log() << Verbose(0) << "Not implemented yet." << endl);
-      break;
-    case 't':
+      {
-        int src, dest;
-        molecule *srcmol = NULL, *destmol = NULL;
+        {
-          do {
-            DoLog(0) && (Log() << Verbose(0) << "Enter index of destination molecule: ");
-            cin >> dest;
-            destmol = molecules->ReturnIndex(dest);
-          } while ((destmol == NULL) && (dest != -1));
-          do {
-            DoLog(0) && (Log() << Verbose(0) << "Enter index of source molecule to merge into: ");
-            cin >> src;
-            srcmol = molecules->ReturnIndex(src);
-          } while ((srcmol == NULL) && (src != -1));
-          if ((src != -1) && (dest != -1))
-            molecules->SimpleMerge(srcmol, destmol);
+        }
+      }
-      break;
+  }
-};
-/********************************************** Test routine **************************************/
-/** Is called always as option 'T' in the menu.
- * \param *molecules list of molecules
- */
-static void testroutine(MoleculeListClass *molecules)
+{
-  // the current test routine checks the functionality of the KeySet&Graph concept:
-  // We want to have a multiindex (the KeySet) describing a unique subgraph
-  int i, comp, counter=0;
-  // create a clone
-  molecule *mol = NULL;
-  if (molecules->ListOfMolecules.size() != 0) // clone
-    mol = (molecules->ListOfMolecules.front())->CopyMolecule();
-  else {
-    DoeLog(0) && (eLog()<< Verbose(0) << "I don't have anything to test on ... ");
-    performCriticalExit();
-    return;
+  }
-  atom *Walker = mol->start;
-  // generate some KeySets
-  DoLog(0) && (Log() << Verbose(0) << "Generating KeySets." << endl);
-  KeySet TestSets[mol->getAtomCount()+1];
-  i=1;
-  while (Walker->next != mol->end) {
-    Walker = Walker->next;
-    for (int j=0;j<i;j++) {
-      TestSets[j].insert(Walker->nr);
+    }
-    i++;
+  }
-  DoLog(0) && (Log() << Verbose(0) << "Testing insertion of already present item in KeySets." << endl);
-  KeySetTestPair test;
-  test = TestSets[mol->getAtomCount()-1].insert(Walker->nr);
-  if (test.second) {
-    DoLog(1) && (Log() << Verbose(1) << "Insertion worked?!" << endl);
-  } else {
-    DoLog(1) && (Log() << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl);
+  }
-  TestSets[mol->getAtomCount()].insert(mol->end->previous->nr);
-  TestSets[mol->getAtomCount()].insert(mol->end->previous->previous->previous->nr);
-  // constructing Graph structure
-  DoLog(0) && (Log() << Verbose(0) << "Generating Subgraph class." << endl);
-  Graph Subgraphs;
-  // insert KeySets into Subgraphs
-  DoLog(0) && (Log() << Verbose(0) << "Inserting KeySets into Subgraph class." << endl);
-  for (int j=0;j<mol->getAtomCount();j++) {
-    Subgraphs.insert(GraphPair (TestSets[j],pair<int, double>(counter++, 1.)));
+  }
-  DoLog(0) && (Log() << Verbose(0) << "Testing insertion of already present item in Subgraph." << endl);
-  GraphTestPair test2;
-  test2 = Subgraphs.insert(GraphPair (TestSets[mol->getAtomCount()],pair<int, double>(counter++, 1.)));
-  if (test2.second) {
-    DoLog(1) && (Log() << Verbose(1) << "Insertion worked?!" << endl);
-  } else {
-    DoLog(1) && (Log() << Verbose(1) << "Insertion rejected: Present object is " << (*(test2.first)).second.first << "." << endl);
+  }
-  // show graphs
-  DoLog(0) && (Log() << Verbose(0) << "Showing Subgraph's contents, checking that it's sorted." << endl);
-  Graph::iterator A = Subgraphs.begin();
-  while (A !=  Subgraphs.end()) {
-    DoLog(0) && (Log() << Verbose(0) << (*A).second.first << ": ");
-    KeySet::iterator key = (*A).first.begin();
-    comp = -1;
-    while (key != (*A).first.end()) {
-      if ((*key) > comp)
-        DoLog(0) && (Log() << Verbose(0) << (*key) << " ");
-      else
-        DoLog(0) && (Log() << Verbose(0) << (*key) << "! ");
-      comp = (*key);
-      key++;
+    }
-    DoLog(0) && (Log() << Verbose(0) << endl);
-    A++;
+  }
-  delete(mol);
-};
-#endif
-/** Tries given filename or standard on saving the config file.
- * \param *ConfigFileName name of file
- * \param *configuration pointer to configuration structure with all the values
- * \param *periode pointer to periodentafel structure with all the elements
- * \param *molecules list of molecules structure with all the atoms and coordinates
- */
-static void SaveConfig(char *ConfigFileName, config *configuration, periodentafel *periode, MoleculeListClass *molecules)
+{
-  char filename[MAXSTRINGSIZE];
-  ofstream output;
-  molecule *mol = World::getInstance().createMolecule();
-  mol->SetNameFromFilename(ConfigFileName);
-  if (!strcmp(configuration->configpath, configuration->GetDefaultPath())) {
-    DoeLog(2) && (eLog()<< Verbose(2) << "config is found under different path then stated in config file::defaultpath!" << endl);
+  }
-  // first save as PDB data
-  if (ConfigFileName != NULL)
-    strcpy(filename, ConfigFileName);
-  if (output == NULL)
-    strcpy(filename,"main_pcp_linux");
-  DoLog(0) && (Log() << Verbose(0) << "Saving as pdb input ");
-  if (configuration->SavePDB(filename, molecules))
-    DoLog(0) && (Log() << Verbose(0) << "done." << endl);
-  else
-    DoLog(0) && (Log() << Verbose(0) << "failed." << endl);
-  // then save as tremolo data file
-  if (ConfigFileName != NULL)
-    strcpy(filename, ConfigFileName);
-  if (output == NULL)
-    strcpy(filename,"main_pcp_linux");
-  DoLog(0) && (Log() << Verbose(0) << "Saving as tremolo data input ");
-  if (configuration->SaveTREMOLO(filename, molecules))
-    DoLog(0) && (Log() << Verbose(0) << "done." << endl);
-  else
-    DoLog(0) && (Log() << Verbose(0) << "failed." << endl);
-  // translate each to its center and merge all molecules in MoleculeListClass into this molecule
-  int N = molecules->ListOfMolecules.size();
-  int *src = new int[N];
-  N=0;
-  for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
-    src[N++] = (*ListRunner)->IndexNr;
-    (*ListRunner)->Translate(&(*ListRunner)->Center);
+  }
-  molecules->SimpleMultiAdd(mol, src, N);
-  delete[](src);
-  // ... and translate back
-  for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
-    (*ListRunner)->Center.Scale(-1.);
-    (*ListRunner)->Translate(&(*ListRunner)->Center);
-    (*ListRunner)->Center.Scale(-1.);
+  }
-  DoLog(0) && (Log() << Verbose(0) << "Storing configuration ... " << endl);
-  // get correct valence orbitals
-  mol->CalculateOrbitals(*configuration);
-  configuration->InitMaxMinStopStep = configuration->MaxMinStopStep = configuration->MaxPsiDouble;
-  if (ConfigFileName != NULL) { // test the file name
-    strcpy(filename, ConfigFileName);
-    output.open(filename, ios::trunc);
-  } else if (strlen(configuration->configname) != 0) {
-    strcpy(filename, configuration->configname);
-    output.open(configuration->configname, ios::trunc);
-    } else {
-      strcpy(filename, DEFAULTCONFIG);
-      output.open(DEFAULTCONFIG, ios::trunc);
+    }
-  output.close();
-  output.clear();
-  DoLog(0) && (Log() << Verbose(0) << "Saving of config file ");
-  if (configuration->Save(filename, periode, mol))
-    DoLog(0) && (Log() << Verbose(0) << "successful." << endl);
-  else
-    DoLog(0) && (Log() << Verbose(0) << "failed." << endl);
-  // and save to xyz file
-  if (ConfigFileName != NULL) {
-    strcpy(filename, ConfigFileName);
-    strcat(filename, ".xyz");
-    output.open(filename, ios::trunc);
+  }
-  if (output == NULL) {
-    strcpy(filename,"main_pcp_linux");
-    strcat(filename, ".xyz");
-    output.open(filename, ios::trunc);
+  }
-  DoLog(0) && (Log() << Verbose(0) << "Saving of XYZ file ");
-  if (mol->MDSteps <= 1) {
-    if (mol->OutputXYZ(&output))
-      DoLog(0) && (Log() << Verbose(0) << "successful." << endl);
-    else
-      DoLog(0) && (Log() << Verbose(0) << "failed." << endl);
-  } else {
-    if (mol->OutputTrajectoriesXYZ(&output))
-      DoLog(0) && (Log() << Verbose(0) << "successful." << endl);
-    else
-      DoLog(0) && (Log() << Verbose(0) << "failed." << endl);
+  }
-  output.close();
-  output.clear();
-  // and save as MPQC configuration
-  if (ConfigFileName != NULL)
-    strcpy(filename, ConfigFileName);
-  if (output == NULL)
-    strcpy(filename,"main_pcp_linux");
-  DoLog(0) && (Log() << Verbose(0) << "Saving as mpqc input ");
-  if (configuration->SaveMPQC(filename, mol))
-    DoLog(0) && (Log() << Verbose(0) << "done." << endl);
-  else
-    DoLog(0) && (Log() << Verbose(0) << "failed." << endl);
-  if (!strcmp(configuration->configpath, configuration->GetDefaultPath())) {
-    DoeLog(2) && (eLog()<< Verbose(2) << "config is found under different path then stated in config file::defaultpath!" << endl);
+  }
-  World::getInstance().destroyMolecule(mol);
-};
-/** Parses the command line options.
- * Note that this function is from now on transitional. All commands that are not passed
- * here are handled by CommandLineParser and the actions of CommandLineUIFactory.
- * \param argc argument count
- * \param **argv arguments array
- * \param *molecules list of molecules structure
- * \param *periode elements structure
- * \param configuration config file structure
- * \param *ConfigFileName pointer to config file name in **argv
- * \param *PathToDatabases pointer to db's path in **argv
- * \param &ArgcList list of arguments that we do not parse here
- * \return exit code (0 - successful, all else - something's wrong)
- */
-static int ParseCommandLineOptions(int argc, char **argv, MoleculeListClass *&molecules, periodentafel *&periode,
-                                   config& configuration, char **ConfigFileName, set<int> &ArgcList)
+{
-  Vector x,y,z,n;  // coordinates for absolute point in cell volume
-  double *factor; // unit factor if desired
-  ifstream test;
-  ofstream output;
-  string line;
-  atom *first;
-  bool SaveFlag = false;
-  int ExitFlag = 0;
-  int j;
-  double volume = 0.;
-  enum ConfigStatus configPresent = absent;
-  clock_t start,end;
-  double MaxDistance = -1;
-  int argptr;
-  molecule *mol = NULL;
-  string BondGraphFileName("\n");
-  bool DatabasePathGiven = false;
-  if (argc > 1) { // config file specified as option
-    // 1. : Parse options that just set variables or print help
-    argptr = 1;
-    do {
-      if (argv[argptr][0] == '-') {
-        DoLog(0) && (Log() << Verbose(0) << "Recognized command line argument: " << argv[argptr][1] << ".\n");
-        argptr++;
-        switch(argv[argptr-1][1]) {
-          case 'h':
-          case 'H':
-          case '?':
-            ArgcList.insert(argptr-1);
-            return(1);
-            break;
-          case 'v':
-            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments for specifying verbosity: -v <level>" << endl);
-              performCriticalExit();
-            } else {
-              setVerbosity(atoi(argv[argptr]));
-              ArgcList.insert(argptr-1);
-              ArgcList.insert(argptr);
-              argptr++;
+            }
-            break;
-          case 'V':
-            ArgcList.insert(argptr-1);
-            return(1);
-            break;
-          case 'B':
-            if (ExitFlag == 0) ExitFlag = 1;
-            if ((argptr+5 >= argc)) {
-              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments for setting Box: -B <xx> <<xy> <<xz> <yy> <yz> <zz>" << endl);
-              performCriticalExit();
-            } else {
-              ArgcList.insert(argptr-1);
-              ArgcList.insert(argptr);
-              ArgcList.insert(argptr+1);
-              ArgcList.insert(argptr+2);
-              ArgcList.insert(argptr+3);
-              ArgcList.insert(argptr+4);
-              ArgcList.insert(argptr+5);
-              argptr+=6;
+            }
-            break;
-          case 'e':
-            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments for specifying element db: -e <db file>" << endl);
-              performCriticalExit();
-            } else {
-              ArgcList.insert(argptr-1);
-              ArgcList.insert(argptr);
-              argptr+=1;
+            }
-            break;
-          case 'g':
-            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments for specifying bond length table: -g <table file>" << endl);
-              performCriticalExit();
-            } else {
-              ArgcList.insert(argptr-1);
-              ArgcList.insert(argptr);
-              argptr+=1;
+            }
-            break;
-          case 'M':
-            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-              ExitFlag = 255;
-              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for setting MPQC basis: -M <basis name>" << endl);
-              performCriticalExit();
-            } else {
-              ArgcList.insert(argptr-1);
-              ArgcList.insert(argptr);
-              argptr+=1;
+            }
-            break;
-          case 'n':
-            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-              ExitFlag = 255;
-              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for setting fast-parsing: -n <0/1>" << endl);
-              performCriticalExit();
-            } else {
-              ArgcList.insert(argptr-1);
-              ArgcList.insert(argptr);
-              argptr+=1;
+            }
-            break;
-          case 'X':
-            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-              ExitFlag = 255;
-              DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for setting default molecule name: -X <name>" << endl);
-              performCriticalExit();
-            } else {
-              ArgcList.insert(argptr-1);
-              ArgcList.insert(argptr);
-              argptr+=1;
+            }
-            break;
-          default:   // no match? Step on
-            argptr++;
-            break;
+        }
-      } else
-        argptr++;
-    } while (argptr < argc);
-    // 3b. Find config file name and parse if possible, also BondGraphFileName
-    if (argv[1][0] != '-') {
-      // simply create a new molecule, wherein the config file is loaded and the manipulation takes place
-      DoLog(0) && (Log() << Verbose(0) << "Config file given." << endl);
-      test.open(argv[1], ios::in);
-      if (test == NULL) {
-        //return (1);
-        output.open(argv[1], ios::out);
-        if (output == NULL) {
-          DoLog(1) && (Log() << Verbose(1) << "Specified config file " << argv[1] << " not found." << endl);
-          configPresent = absent;
-        } else {
-          DoLog(0) && (Log() << Verbose(0) << "Empty configuration file." << endl);
-          strcpy(*ConfigFileName, argv[1]);
-          configPresent = empty;
-          output.close();
+        }
-      } else {
-        test.close();
-        strcpy(*ConfigFileName, argv[1]);
-        DoLog(1) && (Log() << Verbose(1) << "Specified config file found, parsing ... ");
-        switch (configuration.TestSyntax(*ConfigFileName, periode)) {
-          case 1:
-            DoLog(0) && (Log() << Verbose(0) << "new syntax." << endl);
-            configuration.Load(*ConfigFileName, BondGraphFileName, periode, molecules);
-            configPresent = present;
-            break;
-          case 0:
-            DoLog(0) && (Log() << Verbose(0) << "old syntax." << endl);
-            configuration.LoadOld(*ConfigFileName, BondGraphFileName, periode, molecules);
-            configPresent = present;
-            break;
-          default:
-            DoLog(0) && (Log() << Verbose(0) << "Unknown syntax or empty, yet present file." << endl);
-            configPresent = empty;
+       }
+      }
-    } else
-      configPresent = absent;
-     // set mol to first active molecule
-     if (molecules->ListOfMolecules.size() != 0) {
-       for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
-         if ((*ListRunner)->ActiveFlag) {
-           mol = *ListRunner;
-           break;
+         }
+     }
-     if (mol == NULL) {
-       mol = World::getInstance().createMolecule();
-       mol->ActiveFlag = true;
-       if (*ConfigFileName != NULL)
-         mol->SetNameFromFilename(*ConfigFileName);
-       molecules->insert(mol);
+     }
-    // 4. parse again through options, now for those depending on elements db and config presence
-    argptr = 1;
-    do {
-      DoLog(0) && (Log() << Verbose(0) << "Current Command line argument: " << argv[argptr] << "." << endl);
-      if (argv[argptr][0] == '-') {
-        argptr++;
-        if ((configPresent == present) || (configPresent == empty)) {
-          switch(argv[argptr-1][1]) {
-            case 'p':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough arguments for parsing: -p <xyz file>" << endl);
-                performCriticalExit();
-              } else {
-                SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Parsing xyz file for new atoms." << endl);
-                if (!mol->AddXYZFile(argv[argptr]))
-                  DoLog(2) && (Log() << Verbose(2) << "File not found." << endl);
-                else {
-                  DoLog(2) && (Log() << Verbose(2) << "File found and parsed." << endl);
-                  configPresent = present;
+                }
+              }
-              break;
-            case 'a':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+4 >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough arguments for adding atom: -a <Z> --position <x> <y> <z>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                ArgcList.insert(argptr+3);
-                ArgcList.insert(argptr+4);
-                argptr+=5;
+              }
-              break;
-            default:   // no match? Don't step on (this is done in next switch's default)
-              break;
+          }
+        }
-        if (configPresent == present) {
-          switch(argv[argptr-1][1]) {
-            case 'D':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for depth-first-search analysis: -D <max. bond distance>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                argptr+=1;
+              }
-              break;
-            case 'I':
-              DoLog(1) && (Log() << Verbose(1) << "Dissecting molecular system into a set of disconnected subgraphs ... " << endl);
-              ArgcList.insert(argptr-1);
-              argptr+=0;
-              break;
-            case 'C':
+              {
-                if (ExitFlag == 0) ExitFlag = 1;
-                if ((argptr+11 >= argc)) {
-                  ExitFlag = 255;
-                  DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for pair correlation analysis: -C[p] <type: E/P/S> [more params] <output> <bin output> <BinStart> <BinEnd>" << endl);
-                  performCriticalExit();
-                } else {
-                  switch(argv[argptr][0]) {
-                    case 'E':
-                      ArgcList.insert(argptr-1);
-                      ArgcList.insert(argptr);
-                      ArgcList.insert(argptr+1);
-                      ArgcList.insert(argptr+2);
-                      ArgcList.insert(argptr+3);
-                      ArgcList.insert(argptr+4);
-                      ArgcList.insert(argptr+5);
-                      ArgcList.insert(argptr+6);
-                      ArgcList.insert(argptr+7);
-                      ArgcList.insert(argptr+8);
-                      ArgcList.insert(argptr+9);
-                      ArgcList.insert(argptr+10);
-                      ArgcList.insert(argptr+11);
-                      argptr+=12;
-                      break;
-                    case 'P':
-                      ArgcList.insert(argptr-1);
-                      ArgcList.insert(argptr);
-                      ArgcList.insert(argptr+1);
-                      ArgcList.insert(argptr+2);
-                      ArgcList.insert(argptr+3);
-                      ArgcList.insert(argptr+4);
-                      ArgcList.insert(argptr+5);
-                      ArgcList.insert(argptr+6);
-                      ArgcList.insert(argptr+7);
-                      ArgcList.insert(argptr+8);
-                      ArgcList.insert(argptr+9);
-                      ArgcList.insert(argptr+10);
-                      ArgcList.insert(argptr+11);
-                      ArgcList.insert(argptr+12);
-                      ArgcList.insert(argptr+13);
-                      ArgcList.insert(argptr+14);
-                      argptr+=15;
-                      break;
-                    case 'S':
-                      ArgcList.insert(argptr-1);
-                      ArgcList.insert(argptr);
-                      ArgcList.insert(argptr+1);
-                      ArgcList.insert(argptr+2);
-                      ArgcList.insert(argptr+3);
-                      ArgcList.insert(argptr+4);
-                      ArgcList.insert(argptr+5);
-                      ArgcList.insert(argptr+6);
-                      ArgcList.insert(argptr+7);
-                      ArgcList.insert(argptr+8);
-                      ArgcList.insert(argptr+9);
-                      ArgcList.insert(argptr+10);
-                      ArgcList.insert(argptr+11);
-                      ArgcList.insert(argptr+12);
-                      ArgcList.insert(argptr+13);
-                      ArgcList.insert(argptr+14);
-                      argptr+=15;
-                      break;
-                    default:
-                      ExitFlag = 255;
-                      DoeLog(0) && (eLog()<< Verbose(0) << "Invalid type given for pair correlation analysis: -C <type: E/P/S> [more params] <output> <bin output>" << endl);
-                      performCriticalExit();
-                      break;
+                  }
+                }
-                break;
+              }
-            case 'E':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr]))) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for changing element: -E <atom nr.> --element <Z>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                argptr+=3;
+              }
-              break;
-            case 'F':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+12 >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for filling with molecule: -F <filler xyz file> --MaxDistance <distance or -1> --distances <x> <y> <z>  --lengths <surface> <randatm> <randmol> --DoRotate <0/1>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                ArgcList.insert(argptr+3);
-                ArgcList.insert(argptr+4);
-                ArgcList.insert(argptr+5);
-                ArgcList.insert(argptr+6);
-                ArgcList.insert(argptr+7);
-                ArgcList.insert(argptr+8);
-                ArgcList.insert(argptr+9);
-                ArgcList.insert(argptr+10);
-                ArgcList.insert(argptr+11);
-                ArgcList.insert(argptr+12);
-                argptr+=13;
+              }
-              break;
-            case 'A':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+2 >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag =255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Missing source file for bonds in molecule: -A <bond sourcefile> --molecule-by-id <molecule_id>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                argptr+=3;
+              }
-              break;
-            case 'J':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+2 >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag =255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Missing path of adjacency file: -J <path> --molecule-by-id <molecule_id>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                argptr+=3;
+              }
-              break;
-            case 'j':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag =255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Missing path of bonds file: -j <path> --molecule-by-id <molecule_id>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                argptr+=3;
+              }
-              break;
-            case 'N':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+4 >= argc) || (argv[argptr][0] == '-')){
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for non-convex envelope: -N <molecule_id> --sphere-radius <radius> --nonconvex-file <output prefix>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                ArgcList.insert(argptr+3);
-                ArgcList.insert(argptr+4);
-                argptr+=5;
+              }
-              break;
-            case 'S':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+2 >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for storing tempature: -S <temperature file> --molecule-by-id 0" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                argptr+=3;
+              }
-              break;
-            case 'L':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+8 >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for linear interpolation: -L <prefix> --start-step <step0> --end-step <step1> --molecule-by-id 0 --id-mapping <0/1>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                ArgcList.insert(argptr+3);
-                ArgcList.insert(argptr+4);
-                ArgcList.insert(argptr+5);
-                ArgcList.insert(argptr+6);
-                ArgcList.insert(argptr+7);
-                ArgcList.insert(argptr+8);
-                argptr+=9;
+              }
-              break;
-            case 'P':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+2 >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for parsing and integrating forces: -P <forces file> --molecule-by-id <molecule_id>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                argptr+=3;
+              }
-              break;
-            case 'R':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+4 >= argc) || (argv[argptr][0] == '-'))  {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for removing atoms: -R <distance> --position <x> <y> <z>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                ArgcList.insert(argptr+3);
-                ArgcList.insert(argptr+4);
-                argptr+=5;
+              }
-              break;
-            case 't':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+4 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for translation: -t <x> <y> <z> --molecule-by-id <molecule_id> --periodic <0/1>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                ArgcList.insert(argptr+3);
-                ArgcList.insert(argptr+4);
-                ArgcList.insert(argptr+5);
-                ArgcList.insert(argptr+6);
-                argptr+=7;
+              }
-              break;
-            case 's':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for scaling: -s <factor_x> [factor_y] [factor_z]" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                argptr+=3;
+              }
-              break;
-            case 'b':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+5 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3])) || (!IsValidNumber(argv[argptr+4])) || (!IsValidNumber(argv[argptr+5])) ) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for centering in box: -b <xx> <xy> <xz> <yy> <yz> <zz>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                ArgcList.insert(argptr+3);
-                ArgcList.insert(argptr+4);
-                ArgcList.insert(argptr+5);
-                argptr+=6;
+              }
-              break;
-            case 'B':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+5 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3])) || (!IsValidNumber(argv[argptr+4])) || (!IsValidNumber(argv[argptr+5])) ) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for bounding in box: -B <xx> <xy> <xz> <yy> <yz> <zz>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                ArgcList.insert(argptr+3);
-                ArgcList.insert(argptr+4);
-                ArgcList.insert(argptr+5);
-                argptr+=6;
+              }
-              break;
-            case 'c':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+2 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for centering with boundary: -c <boundary_x> <boundary_y> <boundary_z>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                argptr+=3;
+              }
-              break;
-            case 'O':
-              if (ExitFlag == 0) ExitFlag = 1;
-              ArgcList.insert(argptr-1);
-              argptr+=0;
-              break;
-            case 'r':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])))  {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for removing atoms: -r <id>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                argptr+=1;
+              }
-              break;
-            case 'f':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+1 >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments for fragmentation: -f <max. bond distance> <bond order>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                ArgcList.insert(argptr+3);
-                ArgcList.insert(argptr+4);
-                argptr+=5;
+              }
-              break;
-            case 'm':
-              if (ExitFlag == 0) ExitFlag = 1;
-              j = atoi(argv[argptr++]);
-              if ((j<0) || (j>1)) {
-                DoeLog(1) && (eLog()<< Verbose(1) << "Argument of '-m' should be either 0 for no-rotate or 1 for rotate." << endl);
-                j = 0;
+              }
-              if (j) {
-                SaveFlag = true;
-                DoLog(0) && (Log() << Verbose(0) << "Converting to prinicipal axis system." << endl);
-                mol->PrincipalAxisSystem((bool)j);
-              } else
-                ArgcList.insert(argptr-1);
-                argptr+=0;
-              break;
-            case 'o':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+4 >= argc) || (argv[argptr][0] == '-')){
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for convex envelope: -o <molecule_id> --output-file <output file> --output-file <binned output file>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                ArgcList.insert(argptr+3);
-                ArgcList.insert(argptr+4);
-                argptr+=5;
+              }
-              break;
-            case 'U':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+1 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) ) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for suspension with specified volume: -U <volume> <density>" << endl);
-                performCriticalExit();
-              } else {
-                volume = atof(argv[argptr++]);
-                DoLog(0) && (Log() << Verbose(0) << "Using " << volume << " angstrom^3 as the volume instead of convex envelope one's." << endl);
+              }
-            case 'u':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) ) {
-                if (volume != -1)
-                  ExitFlag = 255;
-                  DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for suspension: -u <density>" << endl);
-                  performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                argptr+=1;
+              }
-              break;
-            case 'd':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+2 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for repeating cells: -d <repeat_x> <repeat_y> <repeat_z>" << endl);
-                performCriticalExit();
-              } else {
-                ArgcList.insert(argptr-1);
-                ArgcList.insert(argptr);
-                ArgcList.insert(argptr+1);
-                ArgcList.insert(argptr+2);
-                argptr+=3;
+              }
-              break;
-            default:   // no match? Step on
-              if ((argptr < argc) && (argv[argptr][0] != '-')) // if it started with a '-' we've already made a step!
-                argptr++;
-              break;
+          }
+        }
-      } else argptr++;
-    } while (argptr < argc);
-    if (SaveFlag)
-      configuration.SaveAll(*ConfigFileName, periode, molecules);
-  } else {  // no arguments, hence scan the elements db
-    if (periode->LoadPeriodentafel(configuration.databasepath))
-      DoLog(0) && (Log() << Verbose(0) << "Element list loaded successfully." << endl);
-    else
-      DoLog(0) && (Log() << Verbose(0) << "Element list loading failed." << endl);
-    configuration.RetrieveConfigPathAndName("main_pcp_linux");
+  }
-  return(ExitFlag);
-};
 /********************************************** Main routine **************************************/
 void cleanUp(){
+  FormatParserStorage::purgeInstance();
+  ChangeTracker::purgeInstance();
   World::purgeInstance();
   logger::purgeInstance();
 …
+}
+void dumpMemory(){
+  ofstream ost("molecuilder.memdump");
+  Memory::dumpMemory(ost);
+}
 int main(int argc, char **argv)
+{
+    config *configuration = World::getInstance().getConfig();
+    // while we are non interactive, we want to abort from asserts
+    //ASSERT_DO(Assert::Abort);
+    molecule *mol = NULL;
+    Vector x, y, z, n;
+    ifstream test;
+    ofstream output;
+    string line;
+    char **Arguments = NULL;
+    int ArgcSize = 0;
+    int ExitFlag = 0;
+    bool ArgumentsCopied = false;
+    char *ConfigFileName = new char[MAXSTRINGSIZE];
+  // while we are non interactive, we want to abort from asserts
+  ASSERT_DO(Assert::Abort);
+  ASSERT_HOOK(dumpMemory);
+  string line;
+  char **Arguments = NULL;
+  int ArgcSize = 0;
+  int ExitFlag = 0;
+  bool ArgumentsCopied = false;
+  std::string BondGraphFileName("\n");
+    // print version check whether arguments are present at all
+    cout << ESPACKVersion << endl;
+    if (argc < 2) {
+      cout << "Obtain help with " << argv[0] << " -h." << endl;
+      cleanUp();
+      Memory::getState();
+      return(1);
+  // print version check whether arguments are present at all
+  cout << ESPACKVersion << endl;
+  setVerbosity(0);
+  // need to init the history before any action is created
+  ActionHistory::init();
+  // from this moment on, we need to be sure to deeinitialize in the correct order
+  // this is handled by the cleanup function
+  atexit(cleanUp);
+  // Parse command line options and if present create respective UI
+  {
+    // construct bond graph
+    if (World::getInstance().getConfig()->BG == NULL) {
+      World::getInstance().getConfig()->BG = new BondGraph(World::getInstance().getConfig()->GetIsAngstroem());
+      if (World::getInstance().getConfig()->BG->LoadBondLengthTable(BondGraphFileName)) {
+        DoLog(0) && (Log() << Verbose(0) << "Bond length table loaded successfully." << endl);
+      } else {
+        DoeLog(1) && (eLog()<< Verbose(1) << "Bond length table loading failed." << endl);
+      }
+    }
+    setVerbosity(0);
+    // need to init the history before any action is created
+    ActionHistory::init();
+    // In the interactive mode, we can leave the user the choice in case of error
+    ASSERT_DO(Assert::Ask);
+    // from this moment on, we need to be sure to deeinitialize in the correct order
+    // this is handled by the cleanup function
+    atexit(cleanUp);
+    // Parse command line options and if present create respective UI
+    {
+      set<int> ArgcList;
+      ArgcList.insert(0); // push back program!
+      ArgcList.insert(1); // push back config file name
+      // handle arguments by ParseCommandLineOptions()
+      ExitFlag = ParseCommandLineOptions(argc,argv,World::getInstance().getMolecules(),World::getInstance().getPeriode(),*World::getInstance().getConfig(), &ConfigFileName, ArgcList);
+      World::getInstance().setExitFlag(ExitFlag);
+      // copy all remaining arguments to a new argv
+      Arguments = new char *[ArgcList.size()];
+      cout << "The following arguments are handled by CommandLineParser: ";
+      for (set<int>::iterator ArgcRunner = ArgcList.begin(); ArgcRunner != ArgcList.end(); ++ArgcRunner) {
+        Arguments[ArgcSize] = new char[strlen(argv[*ArgcRunner])+2];
+        strcpy(Arguments[ArgcSize], argv[*ArgcRunner]);
+        cout << " " << argv[*ArgcRunner];
+        ArgcSize++;
+      }
+      cout << endl;
+      ArgumentsCopied = true;
+      // handle remaining arguments by CommandLineParser
+    // handle remaining arguments by CommandLineParser
+    if (argc>1) {
       MapOfActions::getInstance().AddOptionsToParser();
       map <std::string, std::string> ShortFormToActionMap = MapOfActions::getInstance().getShortFormToActionMap();
+      CommandLineParser::getInstance().Run(ArgcSize,Arguments, ShortFormToActionMap);
+      if (!CommandLineParser::getInstance().isEmpty()) {
+        DoLog(0) && (Log() << Verbose(0) << "Setting UI to CommandLine." << endl);
+        UIFactory::registerFactory(new CommandLineUIFactory::description());
+        UIFactory::makeUserInterface("CommandLine");
+      } else {
+      CommandLineParser::getInstance().Run(argc,argv, ShortFormToActionMap);
+      DoLog(0) && (Log() << Verbose(0) << "Setting UI to CommandLine." << endl);
+      UIFactory::registerFactory(new CommandLineUIFactory::description());
+      UIFactory::makeUserInterface("CommandLine");
+    } else {
+      // In the interactive mode, we can leave the user the choice in case of error
+      ASSERT_DO(Assert::Ask);
+      #ifdef USE_GUI_QT
+        DoLog(0) && (Log() << Verbose(0) << "Setting UI to QT4." << endl);
+        UIFactory::registerFactory(new QTUIFactory::description());
+        UIFactory::makeUserInterface("QT4");
+      #else
         DoLog(0) && (Log() << Verbose(0) << "Setting UI to Text." << endl);
+        cout << ESPACKVersion << endl;
         UIFactory::registerFactory(new TextUIFactory::description());
         UIFactory::makeUserInterface("Text");
+      }
+      #endif
+    }
+  }
+    {
       MainWindow *mainWindow = UIFactory::getInstance().makeMainWindow();
       mainWindow->display();
       delete mainWindow;
+    }
+  {
+    MainWindow *mainWindow = UIFactory::getInstance().makeMainWindow();
+    mainWindow->display();
+    delete mainWindow;
+  }
     Log() << Verbose(0) << "Saving to " << ConfigFileName << "." << endl;
     World::getInstance().getConfig()->SaveAll(ConfigFileName, World::getInstance().getPeriode(), World::getInstance().getMolecules());
+  FormatParserStorage::getInstance().SaveAll();
+  ChangeTracker::getInstance().saveStatus();
   // free the new argv
 …
     delete[](Arguments);
+  }
   delete[](ConfigFileName);
+  //delete[](ConfigFileName);
   ExitFlag = World::getInstance().getExitFlag();

src/config.cpp

-              r06f4ef6
+              rb6da28
 #include <cstring>
-#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
+#include "bondgraph.hpp"
 #include "config.hpp"
+#include "ConfigFileBuffer.hpp"
 #include "element.hpp"
 #include "helpers.hpp"
 #include "info.hpp"
 #include "lists.hpp"
+#include "verbose.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
-#include "memoryallocator.hpp"
 #include "molecule.hpp"
 #include "periodentafel.hpp"
+#include "ThermoStatContainer.hpp"
 #include "World.hpp"
+/******************************** Functions for class ConfigFileBuffer **********************/
+/** Structure containing compare function for Ion_Type sorting.
+ */
+struct IonTypeCompare {
+  bool operator()(const char* s1, const char *s2) const {
+    char number1[8];
+    char number2[8];
+    const char *dummy1, *dummy2;
+    //Log() << Verbose(0) << s1 << "  " << s2 << endl;
+    dummy1 = strchr(s1, '_')+sizeof(char)*5;  // go just after "Ion_Type"
+    dummy2 = strchr(dummy1, '_');
+    strncpy(number1, dummy1, dummy2-dummy1); // copy the number
+    number1[dummy2-dummy1]='\0';
+    dummy1 = strchr(s2, '_')+sizeof(char)*5;  // go just after "Ion_Type"
+    dummy2 = strchr(dummy1, '_');
+    strncpy(number2, dummy1, dummy2-dummy1); // copy the number
+    number2[dummy2-dummy1]='\0';
+    if (atoi(number1) != atoi(number2))
+      return (atoi(number1) < atoi(number2));
+    else {
+      dummy1 = strchr(s1, '_')+sizeof(char);
+      dummy1 = strchr(dummy1, '_')+sizeof(char);
+      dummy2 = strchr(dummy1, ' ') < strchr(dummy1, '\t') ? strchr(dummy1, ' ') : strchr(dummy1, '\t');
+      strncpy(number1, dummy1, dummy2-dummy1); // copy the number
+      number1[dummy2-dummy1]='\0';
+      dummy1 = strchr(s2, '_')+sizeof(char);
+      dummy1 = strchr(dummy1, '_')+sizeof(char);
+      dummy2 = strchr(dummy1, ' ') < strchr(dummy1, '\t') ? strchr(dummy1, ' ') : strchr(dummy1, '\t');
+      strncpy(number2, dummy1, dummy2-dummy1); // copy the number
+      number2[dummy2-dummy1]='\0';
+      return (atoi(number1) < atoi(number2));
+    }
+  }
+};
+/** Constructor for ConfigFileBuffer class.
+ */
+ConfigFileBuffer::ConfigFileBuffer() : buffer(NULL), LineMapping(NULL), CurrentLine(0), NoLines(0)
+{
+};
+/** Constructor for ConfigFileBuffer class with filename to be parsed.
+ * \param *filename file name
+ */
+ConfigFileBuffer::ConfigFileBuffer(const char * const filename) : buffer(NULL), LineMapping(NULL), CurrentLine(0), NoLines(0)
+{
+  ifstream *file = NULL;
+  char line[MAXSTRINGSIZE];
+  // prescan number of lines
+  file= new ifstream(filename);
+  if (file == NULL) {
+    DoeLog(1) && (eLog()<< Verbose(1) << "config file " << filename << " missing!" << endl);
+    return;
+  }
+  NoLines = 0; // we're overcounting by one
+  long file_position = file->tellg(); // mark current position
+  do {
+    file->getline(line, 256);
+    NoLines++;
+  } while (!file->eof());
+  file->clear();
+  file->seekg(file_position, ios::beg);
+  DoLog(1) && (Log() << Verbose(1) << NoLines-1 << " lines were recognized." << endl);
+  // allocate buffer's 1st dimension
+  if (buffer != NULL) {
+    DoeLog(1) && (eLog()<< Verbose(1) << "FileBuffer->buffer is not NULL!" << endl);
+    return;
+  } else
+    buffer = new char *[NoLines];
+  // scan each line and put into buffer
+  int lines=0;
+  int i;
+  do {
+    buffer[lines] = new char[MAXSTRINGSIZE];
+    file->getline(buffer[lines], MAXSTRINGSIZE-1);
+    i = strlen(buffer[lines]);
+    buffer[lines][i] = '\n';
+    buffer[lines][i+1] = '\0';
+    lines++;
+  } while((!file->eof()) && (lines < NoLines));
+  DoLog(1) && (Log() << Verbose(1) << lines-1 << " lines were read into the buffer." << endl);
+  // close and exit
+  file->close();
+  file->clear();
+  delete(file);
+}
+/** Destructor for ConfigFileBuffer class.
+ */
+ConfigFileBuffer::~ConfigFileBuffer()
+{
+  for(int i=0;i<NoLines;++i)
+    delete[](buffer[i]);
+  delete[](buffer);
+  delete[](LineMapping);
+}
+/** Create trivial mapping.
+ */
+void ConfigFileBuffer::InitMapping()
+{
+  LineMapping = new int[NoLines];
+  for (int i=0;i<NoLines;i++)
+    LineMapping[i] = i;
+}
+/** Creates a mapping for the \a *FileBuffer's lines containing the Ion_Type keyword such that they are sorted.
+ * \a *map on return contains a list of NoAtom entries such that going through the list, yields indices to the
+ * lines in \a *FileBuffer in a sorted manner of the Ion_Type?_? keywords. We assume that ConfigFileBuffer::CurrentLine
+ * points to first Ion_Type entry.
+ * \param *FileBuffer pointer to buffer structure
+ * \param NoAtoms of subsequent lines to look at
+ */
+void ConfigFileBuffer::MapIonTypesInBuffer(const int NoAtoms)
+{
+  map<const char *, int, IonTypeCompare> IonTypeLineMap;
+  if (LineMapping == NULL) {
+    DoeLog(0) && (eLog()<< Verbose(0) << "map pointer is NULL: " << LineMapping << endl);
+    performCriticalExit();
+    return;
+  }
+  // put all into hashed map
+  for (int i=0; i<NoAtoms; ++i) {
+    IonTypeLineMap.insert(pair<const char *, int> (buffer[CurrentLine+i], CurrentLine+i));
+  }
+  // fill map
+  int nr=0;
+  for (map<const char *, int, IonTypeCompare>::iterator runner = IonTypeLineMap.begin(); runner != IonTypeLineMap.end(); ++runner) {
+    if (CurrentLine+nr < NoLines)
+      LineMapping[CurrentLine+(nr++)] = runner->second;
+    else {
+      DoeLog(0) && (eLog()<< Verbose(0) << "config::MapIonTypesInBuffer - NoAtoms is wrong: We are past the end of the file!" << endl);
+      performCriticalExit();
+    }
+  }
+}
+#include "Matrix.hpp"
+#include "Box.hpp"
 /************************************* Functions for class config ***************************/
 …
 /** Constructor for config file class.
  */
+config::config() : BG(NULL), PsiType(0), MaxPsiDouble(0), PsiMaxNoUp(0), PsiMaxNoDown(0), MaxMinStopStep(1), InitMaxMinStopStep(1), ProcPEGamma(8), ProcPEPsi(1), configpath(NULL),
+    configname(NULL), FastParsing(false), Deltat(0.01), basis(""), databasepath(NULL), DoConstrainedMD(0), MaxOuterStep(0), Thermostat(4), ThermostatImplemented(NULL),
+    ThermostatNames(NULL), TempFrequency(2.5), alpha(0.), HooverMass(0.), TargetTemp(0.00095004455), ScaleTempStep(25),  mainname(NULL), defaultpath(NULL), pseudopotpath(NULL),
+config::config() : BG(NULL), Thermostats(0), PsiType(0), MaxPsiDouble(0), PsiMaxNoUp(0), PsiMaxNoDown(0), MaxMinStopStep(1), InitMaxMinStopStep(1), ProcPEGamma(8), ProcPEPsi(1),
+    configname(NULL), FastParsing(false), Deltat(0.01), basis(""), databasepath(NULL), DoConstrainedMD(0), MaxOuterStep(0), mainname(NULL), defaultpath(NULL), pseudopotpath(NULL),
     DoOutVis(0), DoOutMes(1), DoOutNICS(0), DoOutOrbitals(0), DoOutCurrent(0), DoFullCurrent(0), DoPerturbation(0), DoWannier(0), CommonWannier(0), SawtoothStart(0.01),
     VectorPlane(0), VectorCut(0.), UseAddGramSch(1), Seed(1), OutVisStep(10), OutSrcStep(5), MaxPsiStep(0), EpsWannier(1e-7), MaxMinStep(100), RelEpsTotalEnergy(1e-7),
 …
   pseudopotpath = new char[MAXSTRINGSIZE];
   databasepath = new char[MAXSTRINGSIZE];
-  configpath = new char[MAXSTRINGSIZE];
   configname = new char[MAXSTRINGSIZE];
+  Thermostats = new ThermoStatContainer();
   strcpy(mainname,"pcp");
   strcpy(defaultpath,"not specified");
   strcpy(pseudopotpath,"not specified");
-  configpath[0]='\0';
   configname[0]='\0';
   basis = "3-21G";
-  InitThermostats();
 };
 …
   delete[](pseudopotpath);
   delete[](databasepath);
-  delete[](configpath);
   delete[](configname);
+  delete[](ThermostatImplemented);
+  for (int j=0;j<MaxThermostats;j++)
+    delete[](ThermostatNames[j]);
+  delete[](ThermostatNames);
+  if (Thermostats != NULL)
+    delete(Thermostats);
   if (BG != NULL)
     delete(BG);
 };
-/** Initialises variables in class config for Thermostats.
- */
-void config::InitThermostats()
+{
-  ThermostatImplemented = new int[MaxThermostats];
-  ThermostatNames = new char *[MaxThermostats];
-  for (int j=0;j<MaxThermostats;j++)
-    ThermostatNames[j] = new char[12];
-  strcpy(ThermostatNames[0],"None");
-  ThermostatImplemented[0] = 1;
-  strcpy(ThermostatNames[1],"Woodcock");
-  ThermostatImplemented[1] = 1;
-  strcpy(ThermostatNames[2],"Gaussian");
-  ThermostatImplemented[2] = 1;
-  strcpy(ThermostatNames[3],"Langevin");
-  ThermostatImplemented[3] = 1;
-  strcpy(ThermostatNames[4],"Berendsen");
-  ThermostatImplemented[4] = 1;
-  strcpy(ThermostatNames[5],"NoseHoover");
-  ThermostatImplemented[5] = 1;
-};
-/** Readin of Thermostat related values from parameter file.
- * \param *fb file buffer containing the config file
- */
-void config::ParseThermostats(class ConfigFileBuffer * const fb)
+{
-  char * const thermo = new char[12];
-  const int verbose = 0;
-  // read desired Thermostat from file along with needed additional parameters
-  if (ParseForParameter(verbose,fb,"Thermostat", 0, 1, 1, string_type, thermo, 1, optional)) {
-    if (strcmp(thermo, ThermostatNames[0]) == 0) { // None
-      if (ThermostatImplemented[0] == 1) {
-        Thermostat = None;
-      } else {
-        DoLog(1) && (Log() << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
-        Thermostat = None;
+      }
-    } else if (strcmp(thermo, ThermostatNames[1]) == 0) { // Woodcock
-      if (ThermostatImplemented[1] == 1) {
-        Thermostat = Woodcock;
-        ParseForParameter(verbose,fb,"Thermostat", 0, 2, 1, int_type, &ScaleTempStep, 1, critical); // read scaling frequency
-      } else {
-        DoLog(1) && (Log() << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
-        Thermostat = None;
+      }
-    } else if (strcmp(thermo, ThermostatNames[2]) == 0) { // Gaussian
-      if (ThermostatImplemented[2] == 1) {
-        Thermostat = Gaussian;
-        ParseForParameter(verbose,fb,"Thermostat", 0, 2, 1, int_type, &ScaleTempStep, 1, critical); // read collision rate
-      } else {
-        DoLog(1) && (Log() << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
-        Thermostat = None;
+      }
-    } else if (strcmp(thermo, ThermostatNames[3]) == 0) { // Langevin
-      if (ThermostatImplemented[3] == 1) {
-        Thermostat = Langevin;
-        ParseForParameter(verbose,fb,"Thermostat", 0, 2, 1, double_type, &TempFrequency, 1, critical); // read gamma
-        if (ParseForParameter(verbose,fb,"Thermostat", 0, 3, 1, double_type, &alpha, 1, optional)) {
-          DoLog(2) && (Log() << Verbose(2) << "Extended Stochastic Thermostat detected with interpolation coefficient " << alpha << "." << endl);
-        } else {
-          alpha = 1.;
+        }
-      } else {
-        DoLog(1) && (Log() << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
-        Thermostat = None;
+      }
-    } else if (strcmp(thermo, ThermostatNames[4]) == 0) { // Berendsen
-      if (ThermostatImplemented[4] == 1) {
-        Thermostat = Berendsen;
-        ParseForParameter(verbose,fb,"Thermostat", 0, 2, 1, double_type, &TempFrequency, 1, critical); // read \tau_T
-      } else {
-        DoLog(1) && (Log() << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
-        Thermostat = None;
+      }
-    } else if (strcmp(thermo, ThermostatNames[5]) == 0) { // Nose-Hoover
-      if (ThermostatImplemented[5] == 1) {
-        Thermostat = NoseHoover;
-        ParseForParameter(verbose,fb,"Thermostat", 0, 2, 1, double_type, &HooverMass, 1, critical); // read Hoovermass
-        alpha = 0.;
-      } else {
-        DoLog(1) && (Log() << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
-        Thermostat = None;
+      }
-    } else {
-      DoLog(1) && (Log() << Verbose(1) << " Warning: thermostat name was not understood!" << endl);
-      Thermostat = None;
+    }
-  } else {
-    if ((MaxOuterStep > 0) && (TargetTemp != 0))
-      DoLog(2) && (Log() << Verbose(2) <<  "No thermostat chosen despite finite temperature MD, falling back to None." << endl);
-    Thermostat = None;
+  }
-  delete[](thermo);
-};
 /** Displays menu for editing each entry of the config file.
 …
 };
-/** Retrieves the path in the given config file name.
- * \param filename config file string
- */
-void config::RetrieveConfigPathAndName(const string filename)
+{
-  char *ptr = NULL;
-  char *buffer = new char[MAXSTRINGSIZE];
-  strncpy(buffer, filename.c_str(), MAXSTRINGSIZE);
-  int last = -1;
-  for(last=MAXSTRINGSIZE;last--;) {
-    if (buffer[last] == '/')
-      break;
+  }
-  if (last == -1) { // no path in front, set to local directory.
-    strcpy(configpath, "./");
-    ptr = buffer;
-  } else {
-    strncpy(configpath, buffer, last+1);
-    ptr = &buffer[last+1];
-    if (last < 254)
-      configpath[last+1]='\0';
+  }
-  strcpy(configname, ptr);
-  DoLog(0) && (Log() << Verbose(0) << "Found configpath: " << configpath << ", dir slash was found at " << last << ", config name is " << configname << "." << endl);
-  delete[](buffer);
-};
-/** Initializes ConfigFileBuffer from a file.
- * \param *file input file stream being the opened config file
- * \param *FileBuffer pointer to FileBuffer on return, should point to NULL
- */
-void PrepareFileBuffer(const char * const filename, struct ConfigFileBuffer *&FileBuffer)
+{
-  if (FileBuffer != NULL) {
-    DoeLog(2) && (eLog()<< Verbose(2) << "deleting present FileBuffer in PrepareFileBuffer()." << endl);
-    delete(FileBuffer);
+  }
-  FileBuffer = new ConfigFileBuffer(filename);
-  FileBuffer->InitMapping();
-};
 /** Loads a molecule from a ConfigFileBuffer.
  * \param *mol molecule to load
 …
   file->close();
   delete(file);
-  RetrieveConfigPathAndName(filename);
   // ParseParameterFile
+  struct ConfigFileBuffer *FileBuffer = NULL;
+  PrepareFileBuffer(filename,FileBuffer);
+  class ConfigFileBuffer *FileBuffer = new ConfigFileBuffer(filename);
   /* Oeffne Hauptparameterdatei */
 …
   int verbose = 0;
+  //TODO: This is actually sensible?: if (MaxOuterStep > 0)
   ParseThermostats(FileBuffer);
 …
   ParseForParameter(verbose,FileBuffer,"OutVisStep", 0, 1, 1, int_type, &(config::OutVisStep), 1, optional);
   ParseForParameter(verbose,FileBuffer,"OutSrcStep", 0, 1, 1, int_type, &(config::OutSrcStep), 1, optional);
   ParseForParameter(verbose,FileBuffer,"TargetTemp", 0, 1, 1, double_type, &(config::TargetTemp), 1, optional);
+  ParseForParameter(verbose,FileBuffer,"TargetTemp", 0, 1, 1, double_type, &(Thermostats->TargetTemp), 1, optional);
   //ParseForParameter(verbose,FileBuffer,"Thermostat", 0, 1, 1, int_type, &(config::ScaleTempStep), 1, optional);
   if (!ParseForParameter(verbose,FileBuffer,"EpsWannier", 0, 1, 1, double_type, &(config::EpsWannier), 1, optional))
 …
   // Unit cell and magnetic field
   ParseForParameter(verbose,FileBuffer, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
   double * const cell_size = World::getInstance().getDomain();
+  double * cell_size = new double[6];
   cell_size[0] = BoxLength[0];
   cell_size[1] = BoxLength[3];
 …
   cell_size[4] = BoxLength[7];
   cell_size[5] = BoxLength[8];
+  World::getInstance().setDomain(cell_size);
+  delete cell_size;
   //if (1) fprintf(stderr,"\n");
 …
     return;
+  }
-  RetrieveConfigPathAndName(filename);
   // ParseParameters
 …
   ParseForParameter(verbose,file,"VisOuterStep", 0, 1, 1, int_type, &(config::OutVisStep), 1, optional);
   ParseForParameter(verbose,file,"VisSrcOuterStep", 0, 1, 1, int_type, &(config::OutSrcStep), 1, optional);
   ParseForParameter(verbose,file,"TargetTemp", 0, 1, 1, double_type, &(config::TargetTemp), 1, optional);
   ParseForParameter(verbose,file,"ScaleTempStep", 0, 1, 1, int_type, &(config::ScaleTempStep), 1, optional);
+  ParseForParameter(verbose,file,"TargetTemp", 0, 1, 1, double_type, &(Thermostats->TargetTemp), 1, optional);
+  ParseForParameter(verbose,file,"ScaleTempStep", 0, 1, 1, int_type, &(Thermostats->ScaleTempStep), 1, optional);
   config::EpsWannier = 1e-8;
 …
   ParseForParameter(verbose,file, "BoxLength", 0, 3, 3, lower_trigrid, BoxLength, 1, critical); /* Lattice->RealBasis */
   double * const cell_size = World::getInstance().getDomain();
+  double * cell_size = new double[6];
   cell_size[0] = BoxLength[0];
   cell_size[1] = BoxLength[3];
 …
   cell_size[4] = BoxLength[7];
   cell_size[5] = BoxLength[8];
+  World::getInstance().setDomain(cell_size);
+  delete[] cell_size;
   if (1) fprintf(stderr,"\n");
   config::DoPerturbation = 0;
 …
+{
   bool result = true;
+  // bring MaxTypes up to date
+  mol->CountElements();
+  const double * const cell_size = World::getInstance().getDomain();
+  const Matrix &domain = World::getInstance().getDomain().getM();
   ofstream * const output = new ofstream(filename, ios::out);
   if (output != NULL) {
 …
     *output << "DoFullCurrent\t" << config::DoFullCurrent << "\t# Do full perturbation" << endl;
     *output << "DoConstrainedMD\t" << config::DoConstrainedMD << "\t# Do perform a constrained (>0, relating to current MD step) instead of unconstrained (0) MD" << endl;
     *output << "Thermostat\t" << ThermostatNames[Thermostat] << "\t";
     switch(Thermostat) {
+    *output << "Thermostat\t" << Thermostats->ThermostatNames[Thermostats->Thermostat] << "\t";
+    switch(Thermostats->Thermostat) {
       default:
       case None:
         break;
       case Woodcock:
         *output << ScaleTempStep;
+        *output << Thermostats->ScaleTempStep;
         break;
       case Gaussian:
         *output << ScaleTempStep;
+        *output << Thermostats->ScaleTempStep;
         break;
       case Langevin:
         *output << TempFrequency << "\t" << alpha;
+        *output << Thermostats->TempFrequency << "\t" << Thermostats->alpha;
         break;
       case Berendsen:
         *output << TempFrequency;
+        *output << Thermostats->TempFrequency;
         break;
       case NoseHoover:
         *output << HooverMass;
+        *output << Thermostats->HooverMass;
         break;
     };
 …
     *output << "OutVisStep\t" << config::OutVisStep << "\t# Output visual data every ...th step" << endl;
     *output << "OutSrcStep\t" << config::OutSrcStep << "\t# Output \"restart\" data every ..th step" << endl;
     *output << "TargetTemp\t" << config::TargetTemp << "\t# Target temperature" << endl;
+    *output << "TargetTemp\t" << Thermostats->TargetTemp << "\t# Target temperature" << endl;
     *output << "MaxPsiStep\t" << config::MaxPsiStep << "\t# number of Minimisation steps per state (0 - default)" << endl;
     *output << "EpsWannier\t" << config::EpsWannier << "\t# tolerance value for spread minimisation of orbitals" << endl;
 …
     *output << endl;
     *output << "BoxLength\t\t\t# (Length of a unit cell)" << endl;
     *output << cell_size[0] << "\t" << endl;
     *output << cell_size[1] << "\t" << cell_size[2] << "\t" << endl;
     *output << cell_size[3] << "\t" << cell_size[4] << "\t" << cell_size[5] << "\t" << endl;
+    *output << domain.at(0,0) << "\t" << endl;
+    *output << domain.at(1,0) << "\t" << domain.at(1,1) << "\t" << endl;
+    *output << domain.at(2,0) << "\t" << domain.at(2,1) << "\t" << domain.at(2,2) << "\t" << endl;
     // FIXME
     *output << endl;
 …
     *output << "IsAngstroem\t" << config::IsAngstroem << "\t# 0 - Bohr, 1 - Angstroem" << endl;
     *output << "RelativeCoord\t" << config::RelativeCoord << "\t# whether ion coordinates are relative (1) or absolute (0)" << endl;
     *output << "MaxTypes\t" << mol->ElementCount <<  "\t# maximum number of different ion types" << endl;
+    *output << "MaxTypes\t" << mol->getElementCount() <<  "\t# maximum number of different ion types" << endl;
     *output << endl;
     result = result && mol->Checkout(output);
 …
     // output of atoms
     AtomNo = 0;
     mol->ActOnAllAtoms( &atom::OutputMPQCLine, output, (const Vector *)center, &AtomNo );
+    mol->ActOnAllAtoms( &atom::OutputMPQCLine, (ostream * const) output, (const Vector *)center, &AtomNo );
     delete(center);
     *output << "\t}" << endl;
 …
     // output of atoms
     AtomNo = 0;
     mol->ActOnAllAtoms( &atom::OutputMPQCLine, output, (const Vector *)center, &AtomNo );
+    mol->ActOnAllAtoms( &atom::OutputMPQCLine, (ostream * const) output, (const Vector *)center, &AtomNo );
     delete(center);
     *output << "\t}" << endl;
 …
   char filename[MAXSTRINGSIZE];
   ofstream output;
+  molecule *mol = World::getInstance().createMolecule();
+  mol->SetNameFromFilename(ConfigFileName);
+  if (!strcmp(configpath, GetDefaultPath())) {
+    eLog() << Verbose(2) << "config is found under different path then stated in config file::defaultpath!" << endl;
+  }
+  molecule *mol = NULL;
   // first save as PDB data
 …
   // translate each to its center and merge all molecules in MoleculeListClass into this molecule
   int N = molecules->ListOfMolecules.size();
+  int *src = new int[N];
+  N=0;
+  for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+    src[N++] = (*ListRunner)->IndexNr;
+    (*ListRunner)->Translate(&(*ListRunner)->Center);
+  }
+  molecules->SimpleMultiAdd(mol, src, N);
+  delete[](src);
+  // ... and translate back
+  for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+    (*ListRunner)->Center.Scale(-1.);
+    (*ListRunner)->Translate(&(*ListRunner)->Center);
+    (*ListRunner)->Center.Scale(-1.);
+  if (N != 1) { // don't do anything in case of only one molecule (shifts mol ids otherwise)
+    int *src = new int[N];
+    N=0;
+    for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++) {
+      src[N++] = (*ListRunner)->IndexNr;
+      (*ListRunner)->Translate(&(*ListRunner)->Center);
+    }
+    mol = World::getInstance().createMolecule();
+    mol->SetNameFromFilename(ConfigFileName);
+    molecules->SimpleMultiMerge(mol, src, N);
+    //mol->CalculateOrbitals(*this);
+    delete[](src);
+  } else {
+    if (!molecules->ListOfMolecules.empty()) {
+      mol = *(molecules->ListOfMolecules.begin());
+      mol->doCountAtoms();
+      //mol->CalculateOrbitals(*this);
+    } else {
+      DoeLog(1) && (eLog() << Verbose(1) << "There are no molecules to save!" << endl);
+    }
+  }
   Log() << Verbose(0) << "Storing configuration ... " << endl;
   // get correct valence orbitals
-  mol->CalculateOrbitals(*this);
-  InitMaxMinStopStep = MaxMinStopStep = MaxPsiDouble;
   if (ConfigFileName != NULL) { // test the file name
     strcpy(filename, ConfigFileName);
 …
     Log() << Verbose(0) << "\t... failed." << endl;
+  if (!strcmp(configpath, GetDefaultPath())) {
+    eLog() << Verbose(2) << "config is found under different path then stated in config file::defaultpath!" << endl;
+  }
+  World::getInstance().destroyMolecule(mol);
+  // don't destroy molecule as it contains all our atoms
+  //World::getInstance().destroyMolecule(mol);
 };
 …
   return (found); // true if found, false if not
+}
+/** Reading of Thermostat related values from parameter file.
+ * \param *fb file buffer containing the config file
+ */
+void config::ParseThermostats(class ConfigFileBuffer * const fb)
+{
+  char * const thermo = new char[12];
+  const int verbose = 0;
+  // read desired Thermostat from file along with needed additional parameters
+  if (ParseForParameter(verbose,fb,"Thermostat", 0, 1, 1, string_type, thermo, 1, optional)) {
+    if (strcmp(thermo, Thermostats->ThermostatNames[0]) == 0) { // None
+      if (Thermostats->ThermostatImplemented[0] == 1) {
+        Thermostats->Thermostat = None;
+      } else {
+        DoLog(1) && (Log() << Verbose(1) << "Warning: " << Thermostats->ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
+        Thermostats->Thermostat = None;
+      }
+    } else if (strcmp(thermo, Thermostats->ThermostatNames[1]) == 0) { // Woodcock
+      if (Thermostats->ThermostatImplemented[1] == 1) {
+        Thermostats->Thermostat = Woodcock;
+        ParseForParameter(verbose,fb,"Thermostat", 0, 2, 1, int_type, &Thermostats->ScaleTempStep, 1, critical); // read scaling frequency
+      } else {
+        DoLog(1) && (Log() << Verbose(1) << "Warning: " << Thermostats->ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
+        Thermostats->Thermostat = None;
+      }
+    } else if (strcmp(thermo, Thermostats->ThermostatNames[2]) == 0) { // Gaussian
+      if (Thermostats->ThermostatImplemented[2] == 1) {
+        Thermostats->Thermostat = Gaussian;
+        ParseForParameter(verbose,fb,"Thermostat", 0, 2, 1, int_type, &Thermostats->ScaleTempStep, 1, critical); // read collision rate
+      } else {
+        DoLog(1) && (Log() << Verbose(1) << "Warning: " << Thermostats->ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
+        Thermostats->Thermostat = None;
+      }
+    } else if (strcmp(thermo, Thermostats->ThermostatNames[3]) == 0) { // Langevin
+      if (Thermostats->ThermostatImplemented[3] == 1) {
+        Thermostats->Thermostat = Langevin;
+        ParseForParameter(verbose,fb,"Thermostat", 0, 2, 1, double_type, &Thermostats->TempFrequency, 1, critical); // read gamma
+        if (ParseForParameter(verbose,fb,"Thermostat", 0, 3, 1, double_type, &Thermostats->alpha, 1, optional)) {
+          DoLog(2) && (Log() << Verbose(2) << "Extended Stochastic Thermostat detected with interpolation coefficient " << Thermostats->alpha << "." << endl);
+        } else {
+          Thermostats->alpha = 1.;
+        }
+      } else {
+        DoLog(1) && (Log() << Verbose(1) << "Warning: " << Thermostats->ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
+        Thermostats->Thermostat = None;
+      }
+    } else if (strcmp(thermo, Thermostats->ThermostatNames[4]) == 0) { // Berendsen
+      if (Thermostats->ThermostatImplemented[4] == 1) {
+        Thermostats->Thermostat = Berendsen;
+        ParseForParameter(verbose,fb,"Thermostat", 0, 2, 1, double_type, &Thermostats->TempFrequency, 1, critical); // read \tau_T
+      } else {
+        DoLog(1) && (Log() << Verbose(1) << "Warning: " << Thermostats->ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
+        Thermostats->Thermostat = None;
+      }
+    } else if (strcmp(thermo, Thermostats->ThermostatNames[5]) == 0) { // Nose-Hoover
+      if (Thermostats->ThermostatImplemented[5] == 1) {
+        Thermostats->Thermostat = NoseHoover;
+        ParseForParameter(verbose,fb,"Thermostat", 0, 2, 1, double_type, &Thermostats->HooverMass, 1, critical); // read Hoovermass
+        Thermostats->alpha = 0.;
+      } else {
+        DoLog(1) && (Log() << Verbose(1) << "Warning: " << Thermostats->ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl);
+        Thermostats->Thermostat = None;
+      }
+    } else {
+      DoLog(1) && (Log() << Verbose(1) << " Warning: thermostat name was not understood!" << endl);
+      Thermostats->Thermostat = None;
+    }
+  } else {
+    if ((Thermostats->TargetTemp != 0))
+      DoLog(2) && (Log() << Verbose(2) <<  "No thermostat chosen despite finite temperature MD, falling back to None." << endl);
+    Thermostats->Thermostat = None;
+  }
+  delete[](thermo);
+};

src/config.hpp

-              r06f4ef6
+              rb6da28
 #include <string>
-#include "bondgraph.hpp"
 /****************************************** forward declarations *****************************/
+class BondGraph;
+class ConfigFileBuffer;
 class molecule;
 class MoleculeListClass;
 class periodentafel;
+class ThermoStatContainer;
 /********************************************** declarations *******************************/
-class ConfigFileBuffer {
-  public:
-    char **buffer;
-    int *LineMapping;
-    int CurrentLine;
-    int NoLines;
-    ConfigFileBuffer();
-    ConfigFileBuffer(const char * const filename);
-    ~ConfigFileBuffer();
-    void InitMapping();
-    void MapIonTypesInBuffer(const int NoAtoms);
-};
 /** The config file.
 …
   public:
     class BondGraph *BG;
+    class ThermoStatContainer *Thermostats;
     int PsiType;
 …
     int ProcPEGamma;
     int ProcPEPsi;
-    char *configpath;
     char *configname;
     bool FastParsing;
 …
     int DoConstrainedMD;
     int MaxOuterStep;
-    int Thermostat;
-    int *ThermostatImplemented;
-    char **ThermostatNames;
-    double TempFrequency;
-    double alpha;
-    double HooverMass;
-    double TargetTemp;
-    int ScaleTempStep;
   private:
 …
   void Load(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList);
   void LoadOld(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList);
-  void RetrieveConfigPathAndName(const string filename);
   bool Save(const char * const filename, const periodentafel * const periode, molecule * const mol) const;
   bool SaveMPQC(const char * const filename, const molecule * const mol) const;
 …
   char *GetDefaultPath() const;
   void SetDefaultPath(const char * const path);
-  void InitThermostats();
   void ParseThermostats(class ConfigFileBuffer * const fb);
 };

src/datacreator.cpp

-              r06f4ef6
+              rb6da28
 #include "helpers.hpp"
 #include "parser.hpp"
+#include "verbose.hpp"
+#include <iomanip>
 //=========================== FUNCTIONS============================

src/datacreator.hpp

r06f4ef6	rb6da28
10	10	using namespace std;
11	11
12		#include <ios~~tream~~>
	12	#include <iosfwd>
13	13
14	14	/**************************************** forward declarations ***************************/

src/defs.hpp

-              r06f4ef6
+              rb6da28
 #define STD_SEPERATOR_SPACER '-'
+#define MOLECUILDER_NAME "Molecuilder"
+const extern unsigned int MAX_POOL_FRAGMENTATION;
+const extern unsigned int MAX_FRAGMENTATION_SKIPS;
 #endif /*DEFS_HPP_*/

src/element.cpp

-              r06f4ef6
+              rb6da28
         next(NULL),
         sort(NULL),
-        No(-1),
         Valence(0),
         NoValenceOrbitals(0)
 …
   return string(symbol);
+}
+std::string element::getName() const{
+  return string(name);
+}
+std::ostream &operator<<(std::ostream &ost,const element &elem){
+  ost << elem.getName() << "(" << elem.getNumber() << ")";
+  return ost;
+}

src/element.hpp

-              r06f4ef6
+              rb6da28
 #endif
 #include <iostream>
+#include <iosfwd>
 #include <string>
 …
     element *next;  //!< next element in list
     int *sort;      //!< sorc criteria
-    int No;         //!< number of element set on periodentafel::Output()
     double Valence;   //!< number of valence electrons for this element
     int NoValenceOrbitals;  //!< number of valence orbitals, used for determining bond degree in molecule::CreateConnectmatrix()
 …
   atomicNumber_t getNumber() const;
   std::string getSymbol() const;
+  std::string getName() const;
   //> print element entries to screen
 …
 };
+std::ostream &operator<<(std::ostream&,const element&);
 #endif /* ELEMENT_HPP_ */

src/ellipsoid.cpp

-              r06f4ef6
+              rb6da28
 #include "tesselation.hpp"
 #include "vector.hpp"
+#include "Matrix.hpp"
 #include "verbose.hpp"
 …
   Vector helper, RefPoint;
   double distance = -1.;
   double Matrix[NDIM*NDIM];
+  Matrix Matrix;
   double InverseLength[3];
   double psi,theta,phi; // euler angles in ZX'Z'' convention
 …
   theta = EllipsoidAngle[1];
   phi = EllipsoidAngle[2];
   Matrix[0] = cos(psi)*cos(phi) - sin(psi)*cos(theta)*sin(phi);
   Matrix[1] = -cos(psi)*sin(phi) - sin(psi)*cos(theta)*cos(phi);
   Matrix[2] = sin(psi)*sin(theta);
   Matrix[3] = sin(psi)*cos(phi) + cos(psi)*cos(theta)*sin(phi);
   Matrix[4] = cos(psi)*cos(theta)*cos(phi) - sin(psi)*sin(phi);
   Matrix[5] = -cos(psi)*sin(theta);
   Matrix[6] = sin(theta)*sin(phi);
   Matrix[7] = sin(theta)*cos(phi);
   Matrix[8] = cos(theta);
   helper.MatrixMultiplication(Matrix);
+  Matrix.set(0,0, cos(psi)*cos(phi) - sin(psi)*cos(theta)*sin(phi));
+  Matrix.set(1,0, -cos(psi)*sin(phi) - sin(psi)*cos(theta)*cos(phi));
+  Matrix.set(2,0, sin(psi)*sin(theta));
+  Matrix.set(0,1, sin(psi)*cos(phi) + cos(psi)*cos(theta)*sin(phi));
+  Matrix.set(1,1, cos(psi)*cos(theta)*cos(phi) - sin(psi)*sin(phi));
+  Matrix.set(2,1, -cos(psi)*sin(theta));
+  Matrix.set(0,2, sin(theta)*sin(phi));
+  Matrix.set(1,2, sin(theta)*cos(phi));
+  Matrix.set(2,2, cos(theta));
+  helper *= Matrix;
   helper.ScaleAll(InverseLength);
   //Log() << Verbose(4) << "Transformed RefPoint is at " << helper << "." << endl;
 …
   phi = -EllipsoidAngle[2];
   helper.ScaleAll(EllipsoidLength);
   Matrix[0] = cos(psi)*cos(phi) - sin(psi)*cos(theta)*sin(phi);
   Matrix[1] = -cos(psi)*sin(phi) - sin(psi)*cos(theta)*cos(phi);
   Matrix[2] = sin(psi)*sin(theta);
   Matrix[3] = sin(psi)*cos(phi) + cos(psi)*cos(theta)*sin(phi);
   Matrix[4] = cos(psi)*cos(theta)*cos(phi) - sin(psi)*sin(phi);
   Matrix[5] = -cos(psi)*sin(theta);
   Matrix[6] = sin(theta)*sin(phi);
   Matrix[7] = sin(theta)*cos(phi);
   Matrix[8] = cos(theta);
   helper.MatrixMultiplication(Matrix);
+  Matrix.set(0,0, cos(psi)*cos(phi) - sin(psi)*cos(theta)*sin(phi));
+  Matrix.set(1,0, -cos(psi)*sin(phi) - sin(psi)*cos(theta)*cos(phi));
+  Matrix.set(2,0, sin(psi)*sin(theta));
+  Matrix.set(0,1, sin(psi)*cos(phi) + cos(psi)*cos(theta)*sin(phi));
+  Matrix.set(1,1, cos(psi)*cos(theta)*cos(phi) - sin(psi)*sin(phi));
+  Matrix.set(2,1, -cos(psi)*sin(theta));
+  Matrix.set(0,2, sin(theta)*sin(phi));
+  Matrix.set(1,2, sin(theta)*cos(phi));
+  Matrix.set(2,2, cos(theta));
+  helper *= Matrix;
   //Log() << Verbose(4) << "Intersection is at " << helper << "." << endl;

src/errorlogger.cpp

r06f4ef6	rb6da28
9	9
10	10	#include <fstream>
	11	#include <iostream>
11	12	#include "errorlogger.hpp"
12	13	#include "verbose.hpp"

src/errorlogger.hpp

r06f4ef6	rb6da28
9	9	#define ERRORLOGGER_HPP_
10	10
11		#include <ios~~tream~~>
	11	#include <iosfwd>
12	12
13	13	#include "Patterns/Singleton.hpp"

src/graph.cpp

r06f4ef6	rb6da28
13	13	#include "config.hpp"
14	14	#include "graph.hpp"
	15	#include "verbose.hpp"
15	16	#include "log.hpp"
16	17	#include "molecule.hpp"

src/graph.hpp

-              r06f4ef6
+              rb6da28
 class molecule;
-class Graph;
 class SubGraph;
 class Node;
 …
 /********************************************** definitions *********************************/
+#define NodeMap pair < int, class Node* >
+#define EdgeMap multimap < class Node*, class Edge* >
+typedef std::pair < int, class Node* > NodeMap;
+typedef std::multimap < class Node*, class Edge* > EdgeMap;
+#define KeyStack deque<int>
+#define KeySet set<int>
+#define NumberValuePair pair<int, double>
+#define Graph map <KeySet, NumberValuePair, KeyCompare >
+#define GraphPair pair <KeySet, NumberValuePair >
+#define KeySetTestPair pair<KeySet::iterator, bool>
+#define GraphTestPair pair<Graph::iterator, bool>
+typedef std::deque<int> KeyStack;
+typedef std::set<int> KeySet;
+typedef std::pair<int, double> NumberValuePair;
+/******************************** Some small functions and/or structures **********************************/
+// needed for definition of Graph and GraphTestPair
 struct KeyCompare
+{
   bool operator() (const KeySet SubgraphA, const KeySet SubgraphB) const;
 };
+typedef std::map <KeySet, NumberValuePair, KeyCompare > Graph;
+typedef std::pair <KeySet, NumberValuePair > GraphPair;
+typedef std::pair<KeySet::iterator, bool> KeySetTestPair;
+typedef std::pair<Graph::iterator, bool> GraphTestPair;
+/******************************** Some small functions and/or structures **********************************/
 //bool operator < (KeySet SubgraphA, KeySet SubgraphB);   //note: this declaration is important, otherwise normal < is used (producing wrong order)

src/gslvector.cpp

-              r06f4ef6
+              rb6da28
 #include <cassert>
 #include <cmath>
+#include <iostream>
 #include "gslvector.hpp"
 #include "defs.hpp"
 #include "vector.hpp"
+#include "VectorContent.hpp"
 /** Constructor of class GSLVector.
 …
  */
 void GSLVector::SetFromVector(Vector &v){
   gsl_vector_memcpy (vector, v.get());
+  gsl_vector_memcpy (vector, v.get()->content);
+}

src/gslvector.hpp

r06f4ef6	rb6da28
18	18	#endif
19	19
20		#include <ios~~tream~~>
	20	#include <iosfwd>
21	21	#include <gsl/gsl_vector.h>
22	22

src/helpers.cpp

-              r06f4ef6
+              rb6da28
 #include "helpers.hpp"
 #include "Helpers/fast_functions.hpp"
+#include "verbose.hpp"
 #include "log.hpp"
+#include "memoryusageobserver.hpp"
+#include <iostream>
 /********************************************** helpful functions *********************************/
 …
 };
-/** Blows the 6-dimensional \a cell_size array up to a full NDIM by NDIM matrix.
- * \param *symm 6-dim array of unique symmetric matrix components
- * \return allocated NDIM*NDIM array with the symmetric matrix
- */
-double * ReturnFullMatrixforSymmetric(const double * const symm)
+{
-  double *matrix = new double[NDIM * NDIM];
-  matrix[0] = symm[0];
-  matrix[1] = symm[1];
-  matrix[2] = symm[3];
-  matrix[3] = symm[1];
-  matrix[4] = symm[2];
-  matrix[5] = symm[4];
-  matrix[6] = symm[3];
-  matrix[7] = symm[4];
-  matrix[8] = symm[5];
-  return matrix;
-};
-/** Calculate the inverse of a 3x3 matrix.
- * \param *matrix NDIM_NDIM array
- */
-double * InverseMatrix( const double * const A)
+{
-  double *B = new double[NDIM * NDIM];
-  double detA = RDET3(A);
-  double detAReci;
-  for (int i=0;i<NDIM*NDIM;++i)
-    B[i] = 0.;
-  // calculate the inverse B
-  if (fabs(detA) > MYEPSILON) {;  // RDET3(A) yields precisely zero if A irregular
-    detAReci = 1./detA;
-    B[0] =  detAReci*RDET2(A[4],A[5],A[7],A[8]);    // A_11
-    B[1] = -detAReci*RDET2(A[1],A[2],A[7],A[8]);    // A_12
-    B[2] =  detAReci*RDET2(A[1],A[2],A[4],A[5]);    // A_13
-    B[3] = -detAReci*RDET2(A[3],A[5],A[6],A[8]);    // A_21
-    B[4] =  detAReci*RDET2(A[0],A[2],A[6],A[8]);    // A_22
-    B[5] = -detAReci*RDET2(A[0],A[2],A[3],A[5]);    // A_23
-    B[6] =  detAReci*RDET2(A[3],A[4],A[6],A[7]);    // A_31
-    B[7] = -detAReci*RDET2(A[0],A[1],A[6],A[7]);    // A_32
-    B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);    // A_33
+  }
-  return B;
-};
 /** Comparison function for GSL heapsort on distances in two molecules.
  * \param *a

src/helpers.hpp

-              r06f4ef6
+              rb6da28
 #include "defs.hpp"
 #include "log.hpp"
-#include "memoryallocator.hpp"
 /********************************************** definitions *********************************/
 …
 bool IsValidNumber( const char *string);
 int CompareDoubles (const void * a, const void * b);
-double * ReturnFullMatrixforSymmetric(const double * const cell_size);
-double * InverseMatrix(const double * const A);
 void performCriticalExit();
 …
 };
+/************ struct to contain simple enumerations ***************/
+template <class C>
+struct enumeration{
+  enumeration() : max(0) {}
+  enumeration(unsigned int i) : max(i) {}
+  enumeration(const enumeration &src) :
+    there(src.there),
+    back(src.back),
+    max(src.max)
+  {}
+  enumeration &operator=(const enumeration &src){
+    /* no self-assignment check needed */
+    there = src.there;
+    back = src.back;
+    max = src.max;
+    return *this;
+  }
+  void add(const C &value){
+    if(!there.count(value)){
+      there[value]=max;
+      back[max++]=value;
+    }
+  }
+  unsigned int getMax() const{
+    return max;
+  }
+  map<C,unsigned int> there;
+  map<unsigned int,C> back;
+private:
+  unsigned int max;
+};
+/***** A counter to generate sequential numbers *******************/
+struct counter{
+  inline counter() : count(0){};
+  inline counter(int i) : count(i){};
+  inline unsigned int operator()(){
+    return count++;
+  }
+private:
+  unsigned int count;
+};
+template <class C,class ForwardIterator>
+enumeration<C> enumerate(ForwardIterator first,ForwardIterator last){
+  enumeration<C> res;
+  for_each(first,last,bind1st(mem_fun(&enumeration<C>::add),&res));
+  return res;
+}
 #endif /*HELPERS_HPP_*/

src/joiner.cpp

-              r06f4ef6
+              rb6da28
 #include "datacreator.hpp"
 #include "helpers.hpp"
-#include "memoryallocator.hpp"
 #include "parser.hpp"
 #include "periodentafel.hpp"
+#include "verbose.hpp"
 //============================== MAIN =============================

src/linearsystemofequations.hpp

-              r06f4ef6
+              rb6da28
  */
+using namespace std;
+#ifndef LINEARSYSTEMSOFEQUATIONS_HPP
+#define LINEARSYSTEMSOFEQUATIONS_HPP
 /*********************************************** includes ***********************************/
 …
   bool IsSymmetric;
 };
+#endif /* LINEARSYSTEMSOFEQUATIONS_HPP */

src/linkedcell.cpp

-              r06f4ef6
+              rb6da28
 #include "helpers.hpp"
 #include "linkedcell.hpp"
+#include "verbose.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 …
     N[i] = 0;
   index = -1;
-  max.Zero();
-  min.Zero();
 };
 …
   for(int i=0;i<NDIM;i++)
     status = status && ((n[i] >=0) && (n[i] < N[i]));
   if (!status)
   DoeLog(1) && (eLog()<< Verbose(1) << "indices are out of bounds!" << endl);
+//  if (!status)
+//    DoeLog(1) && (eLog()<< Verbose(1) << "indices are out of bounds!" << endl);
   return status;
 };
 …
 /** Calculates the interval bounds of the linked cell grid.
  * \param *lower lower bounds
  * \param *upper upper bounds
+ * \param lower lower bounds
+ * \param upper upper bounds
  * \param step how deep to check the neighbouring cells (i.e. number of layers to check)
  */
 …
+{
   for (int i=0;i<NDIM;i++) {
+    lower[i] = n[i];
+    for (int s=step; s>0;--s)
+      if ((n[i]-s) >= 0) {
+        lower[i] = n[i]-s;
+        break;
+      }
+    upper[i] = n[i];
+    for (int s=step; s>0;--s)
+      if ((n[i]+s) < N[i]) {
+        upper[i] = n[i]+s;
+        break;
+      }
+    lower[i] = n[i]-step;
+    if (lower[i] < 0)
+      lower[i] = 0;
+    if (lower[i] >= N[i])
+      lower[i] = N[i]-1;
+    upper[i] = n[i]+step;
+    if (upper[i] >= N[i])
+      upper[i] = N[i]-1;
+    if (upper[i] < 0)
+      upper[i] = 0;
     //Log() << Verbose(0) << "axis " << i << " has bounds [" << lower[i] << "," << upper[i] << "]" << endl;
+  }

src/log.hpp

-              r06f4ef6
+              rb6da28
 #include "logger.hpp"
 class logger * Log();
 class errorLogger * eLog();
+class logger & Log();
+class errorLogger & eLog();
 void setVerbosity(int verbosityLevel);
 bool DoLog(int verbose);

src/logger.cpp

r06f4ef6	rb6da28
9	9
10	10	#include <fstream>
	11	#include <iostream>
11	12	#include "logger.hpp"
12	13	#include "verbose.hpp"

src/logger.hpp

r06f4ef6	rb6da28
9	9	#define LOGGER_HPP_
10	10
11		#include <ios~~tream~~>
	11	#include <iosfwd>
12	12
13	13	#include "Patterns/Singleton.hpp"

src/molecule.cpp

-              r06f4ef6
+              rb6da28
  */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 #include <cstring>
 #include <boost/bind.hpp>
+#include <boost/foreach.hpp>
+#include <gsl/gsl_inline.h>
+#include <gsl/gsl_heapsort.h>
 #include "World.hpp"
 …
 #include "log.hpp"
 #include "molecule.hpp"
+#include "memoryallocator.hpp"
 #include "periodentafel.hpp"
 #include "stackclass.hpp"
 #include "tesselation.hpp"
 #include "vector.hpp"
+#include "Matrix.hpp"
 #include "World.hpp"
+#include "Box.hpp"
 #include "Plane.hpp"
 #include "Exceptions/LinearDependenceException.hpp"
 …
 molecule::molecule(const periodentafel * const teil) :
   Observable("molecule"),
   elemente(teil),  MDSteps(0),  BondCount(0), ElementCount(0), NoNonHydrogen(0), NoNonBonds(0),
+  elemente(teil),  MDSteps(0),  BondCount(0), NoNonHydrogen(0), NoNonBonds(0),
   NoCyclicBonds(0), BondDistance(0.),  ActiveFlag(false), IndexNr(-1),
+  formula(this,boost::bind(&molecule::calcFormula,this),"formula"),
+  AtomCount(this,boost::bind(&molecule::doCountAtoms,this),"AtomCount"), last_atom(0),  InternalPointer(begin())
+{
+  // other stuff
+  for(int i=MAX_ELEMENTS;i--;)
+    ElementsInMolecule[i] = 0;
+  AtomCount(this,boost::bind(&molecule::doCountAtoms,this),"AtomCount"), last_atom(0),  InternalPointer(atoms.begin())
+{
   strcpy(name,World::getInstance().getDefaultName().c_str());
 };
 …
 void molecule::setName(const std::string _name){
   OBSERVE;
+  cout << "Set name of molecule " << getId() << " to " << _name << endl;
   strncpy(name,_name.c_str(),MAXSTRINGSIZE);
+}
 …
+}
+const std::string molecule::getFormula(){
+  return *formula;
+}
+std::string molecule::calcFormula(){
+  std::map<atomicNumber_t,unsigned int> counts;
+  stringstream sstr;
+  periodentafel *periode = World::getInstance().getPeriode();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    counts[(*iter)->type->getNumber()]++;
+  }
+  std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
+  for(iter = counts.rbegin(); iter != counts.rend(); ++iter) {
+    atomicNumber_t Z = (*iter).first;
+    sstr << periode->FindElement(Z)->symbol << (*iter).second;
+  }
+  return sstr.str();
+const Formula &molecule::getFormula(){
+  return formula;
+}
+unsigned int molecule::getElementCount(){
+  return formula.getElementCount();
+}
+bool molecule::hasElement(const element *element) const{
+  return formula.hasElement(element);
+}
+bool molecule::hasElement(atomicNumber_t Z) const{
+  return formula.hasElement(Z);
+}
+bool molecule::hasElement(const string &shorthand) const{
+  return formula.hasElement(shorthand);
+}
 …
 molecule::const_iterator molecule::erase( const_iterator loc )
+{
+  OBSERVE;
   molecule::const_iterator iter = loc;
   iter--;
   atom* atom = *loc;
+  atoms.erase( loc );
+  atomIds.erase( atom->getId() );
+  atoms.remove( atom );
+  formula-=atom->type;
   atom->removeFromMolecule();
   return iter;
 …
 molecule::const_iterator molecule::erase( atom * key )
+{
   cout << "trying to erase atom" << endl;
+  OBSERVE;
   molecule::const_iterator iter = find(key);
   if (iter != end()){
+    atoms.erase( iter++ );
+    atomIds.erase( key->getId() );
+    atoms.remove( key );
+    formula-=key->type;
     key->removeFromMolecule();
+  }
 …
 molecule::const_iterator molecule::find ( atom * key ) const
+{
+  return atoms.find( key );
+  molecule::const_iterator iter;
+  for (molecule::const_iterator Runner = begin(); Runner != end(); ++Runner) {
+    if (*Runner == key)
+      return molecule::const_iterator(Runner);
+  }
+  return molecule::const_iterator(atoms.end());
+}
 pair<molecule::iterator,bool> molecule::insert ( atom * const key )
+{
+  pair<atomSet::iterator,bool> res = atoms.insert(key);
+  return pair<iterator,bool>(iterator(res.first,this),res.second);
+  OBSERVE;
+  pair<atomIdSet::iterator,bool> res = atomIds.insert(key->getId());
+  if (res.second) { // push atom if went well
+    atoms.push_back(key);
+    formula+=key->type;
+    return pair<iterator,bool>(molecule::iterator(--end()),res.second);
+  } else {
+    return pair<iterator,bool>(molecule::iterator(end()),res.second);
+  }
+}
 bool molecule::containsAtom(atom* key){
   return atoms.count(key);
+  return (find(key) != end());
+}
 …
     pointer->sort = &pointer->nr;
     if (pointer->type != NULL) {
+      if (ElementsInMolecule[pointer->type->Z] == 0)
+        ElementCount++;
+      ElementsInMolecule[pointer->type->Z]++; // increase number of elements
+      formula += pointer->type;
       if (pointer->type->Z != 1)
         NoNonHydrogen++;
 …
   if (pointer != NULL) {
     atom *walker = pointer->clone();
+    formula += walker->type;
     walker->setName(pointer->getName());
     walker->nr = last_atom++;  // increase number within molecule
 …
   Vector Orthovector1, Orthovector2;  // temporary vectors in coordination construction
   Vector InBondvector;    // vector in direction of *Bond
   double *matrix = NULL;
+  const Matrix &matrix =  World::getInstance().getDomain().getM();
   bond *Binder = NULL;
-  double * const cell_size = World::getInstance().getDomain();
 //  Log() << Verbose(3) << "Begin of AddHydrogenReplacementAtom." << endl;
 …
       } // (signs are correct, was tested!)
+    }
+    matrix = ReturnFullMatrixforSymmetric(cell_size);
+    Orthovector1.MatrixMultiplication(matrix);
+    Orthovector1 *= matrix;
     InBondvector -= Orthovector1; // subtract just the additional translation
-    delete[](matrix);
     bondlength = InBondvector.Norm();
 //    Log() << Verbose(4) << "Corrected InBondvector is now: ";
 …
       break;
+  }
-  delete[](matrix);
 //  Log() << Verbose(3) << "End of AddHydrogenReplacementAtom." << endl;
 …
+{
   molecule *copy = World::getInstance().createMolecule();
-  atom *LeftAtom = NULL, *RightAtom = NULL;
   // copy all atoms
   ActOnCopyWithEachAtom ( &molecule::AddCopyAtom, copy );
+  for_each(atoms.begin(),atoms.end(),bind1st(mem_fun(&molecule::AddCopyAtom),copy));
   // copy all bonds
-  bond *Binder = NULL;
-  bond *NewBond = NULL;
   for(molecule::iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
     for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
       if ((*BondRunner)->leftatom == *AtomRunner) {
         Binder = (*BondRunner);
+        bond *Binder = (*BondRunner);
         // get the pendant atoms of current bond in the copy molecule
+        copy->ActOnAllAtoms( &atom::EqualsFather, (const atom *)Binder->leftatom, (const atom **)&LeftAtom );
+        copy->ActOnAllAtoms( &atom::EqualsFather, (const atom *)Binder->rightatom, (const atom **)&RightAtom );
+        NewBond = copy->AddBond(LeftAtom, RightAtom, Binder->BondDegree);
+        atomSet::iterator leftiter=find_if(atoms.begin(),atoms.end(),bind2nd(mem_fun(&atom::isFather),Binder->leftatom));
+        atomSet::iterator rightiter=find_if(atoms.begin(),atoms.end(),bind2nd(mem_fun(&atom::isFather),Binder->rightatom));
+        ASSERT(leftiter!=atoms.end(),"No original left atom for bondcopy found");
+        ASSERT(leftiter!=atoms.end(),"No original right atom for bondcopy found");
+        atom *LeftAtom = *leftiter;
+        atom *RightAtom = *rightiter;
+        bond *NewBond = copy->AddBond(LeftAtom, RightAtom, Binder->BondDegree);
         NewBond->Cyclic = Binder->Cyclic;
         if (Binder->Cyclic)
 …
+      }
   // correct fathers
   ActOnAllAtoms( &atom::CorrectFather );
+  for_each(atoms.begin(),atoms.end(),mem_fun(&atom::CorrectFather));
   // copy values
-  copy->CountElements();
   if (hasBondStructure()) {  // if adjaceny list is present
     copy->BondDistance = BondDistance;
 …
  * @param three vectors forming the matrix that defines the shape of the parallelpiped
  */
 molecule* molecule::CopyMoleculeFromSubRegion(const Vector offset, const double *parallelepiped) const {
+molecule* molecule::CopyMoleculeFromSubRegion(const Shape &region) const {
   molecule *copy = World::getInstance().createMolecule();
+  ActOnCopyWithEachAtomIfTrue ( &molecule::AddCopyAtom, copy, &atom::IsInParallelepiped, offset, parallelepiped );
+  BOOST_FOREACH(atom *iter,atoms){
+    if(iter->IsInShape(region)){
+      copy->AddCopyAtom(iter);
+    }
+  }
   //TODO: copy->BuildInducedSubgraph(this);
 …
   else
     length = strlen(molname) - strlen(endname);
+  cout << "Set name of molecule " << getId() << " to " << molname << endl;
   strncpy(name, molname, length);
   name[length]='\0';
 …
 void molecule::SetBoxDimension(Vector *dim)
+{
+  double * const cell_size = World::getInstance().getDomain();
+  cell_size[0] = dim->at(0);
+  cell_size[1] = 0.;
+  cell_size[2] = dim->at(1);
+  cell_size[3] = 0.;
+  cell_size[4] = 0.;
+  cell_size[5] = dim->at(2);
+  Matrix domain;
+  for(int i =0; i<NDIM;++i)
+    domain.at(i,i) = dim->at(i);
+  World::getInstance().setDomain(domain);
 };
 …
   ASSERT(pointer, "Null pointer passed to molecule::RemoveAtom().");
   OBSERVE;
+  if (ElementsInMolecule[pointer->type->Z] != 0)  { // this would indicate an error
+    ElementsInMolecule[pointer->type->Z]--;  // decrease number of atom of this element
+  } else
+    DoeLog(1) && (eLog()<< Verbose(1) << "Atom " << pointer->getName() << " is of element " << pointer->type->Z << " but the entry in the table of the molecule is 0!" << endl);
+  if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
+    ElementCount--;
+  formula-=pointer->type;
   RemoveBonds(pointer);
   erase(pointer);
 …
   if (pointer == NULL)
     return false;
+  if (ElementsInMolecule[pointer->type->Z] != 0)  // this would indicate an error
+    ElementsInMolecule[pointer->type->Z]--; // decrease number of atom of this element
+  else
+    DoeLog(1) && (eLog()<< Verbose(1) << "Atom " << pointer->getName() << " is of element " << pointer->type->Z << " but the entry in the table of the molecule is 0!" << endl);
+  if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
+    ElementCount--;
+  formula-=pointer->type;
   erase(pointer);
   return true;
 …
   for (molecule::iterator iter = begin(); !empty(); iter = begin())
       erase(iter);
+  return empty();
 };
 …
 bool molecule::CheckBounds(const Vector *x) const
+{
   double * const cell_size = World::getInstance().getDomain();
+  const Matrix &domain = World::getInstance().getDomain().getM();
   bool result = true;
-  int j =-1;
   for (int i=0;i<NDIM;i++) {
+    j += i+1;
+    result = result && ((x->at(i) >= 0) && (x->at(i) < cell_size[j]));
+    result = result && ((x->at(i) >= 0) && (x->at(i) < domain.at(i,i)));
+  }
   //return result;
 …
  * \param *out output stream
  */
+bool molecule::Output(ofstream * const output)
+{
+  int ElementNo[MAX_ELEMENTS], AtomNo[MAX_ELEMENTS];
+  CountElements();
+  for (int i=0;i<MAX_ELEMENTS;++i) {
+    AtomNo[i] = 0;
+    ElementNo[i] = 0;
+  }
+bool molecule::Output(ostream * const output)
+{
   if (output == NULL) {
     return false;
   } else {
+    int AtomNo[MAX_ELEMENTS];
+    memset(AtomNo,0,(MAX_ELEMENTS-1)*sizeof(*AtomNo));
+    enumeration<const element*> elementLookup = formula.enumerateElements();
+    for(map<const element*,unsigned int>::iterator iter=elementLookup.there.begin();
+        iter!=elementLookup.there.end();++iter){
+      cout << "Enumerated element " << *iter->first << " with number " << iter->second << endl;
+    }
     *output << "#Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)" << endl;
+    SetIndexedArrayForEachAtomTo ( ElementNo, &element::Z, &AbsoluteValue, 1);
+    int current=1;
+    for (int i=0;i<MAX_ELEMENTS;++i) {
+      if (ElementNo[i] == 1)
+        ElementNo[i] = current++;
+    }
+    ActOnAllAtoms( &atom::OutputArrayIndexed, output, (const int *)ElementNo, (int *)AtomNo, (const char *) NULL );
+    for_each(atoms.begin(),atoms.end(),boost::bind(&atom::OutputArrayIndexed,_1,output,elementLookup,AtomNo,(const char*)0));
     return true;
+  }
 …
+{
   int ElementNo[MAX_ELEMENTS], AtomNo[MAX_ELEMENTS];
-  CountElements();
   if (output == NULL) {
 …
+{
   DoLog(2) && (Log() << Verbose(2) << endl << "From Contents of ListOfBonds, all non-hydrogen atoms:" << endl);
   ActOnAllAtoms (&atom::OutputBondOfAtom );
+  for_each(atoms.begin(),atoms.end(),mem_fun(&atom::OutputBondOfAtom));
   DoLog(0) && (Log() << Verbose(0) << endl);
 };
 …
 bool molecule::Checkout(ofstream * const output)  const
+{
   return elemente->Checkout(output, ElementsInMolecule);
+  return formula.checkOut(output);
 };
 …
     for (int step=0;step<MDSteps;step++) {
       *output << getAtomCount() << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
       ActOnAllAtoms( &atom::OutputTrajectoryXYZ, output, step );
+      for_each(atoms.begin(),atoms.end(),boost::bind(&atom::OutputTrajectoryXYZ,_1,output,step));
+    }
     return true;
 …
     now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
     *output << getAtomCount() << "\n\tCreated by molecuilder on " << ctime(&now);
     ActOnAllAtoms( &atom::OutputXYZLine, output );
+    for_each(atoms.begin(),atoms.end(),bind2nd(mem_fun(&atom::OutputXYZLine),output));
     return true;
   } else
 …
 };
-/** Brings molecule::ElementCount and molecule::ElementsInMolecule up-to-date.
- */
-void molecule::CountElements()
+{
-  for(int i=MAX_ELEMENTS;i--;)
-    ElementsInMolecule[i] = 0;
-  ElementCount = 0;
-  SetIndexedArrayForEachAtomTo ( ElementsInMolecule, &element::Z, &Increment, 1);
-  for(int i=MAX_ELEMENTS;i--;)
-    ElementCount += (ElementsInMolecule[i] != 0 ? 1 : 0);
-};
-/** Counts necessary number of valence electrons and returns number and SpinType.
- * \param configuration containing everything
- */
-void molecule::CalculateOrbitals(class config &configuration)
+{
-  configuration.MaxPsiDouble = configuration.PsiMaxNoDown = configuration.PsiMaxNoUp = configuration.PsiType = 0;
-  for(int i=MAX_ELEMENTS;i--;) {
-    if (ElementsInMolecule[i] != 0) {
-      //Log() << Verbose(0) << "CalculateOrbitals: " << elemente->FindElement(i)->name << " has a valence of " << (int)elemente->FindElement(i)->Valence << " and there are " << ElementsInMolecule[i] << " of it." << endl;
-      configuration.MaxPsiDouble += ElementsInMolecule[i]*((int)elemente->FindElement(i)->Valence);
+    }
+  }
-  configuration.PsiMaxNoDown = configuration.MaxPsiDouble/2 + (configuration.MaxPsiDouble % 2);
-  configuration.PsiMaxNoUp = configuration.MaxPsiDouble/2;
-  configuration.MaxPsiDouble /= 2;
-  configuration.PsiType = (configuration.PsiMaxNoDown == configuration.PsiMaxNoUp) ? 0 : 1;
-  if ((configuration.PsiType == 1) && (configuration.ProcPEPsi < 2)) {
-    configuration.ProcPEGamma /= 2;
-    configuration.ProcPEPsi *= 2;
-  } else {
-    configuration.ProcPEGamma *= configuration.ProcPEPsi;
-    configuration.ProcPEPsi = 1;
+  }
-  configuration.InitMaxMinStopStep = configuration.MaxMinStopStep = configuration.MaxPsiDouble;
-};
 /** Determines whether two molecules actually contain the same atoms and coordination.
  * \param *out output stream for debugging
 …
   /// first count both their atoms and elements and update lists thereby ...
   //Log() << Verbose(0) << "Counting atoms, updating list" << endl;
-  CountElements();
-  OtherMolecule->CountElements();
   /// ... and compare:
 …
     } else Log() << Verbose(4) << "AtomCounts match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl;
+  }
   /// -# ElementCount
+  /// -# Formula
   if (result) {
     if (ElementCount != OtherMolecule->ElementCount) {
       DoLog(4) && (Log() << Verbose(4) << "ElementCount don't match: " << ElementCount << " == " << OtherMolecule->ElementCount << endl);
+    if (formula != OtherMolecule->formula) {
+      DoLog(4) && (Log() << Verbose(4) << "Formulas don't match: " << formula << " == " << OtherMolecule->formula << endl);
       result = false;
+    } else Log() << Verbose(4) << "ElementCount match: " << ElementCount << " == " << OtherMolecule->ElementCount << endl;
+  }
+  /// -# ElementsInMolecule
+  if (result) {
+    for (flag=MAX_ELEMENTS;flag--;) {
+      //Log() << Verbose(5) << "Element " <<  flag << ": " << ElementsInMolecule[flag] << " <-> " << OtherMolecule->ElementsInMolecule[flag] << "." << endl;
+      if (ElementsInMolecule[flag] != OtherMolecule->ElementsInMolecule[flag])
+        break;
+    }
+    if (flag < MAX_ELEMENTS) {
+      DoLog(4) && (Log() << Verbose(4) << "ElementsInMolecule don't match." << endl);
+      result = false;
+    } else Log() << Verbose(4) << "ElementsInMolecule match." << endl;
+    } else Log() << Verbose(4) << "Formulas match: " << formula << " == " << OtherMolecule->formula << endl;
+  }
   /// then determine and compare center of gravity for each molecule ...

src/molecule.hpp

-              r06f4ef6
+              rb6da28
 #define MOLECULES_HPP_
-using namespace std;
 /*********************************************** includes ***********************************/
+// GSL headers
+#include <gsl/gsl_eigen.h>
+#include <gsl/gsl_heapsort.h>
+#include <gsl/gsl_linalg.h>
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_multimin.h>
+#include <gsl/gsl_vector.h>
+#include <gsl/gsl_randist.h>
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 //// STL headers
 …
 #include <string>
 #include "defs.hpp"
+#include "types.hpp"
 #include "graph.hpp"
-#include "stackclass.hpp"
 #include "tesselation.hpp"
 #include "Patterns/Observer.hpp"
 #include "Patterns/ObservedIterator.hpp"
 #include "Patterns/Cacheable.hpp"
+#include "Formula.hpp"
+#include "AtomSet.hpp"
 #include "Descriptors/MoleculeDescriptor_impl.hpp"
 …
 class periodentafel;
 class Vector;
+class Shape;
+template <class> class StackClass;
 /******************************** Some definitions for easier reading **********************************/
 …
 };
-#define MaxThermostats 6      //!< maximum number of thermostat entries in Ions#ThermostatNames and Ions#ThermostatImplemented
-enum thermostats { None, Woodcock, Gaussian, Langevin, Berendsen, NoseHoover };   //!< Thermostat names for output
 /** The complete molecule.
  * Class incorporates number of types
 …
   public:
+    typedef std::set<atom*> atomSet;
+    typedef ATOMSET(std::list) atomSet;
+    typedef std::set<atomId_t> atomIdSet;
     typedef ObservedIterator<atomSet> iterator;
     typedef atomSet::const_iterator const_iterator;
 …
     //int AtomCount;          //!< number of atoms, brought up-to-date by CountAtoms()
     int BondCount;          //!< number of atoms, brought up-to-date by CountBonds()
-    int ElementCount;       //!< how many unique elements are therein
-    int ElementsInMolecule[MAX_ELEMENTS]; //!< list whether element (sorted by atomic number) is alread present or not
     mutable int NoNonHydrogen;  //!< number of non-hydrogen atoms in molecule
     mutable int NoNonBonds;     //!< number of non-hydrogen bonds in molecule
 …
   private:
     Cacheable<string> formula;
+    Formula formula;
     Cacheable<int>    AtomCount;
     moleculeId_t id;
+    atomSet atoms; //<!set of atoms
+    atomSet atoms; //<!list of atoms
+    atomIdSet atomIds; //<!set of atomic ids to check uniqueness of atoms
   protected:
     //void CountAtoms();
 …
   void setId(moleculeId_t);
   void setName(const std::string);
+  const std::string getFormula();
+  std::string calcFormula();
+  const Formula &getFormula();
+  unsigned int getElementCount();
+  bool hasElement(const element*) const;
+  bool hasElement(atomicNumber_t) const;
+  bool hasElement(const std::string&) const;
   iterator begin();
 …
   /// Count and change present atoms' coordination.
-  void CountElements();
-  void CalculateOrbitals(class config &configuration);
   bool CenterInBox();
   bool BoundInBox();
 …
   void SetBoxDimension(Vector *dim);
   void ScanForPeriodicCorrection();
   bool VerletForceIntegration(char *file, config &configuration);
+  bool VerletForceIntegration(char *file, config &configuration, const size_t offset);
   void Thermostats(config &configuration, double ActualTemp, int Thermostat);
   void PrincipalAxisSystem(bool DoRotate);
 …
   double MinimiseConstrainedPotential(atom **&permutation, int startstep, int endstep, bool IsAngstroem);
   void EvaluateConstrainedForces(int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force);
   bool LinearInterpolationBetweenConfiguration(int startstep, int endstep, const char *prefix, config &configuration, bool MapByIdentity);
+  bool LinearInterpolationBetweenConfiguration(int startstep, int endstep, std::string &prefix, config &configuration, bool MapByIdentity);
   bool CheckBounds(const Vector *x) const;
 …
   molecule *CopyMolecule();
   molecule* CopyMoleculeFromSubRegion(const Vector offset, const double *parallelepiped) const;
+  molecule* CopyMoleculeFromSubRegion(const Shape&) const;
   /// Fragment molecule by two different approaches:
   int FragmentMolecule(int Order, config *configuration);
   bool CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, char *path = NULL);
   bool StoreBondsToFile(char *path, char *filename);
   bool StoreAdjacencyToFile(char *path, char *filename);
   bool CheckAdjacencyFileAgainstMolecule(char *path, atom **ListOfAtoms);
   bool ParseOrderAtSiteFromFile(char *path);
   bool StoreOrderAtSiteFile(char *path);
   bool StoreForcesFile(MoleculeListClass *BondFragments, char *path, int *SortIndex);
+  int FragmentMolecule(int Order, std::string &prefix);
+  bool CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, std::string path = "");
+  bool StoreBondsToFile(std::string &filename, std::string path = "");
+  bool StoreAdjacencyToFile(std::string &filename, std::string path = "");
+  bool CheckAdjacencyFileAgainstMolecule(std::string &path, atom **ListOfAtoms);
+  bool ParseOrderAtSiteFromFile(std::string &path);
+  bool StoreOrderAtSiteFile(std::string &path);
+  bool StoreForcesFile(MoleculeListClass *BondFragments, std::string &path, int *SortIndex);
   bool CreateMappingLabelsToConfigSequence(int *&SortIndex);
   bool CreateFatherLookupTable(atom **&LookupTable, int count = 0);
 …
   // Output routines.
   bool Output(ofstream * const output);
+  bool Output(std::ostream * const output);
   bool OutputTrajectories(ofstream * const output);
   void OutputListOfBonds() const;
 …
   ~MoleculeListClass();
   bool AddHydrogenCorrection(char *path);
   bool StoreForcesFile(char *path, int *SortIndex);
+  bool AddHydrogenCorrection(std::string &path);
+  bool StoreForcesFile(std::string &path, int *SortIndex);
   void insert(molecule *mol);
   void erase(molecule *mol);
   molecule * ReturnIndex(int index);
   bool OutputConfigForListOfFragments(config *configuration, int *SortIndex);
+  bool OutputConfigForListOfFragments(std::string &prefix, int *SortIndex);
   int NumberOfActiveMolecules();
   void Enumerate(ostream *out);
 …
   bool AddLeaf(molecule *ptr, MoleculeLeafClass *Previous);
   bool FillBondStructureFromReference(const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList = false);
+  bool FillBondStructureFromReference(const molecule * const reference, atom **&ListOfLocalAtoms, bool FreeList = false);
   bool FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter);
   bool AssignKeySetsToFragment(molecule *reference, Graph *KeySetList, atom ***&ListOfLocalAtoms, Graph **&FragmentList, int &FragmentCounter, bool FreeList = false);
   bool FillListOfLocalAtoms(atom ***&ListOfLocalAtoms, const int FragmentCounter, const int GlobalAtomCount, bool &FreeList);
+  bool FillListOfLocalAtoms(atom **&ListOfLocalAtoms, const int GlobalAtomCount, bool &FreeList);
   void TranslateIndicesToGlobalIDs(Graph **FragmentList, int &FragmentCounter, int &TotalNumberOfKeySets, Graph &TotalGraph);
   int Count() const;

src/molecule_dynamics.cpp

-              r06f4ef6
+              rb6da28
 #include "element.hpp"
 #include "info.hpp"
+#include "verbose.hpp"
 #include "log.hpp"
-#include "memoryallocator.hpp"
 #include "molecule.hpp"
 #include "parser.hpp"
 #include "Plane.hpp"
+#include "ThermoStatContainer.hpp"
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_vector.h>
+#include <gsl/gsl_linalg.h>
 /************************************* Functions for class molecule *********************************/
 …
  * \param startstep stating initial configuration in molecule::Trajectories
  * \param endstep stating final configuration in molecule::Trajectories
+ * \param &prefix path and prefix
  * \param &config configuration structure
  * \param MapByIdentity if true we just use the identity to map atoms in start config to end config, if not we find mapping by \sa MinimiseConstrainedPotential()
  * \return true - success in writing step files, false - error writing files or only one step in molecule::Trajectories
  */
 bool molecule::LinearInterpolationBetweenConfiguration(int startstep, int endstep, const char *prefix, config &configuration, bool MapByIdentity)
+bool molecule::LinearInterpolationBetweenConfiguration(int startstep, int endstep, std::string &prefix, config &configuration, bool MapByIdentity)
+{
   molecule *mol = NULL;
 …
   for (int i=getAtomCount(); i--; )
     SortIndex[i] = i;
+  status = MoleculePerStep->OutputConfigForListOfFragments(&configuration, SortIndex);
+  status = MoleculePerStep->OutputConfigForListOfFragments(prefix, SortIndex);
   delete[](SortIndex);
 …
  * have to transform them).
  * This adds a new MD step to the config file.
- * \param *out output stream for debugging
  * \param *file filename
  * \param config structure with config::Deltat, config::IsAngstroem, config::DoConstrained
+ * \param delta_t time step width in atomic units
+ * \param IsAngstroem whether coordinates are in angstroem (true) or bohrradius (false)
+ * \param DoConstrained whether we perform a constrained (>0, target step in molecule::trajectories) or unconstrained (0) molecular dynamics, \sa molecule::MinimiseConstrainedPotential()
+ * \param offset offset in matrix file to the first force component
  * \return true - file found and parsed, false - file not found or imparsable
  * \todo This is not yet checked if it is correctly working with DoConstrained set to true.
  */
 bool molecule::VerletForceIntegration(char *file, config &configuration)
+bool molecule::VerletForceIntegration(char *file, config &configuration, const size_t offset)
+{
   Info FunctionInfo(__func__);
 …
   ForceMatrix Force;
+  CountElements();  // make sure ElementsInMolecule is up to date
+  const int AtomCount = getAtomCount();
   // check file
   if (input == NULL) {
 …
       return false;
+    }
     if (Force.RowCounter[0] != getAtomCount()) {
+    if (Force.RowCounter[0] != AtomCount) {
       DoeLog(0) && (eLog()<< Verbose(0) << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << getAtomCount() << "." << endl);
       performCriticalExit();
 …
     // correct Forces
     Velocity.Zero();
     for(int i=0;i<getAtomCount();i++)
+    for(int i=0;i<AtomCount;i++)
       for(int d=0;d<NDIM;d++) {
         Velocity[d] += Force.Matrix[0][i][d+5];
+        Velocity[d] += Force.Matrix[0][i][d+offset];
+      }
     for(int i=0;i<getAtomCount();i++)
+    for(int i=0;i<AtomCount;i++)
       for(int d=0;d<NDIM;d++) {
         Force.Matrix[0][i][d+5] -= Velocity[d]/static_cast<double>(getAtomCount());
+        Force.Matrix[0][i][d+offset] -= Velocity[d]/static_cast<double>(AtomCount);
+      }
     // solve a constrained potential if we are meant to
 …
     //ActOnAllAtoms( &atom::ResizeTrajectory, MDSteps+10 );
     ActOnAllAtoms( &atom::VelocityVerletUpdate, MDSteps+1, &configuration, &Force);
+    ActOnAllAtoms( &atom::VelocityVerletUpdate, MDSteps+1, &configuration, &Force, (const size_t) 0);
+  }
   // correct velocities (rather momenta) so that center of mass remains motionless
 …
   // calculate scale configuration
   ScaleTempFactor = configuration.TargetTemp/ActualTemp;
+  ScaleTempFactor = configuration.Thermostats->TargetTemp/ActualTemp;
   // differentating between the various thermostats
 …
       break;
      case Woodcock:
       if ((configuration.ScaleTempStep > 0) && ((MDSteps-1) % configuration.ScaleTempStep == 0)) {
+      if ((configuration.Thermostats->ScaleTempStep > 0) && ((MDSteps-1) % configuration.Thermostats->ScaleTempStep == 0)) {
         DoLog(2) && (Log() << Verbose(2) <<  "Applying Woodcock thermostat..." << endl);
         ActOnAllAtoms( &atom::Thermostat_Woodcock, sqrt(ScaleTempFactor), MDSteps, &ekin );
 …
       delta_alpha = 0.;
       ActOnAllAtoms( &atom::Thermostat_NoseHoover_init, MDSteps, &delta_alpha );
       delta_alpha = (delta_alpha - (3.*getAtomCount()+1.) * configuration.TargetTemp)/(configuration.HooverMass*Units2Electronmass);
       configuration.alpha += delta_alpha*configuration.Deltat;
       DoLog(3) && (Log() << Verbose(3) << "alpha = " << delta_alpha << " * " << configuration.Deltat << " = " << configuration.alpha << "." << endl);
+      delta_alpha = (delta_alpha - (3.*getAtomCount()+1.) * configuration.Thermostats->TargetTemp)/(configuration.Thermostats->HooverMass*Units2Electronmass);
+      configuration.Thermostats->alpha += delta_alpha*configuration.Deltat;
+      DoLog(3) && (Log() << Verbose(3) << "alpha = " << delta_alpha << " * " << configuration.Deltat << " = " << configuration.Thermostats->alpha << "." << endl);
       // apply updated alpha as additional force
       ActOnAllAtoms( &atom::Thermostat_NoseHoover_scale, MDSteps, &ekin, &configuration );

src/molecule_fragmentation.cpp

-              r06f4ef6
+              rb6da28
 #include "helpers.hpp"
 #include "lists.hpp"
+#include "verbose.hpp"
 #include "log.hpp"
-#include "memoryallocator.hpp"
 #include "molecule.hpp"
 #include "periodentafel.hpp"
 #include "World.hpp"
+#include "Matrix.hpp"
+#include "Box.hpp"
+#include "stackclass.hpp"
 /************************************* Functions for class molecule *********************************/
 …
  * -# Scans TEFactors file and sets the TEFactor of each key set in the temporary graph accordingly
  * Finally, the temporary graph is inserted into the given \a FragmentList for return.
+ * \param *out output stream for debugging
+ * \param *path path to file
+ * \param &path path to file
  * \param *FragmentList empty, filled on return
  * \return true - parsing successfully, false - failure on parsing (FragmentList will be NULL)
  */
 bool ParseKeySetFile(char *path, Graph *&FragmentList)
+bool ParseKeySetFile(std::string &path, Graph *&FragmentList)
+{
   bool status = true;
 …
   GraphTestPair testGraphInsert;
   int NumberOfFragments = 0;
   char filename[MAXSTRINGSIZE];
+  string filename;
   if (FragmentList == NULL) { // check list pointer
 …
   // 1st pass: open file and read
   DoLog(1) && (Log() << Verbose(1) << "Parsing the KeySet file ... " << endl);
   sprintf(filename, "%s/%s%s", path, FRAGMENTPREFIX, KEYSETFILE);
   InputFile.open(filename);
   if (InputFile != NULL) {
+  filename = path + KEYSETFILE;
+  InputFile.open(filename.c_str());
+  if (InputFile.good()) {
     // each line represents a new fragment
     char buffer[MAXSTRINGSIZE];
 …
 /** Stores key sets to file.
- * \param *out output stream for debugging
  * \param KeySetList Graph with Keysets
  * \param *path path to file
+ * \param &path path to file
  * \return true - file written successfully, false - writing failed
  */
+bool StoreKeySetFile(Graph &KeySetList, char *path)
+{
+  ofstream output;
+bool StoreKeySetFile(Graph &KeySetList, std::string &path)
+{
   bool status =  true;
+  string line;
+  string line = path + KEYSETFILE;
+  ofstream output(line.c_str());
   // open KeySet file
-  line = path;
-  line.append("/");
-  line += FRAGMENTPREFIX;
-  line += KEYSETFILE;
-  output.open(line.c_str(), ios::out);
   DoLog(1) && (Log() << Verbose(1) << "Saving key sets of the total graph ... ");
   if(output != NULL) {
+  if(output.good()) {
     for(Graph::iterator runner = KeySetList.begin(); runner != KeySetList.end(); runner++) {
       for (KeySet::iterator sprinter = (*runner).first.begin();sprinter != (*runner).first.end(); sprinter++) {
 …
 /** Scans the adaptive order file and insert (index, value) into map.
+ * \param *out output stream for debugging
+ * \param *path path to ENERGYPERFRAGMENT file (may be NULL if Order is non-negative)
+ * \param &path path to ENERGYPERFRAGMENT file (may be NULL if Order is non-negative)
  * \param &IndexedKeySetList list to find key set for a given index \a No
  * \return adaptive criteria list from file
  */
 map<int, pair<double,int> > * ScanAdaptiveFileIntoMap(char *path, map<int,KeySet> &IndexKeySetList)
+map<int, pair<double,int> > * ScanAdaptiveFileIntoMap(std::string &path, map<int,KeySet> &IndexKeySetList)
+{
   map<int, pair<double,int> > *AdaptiveCriteriaList = new map<int, pair<double,int> >;
 …
   double Value = 0.;
   char buffer[MAXSTRINGSIZE];
+  sprintf(buffer, "%s/%s%s.dat", path, FRAGMENTPREFIX, ENERGYPERFRAGMENT);
+  ifstream InputFile(buffer, ios::in);
+  string filename = path + ENERGYPERFRAGMENT;
+  ifstream InputFile(filename.c_str());
+  if (InputFile.fail()) {
+    DoeLog(1) && (eLog() << Verbose(1) << "Cannot find file " << filename << "." << endl);
+    return AdaptiveCriteriaList;
+  }
   if (CountLinesinFile(InputFile) > 0) {
 …
 /** Checks whether the OrderAtSite is still below \a Order at some site.
- * \param *out output stream for debugging
  * \param *AtomMask defines true/false per global Atom::nr to mask in/out each nuclear site, used to activate given number of site to increment order adaptively
  * \param *GlobalKeySetList list of keysets with global ids (valid in "this" molecule) needed for adaptive increase
  * \param Order desired Order if positive, desired exponent in threshold criteria if negative (0 is single-step)
  * \param *MinimumRingSize array of max. possible order to avoid loops
  * \param *path path to ENERGYPERFRAGMENT file (may be NULL if Order is non-negative)
+ * \param path path to ENERGYPERFRAGMENT file (may be NULL if Order is non-negative)
  * \return true - needs further fragmentation, false - does not need fragmentation
  */
 bool molecule::CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, char *path)
+bool molecule::CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, std::string path)
+{
   bool status = false;
 …
  * of vertex indices: Global always means the index in "this" molecule, whereas local refers to the molecule or
  * subgraph in the MoleculeListClass.
- * \param *out output stream for debugging
  * \param Order up to how many neighbouring bonds a fragment contains in BondOrderScheme::BottumUp scheme
  * \param *configuration configuration for writing config files for each fragment
+ * \param &prefix path and prefix of the bond order configs to be written
  * \return 1 - continue, 2 - stop (no fragmentation occured)
  */
 int molecule::FragmentMolecule(int Order, config *configuration)
+int molecule::FragmentMolecule(int Order, std::string &prefix)
+{
   MoleculeListClass *BondFragments = NULL;
 …
   // === compare it with adjacency file ===
   FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(configuration->configpath, ListOfAtoms);
+  FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(prefix, ListOfAtoms);
   delete[](ListOfAtoms);
 …
     MinimumRingSize[i] = getAtomCount();
   MolecularWalker = Subgraphs;
+  const int LeafCount = Subgraphs->next->Count();
   FragmentCounter = 0;
   while (MolecularWalker->next != NULL) {
     MolecularWalker = MolecularWalker->next;
     // fill the bond structure of the individually stored subgraphs
+    MolecularWalker->FillBondStructureFromReference(this, FragmentCounter, ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
+    ListOfAtoms = NULL;
+    MolecularWalker->FillBondStructureFromReference(this, ListOfAtoms, false);  // we want to keep the created ListOfLocalAtoms
     DoLog(0) && (Log() << Verbose(0) << "Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl);
     LocalBackEdgeStack = new StackClass<bond *> (MolecularWalker->Leaf->BondCount);
 …
 //        Log() << Verbose(0) << "\t" << ListOfLocalAtoms[FragmentCounter][i]->Name;
     DoLog(0) && (Log() << Verbose(0) << "Gathering local back edges for subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl);
     MolecularWalker->Leaf->PickLocalBackEdges(ListOfLocalAtoms[FragmentCounter++], BackEdgeStack, LocalBackEdgeStack);
+    MolecularWalker->Leaf->PickLocalBackEdges(ListOfAtoms, BackEdgeStack, LocalBackEdgeStack);
     DoLog(0) && (Log() << Verbose(0) << "Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl);
     MolecularWalker->Leaf->CyclicStructureAnalysis(LocalBackEdgeStack, MinimumRingSize);
     DoLog(0) && (Log() << Verbose(0) << "Done with Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl);
     delete(LocalBackEdgeStack);
+    delete(ListOfAtoms);
+    FragmentCounter++;
+  }
   delete(BackEdgeStack);
   // ===== 3. if structure still valid, parse key set file and others =====
   FragmentationToDo = FragmentationToDo && ParseKeySetFile(configuration->configpath, ParsedFragmentList);
+  FragmentationToDo = FragmentationToDo && ParseKeySetFile(prefix, ParsedFragmentList);
   // ===== 4. check globally whether there's something to do actually (first adaptivity check)
   FragmentationToDo = FragmentationToDo && ParseOrderAtSiteFromFile(configuration->configpath);
+  FragmentationToDo = FragmentationToDo && ParseOrderAtSiteFromFile(prefix);
   // =================================== Begin of FRAGMENTATION ===============================
   // ===== 6a. assign each keyset to its respective subgraph =====
+  Subgraphs->next->AssignKeySetsToFragment(this, ParsedFragmentList, ListOfLocalAtoms, FragmentList, (FragmentCounter = 0), true);
+  ListOfLocalAtoms = new atom **[LeafCount];
+  for (int i=0;i<LeafCount;i++)
+    ListOfLocalAtoms[i] = NULL;
+  FragmentCounter = 0;
+  Subgraphs->next->AssignKeySetsToFragment(this, ParsedFragmentList, ListOfLocalAtoms, FragmentList, FragmentCounter, true);
+  delete[](ListOfLocalAtoms);
   // ===== 6b. prepare and go into the adaptive (Order<0), single-step (Order==0) or incremental (Order>0) cycle
 …
   AtomMask[getAtomCount()] = false;
   FragmentationToDo = false;  // if CheckOrderAtSite just ones recommends fragmentation, we will save fragments afterwards
   while ((CheckOrder = CheckOrderAtSite(AtomMask, ParsedFragmentList, Order, MinimumRingSize, configuration->configpath))) {
+  while ((CheckOrder = CheckOrderAtSite(AtomMask, ParsedFragmentList, Order, MinimumRingSize, prefix))) {
     FragmentationToDo = FragmentationToDo || CheckOrder;
     AtomMask[getAtomCount()] = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
 …
   delete[](MinimumRingSize);
   // ==================================== End of FRAGMENTATION ============================================
 …
     KeySet test = (*runner).first;
     DoLog(0) && (Log() << Verbose(0) << "Fragment No." << (*runner).second.first << " with TEFactor " << (*runner).second.second << "." << endl);
     BondFragments->insert(StoreFragmentFromKeySet(test, configuration));
+    BondFragments->insert(StoreFragmentFromKeySet(test, World::getInstance().getConfig()));
     k++;
+  }
 …
     DoLog(1) && (Log() << Verbose(1) << "Writing " << BondFragments->ListOfMolecules.size() << " possible bond fragmentation configs" << endl);
     if (BondFragments->OutputConfigForListOfFragments(configuration, SortIndex))
+    if (BondFragments->OutputConfigForListOfFragments(prefix, SortIndex))
       DoLog(1) && (Log() << Verbose(1) << "All configs written." << endl);
     else
 …
     // store force index reference file
     BondFragments->StoreForcesFile(configuration->configpath, SortIndex);
+    BondFragments->StoreForcesFile(prefix, SortIndex);
     // store keysets file
     StoreKeySetFile(TotalGraph, configuration->configpath);
+    StoreKeySetFile(TotalGraph, prefix);
+    {
       // store Adjacency file
+      char filename[MAXSTRINGSIZE];
+      strcpy(filename, FRAGMENTPREFIX);
+      strcat(filename, ADJACENCYFILE);
+      StoreAdjacencyToFile(configuration->configpath, filename);
+      std::string filename = prefix + ADJACENCYFILE;
+      StoreAdjacencyToFile(filename);
+    }
     // store Hydrogen saturation correction file
     BondFragments->AddHydrogenCorrection(configuration->configpath);
+    BondFragments->AddHydrogenCorrection(prefix);
     // store adaptive orders into file
     StoreOrderAtSiteFile(configuration->configpath);
+    StoreOrderAtSiteFile(prefix);
     // restore orbital and Stop values
     CalculateOrbitals(*configuration);
+    //CalculateOrbitals(*configuration);
     // free memory for bond part
 …
 /** Stores pairs (Atom::nr, Atom::AdaptiveOrder) into file.
  * Atoms not present in the file get "-1".
+ * \param *out output stream for debugging
+ * \param *path path to file ORDERATSITEFILE
+ * \param &path path to file ORDERATSITEFILE
  * \return true - file writable, false - not writable
  */
 bool molecule::StoreOrderAtSiteFile(char *path)
+{
   stringstream line;
+bool molecule::StoreOrderAtSiteFile(std::string &path)
+{
+  string line;
   ofstream file;
   line << path << "/" << FRAGMENTPREFIX << ORDERATSITEFILE;
   file.open(line.str().c_str());
+  line = path + ORDERATSITEFILE;
+  file.open(line.c_str());
   DoLog(1) && (Log() << Verbose(1) << "Writing OrderAtSite " << ORDERATSITEFILE << " ... " << endl);
   if (file != NULL) {
+  if (file.good()) {
     ActOnAllAtoms( &atom::OutputOrder, &file );
     file.close();
 …
     return true;
   } else {
     DoLog(1) && (Log() << Verbose(1) << "failed to open file " << line.str() << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "failed to open file " << line << "." << endl);
     return false;
+  }
 …
 /** Parses pairs(Atom::nr, Atom::AdaptiveOrder) from file and stores in molecule's Atom's.
  * Atoms not present in the file get "0".
+ * \param *out output stream for debugging
+ * \param *path path to file ORDERATSITEFILEe
+ * \param &path path to file ORDERATSITEFILEe
  * \return true - file found and scanned, false - file not found
  * \sa ParseKeySetFile() and CheckAdjacencyFileAgainstMolecule() as this is meant to be used in conjunction with the two
  */
 bool molecule::ParseOrderAtSiteFromFile(char *path)
+bool molecule::ParseOrderAtSiteFromFile(std::string &path)
+{
   unsigned char *OrderArray = new unsigned char[getAtomCount()];
 …
   bool status;
   int AtomNr, value;
   stringstream line;
+  string line;
   ifstream file;
 …
   DoLog(1) && (Log() << Verbose(1) << "Begin of ParseOrderAtSiteFromFile" << endl);
   line << path << "/" << FRAGMENTPREFIX << ORDERATSITEFILE;
   file.open(line.str().c_str());
   if (file != NULL) {
+  line = path + ORDERATSITEFILE;
+  file.open(line.c_str());
+  if (file.good()) {
     while (!file.eof()) { // parse from file
       AtomNr = -1;
 …
     status = true;
   } else {
     DoLog(1) && (Log() << Verbose(1) << "\t ... failed to open file " << line.str() << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t ... failed to open file " << line << "." << endl);
     status = false;
+  }
 …
   atom *Walker = NULL;
   atom *OtherWalker = NULL;
+  double * const cell_size = World::getInstance().getDomain();
+  double *matrix = ReturnFullMatrixforSymmetric(cell_size);
+  Matrix matrix = World::getInstance().getDomain().getM();
   enum Shading *ColorList = NULL;
   double tmp;
 …
           Translationvector[i] = (tmp < 0) ? +1. : -1.;
+      }
       Translationvector.MatrixMultiplication(matrix);
+      Translationvector *= matrix;
       //Log() << Verbose(3) << "Translation vector is ";
       Log() << Verbose(0) << Translationvector <<  endl;
 …
   delete(AtomStack);
   delete[](ColorList);
-  delete[](matrix);
   DoLog(2) && (Log() << Verbose(2) << "End of ScanForPeriodicCorrection." << endl);
 };

src/molecule_geometry.cpp

-              r06f4ef6
+              rb6da28
  *      Author: heber
  */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 #include "helpers.hpp"
 #include "leastsquaremin.hpp"
+#include "verbose.hpp"
 #include "log.hpp"
-#include "memoryallocator.hpp"
 #include "molecule.hpp"
 #include "World.hpp"
 #include "Plane.hpp"
+#include "Matrix.hpp"
+#include "Box.hpp"
 #include <boost/foreach.hpp>
+#include <gsl/gsl_eigen.h>
+#include <gsl/gsl_multimin.h>
 …
   const Vector *Center = DetermineCenterOfAll();
   const Vector *CenterBox = DetermineCenterOfBox();
+  double * const cell_size = World::getInstance().getDomain();
+  double *M = ReturnFullMatrixforSymmetric(cell_size);
+  double *Minv = InverseMatrix(M);
+  Box &domain = World::getInstance().getDomain();
   // go through all atoms
   ActOnAllVectors( &Vector::SubtractVector, *Center);
   ActOnAllVectors( &Vector::SubtractVector, *CenterBox);
+  ActOnAllVectors( &Vector::WrapPeriodically, (const double *)M, (const double *)Minv);
+  delete[](M);
+  delete[](Minv);
+  atoms.transformNodes(boost::bind(&Box::WrapPeriodically,domain,_1));
   delete(Center);
+  delete(CenterBox);
   return status;
 };
 …
+{
   bool status = true;
+  double * const cell_size = World::getInstance().getDomain();
+  double *M = ReturnFullMatrixforSymmetric(cell_size);
+  double *Minv = InverseMatrix(M);
+  // go through all atoms
+  ActOnAllVectors( &Vector::WrapPeriodically, (const double *)M, (const double *)Minv);
+  delete[](M);
+  delete[](Minv);
+  Box &domain = World::getInstance().getDomain();
+  atoms.transformNodes(boost::bind(&Box::WrapPeriodically,domain,_1));
   return status;
 };
 …
       Center += (*iter)->x;
+    }
     Center.Scale(-1./Num); // divide through total number (and sign for direction)
+    Center.Scale(-1./(double)Num); // divide through total number (and sign for direction)
     Translate(&Center);
     Center.Zero();
 …
       (*a) += (*iter)->x;
+    }
     a->Scale(1./Num); // divide through total mass (and sign for direction)
+    a->Scale(1./(double)Num); // divide through total mass (and sign for direction)
+  }
   return a;
 …
+{
   Vector *a = new Vector(0.5,0.5,0.5);
+  const double *cell_size = World::getInstance().getDomain();
+  double *M = ReturnFullMatrixforSymmetric(cell_size);
+  a->MatrixMultiplication(M);
+  delete[](M);
+  const Matrix &M = World::getInstance().getDomain().getM();
+  (*a) *= M;
   return a;
 };
 …
       (*a) += tmp;
+    }
     a->Scale(1./Num); // divide through total mass (and sign for direction)
+    a->Scale(1./Num); // divide through total mass
+  }
 //  Log() << Verbose(1) << "Resulting center of gravity: ";
 …
 void molecule::TranslatePeriodically(const Vector *trans)
+{
+  double * const cell_size = World::getInstance().getDomain();
+  double *M = ReturnFullMatrixforSymmetric(cell_size);
+  double *Minv = InverseMatrix(M);
+  Box &domain = World::getInstance().getDomain();
   // go through all atoms
   ActOnAllVectors( &Vector::AddVector, *trans);
+  ActOnAllVectors( &Vector::WrapPeriodically, (const double *)M, (const double *)Minv);
+  delete[](M);
+  delete[](Minv);
+  atoms.transformNodes(boost::bind(&Box::WrapPeriodically,domain,_1));
 };
 …
   OBSERVE;
   Plane p(*n,0);
+  BOOST_FOREACH( atom* iter, atoms ){
+    (*iter->node) = p.mirrorVector(*iter->node);
+  }
+  atoms.transformNodes(boost::bind(&Plane::mirrorVector,p,_1));
 };
 …
 void molecule::DeterminePeriodicCenter(Vector &center)
+{
+  double * const cell_size = World::getInstance().getDomain();
+  double *matrix = ReturnFullMatrixforSymmetric(cell_size);
+  double *inversematrix = InverseMatrix(matrix);
+  const Matrix &matrix = World::getInstance().getDomain().getM();
+  const Matrix &inversematrix = World::getInstance().getDomain().getM();
   double tmp;
   bool flag;
 …
       if ((*iter)->type->Z != 1) {
 #endif
+        Testvector = (*iter)->x;
+        Testvector.MatrixMultiplication(inversematrix);
+        Testvector = inversematrix * (*iter)->x;
         Translationvector.Zero();
         for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
 …
+        }
         Testvector += Translationvector;
         Testvector.MatrixMultiplication(matrix);
+        Testvector *= matrix;
         Center += Testvector;
         Log() << Verbose(1) << "vector is: " << Testvector << endl;
 …
         for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
           if ((*Runner)->GetOtherAtom((*iter))->type->Z == 1) {
+            Testvector = (*Runner)->GetOtherAtom((*iter))->x;
+            Testvector.MatrixMultiplication(inversematrix);
+            Testvector = inversematrix * (*Runner)->GetOtherAtom((*iter))->x;
             Testvector += Translationvector;
             Testvector.MatrixMultiplication(matrix);
+            Testvector *= matrix;
             Center += Testvector;
             Log() << Verbose(1) << "Hydrogen vector is: " << Testvector << endl;
 …
+    }
   } while (!flag);
-  delete[](matrix);
-  delete[](inversematrix);
   Center.Scale(1./static_cast<double>(getAtomCount()));
 …
     DoLog(1) && (Log() << Verbose(1) << "Transforming molecule into PAS ... ");
     // the eigenvectors specify the transformation matrix
+    ActOnAllVectors( &Vector::MatrixMultiplication, (const double *) evec->data );
+    Matrix M = Matrix(evec->data);
+    BOOST_FOREACH(atom* iter, atoms){
+      (*iter->node) *= M;
+    }
     DoLog(0) && (Log() << Verbose(0) << "done." << endl);

src/molecule_graph.cpp

-              r06f4ef6
+              rb6da28
  */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 …
 #include "bondgraph.hpp"
 #include "config.hpp"
+#include "defs.hpp"
 #include "element.hpp"
 #include "helpers.hpp"
 …
 #include "linkedcell.hpp"
 #include "lists.hpp"
+#include "verbose.hpp"
 #include "log.hpp"
-#include "memoryallocator.hpp"
 #include "molecule.hpp"
 #include "World.hpp"
 #include "Helpers/fast_functions.hpp"
 #include "Helpers/Assert.hpp"
+#include "Matrix.hpp"
+#include "Box.hpp"
+#include "stackclass.hpp"
 struct BFSAccounting
 …
   LinkedCell *LC = NULL;
   bool free_BG = false;
   double * const cell_size = World::getInstance().getDomain();
+  Box &domain = World::getInstance().getDomain();
   if (BG == NULL) {
 …
                           //Log() << Verbose(1) << "Checking distance " << OtherWalker->x.PeriodicDistanceSquared(&(Walker->x), cell_size) << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
                           (BG->*minmaxdistance)(Walker, OtherWalker, MinDistance, MaxDistance, IsAngstroem);
                           const double distance = OtherWalker->x.PeriodicDistanceSquared(Walker->x,cell_size);
+                          const double distance = domain.periodicDistanceSquared(OtherWalker->x,Walker->x);
                           const bool status = (distance <= MaxDistance * MaxDistance) && (distance >= MinDistance * MinDistance);
 //                          Log() << Verbose(1) << "MinDistance is " << MinDistance << " and MaxDistance is " << MaxDistance << "." << endl;
 …
     // From OldGraphNr to CurrentGraphNr ranges an disconnected subgraph
     DoLog(0) && (Log() << Verbose(0) << "Disconnected subgraph ranges from " << OldGraphNr << " to " << DFS.CurrentGraphNr << "." << endl);
     LeafWalker->Leaf->Output((ofstream *)&cout);
+    LeafWalker->Leaf->Output((ofstream *)&(Log() << Verbose(0)));
     DoLog(0) && (Log() << Verbose(0) << endl);
 …
   BFS.ColorList = new enum Shading[AtomCount];
   BFS.BFSStack = new StackClass<atom *> (AtomCount);
+  BFS.TouchedStack = new StackClass<atom *> (AtomCount);
   for (int i = AtomCount; i--;) {
     BFS.ShortestPathList[i] = -1;
     BFS.PredecessorList[i] = 0;
+    BFS.ColorList[i] = white;
+  }
 };
 …
   delete[](BFS.ColorList);
   delete (BFS.BFSStack);
+  delete (BFS.TouchedStack);
   BFS.AtomCount = 0;
 };
 …
       MinRingSize = RingSize;
   } else {
     DoLog(1) && (Log() << Verbose(1) << "No ring containing " << *BFS.Root << " with length equal to or smaller than " << MinimumRingSize[Walker->GetTrueFather()->nr] << " found." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "No ring containing " << *BFS.Root << " with length equal to or smaller than " << MinimumRingSize[BFS.Root->GetTrueFather()->nr] << " found." << endl);
+  }
 };
 …
 /** Storing the bond structure of a molecule to file.
  * Simply stores Atom::nr and then the Atom::nr of all bond partners per line.
  * \param *path path to file
  * \param *filename name of file
+ * \param &filename name of file
+ * \param path path to file, defaults to empty
  * \return true - file written successfully, false - writing failed
  */
 bool molecule::StoreAdjacencyToFile(char *path, char *filename)
+bool molecule::StoreAdjacencyToFile(std::string &filename, std::string path)
+{
   ofstream AdjacencyFile;
   stringstream line;
+  string line;
   bool status = true;
   if (path != NULL)
     line << path << "/" << filename;
+  if (path != "")
+    line = path + "/" + filename;
   else
     line << filename;
   AdjacencyFile.open(line.str().c_str(), ios::out);
+    line = filename;
+  AdjacencyFile.open(line.c_str(), ios::out);
   DoLog(1) && (Log() << Verbose(1) << "Saving adjacency list ... " << endl);
   if (AdjacencyFile != NULL) {
+  if (AdjacencyFile.good()) {
     AdjacencyFile << "m\tn" << endl;
     ActOnAllAtoms(&atom::OutputAdjacency, &AdjacencyFile);
 …
     DoLog(1) && (Log() << Verbose(1) << "\t... done." << endl);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "\t... failed to open file " << line.str() << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t... failed to open file " << line << "." << endl);
     status = false;
+  }
 …
 /** Storing the bond structure of a molecule to file.
  * Simply stores Atom::nr and then the Atom::nr of all bond partners, one per line.
  * \param *path path to file
  * \param *filename name of file
+ * \param &filename name of file
+ * \param path path to file, defaults to empty
  * \return true - file written successfully, false - writing failed
  */
 bool molecule::StoreBondsToFile(char *path, char *filename)
+bool molecule::StoreBondsToFile(std::string &filename, std::string path)
+{
   ofstream BondFile;
   stringstream line;
+  string line;
   bool status = true;
   if (path != NULL)
     line << path << "/" << filename;
+  if (path != "")
+    line = path + "/" + filename;
   else
     line << filename;
   BondFile.open(line.str().c_str(), ios::out);
+    line = filename;
+  BondFile.open(line.c_str(), ios::out);
   DoLog(1) && (Log() << Verbose(1) << "Saving adjacency list ... " << endl);
   if (BondFile != NULL) {
+  if (BondFile.good()) {
     BondFile << "m\tn" << endl;
     ActOnAllAtoms(&atom::OutputBonds, &BondFile);
 …
     DoLog(1) && (Log() << Verbose(1) << "\t... done." << endl);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "\t... failed to open file " << line.str() << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t... failed to open file " << line << "." << endl);
     status = false;
+  }
 …
+;
 bool CheckAdjacencyFileAgainstMolecule_Init(char *path, ifstream &File, int *&CurrentBonds)
+{
   stringstream filename;
   filename << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
   File.open(filename.str().c_str(), ios::out);
+bool CheckAdjacencyFileAgainstMolecule_Init(std::string &path, ifstream &File, int *&CurrentBonds)
+{
+  string filename;
+  filename = path + ADJACENCYFILE;
+  File.open(filename.c_str(), ios::out);
   DoLog(1) && (Log() << Verbose(1) << "Looking at bond structure stored in adjacency file and comparing to present one ... " << endl);
   if (File == NULL)
+  if (File.fail())
     return false;
 …
  * \return true - structure is equal, false - not equivalence
  */
 bool molecule::CheckAdjacencyFileAgainstMolecule(char *path, atom **ListOfAtoms)
+bool molecule::CheckAdjacencyFileAgainstMolecule(std::string &path, atom **ListOfAtoms)
+{
   ifstream File;

src/molecule_pointcloud.cpp

-              r06f4ef6
+              rb6da28
 #include "config.hpp"
 #include "info.hpp"
-#include "memoryallocator.hpp"
 #include "molecule.hpp"
 …
 void molecule::GoToFirst() const
+{
+  InternalPointer = atoms.begin();
+  // evil hack necessary because
+  // -# although InternalPointer is mutable
+  // -# only const_iterator begin() is called due to const in the function declaration above
+  // -# and there is no cast from const_iterator to const iterator
+  atomSet::const_iterator test = begin();
+  InternalPointer = *(reinterpret_cast<atomSet::iterator *>(&test));
 };

src/moleculelist.cpp

-              r06f4ef6
+              rb6da28
  */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include "Helpers/MemDebug.hpp"
 #include <cstring>
+#include <gsl/gsl_inline.h>
+#include <gsl/gsl_heapsort.h>
 #include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
+#include "bondgraph.hpp"
 #include "boundary.hpp"
 #include "config.hpp"
 …
 #include "linkedcell.hpp"
 #include "lists.hpp"
+#include "verbose.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
-#include "memoryallocator.hpp"
 #include "periodentafel.hpp"
 #include "Helpers/Assert.hpp"
+#include "Matrix.hpp"
+#include "Box.hpp"
+#include "stackclass.hpp"
 #include "Helpers/Assert.hpp"
 …
   // put all molecules of src into mol
+  molecule::iterator runner;
+  for (molecule::iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
+    runner = iter++;
+    srcmol->UnlinkAtom((*runner));
+    mol->AddAtom((*runner));
+  for (molecule::iterator iter = srcmol->begin(); !srcmol->empty(); iter=srcmol->begin()) {
+    atom * const Walker = *iter;
+    srcmol->UnlinkAtom(Walker);
+    mol->AddAtom(Walker);
+  }
 …
     status = status && SimpleMerge(mol, srcmol);
+  }
+  insert(mol);
   return status;
 };
 …
  * bonded to the same atom, then we add for this pair a correction term constructed from a Morse
  * potential function fit to QM calculations with respecting to the interatomic hydrogen distance.
+ * \param *out output stream for debugging
+ * \param *path path to file
+ */
+bool MoleculeListClass::AddHydrogenCorrection(char *path)
+ * \param &path path to file
+ */
+bool MoleculeListClass::AddHydrogenCorrection(std::string &path)
+{
   bond *Binder = NULL;
 …
   // 0a. find dimension of matrices with constants
   line = path;
-  line.append("/");
-  line += FRAGMENTPREFIX;
   line += "1";
   line += FITCONSTANTSUFFIX;
   input.open(line.c_str());
   if (input == NULL) {
+  if (input.fail()) {
     DoLog(1) && (Log() << Verbose(1) << endl << "Unable to open " << line << ", is the directory correct?" << endl);
     return false;
 …
 /** Store force indices, i.e. the connection between the nuclear index in the total molecule config and the respective atom in fragment config.
+ * \param *out output stream for debugging
+ * \param *path path to file
+ * \param &path path to file
  * \param *SortIndex Index to map from the BFS labeling to the sequence how of Ion_Type in the config
  * \return true - file written successfully, false - writing failed
  */
+bool MoleculeListClass::StoreForcesFile(char *path,
+    int *SortIndex)
+bool MoleculeListClass::StoreForcesFile(std::string &path, int *SortIndex)
+{
   bool status = true;
+  ofstream ForcesFile;
+  stringstream line;
+  string filename(path);
+  filename += FORCESFILE;
+  ofstream ForcesFile(filename.c_str());
   periodentafel *periode=World::getInstance().getPeriode();
   // open file for the force factors
   DoLog(1) && (Log() << Verbose(1) << "Saving  force factors ... ");
+  line << path << "/" << FRAGMENTPREFIX << FORCESFILE;
+  ForcesFile.open(line.str().c_str(), ios::out);
+  if (ForcesFile != NULL) {
+  if (!ForcesFile.fail()) {
     //Log() << Verbose(1) << "Final AtomicForcesList: ";
     //output << prefix << "Forces" << endl;
 …
       periodentafel::const_iterator elemIter;
       for(elemIter=periode->begin();elemIter!=periode->end();++elemIter){
         if ((*ListRunner)->ElementsInMolecule[(*elemIter).first]) { // if this element got atoms
+        if ((*ListRunner)->hasElement((*elemIter).first)) { // if this element got atoms
           for(molecule::iterator atomIter = (*ListRunner)->begin(); atomIter !=(*ListRunner)->end();++atomIter){
             if ((*atomIter)->type->getNumber() == (*elemIter).first) {
 …
   } else {
     status = false;
     DoLog(1) && (Log() << Verbose(1) << "failed to open file " << line.str() << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "failed to open file " << filename << "." << endl);
+  }
   ForcesFile.close();
 …
 /** Writes a config file for each molecule in the given \a **FragmentList.
  * \param *out output stream for debugging
  * \param *configuration standard configuration to attach atoms in fragment molecule to.
+ * \param &prefix path and prefix to the fragment config files
  * \param *SortIndex Index to map from the BFS labeling to the sequence how of Ion_Type in the config
  * \return true - success (each file was written), false - something went wrong.
  */
 bool MoleculeListClass::OutputConfigForListOfFragments(config *configuration, int *SortIndex)
+bool MoleculeListClass::OutputConfigForListOfFragments(std::string &prefix, int *SortIndex)
+{
   ofstream outputFragment;
   char FragmentName[MAXSTRINGSIZE];
+  std::string FragmentName;
   char PathBackup[MAXSTRINGSIZE];
   bool result = true;
 …
   int FragmentCounter = 0;
   ofstream output;
+  double cell_size_backup[6];
+  double * const cell_size = World::getInstance().getDomain();
+  // backup cell_size
+  for (int i=0;i<6;i++)
+    cell_size_backup[i] = cell_size[i];
+  Matrix cell_size = World::getInstance().getDomain().getM();
+  Matrix cell_size_backup = cell_size;
   // store the fragments as config and as xyz
   for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
     // save default path as it is changed for each fragment
     path = configuration->GetDefaultPath();
+    path = World::getInstance().getConfig()->GetDefaultPath();
     if (path != NULL)
       strcpy(PathBackup, path);
 …
     // output xyz file
     FragmentNumber = FixedDigitNumber(ListOfMolecules.size(), FragmentCounter++);
     sprintf(FragmentName, "%s/%s%s.conf.xyz", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
     outputFragment.open(FragmentName, ios::out);
+    FragmentName = prefix + FragmentNumber + ".conf.xyz";
+    outputFragment.open(FragmentName.c_str(), ios::out);
     DoLog(2) && (Log() << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter - 1 << " as XYZ ...");
     if ((intermediateResult = (*ListRunner)->OutputXYZ(&outputFragment)))
 …
     (*ListRunner)->CenterEdge(&BoxDimension);
     (*ListRunner)->SetBoxDimension(&BoxDimension); // update Box of atoms by boundary
-    int j = -1;
     for (int k = 0; k < NDIM; k++) {
       j += k + 1;
       BoxDimension[k] = 2.5 * (configuration->GetIsAngstroem() ? 1. : 1. / AtomicLengthToAngstroem);
       cell_size[j] = BoxDimension[k] * 2.;
+    }
+      BoxDimension[k] = 2.5 * (World::getInstance().getConfig()->GetIsAngstroem() ? 1. : 1. / AtomicLengthToAngstroem);
+      cell_size.at(k,k) = BoxDimension[k] * 2.;
+    }
+    World::getInstance().setDomain(cell_size);
     (*ListRunner)->Translate(&BoxDimension);
     // also calculate necessary orbitals
+    (*ListRunner)->CountElements(); // this is a bugfix, atoms should shoulds actually be added correctly to this fragment
+    (*ListRunner)->CalculateOrbitals(*configuration);
+    //(*ListRunner)->CalculateOrbitals(*World::getInstance().getConfig);
     // change path in config
+    //strcpy(PathBackup, configuration->configpath);
+    sprintf(FragmentName, "%s/%s%s/", PathBackup, FRAGMENTPREFIX, FragmentNumber);
+    configuration->SetDefaultPath(FragmentName);
+    FragmentName = PathBackup;
+    FragmentName += "/";
+    FragmentName += FRAGMENTPREFIX;
+    FragmentName += FragmentNumber;
+    FragmentName += "/";
+    World::getInstance().getConfig()->SetDefaultPath(FragmentName.c_str());
     // and save as config
     sprintf(FragmentName, "%s/%s%s.conf", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
+    FragmentName = prefix + FragmentNumber + ".conf";
     DoLog(2) && (Log() << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter - 1 << " as config ...");
     if ((intermediateResult = configuration->Save(FragmentName, (*ListRunner)->elemente, (*ListRunner))))
+    if ((intermediateResult = World::getInstance().getConfig()->Save(FragmentName.c_str(), (*ListRunner)->elemente, (*ListRunner))))
       DoLog(0) && (Log() << Verbose(0) << " done." << endl);
     else
 …
     // restore old config
     configuration->SetDefaultPath(PathBackup);
+    World::getInstance().getConfig()->SetDefaultPath(PathBackup);
     // and save as mpqc input file
     sprintf(FragmentName, "%s/%s%s.conf", configuration->configpath, FRAGMENTPREFIX, FragmentNumber);
+    FragmentName = prefix + FragmentNumber + ".conf";
     DoLog(2) && (Log() << Verbose(2) << "Saving bond fragment No. " << FragmentNumber << "/" << FragmentCounter - 1 << " as mpqc input ...");
     if ((intermediateResult = configuration->SaveMPQC(FragmentName, (*ListRunner))))
+    if ((intermediateResult = World::getInstance().getConfig()->SaveMPQC(FragmentName.c_str(), (*ListRunner))))
       DoLog(2) && (Log() << Verbose(2) << " done." << endl);
     else
 …
   // restore cell_size
+  for (int i=0;i<6;i++)
+    cell_size[i] = cell_size_backup[i];
+  World::getInstance().setDomain(cell_size_backup);
   return result;
 …
   // 1. dissect the molecule into connected subgraphs
+  if (!configuration->BG->ConstructBondGraph(mol)) {
+    World::getInstance().destroyMolecule(mol);
+    DoeLog(1) && (eLog()<< Verbose(1) << "There are no bonds." << endl);
+  if (configuration->BG != NULL) {
+    if (!configuration->BG->ConstructBondGraph(mol)) {
+      World::getInstance().destroyMolecule(mol);
+      DoeLog(1) && (eLog()<< Verbose(1) << "There are no bonds." << endl);
+      return;
+    }
+  } else {
+    DoeLog(1) && (eLog()<< Verbose(1) << "There is no BondGraph class present to create bonds." << endl);
     return;
+  }
 …
   // center at set box dimensions
   mol->CenterEdge(&center);
+  World::getInstance().getDomain()[0] = center[0];
+  World::getInstance().getDomain()[1] = 0;
+  World::getInstance().getDomain()[2] = center[1];
+  World::getInstance().getDomain()[3] = 0;
+  World::getInstance().getDomain()[4] = 0;
+  World::getInstance().getDomain()[5] = center[2];
+  Matrix domain;
+  for(int i =0;i<NDIM;++i)
+    domain.at(i,i) = center[i];
+  World::getInstance().setDomain(domain);
   insert(mol);
+}
 …
  * \param *out output stream for debugging
  * \param *reference reference molecule with the bond structure to be copied
+ * \param &FragmentCounter Counter needed to address \a **ListOfLocalAtoms
+ * \param ***ListOfLocalAtoms Lookup table for each subgraph and index of each atom in \a *reference, may be NULL on start, then it is filled
+ * \param **&ListOfLocalAtoms Lookup table for this subgraph and index of each atom in \a *reference, may be NULL on start, then it is filled
  * \param FreeList true - ***ListOfLocalAtoms is free'd before return, false - it is not
  * \return true - success, false - faoilure
  */
 bool MoleculeLeafClass::FillBondStructureFromReference(const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList)
+bool MoleculeLeafClass::FillBondStructureFromReference(const molecule * const reference, atom **&ListOfLocalAtoms, bool FreeList)
+{
   atom *OtherWalker = NULL;
 …
   DoLog(1) && (Log() << Verbose(1) << "Begin of FillBondStructureFromReference." << endl);
   // fill ListOfLocalAtoms if NULL was given
   if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
+  if (!FillListOfLocalAtoms(ListOfLocalAtoms, reference->getAtomCount(), FreeList)) {
     DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
     return false;
 …
       AtomNo = Father->nr; // global id of the current walker
       for (BondList::const_iterator Runner = Father->ListOfBonds.begin(); Runner != Father->ListOfBonds.end(); (++Runner)) {
         OtherWalker = ListOfLocalAtoms[FragmentCounter][(*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr]; // local copy of current bond partner of walker
+        OtherWalker = ListOfLocalAtoms[(*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr]; // local copy of current bond partner of walker
         if (OtherWalker != NULL) {
           if (OtherWalker->nr > (*iter)->nr)
             Leaf->AddBond((*iter), OtherWalker, (*Runner)->BondDegree);
         } else {
           DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr << "] is NULL!" << endl);
+          DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << (*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr << "] is NULL!" << endl);
           status = false;
+        }
 …
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
+    delete[](ListOfLocalAtoms[FragmentCounter]);
+    if (FragmentCounter == 0) // first fragments frees the initial pointer to list
+      delete[](ListOfLocalAtoms);
+    delete[](ListOfLocalAtoms);
+  }
   DoLog(1) && (Log() << Verbose(1) << "End of FillBondStructureFromReference." << endl);
 …
 /** Fills a lookup list of father's Atom::nr -> atom for each subgraph.
  * \param *out output stream from debugging
+ * \param ***ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
+ * \param FragmentCounter counts the fragments as we move along the list
+ * \param **&ListOfLocalAtoms Lookup table for each subgraph and index of each atom in global molecule, may be NULL on start, then it is filled
  * \param GlobalAtomCount number of atoms in the complete molecule
  * \param &FreeList true - ***ListOfLocalAtoms is free'd before return, false - it is not
  * \return true - success, false - failure
  */
 bool MoleculeLeafClass::FillListOfLocalAtoms(atom ***&ListOfLocalAtoms, const int FragmentCounter, const int GlobalAtomCount, bool &FreeList)
+ * \return true - success, false - failure (ListOfLocalAtoms != NULL)
+ */
+bool MoleculeLeafClass::FillListOfLocalAtoms(atom **&ListOfLocalAtoms, const int GlobalAtomCount, bool &FreeList)
+{
   bool status = true;
+  if (ListOfLocalAtoms == NULL) { // allocated initial pointer
+    // allocate and set each field to NULL
+    const int Counter = Count();
+    ASSERT(FragmentCounter < Counter, "FillListOfLocalAtoms: FragmenCounter greater than present fragments.");
+    ListOfLocalAtoms = new atom**[Counter];
+    if (ListOfLocalAtoms == NULL) {
+      FreeList = FreeList && false;
+      status = false;
+    }
+    for (int i=0;i<Counter;i++)
+      ListOfLocalAtoms[i] = NULL;
+  }
+  if ((ListOfLocalAtoms != NULL) && (ListOfLocalAtoms[FragmentCounter] == NULL)) { // allocate and fill list of this fragment/subgraph
+    status = status && Leaf->CreateFatherLookupTable(ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
+  if (ListOfLocalAtoms == NULL) { // allocate and fill list of this fragment/subgraph
+    status = status && Leaf->CreateFatherLookupTable(ListOfLocalAtoms, GlobalAtomCount);
     FreeList = FreeList && true;
+  }
+  } else
+    return false;
   return status;
 …
   DoLog(1) && (Log() << Verbose(1) << "Begin of AssignKeySetsToFragment." << endl);
   // fill ListOfLocalAtoms if NULL was given
   if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
+  if (!FillListOfLocalAtoms(ListOfLocalAtoms[FragmentCounter], reference->getAtomCount(), FreeList)) {
     DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
     return false;
 …
     // free the index lookup list
     delete[](ListOfLocalAtoms[FragmentCounter]);
-    if (FragmentCounter == 0) // first fragments frees the initial pointer to list
-      delete[](ListOfLocalAtoms);
+  }
   DoLog(1) && (Log() << Verbose(1) << "End of AssignKeySetsToFragment." << endl);

src/orbitals.db

r06f4ef6	rb6da28
	1	# atomicnumber numberoforbitals
1	2	1 1
2	3	2 0

src/parser.cpp

-              r06f4ef6
+              rb6da28
 #include "helpers.hpp"
-#include "memoryallocator.hpp"
 #include "parser.hpp"
+#include "verbose.hpp"
 // include config.h
 …
 MatrixContainer::~MatrixContainer() {
   if (Matrix != NULL) {
+    // free Matrix[MatrixCounter]
+    if ((ColumnCounter != NULL) && (RowCounter != NULL) && (Matrix[MatrixCounter] != NULL))
+      for(int j=RowCounter[MatrixCounter]+1;j--;)
+        delete[](Matrix[MatrixCounter][j]);
+    //if (MatrixCounter != 0)
+    delete[](Matrix[MatrixCounter]);
+    // free all matrices but ultimate one
     for(int i=MatrixCounter;i--;) {
       if ((ColumnCounter != NULL) && (RowCounter != NULL)) {
 …
+      }
+    }
-    if ((ColumnCounter != NULL) && (RowCounter != NULL) && (Matrix[MatrixCounter] != NULL))
-      for(int j=RowCounter[MatrixCounter]+1;j--;)
-        delete[](Matrix[MatrixCounter][j]);
-    if (MatrixCounter != 0)
-      delete[](Matrix[MatrixCounter]);
     delete[](Matrix);
+  }
+  // free indices
   if (Indices != NULL)
     for(int i=MatrixCounter+1;i--;) {
 …
   delete[](Indices);
+  // free header and counters
   if (Header != NULL)
     for(int i=MatrixCounter+1;i--;)
 …
   // parse header
+  if (Header[MatrixNr] != NULL)
+    delete[] Header[MatrixNr];
   Header[MatrixNr] = new char[1024];
   for (int m=skiplines+1;m--;)
 …
   // allocate matrix if it's not zero dimension in one direction
   if ((ColumnCounter[MatrixNr] > 0) && (RowCounter[MatrixNr] > -1)) {
+    if (Matrix[MatrixNr] != NULL)
+      delete[] Matrix[MatrixNr];
     Matrix[MatrixNr] = new double*[RowCounter[MatrixNr] + 1];
+    for(int j=0;j<RowCounter[MatrixNr]+1;j++)
+      Matrix[MatrixNr][j] = 0;
     // parse in each entry for this matrix
     input.clear();
 …
     strncpy(Header[MatrixNr], line.str().c_str(), 1023);
     for(int j=0;j<RowCounter[MatrixNr];j++) {
+      if (Matrix[MatrixNr][j] != NULL)
+        delete[] Matrix[MatrixNr][j];
       Matrix[MatrixNr][j] = new double[ColumnCounter[MatrixNr]];
+      for(int k=0;k<ColumnCounter[MatrixNr];k++)
+        Matrix[MatrixNr][j][k] = 0;
       input.getline(filename, 1023);
       stringstream lines(filename);
 …
         //Log() << Verbose(1) << " " << setprecision(2) << Matrix[MatrixNr][j][k] << endl;
+      }
+      if (Matrix[MatrixNr][ RowCounter[MatrixNr] ] != NULL)
+        delete[] Matrix[MatrixNr][ RowCounter[MatrixNr] ];
       Matrix[MatrixNr][ RowCounter[MatrixNr] ] = new double[ColumnCounter[MatrixNr]];
       for(int j=ColumnCounter[MatrixNr];j--;)

src/periodentafel.cpp

-              r06f4ef6
+              rb6da28
 periodentafel::periodentafel()
+{
+  bool status = true;
+  status = LoadElementsDatabase(new stringstream(elementsDB,ios_base::in));
+  ASSERT(status,  "General element initialization failed");
+  status = LoadValenceDatabase(new stringstream(valenceDB,ios_base::in));
+  ASSERT(status, "Valence entry of element initialization failed");
+  status = LoadOrbitalsDatabase(new stringstream(orbitalsDB,ios_base::in));
+  ASSERT(status, "Orbitals entry of element initialization failed");
+  status = LoadHBondAngleDatabase(new stringstream(HbondangleDB,ios_base::in));
+  ASSERT(status, "HBond angle entry of element initialization failed");
+  status = LoadHBondLengthsDatabase(new stringstream(HbonddistanceDB,ios_base::in));
+  ASSERT(status, "HBond distance entry of element initialization failed");
+  {
+    stringstream input(elementsDB,ios_base::in);
+    bool status = LoadElementsDatabase(&input);
+    ASSERT(status,  "General element initialization failed");
+  }
+  {
+    stringstream input(valenceDB,ios_base::in);
+    bool status = LoadValenceDatabase(&input);
+    ASSERT(status, "Valence entry of element initialization failed");
+  }
+  {
+    stringstream input(orbitalsDB,ios_base::in);
+    bool status = LoadOrbitalsDatabase(&input);
+    ASSERT(status, "Orbitals entry of element initialization failed");
+  }
+  {
+    stringstream input(HbondangleDB,ios_base::in);
+    bool status = LoadHBondAngleDatabase(&input);
+    ASSERT(status, "HBond angle entry of element initialization failed");
+  }
+  {
+    stringstream input(HbonddistanceDB,ios_base::in);
+    bool status = LoadHBondLengthsDatabase(&input);
+    ASSERT(status, "HBond distance entry of element initialization failed");
+  }
 };
 …
  * \return pointer to element
  */
 element * const periodentafel::FindElement(const char * const shorthand) const
+element * const periodentafel::FindElement(const string &shorthand) const
+{
   element *res = 0;
 …
 };
-/** Prints period table to given stream.
- * \param *output output stream
- * \param *checkliste elements table for this molecule
- */
-bool periodentafel::Checkout(ostream * const output, const int * const checkliste) const
+{
-  bool result = true;
-  int No = 1;
-  if (output != NULL) {
-    *output << "# Ion type data (PP = PseudoPotential, Z = atomic number)" << endl;
-    *output << "#Ion_TypeNr.\tAmount\tZ\tRGauss\tL_Max(PP)L_Loc(PP)IonMass\t# chemical name, symbol" << endl;
-    for(const_iterator iter=elements.begin(); iter!=elements.end();++iter){
-      if (((*iter).first < MAX_ELEMENTS) && (checkliste[(*iter).first])) {
-        (*iter).second->No = No;
-        result = result && (*iter).second->Checkout(output, No++, checkliste[(*iter).first]);
+      }
+    }
-    return result;
-  } else
-    return false;
-};
 /** Loads element list from file.
  * \param *path to to standard file names
 …
           ASSERT(Elemental != NULL, "element should be present but is not??");
           *Elemental = *neues;
+          delete(neues);
+          neues = Elemental;
         } else {
           InserterTest = elements.insert(pair <atomicNumber_t,element*> (neues->getNumber(), neues));
 …
       (*input) >> elements[Z]->Valence;
       (*input) >> ws;
       //Log() << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->Valence << " valence electrons." << endl;
+      //Log() << Verbose(3) << "Element " << Z << " has " << FindElement(Z)->Valence << " valence electrons." << endl;
+    }
     return true;
 …
       (*input) >> elements[Z]->NoValenceOrbitals;
       (*input) >> ws;
       //Log() << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->NoValenceOrbitals << " number of singly occupied valence orbitals." << endl;
+      //Log() << Verbose(3) << "Element " << Z << " has " << FindElement(Z)->NoValenceOrbitals << " number of singly occupied valence orbitals." << endl;
+    }
     return true;

src/periodentafel.hpp

-              r06f4ef6
+              rb6da28
 #endif
 #include <iostream>
+#include <iosfwd>
 #include <map>
 #include <iterator>
+#include <string>
 #include "unittests/periodentafelTest.hpp"
 …
   void CleanupPeriodtable();
   element * const FindElement(atomicNumber_t) const;
   element * const FindElement(const char * const shorthand) const;
+  element * const FindElement(const std::string &shorthand) const;
   element * const AskElement() const;
   element * const EnterElement();
 …
   reverse_iterator rend();
   bool Output(std::ostream * const output) const;
-  bool Checkout(std::ostream * const output, const int * const checkliste) const;
   bool LoadPeriodentafel(const char * const path);
   bool StorePeriodentafel(const char * const path) const;

src/stackclass.hpp

r06f4ef6	rb6da28
12	12
13	13	#include "verbose.hpp"
14		#include "~~memoryallocator~~.hpp"
	14	#include "log.hpp"
15	15
16	16	/**************************************** forward declarations ***************************/

src/tesselation.cpp

-              r06f4ef6
+              rb6da28
 #include <fstream>
 #include <assert.h>
+#include <iomanip>
 #include "helpers.hpp"
 …
 #include "Plane.hpp"
 #include "Exceptions/LinearDependenceException.hpp"
-#include "Helpers/Assert.hpp"
 #include "Helpers/Assert.hpp"
 …
+{
   Info FunctionInfo(__func__);
+  double angle = CalculateConvexity();
+  if (angle > -MYEPSILON) {
+    DoLog(0) && (Log() << Verbose(0) << "ACCEPT: Angle is greater than pi: convex." << endl);
+    return true;
+  } else {
+    DoLog(0) && (Log() << Verbose(0) << "REJECT: Angle is less than pi: concave." << endl);
+    return false;
+  }
+}
+/** Calculates the angle between two triangles with respect to their normal vector.
+ * We sum the two angles of each height vector with respect to the center of the baseline.
+ * \return angle > 0 then convex, if < 0 then concave
+ */
+double BoundaryLineSet::CalculateConvexity() const
+{
+  Info FunctionInfo(__func__);
   Vector BaseLineCenter, BaseLineNormal, BaseLine, helper[2], NormalCheck;
   // get the two triangles
 …
   BaseLineNormal.Scale(-1.);
   double angle = GetAngle(helper[0], helper[1], BaseLineNormal);
+  if ((angle - M_PI) > -MYEPSILON) {
+    DoLog(0) && (Log() << Verbose(0) << "ACCEPT: Angle is greater than pi: convex." << endl);
+    return true;
+  } else {
+    DoLog(0) && (Log() << Verbose(0) << "REJECT: Angle is less than pi: concave." << endl);
+    return false;
+  }
+  return (angle - M_PI);
+}
 …
 /** Returns other endpoint of the line.
  * \param *point other endpoint
  * \return NULL - if endpoint not contained in BoundaryLineSet, or pointer to BoundaryPointSet otherwise
+ * \return NULL - if endpoint not contained in BoundaryLineSet::lines, or pointer to BoundaryPointSet otherwise
  */
 class BoundaryPointSet *BoundaryLineSet::GetOtherEndpoint(const BoundaryPointSet * const point) const
 …
   else
     return NULL;
+}
+;
+/** Returns other triangle of the line.
+ * \param *point other endpoint
+ * \return NULL - if triangle not contained in BoundaryLineSet::triangles, or pointer to BoundaryTriangleSet otherwise
+ */
+class BoundaryTriangleSet *BoundaryLineSet::GetOtherTriangle(const BoundaryTriangleSet * const triangle) const
+{
+  Info FunctionInfo(__func__);
+  if (triangles.size() == 2) {
+    for (TriangleMap::const_iterator TriangleRunner = triangles.begin(); TriangleRunner != triangles.end(); ++TriangleRunner)
+      if (TriangleRunner->second != triangle)
+        return TriangleRunner->second;
+  }
+  return NULL;
+}
+;
 …
+;
+/** Returns the baseline which does not contain the given boundary point \a *point.
+ * \param *point endpoint which is neither endpoint of the desired line
+ * \return pointer to desired third baseline
+ */
+class BoundaryLineSet *BoundaryTriangleSet::GetThirdLine(const BoundaryPointSet * const point) const
+{
+  Info FunctionInfo(__func__);
+  // sanity check
+  if (!ContainsBoundaryPoint(point))
+    return NULL;
+  for (int i = 0; i < 3; i++)
+    if (!lines[i]->ContainsBoundaryPoint(point))
+      return lines[i];
+  // actually, that' impossible :)
+  return NULL;
+}
+;
 /** Calculates the center point of the triangle.
  * Is third of the sum of all endpoints.
 …
     TesselPointList *ListofPoints = LC->GetPointsInsideSphere(RADIUS, (*VRunner));
     DoLog(1) && (Log() << Verbose(1) << "The following atoms are inside sphere at " << OtherOptCenter << ":" << endl);
+    DoLog(1) && (Log() << Verbose(1) << "The following atoms are inside sphere at " << (*VRunner) << ":" << endl);
     for (TesselPointList::const_iterator Runner = ListofPoints->begin(); Runner != ListofPoints->end(); ++Runner)
       DoLog(1) && (Log() << Verbose(1) << "  " << *(*Runner) << " with distance " << (*Runner)->node->distance(OtherOptCenter) << "." << endl);
+      DoLog(1) && (Log() << Verbose(1) << "  " << *(*Runner) << " with distance " << (*Runner)->node->distance(*(*VRunner)) << "." << endl);
     // remove baseline's endpoints and candidates
 …
       DoeLog(1) && (eLog() << Verbose(1) << "External atoms inside of sphere at " << *(*VRunner) << ":" << endl);
       for (TesselPointList::const_iterator Runner = ListofPoints->begin(); Runner != ListofPoints->end(); ++Runner)
+        DoeLog(1) && (eLog() << Verbose(1) << "  " << *(*Runner) << endl);
+        DoeLog(1) && (eLog() << Verbose(1) << "  " << *(*Runner) << " at distance " << setprecision(13) << (*Runner)->node->distance(*(*VRunner)) << setprecision(6) << "." << endl);
+      // check with animate_sphere.tcl VMD script
+      if (ThirdPoint != NULL) {
+        DoeLog(1) && (eLog() << Verbose(1) << "Check by: animate_sphere 0 " << BaseLine->endpoints[0]->Nr + 1 << " " << BaseLine->endpoints[1]->Nr + 1 << " " << ThirdPoint->Nr + 1 << " " << RADIUS << " " << OldCenter[0] << " " << OldCenter[1] << " " << OldCenter[2] << " " << (*VRunner)->at(0) << " " << (*VRunner)->at(1) << " " << (*VRunner)->at(2) << endl);
+      } else {
+        DoeLog(1) && (eLog() << Verbose(1) << "Check by: ... missing third point ..." << endl);
+        DoeLog(1) && (eLog() << Verbose(1) << "Check by: animate_sphere 0 " << BaseLine->endpoints[0]->Nr + 1 << " " << BaseLine->endpoints[1]->Nr + 1 << " ??? " << RADIUS << " " << OldCenter[0] << " " << OldCenter[1] << " " << OldCenter[2] << " " << (*VRunner)->at(0) << " " << (*VRunner)->at(1) << " " << (*VRunner)->at(2) << endl);
+      }
+    }
     delete (ListofPoints);
-    // check with animate_sphere.tcl VMD script
-    if (ThirdPoint != NULL) {
-      DoLog(1) && (Log() << Verbose(1) << "Check by: animate_sphere 0 " << BaseLine->endpoints[0]->Nr + 1 << " " << BaseLine->endpoints[1]->Nr + 1 << " " << ThirdPoint->Nr + 1 << " " << RADIUS << " " << OldCenter[0] << " " << OldCenter[1] << " " << OldCenter[2] << " " << (*VRunner)->at(0) << " " << (*VRunner)->at(1) << " " << (*VRunner)->at(2) << endl);
-    } else {
-      DoLog(1) && (Log() << Verbose(1) << "Check by: ... missing third point ..." << endl);
-      DoLog(1) && (Log() << Verbose(1) << "Check by: animate_sphere 0 " << BaseLine->endpoints[0]->Nr + 1 << " " << BaseLine->endpoints[1]->Nr + 1 << " ??? " << RADIUS << " " << OldCenter[0] << " " << OldCenter[1] << " " << OldCenter[2] << " " << (*VRunner)->at(0) << " " << (*VRunner)->at(1) << " " << (*VRunner)->at(2) << endl);
+    }
+  }
   return flag;
 …
   bool AddFlag = false;
   LinkedCell *BoundaryPoints = NULL;
+  bool SuccessFlag = true;
   cloud->GoToFirst();
 …
     // get the next triangle
     triangles = FindClosestTrianglesToVector(Walker->node, BoundaryPoints);
+    BTS = triangles->front();
+    if ((triangles == NULL) || (BTS->ContainsBoundaryPoint(Walker))) {
+    if (triangles != NULL)
+      BTS = triangles->front();
+    else
+      BTS = NULL;
+    delete triangles;
+    if ((BTS == NULL) || (BTS->ContainsBoundaryPoint(Walker))) {
       DoLog(0) && (Log() << Verbose(0) << "No triangles found, probably a tesselation point itself." << endl);
       cloud->GoToNext();
 …
     } else { // something is wrong with FindClosestTriangleToPoint!
       DoeLog(1) && (eLog() << Verbose(1) << "The closest triangle did not produce an intersection!" << endl);
+      return false;
+      SuccessFlag = false;
+      break;
+    }
     cloud->GoToNext();
 …
   // exit
   delete (Center);
+  return true;
+  delete (BoundaryPoints);
+  return SuccessFlag;
+}
+;
 …
   for (int i = 0; i < NDIM; i++) { // each axis
     LC->n[i] = LC->N[i] - 1; // current axis is topmost cell
+    for (LC->n[(i + 1) % NDIM] = 0; LC->n[(i + 1) % NDIM] < LC->N[(i + 1) % NDIM]; LC->n[(i + 1) % NDIM]++)
+      for (LC->n[(i + 2) % NDIM] = 0; LC->n[(i + 2) % NDIM] < LC->N[(i + 2) % NDIM]; LC->n[(i + 2) % NDIM]++) {
+    const int map[NDIM] = {i, (i + 1) % NDIM, (i + 2) % NDIM};
+    for (LC->n[map[1]] = 0; LC->n[map[1]] < LC->N[map[1]]; LC->n[map[1]]++)
+      for (LC->n[map[2]] = 0; LC->n[map[2]] < LC->N[map[2]]; LC->n[map[2]]++) {
         const LinkedCell::LinkedNodes *List = LC->GetCurrentCell();
         //Log() << Verbose(1) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
         if (List != NULL) {
           for (LinkedCell::LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
             if ((*Runner)->node->at(i) > maxCoordinate[i]) {
               DoLog(1) && (Log() << Verbose(1) << "New maximal for axis " << i << " node is " << *(*Runner) << " at " << *(*Runner)->node << "." << endl);
               maxCoordinate[i] = (*Runner)->node->at(i);
               MaxPoint[i] = (*Runner);
+            if ((*Runner)->node->at(map[0]) > maxCoordinate[map[0]]) {
+              DoLog(1) && (Log() << Verbose(1) << "New maximal for axis " << map[0] << " node is " << *(*Runner) << " at " << *(*Runner)->node << "." << endl);
+              maxCoordinate[map[0]] = (*Runner)->node->at(map[0]);
+              MaxPoint[map[0]] = (*Runner);
+            }
+          }
 …
     baseline = Runner->second;
     if (baseline->pointlist.empty()) {
       assert((baseline->BaseLine->triangles.size() == 1) && ("Open line without exactly one attached triangle"));
+      ASSERT((baseline->BaseLine->triangles.size() == 1),"Open line without exactly one attached triangle");
       T = (((baseline->BaseLine->triangles.begin()))->second);
       DoLog(1) && (Log() << Verbose(1) << "Finding best candidate for open line " << *baseline->BaseLine << " of triangle " << *T << endl);
 …
+                        }
                       } else {
                         DoLog(1) && (Log() << Verbose(1) << "REJECT: Distance to center of circumcircle is not the same from each corner of the triangle: " << fabs(radius - otherradius) << endl);
+                        DoeLog(0) && (eLog() << Verbose(1) << "REJECT: Distance to center of circumcircle is not the same from each corner of the triangle: " << fabs(radius - otherradius) << endl);
+                      }
                     } else {
 …
   DoLog(0) && (Log() << Verbose(0) << "FindAllDegeneratedTriangles() found " << DegeneratedTriangles->size() << " triangles:" << endl);
+  IndexToIndex::iterator it;
+  for (it = DegeneratedTriangles->begin(); it != DegeneratedTriangles->end(); it++)
+  for (IndexToIndex::iterator it = DegeneratedTriangles->begin(); it != DegeneratedTriangles->end(); it++)
     DoLog(0) && (Log() << Verbose(0) << (*it).first << " => " << (*it).second << endl);
 …
   int count = 0;
+  for (IndexToIndex::iterator TriangleKeyRunner = DegeneratedTriangles->begin(); TriangleKeyRunner != DegeneratedTriangles->end(); ++TriangleKeyRunner) {
+  // iterate over all degenerated triangles
+  for (IndexToIndex::iterator TriangleKeyRunner = DegeneratedTriangles->begin(); !DegeneratedTriangles->empty(); TriangleKeyRunner = DegeneratedTriangles->begin()) {
+    DoLog(0) && (Log() << Verbose(0) << "Checking presence of triangles " << TriangleKeyRunner->first << " and " << TriangleKeyRunner->second << "." << endl);
+    // both ways are stored in the map, only use one
+    if (TriangleKeyRunner->first > TriangleKeyRunner->second)
+      continue;
+    // determine from the keys in the map the two _present_ triangles
     finder = TrianglesOnBoundary.find(TriangleKeyRunner->first);
     if (finder != TrianglesOnBoundary.end())
       triangle = finder->second;
     else
       break;
+      continue;
     finder = TrianglesOnBoundary.find(TriangleKeyRunner->second);
     if (finder != TrianglesOnBoundary.end())
       partnerTriangle = finder->second;
     else
+      break;
+      continue;
+    // determine which lines are shared by the two triangles
     bool trianglesShareLine = false;
     for (int i = 0; i < 3; ++i)

src/tesselation.hpp

-              r06f4ef6
+              rb6da28
     bool ContainsBoundaryPoint(const BoundaryPointSet * const point) const;
     bool CheckConvexityCriterion() const;
+    double CalculateConvexity() const;
     class BoundaryPointSet *GetOtherEndpoint(const BoundaryPointSet * const point) const;
+    class BoundaryTriangleSet *GetOtherTriangle(const BoundaryTriangleSet * const triangle) const;
     class BoundaryPointSet *endpoints[2];
 …
     bool ContainsBoundaryPoint(const TesselPoint * const point) const;
     class BoundaryPointSet *GetThirdEndpoint(const BoundaryLineSet * const line) const;
+    class BoundaryLineSet *GetThirdLine(const BoundaryPointSet * const point) const;
     bool IsPresentTupel(const BoundaryPointSet * const Points[3]) const;
     bool IsPresentTupel(const BoundaryTriangleSet * const T) const;

src/tesselationhelpers.cpp

-              r06f4ef6
+              rb6da28
 #include "info.hpp"
 #include "linkedcell.hpp"
+#include "linearsystemofequations.hpp"
 #include "log.hpp"
 #include "tesselation.hpp"
 …
 #include "verbose.hpp"
 #include "Plane.hpp"
+double DetGet(gsl_matrix * const A, const int inPlace)
+{
+        Info FunctionInfo(__func__);
+  /*
+  inPlace = 1 => A is replaced with the LU decomposed copy.
+  inPlace = 0 => A is retained, and a copy is used for LU.
+  */
+  double det;
+  int signum;
+  gsl_permutation *p = gsl_permutation_alloc(A->size1);
+  gsl_matrix *tmpA=0;
+  if (inPlace)
+  tmpA = A;
+  else {
+  gsl_matrix *tmpA = gsl_matrix_alloc(A->size1, A->size2);
+  gsl_matrix_memcpy(tmpA , A);
+  }
+  gsl_linalg_LU_decomp(tmpA , p , &signum);
+  det = gsl_linalg_LU_det(tmpA , signum);
+  gsl_permutation_free(p);
+  if (! inPlace)
+  gsl_matrix_free(tmpA);
+  return det;
+};
+#include "Matrix.hpp"
 void GetSphere(Vector * const center, const Vector &a, const Vector &b, const Vector &c, const double RADIUS)
+{
         Info FunctionInfo(__func__);
   gsl_matrix *A = gsl_matrix_calloc(3,3);
+  Matrix mat;
   double m11, m12, m13, m14;
   for(int i=0;i<3;i++) {
     gsl_matrix_set(A, i, 0, a[i]);
     gsl_matrix_set(A, i, 1, b[i]);
     gsl_matrix_set(A, i, 2, c[i]);
+  }
   m11 = DetGet(A, 1);
+    mat.set(i, 0, a[i]);
+    mat.set(i, 1, b[i]);
+    mat.set(i, 2, c[i]);
+  }
+  m11 = mat.determinant();
   for(int i=0;i<3;i++) {
     gsl_matrix_set(A, i, 0, a[i]*a[i] + b[i]*b[i] + c[i]*c[i]);
     gsl_matrix_set(A, i, 1, b[i]);
     gsl_matrix_set(A, i, 2, c[i]);
+  }
   m12 = DetGet(A, 1);
+    mat.set(i, 0, a[i]*a[i] + b[i]*b[i] + c[i]*c[i]);
+    mat.set(i, 1, b[i]);
+    mat.set(i, 2, c[i]);
+  }
+  m12 = mat.determinant();
   for(int i=0;i<3;i++) {
     gsl_matrix_set(A, i, 0, a[i]*a[i] + b[i]*b[i] + c[i]*c[i]);
     gsl_matrix_set(A, i, 1, a[i]);
     gsl_matrix_set(A, i, 2, c[i]);
+  }
   m13 = DetGet(A, 1);
+    mat.set(i, 0, a[i]*a[i] + b[i]*b[i] + c[i]*c[i]);
+    mat.set(i, 1, a[i]);
+    mat.set(i, 2, c[i]);
+  }
+  m13 = mat.determinant();
   for(int i=0;i<3;i++) {
     gsl_matrix_set(A, i, 0, a[i]*a[i] + b[i]*b[i] + c[i]*c[i]);
     gsl_matrix_set(A, i, 1, a[i]);
     gsl_matrix_set(A, i, 2, b[i]);
+  }
   m14 = DetGet(A, 1);
+    mat.set(i, 0, a[i]*a[i] + b[i]*b[i] + c[i]*c[i]);
+    mat.set(i, 1, a[i]);
+    mat.set(i, 2, b[i]);
+  }
+  m14 = mat.determinant();
   if (fabs(m11) < MYEPSILON)
 …
   if (fabs(a.distance(*center) - RADIUS) > MYEPSILON)
     DoeLog(1) && (eLog()<< Verbose(1) << "The given center is further way by " << fabs(a.distance(*center) - RADIUS) << " from a than RADIUS." << endl);
-  gsl_matrix_free(A);
 };
 …
         Info FunctionInfo(__func__);
   Vector helper;
-  double alpha, beta, gamma;
   Vector SideA = b - c;
   Vector SideB = c - a;
   Vector SideC = a - b;
+  alpha = M_PI - SideB.Angle(SideC);
+  beta = M_PI - SideC.Angle(SideA);
+  gamma = M_PI - SideA.Angle(SideB);
+  //Log() << Verbose(1) << "INFO: alpha = " << alpha/M_PI*180. << ", beta = " << beta/M_PI*180. << ", gamma = " << gamma/M_PI*180. << "." << endl;
+  if (fabs(M_PI - alpha - beta - gamma) > HULLEPSILON) {
+    DoeLog(2) && (eLog()<< Verbose(2) << "GetCenterofCircumcircle: Sum of angles " << (alpha+beta+gamma)/M_PI*180. << " > 180 degrees by " << fabs(M_PI - alpha - beta - gamma)/M_PI*180. << "!" << endl);
+  }
+  helper[0] = SideA.NormSquared()*(SideB.NormSquared()+SideC.NormSquared() - SideA.NormSquared());
+  helper[1] = SideB.NormSquared()*(SideC.NormSquared()+SideA.NormSquared() - SideB.NormSquared());
+  helper[2] = SideC.NormSquared()*(SideA.NormSquared()+SideB.NormSquared() - SideC.NormSquared());
   Center->Zero();
+  helper = sin(2.*alpha) * a;
+  (*Center) += helper;
+  helper = sin(2.*beta) * b;
+  (*Center) += helper;
+  helper = sin(2.*gamma) * c;
+  (*Center) += helper;
+  Center->Scale(1./(sin(2.*alpha) + sin(2.*beta) + sin(2.*gamma)));
+  *Center += helper[0] * a;
+  *Center += helper[1] * b;
+  *Center += helper[2] * c;
+  Center->Scale(1./(helper[0]+helper[1]+helper[2]));
+  Log() << Verbose(1) << "INFO: Center (2nd algo) is at " << *Center << "." << endl;
 };
 …
 };
-/**
- * Intersection calculation function.
+ *
- * @param x to find the result for
- * @param function parameter
- */
-double MinIntersectDistance(const gsl_vector * x, void *params)
+{
-        Info FunctionInfo(__func__);
-  double retval = 0;
-  struct Intersection *I = (struct Intersection *)params;
-  Vector intersection;
-  for (int i=0;i<NDIM;i++)
-    intersection[i] = gsl_vector_get(x, i);
-  Vector SideA = I->x1 -I->x2 ;
-  Vector HeightA = intersection - I->x1;
-  HeightA.ProjectOntoPlane(SideA);
-  Vector SideB = I->x3 - I->x4;
-  Vector HeightB = intersection - I->x3;
-  HeightB.ProjectOntoPlane(SideB);
-  retval = HeightA.ScalarProduct(HeightA) + HeightB.ScalarProduct(HeightB);
-  //Log() << Verbose(1) << "MinIntersectDistance called, result: " << retval << endl;
-  return retval;
-};
-/**
- * Calculates whether there is an intersection between two lines. The first line
- * always goes through point 1 and point 2 and the second line is given by the
- * connection between point 4 and point 5.
+ *
- * @param point 1 of line 1
- * @param point 2 of line 1
- * @param point 1 of line 2
- * @param point 2 of line 2
+ *
- * @return true if there is an intersection between the given lines, false otherwise
- */
-bool existsIntersection(const Vector &point1, const Vector &point2, const Vector &point3, const Vector &point4)
+{
-        Info FunctionInfo(__func__);
-  bool result;
-  struct Intersection par;
-    par.x1 = point1;
-    par.x2 = point2;
-    par.x3 = point3;
-    par.x4 = point4;
-    const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;
-    gsl_multimin_fminimizer *s = NULL;
-    gsl_vector *ss, *x;
-    gsl_multimin_function minexFunction;
-    size_t iter = 0;
-    int status;
-    double size;
-    /* Starting point */
-    x = gsl_vector_alloc(NDIM);
-    gsl_vector_set(x, 0, point1[0]);
-    gsl_vector_set(x, 1, point1[1]);
-    gsl_vector_set(x, 2, point1[2]);
-    /* Set initial step sizes to 1 */
-    ss = gsl_vector_alloc(NDIM);
-    gsl_vector_set_all(ss, 1.0);
-    /* Initialize method and iterate */
-    minexFunction.n = NDIM;
-    minexFunction.f = &MinIntersectDistance;
-    minexFunction.params = (void *)&par;
-    s = gsl_multimin_fminimizer_alloc(T, NDIM);
-    gsl_multimin_fminimizer_set(s, &minexFunction, x, ss);
-    do {
-        iter++;
-        status = gsl_multimin_fminimizer_iterate(s);
-        if (status) {
-          break;
+        }
-        size = gsl_multimin_fminimizer_size(s);
-        status = gsl_multimin_test_size(size, 1e-2);
-        if (status == GSL_SUCCESS) {
-          DoLog(1) && (Log() << Verbose(1) << "converged to minimum" <<  endl);
+        }
-    } while (status == GSL_CONTINUE && iter < 100);
-    // check whether intersection is in between or not
-  Vector intersection;
-  double t1, t2;
-  for (int i = 0; i < NDIM; i++) {
-    intersection[i] = gsl_vector_get(s->x, i);
+  }
-  Vector SideA = par.x2 - par.x1;
-  Vector HeightA = intersection - par.x1;
-  t1 = HeightA.ScalarProduct(SideA)/SideA.ScalarProduct(SideA);
-  Vector SideB = par.x4 - par.x3;
-  Vector HeightB = intersection - par.x3;
-  t2 = HeightB.ScalarProduct(SideB)/SideB.ScalarProduct(SideB);
-  Log() << Verbose(1) << "Intersection " << intersection << " is at "
-    << t1 << " for (" << point1 << "," << point2 << ") and at "
-    << t2 << " for (" << point3 << "," << point4 << "): ";
-  if (((t1 >= 0) && (t1 <= 1)) && ((t2 >= 0) && (t2 <= 1))) {
-    DoLog(1) && (Log() << Verbose(1) << "true intersection." << endl);
-    result = true;
-  } else {
-    DoLog(1) && (Log() << Verbose(1) << "intersection out of region of interest." << endl);
-    result = false;
+  }
-  // free minimizer stuff
-    gsl_vector_free(x);
-    gsl_vector_free(ss);
-    gsl_multimin_fminimizer_free(s);
-  return result;
-};
 /** Gets the angle between a point and a reference relative to the provided center.
  * We have two shanks point and reference between which the angle is calculated
 …
 /** Calculates the volume of a general tetraeder.
  * \param *a first vector
  * \param *a first vector
  * \param *a first vector
  * \param *a first vector
+ * \param *b second vector
+ * \param *c third vector
+ * \param *d fourth vector
  * \return \f$ \frac{1}{6} \cdot ((a-d) \times (a-c) \cdot  (a-b)) \f$
  */
 …
   volume = 1./6. * fabs(Point.ScalarProduct(TetraederVector[2]));
   return volume;
+};
+/** Calculates the area of a general triangle.
+ * We use the Heron's formula of area, [Bronstein, S. 138]
+ * \param &A first vector
+ * \param &B second vector
+ * \param &C third vector
+ * \return \f$ \frac{1}{6} \cdot ((a-d) \times (a-c) \cdot  (a-b)) \f$
+ */
+double CalculateAreaofGeneralTriangle(const Vector &A, const Vector &B, const Vector &C)
+{
+  Info FunctionInfo(__func__);
+  const double sidea = B.distance(C);
+  const double sideb = A.distance(C);
+  const double sidec = A.distance(B);
+  const double s = (sidea+sideb+sidec)/2.;
+  const double area = sqrt(s*(s-sidea)*(s-sideb)*(s-sidec));
+  return area;
 };
 …
+          }
         } else {
+          eLog() << Verbose(1) << "The current cell " << LC->n[0] << "," << LC->n[1] << ","
+            << LC->n[2] << " is invalid!" << endl;
+          DoeLog(1) && (eLog() << Verbose(1) << "The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << " is invalid!" << endl);
+        }
+      }
 …
+          }
         } else {
+          eLog() << Verbose(1) << "The current cell " << LC->n[0] << "," << LC->n[1] << ","
+            << LC->n[2] << " is invalid!" << endl;
+          DoeLog(1) && (eLog() << Verbose(1) << "The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << " is invalid!" << endl);
+        }
+      }
 …
   class BoundaryPointSet *point = NULL;
   class BoundaryLineSet *line = NULL;
+  // calculate remaining concavity
+  class BoundaryTriangleSet *triangle = NULL;
+  double ConcavityPerLine = 0.;
+  double ConcavityPerTriangle = 0.;
+  double area = 0.;
+  double totalarea = 0.;
   for (PointMap::const_iterator PointRunner = TesselStruct->PointsOnBoundary.begin(); PointRunner != TesselStruct->PointsOnBoundary.end(); PointRunner++) {
     point = PointRunner->second;
     DoLog(1) && (Log() << Verbose(1) << "INFO: Current point is " << *point << "." << endl);
+    point->value = 0;
+    // calculate mean concavity over all connected line
+    ConcavityPerLine = 0.;
     for (LineMap::iterator LineRunner = point->lines.begin(); LineRunner != point->lines.end(); LineRunner++) {
       line = LineRunner->second;
       //Log() << Verbose(1) << "INFO: Current line of point " << *point << " is " << *line << "." << endl;
+      if (!line->CheckConvexityCriterion())
+        point->value += 1;
+    }
+  }
+};
+      ConcavityPerLine -= line->CalculateConvexity();
+    }
+    ConcavityPerLine /= point->lines.size();
+    // weigh with total area of the surrounding triangles
+    totalarea  = 0.;
+    TriangleSet *triangles = TesselStruct->GetAllTriangles(PointRunner->second);
+    for (TriangleSet::iterator TriangleRunner = triangles->begin(); TriangleRunner != triangles->end(); ++TriangleRunner) {
+      totalarea += CalculateAreaofGeneralTriangle(*(*TriangleRunner)->endpoints[0]->node->node, *(*TriangleRunner)->endpoints[1]->node->node, *(*TriangleRunner)->endpoints[2]->node->node);
+    }
+    ConcavityPerLine *= totalarea;
+    // calculate mean concavity over all attached triangles
+    ConcavityPerTriangle = 0.;
+    for (TriangleSet::const_iterator TriangleRunner = triangles->begin(); TriangleRunner != triangles->end(); ++TriangleRunner) {
+      line = (*TriangleRunner)->GetThirdLine(PointRunner->second);
+      triangle = line->GetOtherTriangle(*TriangleRunner);
+      area = CalculateAreaofGeneralTriangle(*triangle->endpoints[0]->node->node, *triangle->endpoints[1]->node->node, *triangle->endpoints[2]->node->node);
+      area += CalculateAreaofGeneralTriangle(*(*TriangleRunner)->endpoints[0]->node->node, *(*TriangleRunner)->endpoints[1]->node->node, *(*TriangleRunner)->endpoints[2]->node->node);
+      area *= -line->CalculateConvexity();
+      if (area > 0)
+        ConcavityPerTriangle += area;
+//      else
+//        ConcavityPerTriangle -= area;
+    }
+    ConcavityPerTriangle /= triangles->size()/totalarea;
+    delete(triangles);
+    // add up
+    point->value = ConcavityPerLine + ConcavityPerTriangle;
+  }
+};
+/** Calculates the concavity for each of the BoundaryPointSet's in a Tesselation.
+ * Sets BoundaryPointSet::value equal to the nearest distance to convex envelope.
+ * \param *out output stream for debugging
+ * \param *TesselStruct pointer to Tesselation structure
+ * \param *Convex pointer to convex Tesselation structure as reference
+ */
+void CalculateConstrictionPerBoundaryPoint(const Tesselation * const TesselStruct, const Tesselation * const Convex)
+{
+  Info FunctionInfo(__func__);
+  double distance = 0.;
+  for (PointMap::const_iterator PointRunner = TesselStruct->PointsOnBoundary.begin(); PointRunner != TesselStruct->PointsOnBoundary.end(); PointRunner++) {
+    DoeLog(1) && (eLog() << Verbose(1) << "INFO: Current point is " << * PointRunner->second << "." << endl);
+    distance = 0.;
+    for (TriangleMap::const_iterator TriangleRunner = Convex->TrianglesOnBoundary.begin(); TriangleRunner != Convex->TrianglesOnBoundary.end(); TriangleRunner++) {
+      const double CurrentDistance = Convex->GetDistanceSquaredToTriangle(*PointRunner->second->node->node, TriangleRunner->second);
+      if (CurrentDistance < distance)
+        distance = CurrentDistance;
+    }
+    PointRunner->second->value = distance;
+  }
+};
 /** Checks whether each BoundaryLineSet in the Tesselation has two triangles.

src/tesselationhelpers.hpp

-              r06f4ef6
+              rb6da28
 #endif
+#include <gsl/gsl_linalg.h>
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_multimin.h>
+#include <gsl/gsl_permutation.h>
+#include <gsl/gsl_vector.h>
+#include <iostream>
+#include <iosfwd>
 #include "defs.hpp"
 …
 /********************************************** definitions *********************************/
 #define HULLEPSILON 1e-10
+#define HULLEPSILON 1e-9 //!< TODO: Get rid of HULLEPSILON, points to numerical instabilities
 /********************************************** declarations *******************************/
-double DetGet(gsl_matrix * const A, const int inPlace);
 void GetSphere(Vector * const Center, const Vector &a, const Vector &b, const Vector &c, const double RADIUS);
 void GetCenterOfSphere(Vector* const Center, const Vector &a, const Vector &b, const Vector &c, Vector * const NewUmkreismittelpunkt, const Vector* const Direction, const Vector* const AlternativeDirection, const double HalfplaneIndicator, const double AlternativeIndicator, const double alpha, const double beta, const double gamma, const double RADIUS, const double Umkreisradius);
 void GetCenterofCircumcircle(Vector * const Center, const Vector &a, const Vector &b, const Vector &c);
 double GetPathLengthonCircumCircle(const Vector &CircleCenter, const Vector &CirclePlaneNormal, const double CircleRadius, const Vector &NewSphereCenter, const Vector &OldSphereCenter, const Vector &NormalVector, const Vector &SearchDirection);
-double MinIntersectDistance(const gsl_vector * x, void *params);
-bool existsIntersection(const Vector &point1, const Vector &point2, const Vector &point3, const Vector &point4);
 double CalculateVolumeofGeneralTetraeder(const Vector &a, const Vector &b, const Vector &c, const Vector &d);
+double CalculateAreaofGeneralTriangle(const Vector &A, const Vector &B, const Vector &C);
 double GetAngle(const Vector &point, const Vector &reference, const Vector &OrthogonalVector);
 …
 void WriteVrmlFile(ofstream * const vrmlfile, const Tesselation * const Tess, const PointCloud * const cloud);
 void CalculateConcavityPerBoundaryPoint(const Tesselation * const TesselStruct);
+void CalculateConstrictionPerBoundaryPoint(const Tesselation * const TesselStruct, const Tesselation * const Convex);
 double DistanceToTrianglePlane(const Vector *x, const BoundaryTriangleSet * const triangle);

src/triangleintersectionlist.cpp

-              r06f4ef6
+              rb6da28
 #include "Helpers/MemDebug.hpp"
+#include <boost/scoped_ptr.hpp>
 #include "triangleintersectionlist.hpp"
 …
 #include "tesselation.hpp"
 #include "vector.hpp"
+#include "verbose.hpp"
 /** Constructor for class TriangleIntersectionList.
 …
   // get closest points
   DistanceToPointMap * points = Tess->FindClosestBoundaryPointsToVector(Point,Vicinity);
+  boost::scoped_ptr< DistanceToPointMap > points(Tess->FindClosestBoundaryPointsToVector(Point,Vicinity));
   if (points == NULL) {
     DoeLog(1) && (eLog()<< Verbose(1) << "There is no nearest point: too far away from the surface." << endl);

src/unittests/ActOnAllUnitTest.cpp

r06f4ef6	rb6da28
14	14	#include "../test/ActOnAlltest.hpp"
15	15	#include "ActOnAllUnitTest.hpp"
16		~~#include "memoryallocator.hpp"~~
17	16	#include "vector.hpp"
18	17

src/unittests/ActionSequenceTest.cpp

-              r06f4ef6
+              rb6da28
 #include "Actions/ActionRegistry.hpp"
+#include "DummyUI.hpp"
 #ifdef HAVE_TESTRUNNER
 #include "UnitTestMain.hpp"
 …
   virtual ~canUndoActionStub(){}
+  virtual Dialog* fillDialog(Dialog *dialog){
+    ASSERT(dialog,"No Dialog given when filling action dialog");
+    return dialog;
+  }
   virtual Action::state_ptr performCall(){
     return Action::success;
 …
   cannotUndoActionStub() : Action("cannotUndoActionStub",false){}
   virtual ~cannotUndoActionStub(){}
+  virtual Dialog* fillDialog(Dialog *dialog){
+    ASSERT(dialog,"No Dialog given when filling action dialog");
+    return dialog;
+  }
   virtual Action::state_ptr performCall(){
 …
   virtual ~wasCalledActionStub(){}
+  virtual Dialog* fillDialog(Dialog *dialog){
+    return dialog;
+  }
   virtual Action::state_ptr performCall(){
     called = true;
 …
 void ActionSequenceTest::setUp(){
+  static bool hasDescriptor = false;
   ActionHistory::init();
+  // TODO: find a way to really reset the factory to a clean state in tear-down
+  if(!hasDescriptor){
+    UIFactory::registerFactory(new DummyUIFactory::description());
+    hasDescriptor = true;
+  }
+  UIFactory::makeUserInterface("Dummy");
   // create some necessary stubs used in this test
   positive1 = new canUndoActionStub();
 …
   ActionHistory::purgeInstance();
   ActionRegistry::purgeInstance();
+  UIFactory::purgeInstance();
+}
 …
   CPPUNIT_ASSERT_EQUAL(true,wasCalled1->wasCalled());
   CPPUNIT_ASSERT_EQUAL(true,wasCalled1->wasCalled());
+  CPPUNIT_ASSERT_EQUAL(true,wasCalled2->wasCalled());
   ActionHistory::getInstance().undoLast();
   CPPUNIT_ASSERT_EQUAL(false,wasCalled1->wasCalled());
   CPPUNIT_ASSERT_EQUAL(false,wasCalled1->wasCalled());
+}
+  CPPUNIT_ASSERT_EQUAL(false,wasCalled2->wasCalled());
+}

src/unittests/AnalysisCorrelationToPointUnitTest.cpp

-              r06f4ef6
+              rb6da28
 #include "analysis_correlation.hpp"
 #include "AnalysisCorrelationToPointUnitTest.hpp"
+#include "Descriptors/MoleculeDescriptor.hpp"
 #include "atom.hpp"
 …
   // init private all pointers to zero
-  TestList = NULL;
   TestMolecule = NULL;
   pointmap = NULL;
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
-  TestList = World::getInstance().getMolecules();
-  TestList->insert(TestMolecule);
   TestMolecule->ActiveFlag = true;
 …
   // init maps
+  pointmap = CorrelationToPoint( (MoleculeListClass * const)TestList, elements, (const Vector *)point );
+  World::getInstance().selectAllMolecules(AllMolecules());
+  allMolecules = World::getInstance().getSelectedMolecules();
+  CPPUNIT_ASSERT_EQUAL( (size_t) 1, allMolecules.size());
+  pointmap = CorrelationToPoint( allMolecules, elements, (const Vector *)point );
   binmap = NULL;

src/unittests/AnalysisCorrelationToPointUnitTest.hpp

r06f4ef6	rb6da28
35	35	private:
36	36
37		~~MoleculeListClass *TestList~~;
	37	std::vector<molecule *> allMolecules;
38	38	molecule *TestMolecule;
39	39	element *hydrogen;

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

-              r06f4ef6
+              rb6da28
 #include "analysis_correlation.hpp"
 #include "AnalysisCorrelationToSurfaceUnitTest.hpp"
+#include "Descriptors/MoleculeDescriptor.hpp"
 #include "atom.hpp"
 …
   // init private all pointers to zero
-  TestList = NULL;
   TestSurfaceMolecule = NULL;
   surfacemap = NULL;
 …
   CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->getAtomCount(), 4 );
-  TestList = World::getInstance().getMolecules();
   TestSurfaceMolecule->ActiveFlag = true;
-  TestList->insert(TestSurfaceMolecule);
   // init tesselation and linked cell
 …
   TestSurfaceMolecule->AddAtom(Walker);
+  TestSurfaceMolecule->ActiveFlag = true;
+  TestList->insert(TestSurfaceMolecule);
+  World::getInstance().selectAllMolecules(AllMolecules());
+  allMolecules = World::getInstance().getSelectedMolecules();
+  CPPUNIT_ASSERT_EQUAL( (size_t) 2, allMolecules.size());
   // init maps
 …
+{
   CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->getAtomCount() );
   CPPUNIT_ASSERT_EQUAL( (size_t)2, TestList->ListOfMolecules.size() );
+  CPPUNIT_ASSERT_EQUAL( (size_t)2, allMolecules.size() );
   CPPUNIT_ASSERT_EQUAL( (size_t)4, Surface->PointsOnBoundary.size() );
   CPPUNIT_ASSERT_EQUAL( (size_t)6, Surface->LinesOnBoundary.size() );
 …
   // do the pair correlation
   elements.push_back(hydrogen);
   surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
+  surfacemap = CorrelationToSurface( allMolecules, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   CPPUNIT_ASSERT( surfacemap != NULL );
 …
   BinPairMap::iterator tester;
   elements.push_back(hydrogen);
   surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
+  surfacemap = CorrelationToSurface( allMolecules, elements, Surface, LC );
   // put pair correlation into bins and check with no range
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
 …
   BinPairMap::iterator tester;
   elements.push_back(hydrogen);
   surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
+  surfacemap = CorrelationToSurface( allMolecules, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // ... and check with [0., 2.] range
 …
   BinPairMap::iterator tester;
   elements.push_back(carbon);
   surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
+  surfacemap = CorrelationToSurface( allMolecules, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // put pair correlation into bins and check with no range
 …
   BinPairMap::iterator tester;
   elements.push_back(carbon);
   surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
+  surfacemap = CorrelationToSurface( allMolecules, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // ... and check with [0., 2.] range

src/unittests/AnalysisCorrelationToSurfaceUnitTest.hpp

r06f4ef6	rb6da28
43	43	private:
44	44
45		~~MoleculeListClass *TestList~~;
	45	std::vector<molecule *> allMolecules;
46	46	molecule *TestSurfaceMolecule;
47	47	element *hydrogen;

src/unittests/AnalysisPairCorrelationUnitTest.cpp

-              r06f4ef6
+              rb6da28
 #include "analysis_correlation.hpp"
 #include "AnalysisPairCorrelationUnitTest.hpp"
+#include "Descriptors/MoleculeDescriptor.hpp"
 #include "World.hpp"
 …
   // init private all pointers to zero
-  TestList = NULL;
   TestMolecule = NULL;
   correlationmap = NULL;
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
-  TestList = World::getInstance().getMolecules();
-  TestMolecule->ActiveFlag = true;
-  TestList->insert(TestMolecule);
   // init maps
+  correlationmap = PairCorrelation( TestList, elements);
+  World::getInstance().selectAllMolecules(AllMolecules());
+  allMolecules = World::getInstance().getSelectedMolecules();
+  CPPUNIT_ASSERT_EQUAL( (size_t) 1, allMolecules.size());
+  correlationmap = PairCorrelation( allMolecules, elements);
   binmap = NULL;

src/unittests/AnalysisPairCorrelationUnitTest.hpp

r06f4ef6	rb6da28
35	35	private:
36	36
37		~~MoleculeListClass *TestList~~;
	37	std::vector<molecule *> allMolecules;
38	38	molecule *TestMolecule;
39	39	element *hydrogen;

src/unittests/CountBondsUnitTest.cpp

-              r06f4ef6
+              rb6da28
   Translator  = Vector(3,0,0);
   TestMolecule2->Translate(&Translator);
   CPPUNIT_ASSERT_EQUAL( 1 , CountHydrogenBridgeBonds(molecules, NULL) );
   CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, oxygen) );
+  CPPUNIT_ASSERT_EQUAL( 1 , CountHydrogenBridgeBonds(molecules, NULL, NULL) );
+  CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, oxygen, NULL) );
   //OutputTestMolecule(TestMolecule2, "testmolecule2-1.xyz");
   Translator = Vector(-3,0,0);
 …
   Translator = Vector(0,3,0);
   TestMolecule2->Translate(&Translator);
   CPPUNIT_ASSERT_EQUAL( 1 , CountHydrogenBridgeBonds(molecules, NULL) );
+  CPPUNIT_ASSERT_EQUAL( 1 , CountHydrogenBridgeBonds(molecules, NULL, NULL) );
   //OutputTestMolecule(TestMolecule2, "testmolecule2-2.xyz");
   Translator = Vector(0,-3,0);
 …
   TestMolecule2->Scale((const double ** const)&mirror);
   TestMolecule2->Translate(&Translator);
   CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, NULL) );
+  CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, NULL, NULL) );
   //OutputTestMolecule(TestMolecule2, "testmolecule2-3.xyz");
   Translator = Vector(0,3,0);
 …
   Translator = Vector(2,1,0);
   TestMolecule2->Translate(&Translator);
   CPPUNIT_ASSERT_EQUAL( 1 , CountHydrogenBridgeBonds(molecules, NULL) );
+  CPPUNIT_ASSERT_EQUAL( 1 , CountHydrogenBridgeBonds(molecules, NULL, NULL) );
   //OutputTestMolecule(TestMolecule2, "testmolecule2-4.xyz");
   Translator = Vector(-2,-1,0);
 …
   Translator = Vector(0,0,3);
   TestMolecule2->Translate(&Translator);
   CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, NULL) );
+  CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, NULL, NULL) );
   //OutputTestMolecule(TestMolecule2, "testmolecule2-5.xyz");
   Translator = Vector(0,0,-3);
 …
   TestMolecule2->Scale((const double ** const)&mirror);
   TestMolecule2->Translate(&Translator);
   CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, NULL) );
+  CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, NULL, NULL) );
   //OutputTestMolecule(TestMolecule2, "testmolecule2-6.xyz");
   Translator = Vector(3,0,0);
 …
   TestMolecule2->Scale((const double ** const)&mirror);
   TestMolecule2->Translate(&Translator);
   CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, NULL) );
+  CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, NULL, NULL) );
   //OutputTestMolecule(TestMolecule2, "testmolecule2-7.xyz");
   Translator = Vector(-3,0,0);
 …
   TestMolecule2->Translate(&Translator);
   //OutputTestMolecule(TestMolecule2, "testmolecule2-8.xyz");
   CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, NULL) );
+  CPPUNIT_ASSERT_EQUAL( 0 , CountHydrogenBridgeBonds(molecules, NULL, NULL) );
   Translator = Vector(0,-3,0);
   TestMolecule2->Translate(&Translator);

src/unittests/LineUnittest.cpp

-              r06f4ef6
+              rb6da28
 #include <iostream>
+#include <cmath>
 using namespace std;
 …
   CPPUNIT_ASSERT_EQUAL(fixture,zeroVec);
+}
+void LineUnittest::sphereIntersectionTest(){
+  {
+    std::vector<Vector> res = la1->getSphereIntersections();
+    CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
+    CPPUNIT_ASSERT(testDirection(res[0],e1));
+    CPPUNIT_ASSERT(testDirection(res[1],e1));
+    CPPUNIT_ASSERT(res[0]!=res[1]);
+  }
+  {
+    std::vector<Vector> res = la2->getSphereIntersections();
+    CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
+    CPPUNIT_ASSERT(testDirection(res[0],e2));
+    CPPUNIT_ASSERT(testDirection(res[1],e2));
+    CPPUNIT_ASSERT(res[0]!=res[1]);
+  }
+  {
+    std::vector<Vector> res = la3->getSphereIntersections();
+    CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
+    CPPUNIT_ASSERT(testDirection(res[0],e3));
+    CPPUNIT_ASSERT(testDirection(res[1],e3));
+    CPPUNIT_ASSERT(res[0]!=res[1]);
+  }
+  {
+    std::vector<Vector> res = lp1->getSphereIntersections();
+    CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
+    CPPUNIT_ASSERT((res[0]==e1) || (res[0]==e2));
+    CPPUNIT_ASSERT((res[1]==e1) || (res[1]==e2));
+    CPPUNIT_ASSERT(res[0]!=res[1]);
+  }
+  {
+    std::vector<Vector> res = lp2->getSphereIntersections();
+    CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
+    CPPUNIT_ASSERT((res[0]==e2) || (res[0]==e3));
+    CPPUNIT_ASSERT((res[1]==e2) || (res[1]==e3));
+    CPPUNIT_ASSERT(res[0]!=res[1]);
+  }
+  {
+    std::vector<Vector> res = lp3->getSphereIntersections();
+    CPPUNIT_ASSERT_EQUAL(res.size(),(size_t)2);
+    CPPUNIT_ASSERT((res[0]==e3) || (res[0]==e1));
+    CPPUNIT_ASSERT((res[1]==e3) || (res[1]==e1));
+    CPPUNIT_ASSERT(res[0]!=res[1]);
+  }
+}

src/unittests/LineUnittest.hpp

-              r06f4ef6
+              rb6da28
   CPPUNIT_TEST ( intersectionTest );
   CPPUNIT_TEST ( rotationTest );
+  CPPUNIT_TEST ( sphereIntersectionTest );
   CPPUNIT_TEST_SUITE_END();
 …
   void intersectionTest();
   void rotationTest();
+  void sphereIntersectionTest();
 private:

src/unittests/LinkedCellUnitTest.cpp

-              r06f4ef6
+              rb6da28
   Vector tester;
   LinkedCell::LinkedNodes *ListOfPoints = NULL;
-  atom *Walker = NULL;
   size_t size = 0;
 …
   Vector tester;
   LinkedCell::LinkedNodes *ListOfPoints = NULL;
-  atom *Walker = NULL;
   size_t size = 0;

src/unittests/Makefile.am

-              r06f4ef6
+              rb6da28
 AM_CXXFLAGS = $(CPPUNIT_CFLAGS)
-MENUTESTS = \
-  ActionSequenceTest
 TESTS = \
+  ActionSequenceTest \
   ActOnAllUnitTest \
   AnalysisBondsUnitTests \
 …
   AtomDescriptorTest \
   BondGraphUnitTest \
+  BoxUnittest \
   CacheableTest \
   CountBondsUnitTest \
+  FormulaUnittest \
   GSLMatrixSymmetricUnitTest \
   GSLMatrixUnitTest \
 …
   LogUnitTest \
   manipulateAtomsTest \
+  MemoryUsageObserverUnitTest \
+  MemoryAllocatorUnitTest \
+  MatrixUnittest \
   MoleculeDescriptorTest \
   ObserverTest \
 …
   Tesselation_BoundaryTriangleUnitTest \
   Tesselation_InOutsideUnitTest \
+  VectorUnitTest \
+  ${MENUTESTS}
+  VectorUnitTest
 …
 noinst_PROGRAMS = $(TESTS) TestRunner
 GSLLIBS = ../libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
+GSLLIBS = ../libgslwrapper.a ../libmolecuilderbase.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
 ALLLIBS = ../libmolecuilder.a ${GSLLIBS}
+PARSERLIBS = ../libparser.a ${ALLLIBS}
+UILIBS = ../UIElements/libMolecuilderUI.a ../Actions/libMolecuilderActions.a ${ALLLIBS} ${BOOST_PROGRAM_OPTIONS_LIB}
 TESTSOURCES = \
 …
   atomsCalculationTest.cpp \
   bondgraphunittest.cpp \
+  BoxUnittest.cpp \
   CacheableTest.cpp \
   CountBondsUnitTest.cpp \
+  FormulaUnittest.cpp \
   gslmatrixsymmetricunittest.cpp \
   gslmatrixunittest.cpp \
 …
   listofbondsunittest.cpp \
   logunittest.cpp \
+  MatrixUnittest.cpp \
   manipulateAtomsTest.cpp \
-  memoryallocatorunittest.cpp  \
-  memoryusageobserverunittest.cpp \
   MoleculeDescriptorTest.cpp \
   ObserverTest.cpp \
 …
   atomsCalculationTest.hpp \
   bondgraphunittest.hpp \
+  BoxUnittest.hpp \
   CacheableTest.hpp \
   CountBondsUnitTest.hpp \
+  FormulaUnittest.hpp \
   gslmatrixsymmetricunittest.hpp \
   gslmatrixunittest.hpp \
 …
   logunittest.hpp \
   manipulateAtomsTest.hpp \
+  memoryallocatorunittest.hpp  \
+  memoryusageobserverunittest.hpp \
+  MatrixUnittest.hpp \
   MoleculeDescriptorTest.hpp \
   periodentafelTest.hpp \
 …
 ActionSequenceTest_SOURCES = UnitTestMain.cpp ../../../TestRunnerClient.hpp ActionSequenceTest.cpp ActionSequenceTest.hpp
 ActionSequenceTest_LDADD = ${ALLLIBS}
+ActionSequenceTest_SOURCES = UnitTestMain.cpp ActionSequenceTest.cpp ActionSequenceTest.hpp $(srcdir)/../version.c
+ActionSequenceTest_LDADD = ${UILIBS}
 ActOnAllUnitTest_SOURCES = UnitTestMain.cpp ../test/ActOnAllTest.hpp ActOnAllUnitTest.cpp ActOnAllUnitTest.hpp
 …
 BondGraphUnitTest_LDADD = ${ALLLIBS}
+BoxUnittest_SOURCES = UnitTestMain.cpp BoxUnittest.cpp BoxUnittest.hpp
+BoxUnittest_LDADD = ${ALLLIBS}
 CacheableTest_SOURCES = UnitTestMain.cpp CacheableTest.cpp CacheableTest.hpp
 CacheableTest_LDADD = ${ALLLIBS}
 …
 CountBondsUnitTest_LDADD = ${ALLLIBS}
+FormulaUnittest_SOURCES = UnitTestMain.cpp FormulaUnittest.cpp FormulaUnittest.hpp
+FormulaUnittest_LDADD = ${ALLLIBS}
 GSLMatrixSymmetricUnitTest_SOURCES = UnitTestMain.cpp gslmatrixsymmetricunittest.cpp gslmatrixsymmetricunittest.hpp
 GSLMatrixSymmetricUnitTest_LDADD = ${GSLLIBS}
 …
 LogUnitTest_LDADD = ${ALLLIBS}
+manipulateAtomsTest_SOURCES = UnitTestMain.cpp manipulateAtomsTest.cpp manipulateAtomsTest.hpp
+manipulateAtomsTest_LDADD = ${ALLLIBS}
+MemoryAllocatorUnitTest_SOURCES = UnitTestMain.cpp ../memoryallocator.hpp ../memoryallocator.cpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp
+MemoryAllocatorUnitTest_LDADD = ${ALLLIBS}
+MemoryUsageObserverUnitTest_SOURCES = UnitTestMain.cpp ../memoryallocator.hpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp memoryusageobserverunittest.cpp memoryusageobserverunittest.hpp
+MemoryUsageObserverUnitTest_LDADD = ${ALLLIBS}
+manipulateAtomsTest_SOURCES = UnitTestMain.cpp manipulateAtomsTest.cpp manipulateAtomsTest.hpp $(srcdir)/../version.c
+manipulateAtomsTest_LDADD = ${UILIBS}
+MatrixUnittest_SOURCES = UnitTestMain.cpp MatrixUnittest.cpp MatrixUnittest.hpp
+MatrixUnittest_LDADD = ${ALLLIBS}
 MoleculeDescriptorTest_SOURCES = UnitTestMain.cpp MoleculeDescriptorTest.cpp MoleculeDescriptorTest.hpp
 …
 ParserUnitTest_SOURCES = UnitTestMain.cpp ParserUnitTest.cpp ParserUnitTest.hpp
 ParserUnitTest_LDADD = ${ALLLIBS}
+ParserUnitTest_LDADD = ${PARSERLIBS}
 periodentafelTest_SOURCES = UnitTestMain.cpp periodentafelTest.cpp periodentafelTest.hpp
 …
 SingletonTest_SOURCES = UnitTestMain.cpp SingletonTest.cpp SingletonTest.hpp
 SingletonTest_LDADD = $(BOOST_LIB) ${BOOST_THREAD_LIB}
+SingletonTest_LDADD = ${ALLLIBS} $(BOOST_LIB) ${BOOST_THREAD_LIB}
 StackClassUnitTest_SOURCES = UnitTestMain.cpp stackclassunittest.cpp stackclassunittest.hpp
 …
 Tesselation_InOutsideUnitTest_LDADD = ${ALLLIBS}
 TestRunner_SOURCES = TestRunnerMain.cpp ../memoryallocator.hpp ../memoryallocator.cpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp $(TESTSOURCES) $(TESTHEADERS)
 TestRunner_LDADD = ${ALLLIBS}
+TestRunner_SOURCES = TestRunnerMain.cpp $(srcdir)/../version.c $(TESTSOURCES) $(TESTHEADERS)
+TestRunner_LDADD = ../UIElements/libMolecuilderUI.a ../Actions/libMolecuilderActions.a ../libmolecuilder.a ../libparser.a ../libgslwrapper.a ../libmolecuilderbase.a $(BOOST_LIB) ${BOOST_THREAD_LIB} ${BOOST_PROGRAM_OPTIONS_LIB}
 VectorUnitTest_SOURCES = UnitTestMain.cpp vectorunittest.cpp vectorunittest.hpp

src/unittests/ObserverTest.cpp

-              r06f4ef6
+              rb6da28
 };
 class ObservableCollection : public Observable {
+class ObservableSet : public Observable {
 public:
   typedef std::set<SimpleObservable*> set;
 …
   typedef set::const_iterator const_iterator;
   ObservableCollection(int _num) :
+  ObservableSet(int _num) :
     Observable("ObservableCollection"),
     num(_num)
 …
+  }
   ~ObservableCollection(){
+  ~ObservableSet(){
     set::iterator iter;
     for(iter=theSet.begin(); iter!=theSet.end(); ++iter ){
       delete (*iter);
+    }
+  }
+  iterator begin(){
+    return iterator(theSet.begin(),this);
+  }
+  iterator end(){
+    return iterator(theSet.end(),this);
+  }
+  const int num;
+private:
+  set theSet;
+};
+class ObservableMap : public Observable {
+public:
+  typedef std::map<int,SimpleObservable*> set;
+  typedef ObservedIterator<set> iterator;
+  typedef set::const_iterator const_iterator;
+  ObservableMap(int _num) :
+    Observable("ObservableCollection"),
+    num(_num)
+  {
+    for(int i=0; i<num; ++i){
+      SimpleObservable *content = new SimpleObservable();
+      content->signOn(this);
+      theSet.insert(make_pair(i,content));
+    }
+  }
+  ~ObservableMap(){
+    set::iterator iter;
+    for(iter=theSet.begin(); iter!=theSet.end(); ++iter ){
+      delete iter->second;
+    }
+  }
 …
   blockObservable = new BlockObservable();
   notificationObservable = new NotificationObservable();
+  collection = new ObservableCollection(5);
+  obsset = new ObservableSet(5);
+  obsmap = new ObservableMap(5);
   observer1 = new UpdateCountObserver();
 …
   delete blockObservable;
   delete notificationObservable;
+  delete collection;
+  delete obsset;
+  delete obsmap;
   delete observer1;
 …
   simpleObservable2->signOn(observer4);
+  CPPUNIT_ASSERT_EQUAL( 0, observer1->updates );
+  CPPUNIT_ASSERT_EQUAL( 0, observer2->updates );
+  CPPUNIT_ASSERT_EQUAL( 0, observer3->updates );
+  CPPUNIT_ASSERT_EQUAL( 0, observer4->updates );
   simpleObservable1->changeMethod();
   CPPUNIT_ASSERT_EQUAL( 1, observer1->updates );
 …
 void ObserverTest::doesBlockUpdateTest() {
   callObservable->signOn(observer1);
+  CPPUNIT_ASSERT_EQUAL( 0, observer1->updates );
   callObservable->changeMethod1();
 …
   CPPUNIT_ASSERT_EQUAL( 2, observer1->updates );
   CPPUNIT_ASSERT_EQUAL( 2, observer2->updates );
+}
+void ObserverTest::outsideLockTest(){
+  callObservable->signOn(observer1);
+  CPPUNIT_ASSERT_EQUAL( 0, observer1->updates );
+  {
+    LOCK_OBSERVABLE(*callObservable);
+    CPPUNIT_ASSERT_EQUAL( 0, observer1->updates );
+  }
+  // lock is gone now, observer should have notified
+  CPPUNIT_ASSERT_EQUAL( 1, observer1->updates );
+}
 …
   int i = 0;
   // test the general iterator methods
   for(ObservableCollection::iterator iter=collection->begin(); iter!=collection->end();++iter){
     CPPUNIT_ASSERT(i< collection->num);
+  for(ObservableSet::iterator iter=obsset->begin(); iter!=obsset->end();++iter){
+    CPPUNIT_ASSERT(i< obsset->num);
     i++;
+  }
   i=0;
   for(ObservableCollection::const_iterator iter=collection->begin(); iter!=collection->end();++iter){
     CPPUNIT_ASSERT(i<collection->num);
     i++;
+  }
   collection->signOn(observer1);
+  for(ObservableSet::const_iterator iter=obsset->begin(); iter!=obsset->end();++iter){
+    CPPUNIT_ASSERT(i<obsset->num);
+    i++;
+  }
+  obsset->signOn(observer1);
+  {
     // we construct this out of the loop, so the iterator dies at the end of
     // the scope and not the end of the loop (allows more testing)
     ObservableCollection::iterator iter;
     for(iter=collection->begin(); iter!=collection->end(); ++iter){
+    ObservableSet::iterator iter;
+    for(iter=obsset->begin(); iter!=obsset->end(); ++iter){
       (*iter)->changeMethod();
+    }
 …
   // when using a const_iterator no changes should be propagated
   for(ObservableCollection::const_iterator iter = collection->begin(); iter!=collection->end();++iter);
+  for(ObservableSet::const_iterator iter = obsset->begin(); iter!=obsset->end();++iter);
   CPPUNIT_ASSERT_EQUAL( 1, observer1->updates);
+  collection->signOff(observer1);
+  // we need to test the operator-> as well
+  obsmap->signOn(observer2);
+  {
+    // we construct this out of the loop, so the iterator dies at the end of
+    // the scope and not the end of the loop (allows more testing)
+    ObservableMap::iterator iter;
+    for(iter=obsmap->begin(); iter!=obsmap->end(); ++iter){
+      iter->second->changeMethod();
+    }
+    // At this point no change should have been propagated
+    CPPUNIT_ASSERT_EQUAL( 0, observer2->updates);
+  }
+  // After the Iterator has died the propagation should take place
+  CPPUNIT_ASSERT_EQUAL( 1, observer2->updates);
+  obsset->signOff(observer1);
+  obsmap->signOff(observer2);
+}
 …
   // make this Observable its own subject. NEVER DO THIS IN ACTUAL CODE
   simpleObservable1->signOn(simpleObservable1);
+#ifndef NDEBUG
   CPPUNIT_ASSERT_THROW(simpleObservable1->changeMethod(),Assert::AssertionFailure);
+#else
+  simpleObservable1->changeMethod();
+#endif
   // more complex test
 …
   simpleObservable1->signOn(simpleObservable2);
   simpleObservable2->signOn(simpleObservable1);
+#ifndef NDEBUG
   CPPUNIT_ASSERT_THROW(simpleObservable1->changeMethod(),Assert::AssertionFailure);
+#else
+  simpleObservable1->changeMethod();
+#endif
   simpleObservable1->signOff(simpleObservable2);
   simpleObservable2->signOff(simpleObservable1);

src/unittests/ObserverTest.hpp

-              r06f4ef6
+              rb6da28
 class CallObservable;
 class SuperObservable;
+class ObservableCollection;
+class ObservableSet;
+class ObservableMap;
 class BlockObservable;
 class NotificationObservable;
 …
   CPPUNIT_TEST ( doesBlockUpdateTest );
   CPPUNIT_TEST ( doesSubObservableTest );
+  CPPUNIT_TEST ( outsideLockTest );
   CPPUNIT_TEST ( doesNotifyTest );
   CPPUNIT_TEST ( doesReportTest );
 …
   void doesBlockUpdateTest();
   void doesSubObservableTest();
+  void outsideLockTest();
   void doesNotifyTest();
   void doesReportTest();
 …
   SuperObservable *superObservable;
   NotificationObservable *notificationObservable;
+  ObservableCollection *collection;
+  ObservableSet *obsset;
+  ObservableMap *obsmap;
 };

src/unittests/ParserUnitTest.cpp

-              r06f4ef6
+              rb6da28
 #include <cppunit/ui/text/TestRunner.h>
+#include "Parser/MpqcParser.hpp"
+#include "Parser/PcpParser.hpp"
+#include "Parser/TremoloParser.hpp"
 #include "Parser/XyzParser.hpp"
-#include "Parser/TremoloParser.hpp"
 #include "World.hpp"
 #include "atom.hpp"
 …
 CPPUNIT_TEST_SUITE_REGISTRATION( ParserUnitTest );
+static string waterPcp = "# ParallelCarParinello - main configuration file - created with molecuilder\n\
+\n\
+mainname\tpcp\t# programm name (for runtime files)\n\
+defaultpath\not specified\t# where to put files during runtime\n\
+pseudopotpath\not specified\t# where to find pseudopotentials\n\
+\n\
+ProcPEGamma\t8\t# for parallel computing: share constants\n\
+ProcPEPsi\t1\t# for parallel computing: share wave functions\n\
+DoOutVis\t0\t# Output data for OpenDX\n\
+DoOutMes\t1\t# Output data for measurements\n\
+DoOutOrbitals\t0\t# Output all Orbitals\n\
+DoOutCurr\t0\t# Ouput current density for OpenDx\n\
+DoOutNICS\t0\t# Output Nucleus independent current shieldings\n\
+DoPerturbation\t0\t# Do perturbation calculate and determine susceptibility and shielding\n\
+DoFullCurrent\t0\t# Do full perturbation\n\
+DoConstrainedMD\t0\t# Do perform a constrained (>0, relating to current MD step) instead of unconstrained (0) MD\n\
+Thermostat\tBerendsen\t2.5\t# Which Thermostat and its parameters to use in MD case.\n\
+CommonWannier\t0\t# Put virtual centers at indivual orbits, all common, merged by variance, to grid point, to cell center\n\
+SawtoothStart\t0.01\t# Absolute value for smooth transition at cell border \n\
+VectorPlane\t0\t# Cut plane axis (x, y or z: 0,1,2) for two-dim current vector plot\n\
+VectorCut\t0\t# Cut plane axis value\n\
+AddGramSch\t1\t# Additional GramSchmidtOrtogonalization to be safe\n\
+Seed\t1\t# initial value for random seed for Psi coefficients\n\
+\n\
+MaxOuterStep\t0\t# number of MolecularDynamics/Structure optimization steps\n\
+Deltat\t0.01\t# time per MD step\n\
+OutVisStep\t10\t# Output visual data every ...th step\n\
+OutSrcStep\t5\t# Output \"restart\" data every ..th step\n\
+TargetTemp\t0.000950045\t# Target temperature\n\
+MaxPsiStep\t3\t# number of Minimisation steps per state (0 - default)\n\
+EpsWannier\t1e-07\t# tolerance value for spread minimisation of orbitals\n\
+# Values specifying when to stop\n\
+MaxMinStep\t100\t# Maximum number of steps\n\
+RelEpsTotalE\t1e-07\t# relative change in total energy\n\
+RelEpsKineticE\t1e-05\t# relative change in kinetic energy\n\
+MaxMinStopStep\t2\t# check every ..th steps\n\
+MaxMinGapStopStep\t1\t# check every ..th steps\n\
+\n\
+# Values specifying when to stop for INIT, otherwise same as above\n\
+MaxInitMinStep\t100\t# Maximum number of steps\n\
+InitRelEpsTotalE\t1e-05\t# relative change in total energy\n\
+InitRelEpsKineticE\t0.0001\t# relative change in kinetic energy\n\
+InitMaxMinStopStep\t2\t# check every ..th steps\n\
+InitMaxMinGapStopStep\t1\t# check every ..th steps\n\
+\n\
+BoxLength\t# (Length of a unit cell)\n\
+\n\
+\t20\n\
+\t0\t20\n\
+\n\
+ECut\t128\t# energy cutoff for discretization in Hartrees\n\
+MaxLevel\t5\t# number of different levels in the code, >=2\n\
+Level0Factor\t2\t# factor by which node number increases from S to 0 level\n\
+RiemannTensor\t0\t# (Use metric)\n\
+PsiType\t0\t# 0 - doubly occupied, 1 - SpinUp,SpinDown\n\
+MaxPsiDouble\t2\t# here: specifying both maximum number of SpinUp- and -Down-states\n\
+PsiMaxNoUp\t2\t# here: specifying maximum number of SpinUp-states\n\
+PsiMaxNoDown\t2\t# here: specifying maximum number of SpinDown-states\n\
+AddPsis\t0\t# Additional unoccupied Psis for bandgap determination\n\
+\n\
+RCut\t20\t# R-cut for the ewald summation\n\
+StructOpt\t0\t# Do structure optimization beforehand\n\
+IsAngstroem\t1\t# 0 - Bohr, 1 - Angstroem\n\
+RelativeCoord\t0\t# whether ion coordinates are relative (1) or absolute (0)\n\
+MaxTypes\t2\t# maximum number of different ion types\n\
+\n\
+# Ion type data (PP = PseudoPotential, Z = atomic number)\n\
+#Ion_TypeNr.\tAmount\tZ\tRGauss\tL_Max(PP)L_Loc(PP)IonMass\t# chemical name, symbol\n\
+Ion_Type1\t2\t1\t1.0\t3\t3\t1.008\tHydrogen\tH\n\
+Ion_Type2\t1\t8\t1.0\t3\t3\t15.999\tOxygen\tO\n\
+#Ion_TypeNr._Nr.R[0]\tR[1]\tR[2]\tMoveType (0 MoveIon, 1 FixedIon)\n\
+Ion_Type2_1\t0.000000000\t0.000000000\t0.000000000\t0 # molecule nr 0\n\
+Ion_Type1_1\t0.758602\t0.000000000\t0.504284\t0 # molecule nr 1\n\
+Ion_Type1_2\t0.758602\t0.000000000\t-0.504284\t0 # molecule nr 2\n";
+static string waterMpqc ="% Created by MoleCuilder\n\
+mpqc: (\n\
+\tsavestate = no\n\
+\tdo_gradient = yes\n\
+\tmole<MBPT2>: (\n\
+\t\tmaxiter = 200\n\
+\t\tbasis = $:basis\n\
+\t\tmolecule = $:molecule\n\
+\t\treference<CLHF>: (\n\
+\t\t\tbasis = $:basis\n\
+\t\t\tmolecule = $:molecule\n\
+\t\t)\n\
+\t)\n\
+)\n\
+molecule<Molecule>: (\n\
+\tunit = angstrom\n\
+\t{ atoms geometry } = {\n\
+\t\tO [ -0.505735\t0\t0 ]\n\
+\t\tH [ 0.252867\t0\t0.504284 ]\n\
+\t\tH [ 0.252867\t0\t-0.504284 ]\n\
+\t}\n\
+)\n\
+basis<GaussianBasisSet>: (\n\
+\tname = \"3-21G\"\n\
+\tmolecule = $:molecule\n\
+)\n";
+static string waterXyz = "3\n\tH2O: water molecule\nO\t0\t0\t0\nH\t0.758602\t0\t0.504284\nH\t0.758602\t0\t-0.504284\n";
+static string Tremolo_Atomdata1 = "# ATOMDATA\tId\tname\tType\tx=3\n";
+static string Tremolo_Atomdata2 = "#\n#ATOMDATA Id name Type x=3\n1 hydrogen H 3.0 4.5 0.1\n\n";
+static string Tremolo_invalidkey = "#\n#ATOMDATA Id name foo Type x=3\n\n\n";
+static string Tremolo_velocity = "#\n#ATOMDATA Id name Type u=3\n1 hydrogen H 3.0 4.5 0.1\n\n";
+static string Tremolo_neighbours = "#\n#ATOMDATA Id Type neighbors=2\n1 H 3 0\n2 H 3 0\n3 O 1 2\n";
+static string Tremolo_improper = "#\n#ATOMDATA Id Type imprData\n8 H 9-10\n9 H 10-8,8-10\n10 O -\n";
+static string Tremolo_torsion = "#\n#ATOMDATA Id Type torsion\n8 H 9-10\n9 H 10-8,8-10\n10 O -\n";
+static string Tremolo_full = "# ATOMDATA\tx=3\tu=3\tF\tstress\tId\tneighbors=5\timprData\tGroupMeasureTypeNo\tType\textType\tname\tresName\tchainID\tresSeq\toccupancy\ttempFactor\tsegID\tCharge\tcharge\tGrpTypeNo\ttorsion\n0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t-\t0\tH\t-\t-\t-\t0\t0\t0\t0\t0\t0\t0\t0\t-\t\n";
 void ParserUnitTest::setUp() {
   World::getInstance();
+  // we need hydrogens and oxygens in the following tests
+  CPPUNIT_ASSERT(World::getInstance().getPeriode()->FindElement(1) != NULL);
+  CPPUNIT_ASSERT(World::getInstance().getPeriode()->FindElement(8) != NULL);
+}
 void ParserUnitTest::tearDown() {
+  ChangeTracker::purgeInstance();
   World::purgeInstance();
+}
 …
   cout << "Testing the XYZ parser." << endl;
   XyzParser* testParser = new XyzParser();
-  string waterXyz = "3\nH2O: water molecule\nO\t0.000000\t0.000000\t0.000000\nH\t0.758602\t0.000000\t0.504284\nH\t0.758602\t0.000000\t-0.504284\n";
   stringstream input;
   input << waterXyz;
 …
   TremoloParser* testParser = new TremoloParser();
   stringstream input, output;
-  string waterTremolo;
   // Atomdata beginning with "# ATOMDATA"
+  waterTremolo = "# ATOMDATA\tId\tname\tType\tx=3\n";
+  input << waterTremolo;
+  testParser->load(&input);
+  testParser->save(&output);
+  CPPUNIT_ASSERT(waterTremolo == output.str());
+  input << Tremolo_Atomdata1;
+  testParser->load(&input);
+  testParser->save(&output);
+  CPPUNIT_ASSERT(Tremolo_Atomdata1 == output.str());
   input.clear();
   output.clear();
   // Atomdata beginning with "#ATOMDATA"
+  waterTremolo = "#\n#ATOMDATA Id name Type x=3\n1 hydrogen H 3.0 4.5 0.1\n\n";
+  input << waterTremolo;
+  input << Tremolo_Atomdata2;
   testParser->load(&input);
   testParser->save(&output);
 …
   // Invalid key in Atomdata line
+  waterTremolo = "#\n#ATOMDATA Id name foo Type x=3\n\n\n";
+  input << waterTremolo;
+  input << Tremolo_invalidkey;
   testParser->load(&input);
   //TODO: proove invalidity
 …
   TremoloParser* testParser = new TremoloParser();
   stringstream input;
-  string waterTremolo;
   // One simple data line
+  waterTremolo = "#\n#ATOMDATA Id name Type x=3\n1 hydrogen H 3.0 4.5 0.1\n\n";
+  input << waterTremolo;
+  input << Tremolo_Atomdata2;
   testParser->load(&input);
   CPPUNIT_ASSERT(World::getInstance().getAtom(AtomByType(1))->x[0] == 3.0);
 …
   TremoloParser* testParser = new TremoloParser();
   stringstream input;
-  string waterTremolo;
   // One simple data line
+  waterTremolo = "#\n#ATOMDATA Id name Type u=3\n1 hydrogen H 3.0 4.5 0.1\n\n";
+  input << waterTremolo;
+  input << Tremolo_velocity;
   testParser->load(&input);
   CPPUNIT_ASSERT(World::getInstance().getAtom(AtomByType(1))->v[0] == 3.0);
 …
   TremoloParser* testParser = new TremoloParser();
   stringstream input;
-  string waterTremolo;
   // Neighbor data
+  waterTremolo = "#\n#ATOMDATA Id Type neighbors=2\n1 H 3 0\n2 H 3 0\n3 O 1 2\n";
+  input << waterTremolo;
+  input << Tremolo_neighbours;
   testParser->load(&input);
 …
   TremoloParser* testParser = new TremoloParser();
   stringstream input, output;
-  string waterTremolo;
   // Neighbor data
+  waterTremolo = "#\n#ATOMDATA Id Type imprData\n8 H 9-10\n9 H 10-8,8-10\n10 O -\n";
+  input << waterTremolo;
+  input << Tremolo_improper;
   testParser->load(&input);
   testParser->save(&output);
 …
   TremoloParser* testParser = new TremoloParser();
   stringstream input, output;
-  string waterTremolo;
   // Neighbor data
+  waterTremolo = "#\n#ATOMDATA Id Type torsion\n8 H 9-10\n9 H 10-8,8-10\n10 O -\n";
+  input << waterTremolo;
+  input << Tremolo_torsion;
   testParser->load(&input);
   testParser->save(&output);
 …
   testParser->setFieldsForSave("x=3 u=3 F stress Id neighbors=5 imprData GroupMeasureTypeNo Type extType name resName chainID resSeq occupancy tempFactor segID Charge charge GrpTypeNo torsion");
   testParser->save(&output);
   CPPUNIT_ASSERT(output.str() == "# ATOMDATA\tx=3\tu=3\tF\tstress\tId\tneighbors=5\timprData\tGroupMeasureTypeNo\tType\textType\tname\tresName\tchainID\tresSeq\toccupancy\ttempFactor\tsegID\tCharge\tcharge\tGrpTypeNo\ttorsion\n0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t0\t-\t0\tH\t-\t-\t-\t0\t0\t0\t0\t0\t0\t0\t0\t-\t\n");
+  CPPUNIT_ASSERT(output.str() == Tremolo_full);
   cout << "testing the tremolo parser is done" << endl;
+}
+void ParserUnitTest::readwritePcpTest() {
+  stringstream input(waterPcp);
+  PcpParser* testParser = new PcpParser();
+  testParser->load(&input);
+  input.clear();
+  CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
+  string newWaterPcp = "";
+  stringstream output;
+  testParser->save(&output);
+  input << output;
+  PcpParser* testParser2 = new PcpParser();
+  testParser2->load(&input);
+  CPPUNIT_ASSERT_EQUAL(6, World::getInstance().numAtoms());
+  CPPUNIT_ASSERT(*testParser == *testParser2);
+}
+void ParserUnitTest::writeMpqcTest() {
+  // build up water molecule
+  atom *Walker = NULL;
+  Walker = World::getInstance().createAtom();
+  Walker->type = World::getInstance().getPeriode()->FindElement(8);
+  Walker->x = Vector(0,0,0);
+  Walker = World::getInstance().createAtom();
+  Walker->type = World::getInstance().getPeriode()->FindElement(1);
+  Walker->x = Vector(0.758602,0,0.504284);
+  Walker = World::getInstance().createAtom();
+  Walker->type = World::getInstance().getPeriode()->FindElement(1);
+  Walker->x = Vector(0.758602,0,-0.504284);
+  CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
+  // create two stringstreams, one stored, one created
+  stringstream input(waterMpqc);
+  MpqcParser* testParser = new MpqcParser();
+  stringstream output;
+  testParser->save(&output);
+  // compare both configs
+  string first = input.str();
+  string second = output.str();
+  CPPUNIT_ASSERT(first == second);
+}

src/unittests/ParserUnitTest.hpp

-              r06f4ef6
+              rb6da28
   CPPUNIT_TEST ( readAndWriteTremoloTorsionInformationTest );
   CPPUNIT_TEST ( writeTremoloTest );
+  CPPUNIT_TEST ( readwritePcpTest );
+  CPPUNIT_TEST ( writeMpqcTest );
   CPPUNIT_TEST_SUITE_END();
 …
   void readAndWriteTremoloTorsionInformationTest();
   void writeTremoloTest();
+  void readwritePcpTest();
+  void writeMpqcTest();
 };

src/unittests/PlaneUnittest.cpp

r06f4ef6	rb6da28
11	11	#include <cppunit/extensions/TestFactoryRegistry.h>
12	12	#include <cppunit/ui/text/TestRunner.h>
	13
	14	#include <cmath>
13	15
14	16	#ifdef HAVE_TESTRUNNER

src/unittests/TestRunnerMain.cpp

-              r06f4ef6
+              rb6da28
 #include "../../../TestRunnerClient.h"
 #include "../../../TestRunnerClient.cpp"
 #else
-#include "UnitTestMain.cpp"
-#endif
+#include "unittests/UnitTestMain.cpp"
+#endif /* HAVE_ECUT */

src/unittests/UnitTestMain.cpp

-              r06f4ef6
+              rb6da28
  */
-#include <cppunit/CompilerOutputter.h>
-#include <cppunit/extensions/TestFactoryRegistry.h>
-#include <cppunit/ui/text/TestRunner.h>
 // include config.h
 #ifdef HAVE_CONFIG_H
 #include <config.h>
 #endif
+#include <cppunit/CompilerOutputter.h>
+#include <cppunit/extensions/TestFactoryRegistry.h>
+#include <cppunit/ui/text/TestRunner.h>
 /********************************************** Main routine **************************************/
 …
   return wasSucessful ? 0 : 1;
 };

src/unittests/linearsystemofequationsunittest.cpp

r06f4ef6	rb6da28
12	12	#include <cppunit/extensions/TestFactoryRegistry.h>
13	13	#include <cppunit/ui/text/TestRunner.h>
	14	#include <cmath>
14	15
15	16	#include "linearsystemofequationsunittest.hpp"

src/unittests/manipulateAtomsTest.cpp

-              r06f4ef6
+              rb6da28
 #include "World.hpp"
 #include "atom.hpp"
+#include "DummyUI.hpp"
 #ifdef HAVE_TESTRUNNER
 …
 // set up and tear down
 void manipulateAtomsTest::setUp(){
+  static bool hasDescriptor = false;
   ActionHistory::init();
   World::getInstance();
+  // TODO: find a way to really reset the factory to a clean state in tear-down
+  if(!hasDescriptor){
+    UIFactory::registerFactory(new DummyUIFactory::description());
+    hasDescriptor = true;
+  }
+  UIFactory::makeUserInterface("Dummy");
   for(int i=0;i<ATOM_COUNT;++i){
     atoms[i]= new AtomStub(i);
 …
   ActionRegistry::purgeInstance();
   ActionHistory::purgeInstance();
+  UIFactory::purgeInstance();
+}
 static void operation(atom* _atom){
   AtomStub *atom = dynamic_cast<AtomStub*>(_atom);
   assert(atom);
+  CPPUNIT_ASSERT(atom);
   atom->doSomething();
+}
 …
     AtomStub *atom;
     atom = dynamic_cast<AtomStub*>(*iter);
     assert(atom);
+    CPPUNIT_ASSERT(atom);
     CPPUNIT_ASSERT(atom->manipulated);
+  }
 …
     AtomStub *atom;
     atom = dynamic_cast<AtomStub*>(*iter);
     assert(atom);
+    CPPUNIT_ASSERT(atom);
     if(atom->getId()!=(int)ATOM_COUNT/2)
       CPPUNIT_ASSERT(atom->manipulated);

src/unittests/tesselation_insideoutsideunittest.cpp

r06f4ef6	rb6da28
17	17	#include "tesselation.hpp"
18	18	#include "tesselation_insideoutsideunittest.hpp"
	19	#include "verbose.hpp"
19	20
20	21	#ifdef HAVE_TESTRUNNER

src/unittests/vectorunittest.cpp

-              r06f4ef6
+              rb6da28
 #include "defs.hpp"
 #include "log.hpp"
-#include "memoryusageobserver.hpp"
 #include "vector.hpp"
 #include "vector_ops.hpp"
 …
 #include "Plane.hpp"
 #include "Exceptions/LinearDependenceException.hpp"
+#include "Matrix.hpp"
 #ifdef HAVE_TESTRUNNER
 …
   CPPUNIT_ASSERT(testVector.ScalarProduct(three) < MYEPSILON);
+}
-/**
- * UnitTest for Vector::IsInParallelepiped().
- */
-void VectorTest::IsInParallelepipedTest()
+{
-  double parallelepiped[NDIM*NDIM];
-  parallelepiped[0] = 1;
-  parallelepiped[1] = 0;
-  parallelepiped[2] = 0;
-  parallelepiped[3] = 0;
-  parallelepiped[4] = 1;
-  parallelepiped[5] = 0;
-  parallelepiped[6] = 0;
-  parallelepiped[7] = 0;
-  parallelepiped[8] = 1;
-  fixture = zero;
-  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
-  fixture = Vector(2.5,2.5,2.5);
-  CPPUNIT_ASSERT_EQUAL( true, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
-  fixture = Vector(1.,1.,1.);
-  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
-  fixture = Vector(3.5,3.5,3.5);
-  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
-  fixture = Vector(2.,2.,2.);
-  CPPUNIT_ASSERT_EQUAL( true, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
-  fixture = Vector(2.,3.,2.);
-  CPPUNIT_ASSERT_EQUAL( true, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
-  fixture = Vector(-2.,2.,-1.);
-  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
+}

src/unittests/vectorunittest.hpp

-              r06f4ef6
+              rb6da28
     CPPUNIT_TEST ( ProjectionTest );
     CPPUNIT_TEST ( NormalsTest );
-    CPPUNIT_TEST ( IsInParallelepipedTest );
     CPPUNIT_TEST_SUITE_END();
 …
     void LineIntersectionTest();
     void VectorRotationTest();
-    void IsInParallelepipedTest();
 private:

src/valence.db

r06f4ef6	rb6da28
	1	#atomicnumber numberofvalenceorbitals
1	2	1 0.10000000000000E+01
2	3	2 0.20000000000000E+01

src/vector.cpp

-              r06f4ef6
+              rb6da28
 #include "vector.hpp"
+#include "VectorContent.hpp"
 #include "verbose.hpp"
 #include "World.hpp"
 #include "Helpers/Assert.hpp"
 #include "Helpers/fast_functions.hpp"
+#include "Exceptions/MathException.hpp"
 #include <iostream>
+#include <gsl/gsl_blas.h>
 using namespace std;
 …
 Vector::Vector()
+{
   content = gsl_vector_calloc (NDIM);
+  content = new VectorContent();
 };
 …
 Vector::Vector(const Vector& src)
+{
+  content = gsl_vector_alloc(NDIM);
+  gsl_vector_set(content,0,src[0]);
+  gsl_vector_set(content,1,src[1]);
+  gsl_vector_set(content,2,src[2]);
+  content = new VectorContent();
+  gsl_vector_memcpy(content->content, src.content->content);
+}
 …
 Vector::Vector(const double x1, const double x2, const double x3)
+{
+  content = gsl_vector_alloc(NDIM);
+  gsl_vector_set(content,0,x1);
+  gsl_vector_set(content,1,x2);
+  gsl_vector_set(content,2,x3);
+};
+  content = new VectorContent();
+  gsl_vector_set(content->content,0,x1);
+  gsl_vector_set(content->content,1,x2);
+  gsl_vector_set(content->content,2,x3);
+};
+Vector::Vector(VectorContent *_content) :
+  content(_content)
+{}
 /**
 …
   // check for self assignment
   if(&src!=this){
+    gsl_vector_set(content,0,src[0]);
+    gsl_vector_set(content,1,src[1]);
+    gsl_vector_set(content,2,src[2]);
+    gsl_vector_memcpy(content->content, src.content->content);
+  }
   return *this;
 …
  */
 Vector::~Vector() {
   gsl_vector_free(content);
+  delete content;
 };
 …
+}
-/** Calculates distance between this and another vector in a periodic cell.
- * \param *y array to second vector
- * \param *cell_size 6-dimensional array with (xx, xy, yy, xz, yz, zz) entries specifying the periodic cell
- * \return \f$| x - y |\f$
- */
-double Vector::PeriodicDistance(const Vector &y, const double * const cell_size) const
+{
-  double res = distance(y), tmp, matrix[NDIM*NDIM];
-    Vector Shiftedy, TranslationVector;
-    int N[NDIM];
-    matrix[0] = cell_size[0];
-    matrix[1] = cell_size[1];
-    matrix[2] = cell_size[3];
-    matrix[3] = cell_size[1];
-    matrix[4] = cell_size[2];
-    matrix[5] = cell_size[4];
-    matrix[6] = cell_size[3];
-    matrix[7] = cell_size[4];
-    matrix[8] = cell_size[5];
-    // in order to check the periodic distance, translate one of the vectors into each of the 27 neighbouring cells
-    for (N[0]=-1;N[0]<=1;N[0]++)
-      for (N[1]=-1;N[1]<=1;N[1]++)
-        for (N[2]=-1;N[2]<=1;N[2]++) {
-          // create the translation vector
-          TranslationVector.Zero();
-          for (int i=NDIM;i--;)
-            TranslationVector[i] = (double)N[i];
-          TranslationVector.MatrixMultiplication(matrix);
-          // add onto the original vector to compare with
-          Shiftedy = y + TranslationVector;
-          // get distance and compare with minimum so far
-          tmp = distance(Shiftedy);
-          if (tmp < res) res = tmp;
+        }
-    return (res);
-};
-/** Calculates distance between this and another vector in a periodic cell.
- * \param *y array to second vector
- * \param *cell_size 6-dimensional array with (xx, xy, yy, xz, yz, zz) entries specifying the periodic cell
- * \return \f$| x - y |^2\f$
- */
-double Vector::PeriodicDistanceSquared(const Vector &y, const double * const cell_size) const
+{
-  double res = DistanceSquared(y), tmp, matrix[NDIM*NDIM];
-    Vector Shiftedy, TranslationVector;
-    int N[NDIM];
-    matrix[0] = cell_size[0];
-    matrix[1] = cell_size[1];
-    matrix[2] = cell_size[3];
-    matrix[3] = cell_size[1];
-    matrix[4] = cell_size[2];
-    matrix[5] = cell_size[4];
-    matrix[6] = cell_size[3];
-    matrix[7] = cell_size[4];
-    matrix[8] = cell_size[5];
-    // in order to check the periodic distance, translate one of the vectors into each of the 27 neighbouring cells
-    for (N[0]=-1;N[0]<=1;N[0]++)
-      for (N[1]=-1;N[1]<=1;N[1]++)
-        for (N[2]=-1;N[2]<=1;N[2]++) {
-          // create the translation vector
-          TranslationVector.Zero();
-          for (int i=NDIM;i--;)
-            TranslationVector[i] = (double)N[i];
-          TranslationVector.MatrixMultiplication(matrix);
-          // add onto the original vector to compare with
-          Shiftedy = y + TranslationVector;
-          // get distance and compare with minimum so far
-          tmp = DistanceSquared(Shiftedy);
-          if (tmp < res) res = tmp;
+        }
-    return (res);
-};
-/** Keeps the vector in a periodic cell, defined by the symmetric \a *matrix.
- * \param *out ofstream for debugging messages
- * Tries to translate a vector into each adjacent neighbouring cell.
- */
-void Vector::KeepPeriodic(const double * const matrix)
+{
-  //  int N[NDIM];
-  //  bool flag = false;
-    //vector Shifted, TranslationVector;
-  //  Log() << Verbose(1) << "Begin of KeepPeriodic." << endl;
-  //  Log() << Verbose(2) << "Vector is: ";
-  //  Output(out);
-  //  Log() << Verbose(0) << endl;
-    InverseMatrixMultiplication(matrix);
-    for(int i=NDIM;i--;) { // correct periodically
-      if (at(i) < 0) {  // get every coefficient into the interval [0,1)
-        at(i) += ceil(at(i));
-      } else {
-        at(i) -= floor(at(i));
+      }
+    }
-    MatrixMultiplication(matrix);
-  //  Log() << Verbose(2) << "New corrected vector is: ";
-  //  Output(out);
-  //  Log() << Verbose(0) << endl;
-  //  Log() << Verbose(1) << "End of KeepPeriodic." << endl;
-};
 /** Calculates scalar product between this and another vector.
  * \param *y array to second vector
 …
+{
   double res = 0.;
+  for (int i=NDIM;i--;)
+    res += at(i)*y[i];
+  gsl_blas_ddot(content->content, y.content->content, &res);
   return (res);
 };
 …
 double& Vector::operator[](size_t i){
   ASSERT(i<=NDIM && i>=0,"Vector Index out of Range");
   return *gsl_vector_ptr (content, i);
+  return *gsl_vector_ptr (content->content, i);
+}
 const double& Vector::operator[](size_t i) const{
   ASSERT(i<=NDIM && i>=0,"Vector Index out of Range");
   return *gsl_vector_ptr (content, i);
+  return *gsl_vector_ptr (content->content, i);
+}
 …
+}
 gsl_vector* Vector::get(){
+VectorContent* Vector::get(){
   return content;
+}
 …
 };
+void Vector::ScaleAll(const Vector &factor){
+  gsl_vector_mul(content->content, factor.content->content);
+}
 void Vector::Scale(const double factor)
+{
+  for (int i=NDIM;i--;)
+    at(i) *= factor;
+};
+/** Given a box by its matrix \a *M and its inverse *Minv the vector is made to point within that box.
+ * \param *M matrix of box
+ * \param *Minv inverse matrix
+ */
+void Vector::WrapPeriodically(const double * const M, const double * const Minv)
+{
+  MatrixMultiplication(Minv);
+  // truncate to [0,1] for each axis
+  for (int i=0;i<NDIM;i++) {
+    //at(i) += 0.5;  // set to center of box
+    while (at(i) >= 1.)
+      at(i) -= 1.;
+    while (at(i) < 0.)
+      at(i) += 1.;
+  }
+  MatrixMultiplication(M);
+  gsl_vector_scale(content->content,factor);
 };
 …
   return make_pair(res,helper);
+}
-/** Do a matrix multiplication.
- * \param *matrix NDIM_NDIM array
- */
-void Vector::MatrixMultiplication(const double * const M)
+{
-  Vector tmp;
-  // do the matrix multiplication
-  for(int i=NDIM;i--;)
-    tmp[i] = M[i]*at(0)+M[i+3]*at(1)+M[i+6]*at(2);
-  (*this) = tmp;
-};
-/** Do a matrix multiplication with the \a *A' inverse.
- * \param *matrix NDIM_NDIM array
- */
-bool Vector::InverseMatrixMultiplication(const double * const A)
+{
-  double B[NDIM*NDIM];
-  double detA = RDET3(A);
-  double detAReci;
-  // calculate the inverse B
-  if (fabs(detA) > MYEPSILON) {;  // RDET3(A) yields precisely zero if A irregular
-    detAReci = 1./detA;
-    B[0] =  detAReci*RDET2(A[4],A[5],A[7],A[8]);    // A_11
-    B[1] = -detAReci*RDET2(A[1],A[2],A[7],A[8]);    // A_12
-    B[2] =  detAReci*RDET2(A[1],A[2],A[4],A[5]);    // A_13
-    B[3] = -detAReci*RDET2(A[3],A[5],A[6],A[8]);    // A_21
-    B[4] =  detAReci*RDET2(A[0],A[2],A[6],A[8]);    // A_22
-    B[5] = -detAReci*RDET2(A[0],A[2],A[3],A[5]);    // A_23
-    B[6] =  detAReci*RDET2(A[3],A[4],A[6],A[7]);    // A_31
-    B[7] = -detAReci*RDET2(A[0],A[1],A[6],A[7]);    // A_32
-    B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);    // A_33
-    MatrixMultiplication(B);
-    return true;
-  } else {
-    return false;
+  }
-};
 /** Creates this vector as the b y *factors' components scaled linear combination of the given three.
 …
 void Vector::AddVector(const Vector &y)
+{
+  for(int i=NDIM;i--;)
+    at(i) += y[i];
+  gsl_vector_add(content->content, y.content->content);
+}
 …
 void Vector::SubtractVector(const Vector &y)
+{
+  for(int i=NDIM;i--;)
+    at(i) -= y[i];
+}
+/**
+ * Checks whether this vector is within the parallelepiped defined by the given three vectors and
+ * their offset.
+ *
+ * @param offest for the origin of the parallelepiped
+ * @param three vectors forming the matrix that defines the shape of the parallelpiped
+ */
+bool Vector::IsInParallelepiped(const Vector &offset, const double * const parallelepiped) const
+{
+  Vector a = (*this)-offset;
+  a.InverseMatrixMultiplication(parallelepiped);
+  bool isInside = true;
+  for (int i=NDIM;i--;)
+    isInside = isInside && ((a[i] <= 1) && (a[i] >= 0));
+  return isInside;
+  gsl_vector_sub(content->content, y.content->content);
+}

src/vector.hpp

-              r06f4ef6
+              rb6da28
 #endif
+#include <iostream>
+#include <gsl/gsl_vector.h>
+#include <gsl/gsl_multimin.h>
+#include <iosfwd>
 #include <memory>
 …
 class Vector;
+class Matrix;
+struct VectorContent;
 typedef std::vector<Vector> pointset;
 …
  */
 class Vector : public Space{
+  friend Vector operator*(const Matrix&,const Vector&);
+  friend class Matrix;
 public:
   Vector();
   Vector(const double x1, const double x2, const double x3);
 …
   double DistanceSquared(const Vector &y) const;
   double DistanceToSpace(const Space& space) const;
-  double PeriodicDistance(const Vector &y, const double * const cell_size) const;
-  double PeriodicDistanceSquared(const Vector &y, const double * const cell_size) const;
   double ScalarProduct(const Vector &y) const;
   double Angle(const Vector &y) const;
 …
   Vector Projection(const Vector &y) const;
   void ScaleAll(const double *factor);
+  void ScaleAll(const Vector &factor);
   void Scale(const double factor);
-  void MatrixMultiplication(const double * const M);
-  bool InverseMatrixMultiplication(const double * const M);
-  void KeepPeriodic(const double * const matrix);
   bool GetOneNormalVector(const Vector &x1);
   bool MakeNormalTo(const Vector &y1);
-  bool IsInParallelepiped(const Vector &offset, const double * const parallelepiped) const;
-  void WrapPeriodically(const double * const M, const double * const Minv);
   std::pair<Vector,Vector> partition(const Vector&) const;
   std::pair<pointset,Vector> partition(const pointset&) const;
 …
   // Access to internal structure
   gsl_vector* get();
+  VectorContent* get();
   // Methods that are derived directly from other methods
 …
 private:
+  gsl_vector *content;
+  Vector(VectorContent *);
+  VectorContent *content;
 };

src/vector_ops.cpp

r06f4ef6	rb6da28
23	23	#include <gsl/gsl_permutation.h>
24	24	#include <gsl/gsl_vector.h>
	25	#include <gsl/gsl_multimin.h>
25	26
26	27	/**

src/verbose.cpp

r06f4ef6	rb6da28
5	5	#include "info.hpp"
6	6	#include "verbose.hpp"
	7	#include <iostream>
7	8
8	9	/** Prints the tabs according to verbosity stored in the temporary constructed class.

src/verbose.hpp

r06f4ef6	rb6da28
18	18	#endif
19	19
20		#include <ios~~tream~~>
	20	#include <iosfwd>
21	21
22	22	/*********************************** Class Verbose & Binary *****************************/

tests/Tesselations/Makefile.am

-              r06f4ef6
+              rb6da28
+TESTS = 1_2-dimethoxyethane.test \
+_2-dimethylbenzene.test \
+-methylcyclohexanone.test \
+benzene.test \
+cholesterol.test \
+cycloheptane.test \
+dimethyl_bromomalonate.test \
+glucose.test \
+heptan.test \
+isoleucine.test \
+neohexane.test \
+N_N-dimethylacetamide.test \
+proline.test \
+putrescine.test \
+tartaric_acid.test
+TESTS = \
+_2-dimethoxyethane.test \
+_2-dimethylbenzene.test \
+-methylcyclohexanone.test \
+        benzene.test \
+        cholesterol.test \
+        cycloheptane.test \
+        dimethyl_bromomalonate.test \
+        glucose.test \
+        isoleucine.test \
+        neohexane.test \
+        N_N-dimethylacetamide.test \
+        proline.test \
+        putrescine.test \
+        tartaric_acid.test
+#       heptan.test

tests/Tesselations/defs.in

-              r06f4ef6
+              rb6da28
         #echo "Current dir is `pwd`, calling $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -N $RADIUS $FILENAME."
         if [ -e $mol.dbond ]; then
                 $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -A $mol.dbond -N 0 --sphere-radius $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
+                $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -A $mol.dbond --select-molecule-by-id 0 -N $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
         else
                 $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -N 0 --sphere-radius $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
+                $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz --select-molecule-by-id 0 -N $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
         fi
         #echo "Molecuilder done with exitcode $exitcode."
+        cd ../..
         #cat stderr
         #cat stdout
         grep -E "^[0-9]* [0-9]* [0-9]*$" ../../../../../molecuilder/tests/Tesselations/$mol/$2/${FILENAME}-$mol.dat | sort -n >reference-triangles.dat
         grep -E "^[0-9]* [0-9]* [0-9]*$" ${FILENAME}.dat | sort -n >new-triangles.dat
         diff reference-triangles.dat new-triangles.dat 2>diffstderr >diffstdout || exitcode=$?
+        grep -E "^[0-9]* [0-9]* [0-9]*$" @srcdir@/$mol/$2/${FILENAME}-$mol.dat | sort -n >$testdir/$RADIUS/reference-triangles.dat
+        grep -E "^[0-9]* [0-9]* [0-9]*$" $testdir/$RADIUS/${FILENAME}.dat | sort -n >$testdir/$RADIUS/new-triangles.dat
+        diff $testdir/$RADIUS/reference-triangles.dat $testdir/$RADIUS/new-triangles.dat 2>$testdir/$RADIUS/diffstderr >$testdir/$RADIUS/diffstdout || exitcode=$?
         #echo "Diff done with exitcode $exitcode."
         #cat diffstderr
         #cat diffstdout
-        cd ../..
         test $exitcode = $expected_exitcode || exit 1
+}

tests/Tesselations/heptan/1.5/NonConvexEnvelope-heptan.dat

-              r06f4ef6
+              rb6da28
 TITLE = "3D CONVEX SHELL"
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="heptan", N=23, E=64, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 -7.27e-07 -1.22006 0.930455 3
 -7.27e-07 -1.22006 -0.849545 3
 -1.2492 0.921941 0.930455 3
 -1.2492 0.921941 -0.849545 3
 .2492 0.921941 -0.849545 3
 .2492 0.921941 0.930455 3
 -2.4985 -1.22006 -0.849545 4
 -2.4985 -1.22006 0.930455 4
 .4985 -1.22006 0.930455 4
 .4985 -1.22006 -0.849545 4
 -4.6377 -0.336759 0.0404545 6
 -3.7477 0.921941 0.930455 5
 -3.7477 0.921941 -0.849545 5
 .6377 -0.336759 0.0404545 4
 .7477 0.921941 -0.849545 4
 .7477 0.921941 0.930455 4
 -7.27e-07 -0.590759 0.0404545 6
 -1.2492 0.292641 0.0404545 6
 .2492 0.292641 0.0404545 6
 -2.4985 -0.590759 0.0404545 6
 .4985 -0.590759 0.0404545 6
 -3.7477 0.292641 0.0404545 12
 .7477 0.292641 0.0404545 12
+ZONE T="none", N=23, E=64, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
+-7.27e-07 -1.22006 0.930455 18.7229
+-7.27e-07 -1.22006 -0.849545 18.7229
+-1.2492 0.921941 0.930455 18.7227
+-1.2492 0.921941 -0.849545 18.7227
+.2492 0.921941 -0.849545 18.7222
+.2492 0.921941 0.930455 18.7222
+-2.4985 -1.22006 -0.849545 19.9769
+-2.4985 -1.22006 0.930455 19.9769
+.4985 -1.22006 0.930455 27.4727
+.4985 -1.22006 -0.849545 27.4727
+-4.6377 -0.336759 0.0404545 21.541
+-3.7477 0.921941 0.930455 18.8853
+-3.7477 0.921941 -0.849545 18.8853
+.6377 -0.336759 0.0404545 10.6618
+.7477 0.921941 -0.849545 18.5406
+.7477 0.921941 0.930455 18.5406
+-7.27e-07 -0.590759 0.0404545 23.0174
+-1.2492 0.292641 0.0404545 23.0167
+.2492 0.292641 0.0404545 23.0172
+-2.4985 -0.590759 0.0404545 21.8516
+.4985 -0.590759 0.0404545 16.0669
+-3.7477 0.292641 0.0404545 39.5267
+.7477 0.292641 0.0404545 20.5497
 15 23
 …
 19 23
 15 19
+19 23
+16 19
 6 19
 6 19
 18 19
 5 18
+18 19
+6 18
 4 18
 4 18
 18 19
 6 19
+18 22
+12 22
 18 22
 13 22
-18 22
-12 22
 13 22
 13 22
+19 23
+16 19
+12 22
+12 22
+11 22
+12 22
+13 22
+13 22
+11 22
+13 22
 16 23
 16 23
 14 23
 16 23
+13 22
+13 22
+11 22
+13 22
+12 22
+12 22
+11 22
+12 22
+8 12
+3 8
+3 6
+6 9
+9 16
 7 13
 4 7
 …
 5 10
 10 15
-8 12
-3 8
-3 6
-6 9
-9 16
 14 21
 10 21
 10 21
 14 21
+17 21
+9 17
+2 17
+2 17
 17 21
 10 17
-2 17
-2 17
-17 21
-9 21
-17 20
-7 20
 17 20
 8 20
 8 20
 8 20
+11 20
 11 20
+11 20
+17 20
+7 20

tests/Tesselations/heptan/2.5/NonConvexEnvelope-heptan.dat

-              r06f4ef6
+              rb6da28
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="heptan", N=16, E=28, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 -7.27e-07 -1.22006 0.930455 0
 -7.27e-07 -1.22006 -0.849545 0
 -1.2492 0.921941 0.930455 0
 -1.2492 0.921941 -0.849545 0
 .2492 0.921941 -0.849545 0
 .2492 0.921941 0.930455 0
 -2.4985 -1.22006 -0.849545 0
 -2.4985 -1.22006 0.930455 0
 .4985 -1.22006 0.930455 0
 .4985 -1.22006 -0.849545 0
 -4.6377 -0.336759 0.0404545 0
 -3.7477 0.921941 0.930455 0
 -3.7477 0.921941 -0.849545 0
 .6377 -0.336759 0.0404545 0
 .7477 0.921941 -0.849545 0
 .7477 0.921941 0.930455 0
+-7.27e-07 -1.22006 0.930455 -17.4952
+-7.27e-07 -1.22006 -0.849545 -17.4952
+-1.2492 0.921941 0.930455 -19.6818
+-1.2492 0.921941 -0.849545 -15.323
+.2492 0.921941 -0.849545 -17.495
+.2492 0.921941 0.930455 -17.4951
+-2.4985 -1.22006 -0.849545 -13.1263
+-2.4985 -1.22006 0.930455 -10.8961
+.4985 -1.22006 0.930455 -13.1263
+.4985 -1.22006 -0.849545 -10.8961
+-4.6377 -0.336759 0.0404545 -9.35471
+-3.7477 0.921941 0.930455 -9.24444
+-3.7477 0.921941 -0.849545 -11.4805
+.6377 -0.336759 0.0404545 -9.35473
+.7477 0.921941 -0.849545 -11.4805
+.7477 0.921941 0.930455 -9.24445
 15 16
 …
 12 13
 12 13
+11 12
+8 12
+3 8
+3 6
+6 9
+9 16
+14 16
+11 13
+7 13
+4 7
+4 5
+5 10
+10 15
+14 15
 10 14
 9 10
 …
 7 8
 8 11
+14 15
+10 15
+5 10
+4 5
+4 7
+7 13
+11 13
+14 16
+9 16
+6 9
+3 6
+3 8
+8 12
+11 12

tests/Tesselations/heptan/2/NonConvexEnvelope-heptan.dat

-              r06f4ef6
+              rb6da28
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="heptan", N=16, E=28, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 -7.27e-07 -1.22006 0.930455 0
 -7.27e-07 -1.22006 -0.849545 0
 -1.2492 0.921941 0.930455 0
 -1.2492 0.921941 -0.849545 0
 .2492 0.921941 -0.849545 0
 .2492 0.921941 0.930455 0
 -2.4985 -1.22006 -0.849545 0
 -2.4985 -1.22006 0.930455 0
 .4985 -1.22006 0.930455 0
 .4985 -1.22006 -0.849545 0
 -4.6377 -0.336759 0.0404545 0
 -3.7477 0.921941 0.930455 0
 -3.7477 0.921941 -0.849545 0
 .6377 -0.336759 0.0404545 0
 .7477 0.921941 -0.849545 0
 .7477 0.921941 0.930455 0
+-7.27e-07 -1.22006 0.930455 -17.4952
+-7.27e-07 -1.22006 -0.849545 -17.4952
+-1.2492 0.921941 0.930455 -19.6818
+-1.2492 0.921941 -0.849545 -15.323
+.2492 0.921941 -0.849545 -17.495
+.2492 0.921941 0.930455 -17.4951
+-2.4985 -1.22006 -0.849545 -13.1263
+-2.4985 -1.22006 0.930455 -10.8961
+.4985 -1.22006 0.930455 -13.1263
+.4985 -1.22006 -0.849545 -10.8961
+-4.6377 -0.336759 0.0404545 -9.35471
+-3.7477 0.921941 0.930455 -9.24444
+-3.7477 0.921941 -0.849545 -11.4805
+.6377 -0.336759 0.0404545 -9.35473
+.7477 0.921941 -0.849545 -11.4805
+.7477 0.921941 0.930455 -9.24445
 15 16
 …
 12 13
 12 13
+11 12
+8 12
+3 8
+3 6
+6 9
+9 16
+14 16
+11 13
+7 13
+4 7
+4 5
+5 10
+10 15
+14 15
 10 14
 9 10
 …
 7 8
 8 11
+14 15
+10 15
+5 10
+4 5
+4 7
+7 13
+11 13
+14 16
+9 16
+6 9
+3 6
+3 8
+8 12
+11 12

tests/Tesselations/heptan/25/NonConvexEnvelope-heptan.dat

-              r06f4ef6
+              rb6da28
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="heptan", N=16, E=28, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 -7.27e-07 -1.22006 0.930455 0
 -7.27e-07 -1.22006 -0.849545 0
 -1.2492 0.921941 0.930455 0
 -1.2492 0.921941 -0.849545 0
 .2492 0.921941 -0.849545 0
 .2492 0.921941 0.930455 0
 -2.4985 -1.22006 -0.849545 0
 -2.4985 -1.22006 0.930455 0
 .4985 -1.22006 0.930455 0
 .4985 -1.22006 -0.849545 0
 -4.6377 -0.336759 0.0404545 0
 -3.7477 0.921941 0.930455 0
 -3.7477 0.921941 -0.849545 0
 .6377 -0.336759 0.0404545 0
 .7477 0.921941 -0.849545 0
 .7477 0.921941 0.930455 0
+-7.27e-07 -1.22006 0.930455 -17.4952
+-7.27e-07 -1.22006 -0.849545 -17.4952
+-1.2492 0.921941 0.930455 -19.6818
+-1.2492 0.921941 -0.849545 -15.323
+.2492 0.921941 -0.849545 -17.495
+.2492 0.921941 0.930455 -17.4951
+-2.4985 -1.22006 -0.849545 -13.1263
+-2.4985 -1.22006 0.930455 -10.8961
+.4985 -1.22006 0.930455 -13.1263
+.4985 -1.22006 -0.849545 -10.8961
+-4.6377 -0.336759 0.0404545 -9.35471
+-3.7477 0.921941 0.930455 -9.24444
+-3.7477 0.921941 -0.849545 -11.4805
+.6377 -0.336759 0.0404545 -9.35473
+.7477 0.921941 -0.849545 -11.4805
+.7477 0.921941 0.930455 -9.24445
 15 16
 …
 12 13
 12 13
+11 12
+8 12
+3 8
+3 6
+6 9
+9 16
+14 16
+11 13
+7 13
+4 7
+4 5
+5 10
+10 15
+14 15
 10 14
 9 10
 …
 7 8
 8 11
+14 15
+10 15
+5 10
+4 5
+4 7
+7 13
+11 13
+14 16
+9 16
+6 9
+3 6
+3 8
+8 12
+11 12

tests/Tesselations/heptan/3.5/NonConvexEnvelope-heptan.dat

-              r06f4ef6
+              rb6da28
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="heptan", N=16, E=28, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 -7.27e-07 -1.22006 0.930455 0
 -7.27e-07 -1.22006 -0.849545 0
 -1.2492 0.921941 0.930455 0
 -1.2492 0.921941 -0.849545 0
 .2492 0.921941 -0.849545 0
 .2492 0.921941 0.930455 0
 -2.4985 -1.22006 -0.849545 0
 -2.4985 -1.22006 0.930455 0
 .4985 -1.22006 0.930455 0
 .4985 -1.22006 -0.849545 0
 -4.6377 -0.336759 0.0404545 0
 -3.7477 0.921941 0.930455 0
 -3.7477 0.921941 -0.849545 0
 .6377 -0.336759 0.0404545 0
 .7477 0.921941 -0.849545 0
 .7477 0.921941 0.930455 0
+-7.27e-07 -1.22006 0.930455 -17.4952
+-7.27e-07 -1.22006 -0.849545 -17.4952
+-1.2492 0.921941 0.930455 -19.6818
+-1.2492 0.921941 -0.849545 -15.323
+.2492 0.921941 -0.849545 -17.495
+.2492 0.921941 0.930455 -17.4951
+-2.4985 -1.22006 -0.849545 -13.1263
+-2.4985 -1.22006 0.930455 -10.8961
+.4985 -1.22006 0.930455 -13.1263
+.4985 -1.22006 -0.849545 -10.8961
+-4.6377 -0.336759 0.0404545 -9.35471
+-3.7477 0.921941 0.930455 -9.24444
+-3.7477 0.921941 -0.849545 -11.4805
+.6377 -0.336759 0.0404545 -9.35473
+.7477 0.921941 -0.849545 -11.4805
+.7477 0.921941 0.930455 -9.24445
 15 16
 …
 12 13
 12 13
+11 12
+8 12
+3 8
+3 6
+6 9
+9 16
+14 16
+11 13
+7 13
+4 7
+4 5
+5 10
+10 15
+14 15
 10 14
 9 10
 …
 7 8
 8 11
+14 15
+10 15
+5 10
+4 5
+4 7
+7 13
+11 13
+14 16
+9 16
+6 9
+3 6
+3 8
+8 12
+11 12

tests/Tesselations/heptan/3/NonConvexEnvelope-heptan.dat

-              r06f4ef6
+              rb6da28
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="heptan", N=16, E=28, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 -7.27e-07 -1.22006 0.930455 0
 -7.27e-07 -1.22006 -0.849545 0
 -1.2492 0.921941 0.930455 0
 -1.2492 0.921941 -0.849545 0
 .2492 0.921941 -0.849545 0
 .2492 0.921941 0.930455 0
 -2.4985 -1.22006 -0.849545 0
 -2.4985 -1.22006 0.930455 0
 .4985 -1.22006 0.930455 0
 .4985 -1.22006 -0.849545 0
 -4.6377 -0.336759 0.0404545 0
 -3.7477 0.921941 0.930455 0
 -3.7477 0.921941 -0.849545 0
 .6377 -0.336759 0.0404545 0
 .7477 0.921941 -0.849545 0
 .7477 0.921941 0.930455 0
+-7.27e-07 -1.22006 0.930455 -17.4952
+-7.27e-07 -1.22006 -0.849545 -17.4952
+-1.2492 0.921941 0.930455 -19.6818
+-1.2492 0.921941 -0.849545 -15.323
+.2492 0.921941 -0.849545 -17.495
+.2492 0.921941 0.930455 -17.4951
+-2.4985 -1.22006 -0.849545 -13.1263
+-2.4985 -1.22006 0.930455 -10.8961
+.4985 -1.22006 0.930455 -13.1263
+.4985 -1.22006 -0.849545 -10.8961
+-4.6377 -0.336759 0.0404545 -9.35471
+-3.7477 0.921941 0.930455 -9.24444
+-3.7477 0.921941 -0.849545 -11.4805
+.6377 -0.336759 0.0404545 -9.35473
+.7477 0.921941 -0.849545 -11.4805
+.7477 0.921941 0.930455 -9.24445
 15 16
 …
 12 13
 12 13
+11 12
+8 12
+3 8
+3 6
+6 9
+9 16
+14 16
+11 13
+7 13
+4 7
+4 5
+5 10
+10 15
+14 15
 10 14
 9 10
 …
 7 8
 8 11
+14 15
+10 15
+5 10
+4 5
+4 7
+7 13
+11 13
+14 16
+9 16
+6 9
+3 6
+3 8
+8 12
+11 12

tests/Tesselations/heptan/4/NonConvexEnvelope-heptan.dat

-              r06f4ef6
+              rb6da28
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="heptan", N=16, E=28, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 -7.27e-07 -1.22006 0.930455 0
 -7.27e-07 -1.22006 -0.849545 0
 -1.2492 0.921941 0.930455 0
 -1.2492 0.921941 -0.849545 0
 .2492 0.921941 -0.849545 0
 .2492 0.921941 0.930455 0
 -2.4985 -1.22006 -0.849545 0
 -2.4985 -1.22006 0.930455 0
 .4985 -1.22006 0.930455 0
 .4985 -1.22006 -0.849545 0
 -4.6377 -0.336759 0.0404545 0
 -3.7477 0.921941 0.930455 0
 -3.7477 0.921941 -0.849545 0
 .6377 -0.336759 0.0404545 0
 .7477 0.921941 -0.849545 0
 .7477 0.921941 0.930455 0
+-7.27e-07 -1.22006 0.930455 -17.4952
+-7.27e-07 -1.22006 -0.849545 -17.4952
+-1.2492 0.921941 0.930455 -19.6818
+-1.2492 0.921941 -0.849545 -15.323
+.2492 0.921941 -0.849545 -17.495
+.2492 0.921941 0.930455 -17.4951
+-2.4985 -1.22006 -0.849545 -13.1263
+-2.4985 -1.22006 0.930455 -10.8961
+.4985 -1.22006 0.930455 -13.1263
+.4985 -1.22006 -0.849545 -10.8961
+-4.6377 -0.336759 0.0404545 -9.35471
+-3.7477 0.921941 0.930455 -9.24444
+-3.7477 0.921941 -0.849545 -11.4805
+.6377 -0.336759 0.0404545 -9.35473
+.7477 0.921941 -0.849545 -11.4805
+.7477 0.921941 0.930455 -9.24445
 15 16
 …
 12 13
 12 13
+11 12
+8 12
+3 8
+3 6
+6 9
+9 16
+14 16
+11 13
+7 13
+4 7
+4 5
+5 10
+10 15
+14 15
 10 14
 9 10
 …
 7 8
 8 11
+14 15
+10 15
+5 10
+4 5
+4 7
+7 13
+11 13
+14 16
+9 16
+6 9
+3 6
+3 8
+8 12
+11 12

tests/regression/Domain/2/post/test.conf

-              r06f4ef6
+              rb6da28
 RelEpsTotalE    1e-07   # relative change in total energy
 RelEpsKineticE  1e-05   # relative change in kinetic energy
 MaxMinStopStep  0       # check every ..th steps
+MaxMinStopStep  1       # check every ..th steps
 MaxMinGapStopStep       1       # check every ..th steps
 …
 InitRelEpsTotalE        1e-05   # relative change in total energy
 InitRelEpsKineticE      0.0001  # relative change in kinetic energy
 InitMaxMinStopStep      0       # check every ..th steps
+InitMaxMinStopStep      1       # check every ..th steps
 InitMaxMinGapStopStep   1       # check every ..th steps
 …
 RiemannTensor   0       # (Use metric)
 PsiType         0       # 0 - doubly occupied, 1 - SpinUp,SpinDown
 MaxPsiDouble    0       # here: specifying both maximum number of SpinUp- and -Down-states
 PsiMaxNoUp      0       # here: specifying maximum number of SpinUp-states
 PsiMaxNoDown    0       # here: specifying maximum number of SpinDown-states
+MaxPsiDouble    1       # here: specifying both maximum number of SpinUp- and -Down-states
+PsiMaxNoUp      1       # here: specifying maximum number of SpinUp-states
+PsiMaxNoDown    1       # here: specifying maximum number of SpinDown-states
 AddPsis         0       # Additional unoccupied Psis for bandgap determination

tests/regression/Domain/3/post/test.conf

-              r06f4ef6
+              rb6da28
 RelEpsTotalE    1e-07   # relative change in total energy
 RelEpsKineticE  1e-05   # relative change in kinetic energy
 MaxMinStopStep  0       # check every ..th steps
+MaxMinStopStep  1       # check every ..th steps
 MaxMinGapStopStep       1       # check every ..th steps
 …
 InitRelEpsTotalE        1e-05   # relative change in total energy
 InitRelEpsKineticE      0.0001  # relative change in kinetic energy
 InitMaxMinStopStep      0       # check every ..th steps
+InitMaxMinStopStep      1       # check every ..th steps
 InitMaxMinGapStopStep   1       # check every ..th steps
 …
 RiemannTensor   0       # (Use metric)
 PsiType         0       # 0 - doubly occupied, 1 - SpinUp,SpinDown
 MaxPsiDouble    0       # here: specifying both maximum number of SpinUp- and -Down-states
 PsiMaxNoUp      0       # here: specifying maximum number of SpinUp-states
 PsiMaxNoDown    0       # here: specifying maximum number of SpinDown-states
+MaxPsiDouble    1       # here: specifying both maximum number of SpinUp- and -Down-states
+PsiMaxNoUp      1       # here: specifying maximum number of SpinUp-states
+PsiMaxNoDown    1       # here: specifying maximum number of SpinDown-states
 AddPsis         0       # Additional unoccupied Psis for bandgap determination

tests/regression/Domain/4/post/test.conf

-              r06f4ef6
+              rb6da28
 RelEpsTotalE    1e-07   # relative change in total energy
 RelEpsKineticE  1e-05   # relative change in kinetic energy
 MaxMinStopStep  0       # check every ..th steps
+MaxMinStopStep  1       # check every ..th steps
 MaxMinGapStopStep       1       # check every ..th steps
 …
 InitRelEpsTotalE        1e-05   # relative change in total energy
 InitRelEpsKineticE      0.0001  # relative change in kinetic energy
 InitMaxMinStopStep      0       # check every ..th steps
+InitMaxMinStopStep      1       # check every ..th steps
 InitMaxMinGapStopStep   1       # check every ..th steps
 BoxLength                       # (Length of a unit cell)
        0
+       1
        0       2
 …
 RiemannTensor   0       # (Use metric)
 PsiType         0       # 0 - doubly occupied, 1 - SpinUp,SpinDown
 MaxPsiDouble    0       # here: specifying both maximum number of SpinUp- and -Down-states
 PsiMaxNoUp      0       # here: specifying maximum number of SpinUp-states
 PsiMaxNoDown    0       # here: specifying maximum number of SpinDown-states
+MaxPsiDouble    1       # here: specifying both maximum number of SpinUp- and -Down-states
+PsiMaxNoUp      1       # here: specifying maximum number of SpinUp-states
+PsiMaxNoDown    1       # here: specifying maximum number of SpinDown-states
 AddPsis         0       # Additional unoccupied Psis for bandgap determination

tests/regression/Domain/5/post/test.conf

-              r06f4ef6
+              rb6da28
 RelEpsTotalE    1e-07   # relative change in total energy
 RelEpsKineticE  1e-05   # relative change in kinetic energy
 MaxMinStopStep  0       # check every ..th steps
+MaxMinStopStep  10      # check every ..th steps
 MaxMinGapStopStep       1       # check every ..th steps
 …
 InitRelEpsTotalE        1e-05   # relative change in total energy
 InitRelEpsKineticE      0.0001  # relative change in kinetic energy
 InitMaxMinStopStep      0       # check every ..th steps
+InitMaxMinStopStep      10      # check every ..th steps
 InitMaxMinGapStopStep   1       # check every ..th steps
 …
 RiemannTensor   0       # (Use metric)
 PsiType         0       # 0 - doubly occupied, 1 - SpinUp,SpinDown
 MaxPsiDouble    0       # here: specifying both maximum number of SpinUp- and -Down-states
 PsiMaxNoUp      0       # here: specifying maximum number of SpinUp-states
 PsiMaxNoDown    0       # here: specifying maximum number of SpinDown-states
+MaxPsiDouble    10      # here: specifying both maximum number of SpinUp- and -Down-states
+PsiMaxNoUp      10      # here: specifying maximum number of SpinUp-states
+PsiMaxNoDown    10      # here: specifying maximum number of SpinDown-states
 AddPsis         0       # Additional unoccupied Psis for bandgap determination

tests/regression/Filling/1/post/test.conf

-              r06f4ef6
+              rb6da28
 RelEpsTotalE    1e-07   # relative change in total energy
 RelEpsKineticE  1e-05   # relative change in kinetic energy
 MaxMinStopStep  0       # check every ..th steps
+MaxMinStopStep  680     # check every ..th steps
 MaxMinGapStopStep       1       # check every ..th steps
 …
 InitRelEpsTotalE        1e-05   # relative change in total energy
 InitRelEpsKineticE      0.0001  # relative change in kinetic energy
 InitMaxMinStopStep      0       # check every ..th steps
+InitMaxMinStopStep      680     # check every ..th steps
 InitMaxMinGapStopStep   1       # check every ..th steps
 …
 RiemannTensor   0       # (Use metric)
 PsiType         0       # 0 - doubly occupied, 1 - SpinUp,SpinDown
 MaxPsiDouble    0       # here: specifying both maximum number of SpinUp- and -Down-states
 PsiMaxNoUp      0       # here: specifying maximum number of SpinUp-states
 PsiMaxNoDown    0       # here: specifying maximum number of SpinDown-states
+MaxPsiDouble    680     # here: specifying both maximum number of SpinUp- and -Down-states
+PsiMaxNoUp      680     # here: specifying maximum number of SpinUp-states
+PsiMaxNoDown    680     # here: specifying maximum number of SpinDown-states
 AddPsis         0       # Additional unoccupied Psis for bandgap determination

tests/regression/Filling/1/pre/test.conf

-              r06f4ef6
+              rb6da28
 Ion_Type2       3       6       1.0     3       3       12.01100000000  Carbon  C
 #Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)
 Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 0
 Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 1
 Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 2
 Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 3
 Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 4
 Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 5
 Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 6
 Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 7
 Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 8
 Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 9
 Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 10
+Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 0
+Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 1
+Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 2
+Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 3
+Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 4
+Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 5
+Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 6
+Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 7
+Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 8
+Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 9
+Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 10

tests/regression/Molecules/6/post/test.conf

-              r06f4ef6
+              rb6da28
 RelEpsTotalE    1e-07   # relative change in total energy
 RelEpsKineticE  1e-05   # relative change in kinetic energy
 MaxMinStopStep  0       # check every ..th steps
+MaxMinStopStep  10      # check every ..th steps
 MaxMinGapStopStep       1       # check every ..th steps
 …
 InitRelEpsTotalE        1e-05   # relative change in total energy
 InitRelEpsKineticE      0.0001  # relative change in kinetic energy
 InitMaxMinStopStep      0       # check every ..th steps
+InitMaxMinStopStep      10      # check every ..th steps
 InitMaxMinGapStopStep   1       # check every ..th steps
 …
 RiemannTensor   0       # (Use metric)
 PsiType         0       # 0 - doubly occupied, 1 - SpinUp,SpinDown
 MaxPsiDouble    0       # here: specifying both maximum number of SpinUp- and -Down-states
 PsiMaxNoUp      0       # here: specifying maximum number of SpinUp-states
 PsiMaxNoDown    0       # here: specifying maximum number of SpinDown-states
+MaxPsiDouble    10      # here: specifying both maximum number of SpinUp- and -Down-states
+PsiMaxNoUp      10      # here: specifying maximum number of SpinUp-states
+PsiMaxNoDown    10      # here: specifying maximum number of SpinDown-states
 AddPsis         0       # Additional unoccupied Psis for bandgap determination

tests/regression/Molecules/6/pre/test.conf

-              r06f4ef6
+              rb6da28
 Ion_Type2       3       6       1.0     3       3       12.01100000000  Carbon  C
 #Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)
 Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 0
 Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 1
 Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 2
 Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 3
 Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 4
 Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 5
 Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 6
 Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 7
 Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 8
 Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 9
 Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 10
+Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 0
+Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 1
+Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 2
+Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 3
+Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 4
+Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 5
+Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 6
+Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 7
+Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 8
+Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 9
+Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 10

tests/regression/Molecules/7/post/test.conf

-              r06f4ef6
+              rb6da28
 RelEpsTotalE    1e-07   # relative change in total energy
 RelEpsKineticE  1e-05   # relative change in kinetic energy
 MaxMinStopStep  0       # check every ..th steps
+MaxMinStopStep  10      # check every ..th steps
 MaxMinGapStopStep       1       # check every ..th steps
 …
 InitRelEpsTotalE        1e-05   # relative change in total energy
 InitRelEpsKineticE      0.0001  # relative change in kinetic energy
 InitMaxMinStopStep      0       # check every ..th steps
+InitMaxMinStopStep      10      # check every ..th steps
 InitMaxMinGapStopStep   1       # check every ..th steps
 …
 RiemannTensor   0       # (Use metric)
 PsiType         0       # 0 - doubly occupied, 1 - SpinUp,SpinDown
 MaxPsiDouble    0       # here: specifying both maximum number of SpinUp- and -Down-states
 PsiMaxNoUp      0       # here: specifying maximum number of SpinUp-states
 PsiMaxNoDown    0       # here: specifying maximum number of SpinDown-states
+MaxPsiDouble    10      # here: specifying both maximum number of SpinUp- and -Down-states
+PsiMaxNoUp      10      # here: specifying maximum number of SpinUp-states
+PsiMaxNoDown    10      # here: specifying maximum number of SpinDown-states
 AddPsis         0       # Additional unoccupied Psis for bandgap determination

tests/regression/Molecules/7/pre/test.conf

-              r06f4ef6
+              rb6da28
 Ion_Type2       3       6       1.0     3       3       12.01100000000  Carbon  C
 #Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)
 Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 0
 Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 1
 Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 2
 Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 3
 Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 4
 Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 5
 Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 6
 Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 7
 Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 8
 Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 9
 Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 10
+Ion_Type1_1     9.782085945     2.645886050     2.645886050     0 # molecule nr 0
+Ion_Type1_2     9.782085945     2.645886050     4.425886024     0 # molecule nr 1
+Ion_Type1_3     10.672039608    3.904536878     3.535886037     0 # molecule nr 2
+Ion_Type1_4     8.532785963     4.787886018     2.645886050     0 # molecule nr 3
+Ion_Type1_5     8.532785963     4.787886018     4.425886024     0 # molecule nr 4
+Ion_Type1_6     6.393632318     3.904536877     3.535886037     0 # molecule nr 5
+Ion_Type1_7     7.283585982     2.645886050     2.645886050     0 # molecule nr 6
+Ion_Type1_8     7.283585982     2.645886050     4.425886024     0 # molecule nr 7
+Ion_Type2_1     9.782085945     3.275186040     3.535886037     0 # molecule nr 8
+Ion_Type2_2     8.532785963     4.158586027     3.535886037     0 # molecule nr 9
+Ion_Type2_3     7.283585982     3.275186040     3.535886037     0 # molecule nr 10

tests/regression/Simple_configuration/2/post/test.conf

-              r06f4ef6
+              rb6da28
 RelEpsTotalE    1e-07   # relative change in total energy
 RelEpsKineticE  1e-05   # relative change in kinetic energy
 MaxMinStopStep  0       # check every ..th steps
+MaxMinStopStep  1       # check every ..th steps
 MaxMinGapStopStep       0       # check every ..th steps
 …
 InitRelEpsTotalE        1e-05   # relative change in total energy
 InitRelEpsKineticE      0.0001  # relative change in kinetic energy
 InitMaxMinStopStep      0       # check every ..th steps
+InitMaxMinStopStep      1       # check every ..th steps
 InitMaxMinGapStopStep   0       # check every ..th steps
 …
 Level0Factor    2       # factor by which node number increases from S to 0 level
 RiemannTensor   0       # (Use metric)
 PsiType         0       # 0 - doubly occupied, 1 - SpinUp,SpinDown
+PsiType         1       # 0 - doubly occupied, 1 - SpinUp,SpinDown
 MaxPsiDouble    0       # here: specifying both maximum number of SpinUp- and -Down-states
 PsiMaxNoUp      0       # here: specifying maximum number of SpinUp-states
 PsiMaxNoDown    0       # here: specifying maximum number of SpinDown-states
+PsiMaxNoDown    1       # here: specifying maximum number of SpinDown-states
 AddPsis         0       # Additional unoccupied Psis for bandgap determination

tests/regression/Simple_configuration/3/post/test.conf

-              r06f4ef6
+              rb6da28
 RelEpsTotalE    1e-07   # relative change in total energy
 RelEpsKineticE  1e-05   # relative change in kinetic energy
 MaxMinStopStep  0       # check every ..th steps
+MaxMinStopStep  1       # check every ..th steps
 MaxMinGapStopStep       0       # check every ..th steps
 …
 InitRelEpsTotalE        1e-05   # relative change in total energy
 InitRelEpsKineticE      0.0001  # relative change in kinetic energy
 InitMaxMinStopStep      0       # check every ..th steps
+InitMaxMinStopStep      1       # check every ..th steps
 InitMaxMinGapStopStep   0       # check every ..th steps
 …
 Level0Factor    2       # factor by which node number increases from S to 0 level
 RiemannTensor   0       # (Use metric)
 PsiType         0       # 0 - doubly occupied, 1 - SpinUp,SpinDown
+PsiType         1       # 0 - doubly occupied, 1 - SpinUp,SpinDown
 MaxPsiDouble    0       # here: specifying both maximum number of SpinUp- and -Down-states
 PsiMaxNoUp      0       # here: specifying maximum number of SpinUp-states
 PsiMaxNoDown    0       # here: specifying maximum number of SpinDown-states
+PsiMaxNoDown    1       # here: specifying maximum number of SpinDown-states
 AddPsis         0       # Additional unoccupied Psis for bandgap determination

tests/regression/Tesselation/1/post/NonConvexEnvelope.dat

-              r06f4ef6
+              rb6da28
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="test", N=8, E=12, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 .78209 2.64589 2.64589 0
 .78209 2.64589 4.42589 0
 .672 3.90454 3.53589 0
 .53279 4.78789 2.64589 0
 .53279 4.78789 4.42589 0
 .39363 3.90454 3.53589 0
 .28359 2.64589 2.64589 0
 .28359 2.64589 4.42589 0
+.78209 2.64589 2.64589 -9.24443
+.78209 2.64589 4.42589 -11.4804
+.672 3.90454 3.53589 -9.35464
+.53279 4.78789 2.64589 -9.11459
+.53279 4.78789 4.42589 -9.11459
+.39363 3.90454 3.53589 -9.35431
+.28359 2.64589 2.64589 -11.4803
+.28359 2.64589 4.42589 -9.24433
 3 4

tests/regression/Tesselation/2/post/ConvexEnvelope.dat

-              r06f4ef6
+              rb6da28
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="test", N=8, E=12, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 .78209 2.64589 2.64589 0
 .78209 2.64589 4.42589 0
 .672 3.90454 3.53589 0
 .53279 4.78789 2.64589 0
 .53279 4.78789 4.42589 0
 .39363 3.90454 3.53589 0
 .28359 2.64589 2.64589 0
 .28359 2.64589 4.42589 0
+.78209 2.64589 2.64589 -9.24443
+.78209 2.64589 4.42589 -11.4804
+.672 3.90454 3.53589 -9.35464
+.53279 4.78789 2.64589 -9.11459
+.53279 4.78789 4.42589 -9.11459
+.39363 3.90454 3.53589 -9.35431
+.28359 2.64589 2.64589 -11.4803
+.28359 2.64589 4.42589 -9.24433
 3 4

tests/regression/Tesselation/2/post/NonConvexEnvelope.dat

-              r06f4ef6
+              rb6da28
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="test", N=8, E=12, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 .78209 2.64589 2.64589 0
 .78209 2.64589 4.42589 0
 .672 3.90454 3.53589 0
 .53279 4.78789 2.64589 0
 .53279 4.78789 4.42589 0
 .39363 3.90454 3.53589 0
 .28359 2.64589 2.64589 0
 .28359 2.64589 4.42589 0
+.78209 2.64589 2.64589 -9.24443
+.78209 2.64589 4.42589 -11.4804
+.672 3.90454 3.53589 -9.35464
+.53279 4.78789 2.64589 -9.11459
+.53279 4.78789 4.42589 -9.11459
+.39363 3.90454 3.53589 -9.35431
+.28359 2.64589 2.64589 -11.4803
+.28359 2.64589 4.42589 -9.24433
 3 4

tests/regression/Tesselation/3/post/NonConvexEnvelope.dat

-              r06f4ef6
+              rb6da28
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="test", N=44, E=86, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
+.3612 -3.628 1.323 1
 .4884 -3.5983 -0.4521 3
+.4985 -2.5112 0.5308 4
+-1.9534 -3.5752 0.5362 2
 -1.1883 -0.199 1.5176 3
 -0.7165 -1.6046 2.5129 1
 .7627 -1.4479 -0.8349 4
+-1.003 -1.3584 -2.8848 2
+.0217 -2.6629 -2.2008 1
+-2.8885 -1.5706 1.7543 2
 -2.0579 -3.6765 -1.7622 0
 -2.9259 -2.1146 -1.7672 1
 .0353 0.1785 2.542 3
 .6325 -1.3323 1.8306 2
+.7271 1.177 0.3594 3
 .3374 -0.2942 -2.961 2
+.6036 1.0859 -2.1126 3
+-3.2034 -0.5041 -1.0881 3
 -5.1809 -1.8679 0.9687 1
 -4.6025 -2.4721 -0.6025 2
 -4.3385 -3.4329 0.8725 0
+.191 1.3217 -2.8354 1
+-4.0905 0.6312 1.6028 3
+.8131 1.4776 2.5103 0
+.9137 2.2936 1.3739 0
+.159 2.5738 1.2698 5
+.6606 -0.4593 2.1396 2
 .2007 -1.4419 0.7311 4
+-3.3002 2.3589 0.0094 8
 -4.377 1.6962 -1.2433 3
+.2593 1.4547 -1.7445 0
+.6863 2.7674 -0.6775 0
+.746 -0.9031 1.204 0
 .1212 -0.8867 -0.4582 4
+-5.2641 2.8314 1.4476 0
+.2727 1.6068 1.2828 2
+-6.2394 4.6427 0.0632 0
 -4.4738 4.5591 -0.1458 3
 -5.5506 3.8964 -1.3985 0
 -6.7081 0.9923 0.6224 2
 -7.5442 2.5597 0.5118 0
 -6.8554 1.8134 -0.9499 1
+.1391 2.0447 0.0264 0
+.9077 1.1106 0.1214 1
+.9077 1.1106 0.1214 -6.99715
+.3612 -3.628 1.323 6.00416
+.4884 -3.5983 -0.4521 11.8428
+.4985 -2.5112 0.5308 6.07951
+-1.9534 -3.5752 0.5362 -4.26914
+-1.1883 -0.199 1.5176 14.2992
+-0.7165 -1.6046 2.5129 6.2134
+.7627 -1.4479 -0.8349 7.15053
+-1.003 -1.3584 -2.8848 32.043
+.0217 -2.6629 -2.2008 16.8009
+-2.8885 -1.5706 1.7543 -1.77076
+-2.0579 -3.6765 -1.7622 -7.05319
+-2.9259 -2.1146 -1.7672 33.6663
+.0353 0.1785 2.542 48.8869
+.6325 -1.3323 1.8306 1.44108
+.7271 1.177 0.3594 27.9872
+.3374 -0.2942 -2.961 13.6459
+.6036 1.0859 -2.1126 98.521
+-3.2034 -0.5041 -1.0881 8.44805
+-5.1809 -1.8679 0.9687 -6.07448
+-4.6025 -2.4721 -0.6025 -6.52057
+-4.3385 -3.4329 0.8725 -4.12716
+.191 1.3217 -2.8354 -10.5968
+-4.0905 0.6312 1.6028 21.8745
+.8131 1.4776 2.5103 -0.774194
+.9137 2.2936 1.3739 -2.51806
+.159 2.5738 1.2698 151.494
+.6606 -0.4593 2.1396 2.60004
+.2007 -1.4419 0.7311 2.29272
+-3.3002 2.3589 0.0094 461.065
+-4.377 1.6962 -1.2433 43.4649
+.2593 1.4547 -1.7445 -6.26082
+.6863 2.7674 -0.6775 -8.55931
+.746 -0.9031 1.204 -1.29544
+.1212 -0.8867 -0.4582 31.5177
+-5.2641 2.8314 1.4476 21.5516
+.2727 1.6068 1.2828 -2.57271
+-6.2394 4.6427 0.0632 -9.24392
+-4.4738 4.5591 -0.1458 62.5211
+-5.5506 3.8964 -1.3985 -10.3613
+-6.7081 0.9923 0.6224 -7.08885
+-7.5442 2.5597 0.5118 -11.4252
+-6.8554 1.8134 -0.9499 3.80444
+.1391 2.0447 0.0264 -7.88713
 43 44
+34 44
+34 44
 31 34
 22 34
+16 34
+9 16
+7 9
+7 34
+3 34
+28 34
 33 34
+2 3
+3 28
+14 28
 27 28
 28 33
+6 14
+13 14
 14 27
 24 27
 27 36
 33 36
+36 44
 43 44
 25 36
 25 26
 26 32
 32 43
 36 43
 24 26
 26 29
+13 29
+23 29
 29 35
+35 38
 29 38
 29 38
 26 29
 17 29
 17 26
 26 32
 22 32
+6 23
+6 13
+10 23
 19 23
+23 40
 35 40
 40 41
 19 21
+10 21
+6 10
+4 6
 37 38
 37 41
 29 30
+30 38
 38 39
+17 30
+16 17
 17 22
+18 30
+12 18
 18 30
 20 30
 30 42
 39 42
+11 12
+9 11
+9 16
 12 20
 20 21
+11 21
+4 11
+2 4
+9 11
+20 21
+20 40
 40 42
 41 42
 31 32
 32 43
+41 42
 39 41
 38 39
+32 44
+32 35
+34 35
+32 35
+23 35
+17 35
+10 17
+8 10
+8 35
+4 35
+29 35
+34 35
+3 4
+4 29
+15 29
+28 29
+29 34
+7 15
+14 15
+15 28
+25 28
+28 37
+34 37
+34 37
+37 44
+26 37
+26 27
+27 33
+33 44
+37 44
+25 27
+27 30
+14 30
+24 30
+30 36
+36 39
+30 39
+30 39
+27 30
+18 30
+18 27
+27 33
+23 33
+7 24
+7 14
+11 24
+20 24
+24 41
+36 41
+41 42
+20 22
+11 22
+7 11
+5 7
+38 39
+38 42
+30 31
+31 39
+39 40
+18 31
+17 18
+18 23
+19 31
+13 19
+19 31
+21 31
+31 43
+40 43
+12 13
+10 12
+10 17
+13 21
+21 22
+12 22
+5 12
+3 5
+10 12
+21 22
+21 41
+41 43
+42 43
+32 33
+33 44
+42 43
+40 42
+39 40

tests/regression/Tesselation/3/post/NonConvexEnvelope.r3d

-              r06f4ef6
+              rb6da28
 # All atoms as spheres
+.939662 -3.01666 0.414493    0.1     1. 1. 1.
+  -0.152738 -1.94716 0.354093   0.1     1. 1. 1.
+.0659622 -1.03376 -0.880907  0.1     1. 1. 1.
+  -1.50434 -2.59696 0.0723932   0.1     1. 1. 1.
+  -0.0717378 -1.05346 1.57779   0.1     1. 1. 1.
+.52186 -0.603155 -0.873807   0.1     1. 1. 1.
+  -0.346038 -1.95996 -2.03011   0.1     1. 1. 1.
+  -2.63434 -1.74086 0.647893    0.1     1. 1. 1.
+  -1.61364 -2.66266 -1.47131    0.1     1. 1. 1.
+.36626 -0.519255 1.65039     0.1     1. 1. 1.
+.74646 0.246745 0.389693     0.1     1. 1. 1.
+.78606 0.287745 -2.09451     0.1     1. 1. 1.
+  -2.65324 -0.381955 -0.0548068         0.1     1. 1. 1.
+  -3.97304 -2.44796 0.426993    0.1     1. 1. 1.
+.21726 0.635145 0.478793     0.1     1. 1. 1.
+.13516 0.931145 -1.97401     0.1     1. 1. 1.
+  -3.80794 0.459345 0.492693    0.1     1. 1. 1.
+.34736 1.81094 1.44919       0.1     1. 1. 1.
+.76986 1.05884 -0.855107     0.1     1. 1. 1.
+.05806 -0.522555 1.01199     0.1     1. 1. 1.
+  -3.82684 1.81824 -0.210007    0.1     1. 1. 1.
+.16496 1.66244 -0.848507     0.1     1. 1. 1.
+.48576 -0.422855 0.476393    0.1     1. 1. 1.
+  -4.98154 2.65954 0.337493     0.1     1. 1. 1.
+.91796 1.03174 0.331693      0.1     1. 1. 1.
+  -5.00044 4.01854 -0.365207    0.1     1. 1. 1.
+  -6.30524 1.93554 0.0833932    0.1     1. 1. 1.
+.32406 1.08574 0.0829932     0.1     1. 1. 1.
 .777562 -3.65286 1.28459     0.1     1. 1. 1.
 …
 .55546 2.01984 -0.0120068    0.1     1. 1. 1.
-.939662 -3.01666 0.414493    0.1     1. 1. 1.
-  -0.152738 -1.94716 0.354093   0.1     1. 1. 1.
-.0659622 -1.03376 -0.880907  0.1     1. 1. 1.
-  -1.50434 -2.59696 0.0723932   0.1     1. 1. 1.
-  -0.0717378 -1.05346 1.57779   0.1     1. 1. 1.
-.52186 -0.603155 -0.873807   0.1     1. 1. 1.
-  -0.346038 -1.95996 -2.03011   0.1     1. 1. 1.
-  -2.63434 -1.74086 0.647893    0.1     1. 1. 1.
-  -1.61364 -2.66266 -1.47131    0.1     1. 1. 1.
-.36626 -0.519255 1.65039     0.1     1. 1. 1.
-.74646 0.246745 0.389693     0.1     1. 1. 1.
-.78606 0.287745 -2.09451     0.1     1. 1. 1.
-  -2.65324 -0.381955 -0.0548068         0.1     1. 1. 1.
-  -3.97304 -2.44796 0.426993    0.1     1. 1. 1.
-.21726 0.635145 0.478793     0.1     1. 1. 1.
-.13516 0.931145 -1.97401     0.1     1. 1. 1.
-  -3.80794 0.459345 0.492693    0.1     1. 1. 1.
-.34736 1.81094 1.44919       0.1     1. 1. 1.
-.76986 1.05884 -0.855107     0.1     1. 1. 1.
-.05806 -0.522555 1.01199     0.1     1. 1. 1.
-  -3.82684 1.81824 -0.210007    0.1     1. 1. 1.
-.16496 1.66244 -0.848507     0.1     1. 1. 1.
-.48576 -0.422855 0.476393    0.1     1. 1. 1.
-  -4.98154 2.65954 0.337493     0.1     1. 1. 1.
-.91796 1.03174 0.331693      0.1     1. 1. 1.
-  -5.00044 4.01854 -0.365207    0.1     1. 1. 1.
-  -6.30524 1.93554 0.0833932    0.1     1. 1. 1.
-.32406 1.08574 0.0829932     0.1     1. 1. 1.
 # All tesselation triangles
 …
   BACKFACE  0.3 0.3 1.0   0 0
 .67566 1.42984 -1.78291      7.55546 2.01984 -0.0120068      7.32406 1.08574 0.0829932       1. 0. 0.
 .67566 1.42984 -1.78291      5.53756 -0.911555 -0.496607     7.32406 1.08574 0.0829932       1. 0. 0.
 .16236 -0.927955 1.16559     5.53756 -0.911555 -0.496607     7.32406 1.08574 0.0829932       1. 0. 0.
+.32406 1.08574 0.0829932     5.67566 1.42984 -1.78291        7.55546 2.01984 -0.0120068      1. 0. 0.
+.32406 1.08574 0.0829932     5.67566 1.42984 -1.78291        5.53756 -0.911555 -0.496607     1. 0. 0.
+.32406 1.08574 0.0829932     6.16236 -0.927955 1.16559       5.53756 -0.911555 -0.496607     1. 0. 0.
 .60736 1.29684 -2.87381      5.67566 1.42984 -1.78291        5.53756 -0.911555 -0.496607     1. 0. 0.
 …
 .07696 -0.484155 2.10119     6.16236 -0.927955 1.16559       5.68906 1.58194 1.24439         1. 0. 0.
 .16236 -0.927955 1.16559     5.68906 1.58194 1.24439         7.32406 1.08574 0.0829932       1. 0. 0.
 .68906 1.58194 1.24439       7.55546 2.01984 -0.0120068      7.32406 1.08574 0.0829932       1. 0. 0.
+.32406 1.08574 0.0829932     6.16236 -0.927955 1.16559       5.68906 1.58194 1.24439         1. 0. 0.
+.32406 1.08574 0.0829932     5.68906 1.58194 1.24439         7.55546 2.01984 -0.0120068      1. 0. 0.
 .22946 1.45274 2.47189       4.33006 2.26874 1.33549         5.68906 1.58194 1.24439         1. 0. 0.

tests/regression/testsuite-analysis.at

-              r06f4ef6
+              rb6da28
 AT_KEYWORDS([analysis])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/1/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 3 -C E --elements 1 8 --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-end 20], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 --select-all-molecules --pair-correlation --elements 1 8 --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-end 20], 0, [stdout], [stderr])
 AT_CHECK([fgrep "Begin of PairCorrelation" stdout], 0, [ignore], [ignore])
 #AT_CHECK([file=output.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/1/post/$file], 0, [ignore], [ignore])
 …
 AT_KEYWORDS([analysis])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 3 -C E --elements 1 8 --output-file output-5.csv --bin-output-file bin_output-5.csv --bin-start 0 --bin-end 5], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 --select-all-molecules --pair-correlation --elements 1 8 --output-file output-5.csv --bin-output-file bin_output-5.csv --bin-start 0 --bin-end 5], 0, [stdout], [stderr])
 #AT_CHECK([file=output-5.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=bin_output-5.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 3 -C E --elements 1 8 --output-file output-10.csv --bin-output-file bin_output-10.csv --bin-start 5 --bin-end 10], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 --select-all-molecules --pair-correlation --elements 1 8 --output-file output-10.csv --bin-output-file bin_output-10.csv --bin-start 5 --bin-end 10], 0, [stdout], [stderr])
 #AT_CHECK([file=output-10.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=bin_output-10.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 3 -C E --elements 1 8 --output-file output-20.csv --bin-output-file bin_output-20.csv --bin-start 10 --bin-end 20], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 --select-all-molecules --pair-correlation --elements 1 8 --output-file output-20.csv --bin-output-file bin_output-20.csv --bin-start 10 --bin-end 20], 0, [stdout], [stderr])
 #AT_CHECK([file=output-20.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=bin_output-20.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/2/post/$file], 0, [ignore], [ignore])
 …
 AT_KEYWORDS([analysis])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/3/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 7 -C P --elements 1 --position 10. 10. 10. --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-end 20], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 7 --select-all-molecules --point-correlation --elements 1 --position "10., 10., 10." --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-end 20], 0, [stdout], [stderr])
 AT_CHECK([fgrep "Begin of CorrelationToPoint" stdout], 0, [ignore], [ignore])
 #AT_CHECK([file=output.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/3/post/$file], 0, [ignore], [ignore])
 …
 AT_KEYWORDS([analysis])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/4/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 3 -I -C S --elements 1 --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-width 1. --bin-end 20 --molecule-by-id 208], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -I --select-all-molecules --unselect-molecule-by-id 207 --surface-correlation --elements 1 --output-file output.csv --bin-output-file bin_output.csv --bin-start 0 --bin-width 1. --bin-end 20 --molecule-by-id 207], 0, [stdout], [stderr])
 AT_CHECK([fgrep "Begin of CorrelationToSurface" stdout], 0, [ignore], [ignore])
 #AT_CHECK([file=output.csv; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/4/post/$file], 0, [ignore], [ignore])
 …
 #AT_KEYWORDS([analysis])
 #AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Analysis/5/pre/test.conf .], 0)
 #AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 3 -m 0], 0, [stdout], [stderr])
+#AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -m 0], 0, [stdout], [stderr])
 #AT_CHECK([fgrep "eigenvalue = 4382.53," stdout], 0, [ignore], [ignore])
 #AT_CHECK([fgrep "eigenvalue = 4369.24," stdout], 0, [ignore], [ignore])

tests/regression/testsuite-domain.at

-              r06f4ef6
+              rb6da28
 AT_SETUP([Domain - defining simulation domain])
 AT_KEYWORDS([domain])
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -B 10 0 10 0 0 10], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -o pcp -B "10, 0, 10, 0, 0, 10"], 0, [stdout], [stderr])
 AT_CHECK([fgrep "BoxLength" test.conf], 0, [stdout], [stderr])
 AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/1/post/test.conf], 0, [stdout], [stderr])
 …
 AT_KEYWORDS([domain])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/2/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -b 15 0 15 0 0 15], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -b "15, 0, 15, 0, 0, 15"], 0, [stdout], [stderr])
 AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/2/post/test.conf], 0, [stdout], [stderr])
 AT_CLEANUP
 …
 AT_KEYWORDS([domain])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/3/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -c 5 10 15], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -c "5, 10, 15"], 0, [stdout], [stderr])
 AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/3/post/test.conf], 0, [stdout], [stderr])
 AT_CLEANUP
 …
 AT_KEYWORDS([domain])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/4/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -O], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -O], 0, [stdout], [stderr])
 AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/4/post/test.conf], 0, [stdout], [stderr])
 AT_CLEANUP
 …
 AT_KEYWORDS([domain])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/5/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -s 0.5 1. 0.9], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -s "0.5, 1., 0.9"], 0, [stdout], [stderr])
 AT_CHECK([diff test.conf ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/5/post/test.conf], 0, [stdout], [stderr])
 AT_CLEANUP
 …
 AT_KEYWORDS([domain])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -d 1 1 1], 0, [stdout], [stderr])
 AT_CHECK([file=test.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
 AT_CHECK([file=test.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
 AT_CHECK([file=test.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -o xyz -d "1, 1, 1"], 0, [stdout], [stderr])
+AT_CHECK([file=test.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf test-x.conf], 0)
 AT_CHECK([../../molecuilder test-x.conf -e ${abs_top_srcdir}/src/ -d 2 1 1], 0, [stdout], [stderr])
 AT_CHECK([file=test-x.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
 AT_CHECK([file=test-x.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
 AT_CHECK([file=test-x.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test-x.conf -e ${abs_top_srcdir}/src/ -o xyz -d "2, 1, 1"], 0, [stdout], [stderr])
+AT_CHECK([file=test-x.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-x.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([file=test-x.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf test-y.conf], 0)
 AT_CHECK([../../molecuilder test-y.conf -e ${abs_top_srcdir}/src/ -d 1 2 1], 0, [stdout], [stderr])
 AT_CHECK([file=test-y.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
 AT_CHECK([file=test-y.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
 AT_CHECK([file=test-y.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test-y.conf -e ${abs_top_srcdir}/src/ -o xyz -d "1, 2, 1"], 0, [stdout], [stderr])
+AT_CHECK([file=test-y.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-y.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([file=test-y.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/pre/test.conf test-z.conf], 0)
 AT_CHECK([../../molecuilder test-z.conf -e ${abs_top_srcdir}/src/ -d 1 1 2], 0, [stdout], [stderr])
 AT_CHECK([file=test-z.conf.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
 AT_CHECK([file=test-z.conf.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
 AT_CHECK([file=test-z.conf.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test-z.conf -e ${abs_top_srcdir}/src/ -o xyz -d "1, 1, 2"], 0, [stdout], [stderr])
+AT_CHECK([file=test-z.xyz;sort -n $file | grep -v "Created by" >$file-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test-z.xyz;sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Domain/6/post/$file  | grep -v "Created by" >$file-sorted2], 0, [ignore], [ignore])
+AT_CHECK([file=test-z.xyz; diff $file-sorted $file-sorted2], 0, [ignore], [ignore])
 #AT_CHECK([/bin/false], 12, [ignore], [ignore])
 AT_CLEANUP

tests/regression/testsuite-filling.at

-              r06f4ef6
+              rb6da28
 H       0.758602 0.     -0.504284
 ]])
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 3 -F water.xyz --MaxDistance -1 --distances 3.1 3.1 3.1  --lengths 2.1 0. 0. --DoRotate 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -F water.xyz --MaxDistance -1 --distances "3.1, 3.1, 3.1"  --lengths "2.1, 0., 0." --DoRotate 0], 0, [stdout], [stderr])
 AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Filling/1/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([filling])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Filling/2/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 3 -u 1.3], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 --select-molecule-by-id 0 -u 1.3], 0, [stdout], [stderr])
 #AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Filling/2/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP

tests/regression/testsuite-fragmentation.at

-              r06f4ef6
+              rb6da28
 AT_SETUP([Fragmentation - Fragmentation])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Fragmentation/2/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 1 -f 0 --distance 1.55 --order 2], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2], 0, [ignore], [ignore])
 AT_CHECK([ls -l BondFragment*.conf | wc -l], 0, [5
 ], [ignore])
 …
 AT_SETUP([Fragmentation - BROKEN: Fragmentation is at MaxOrder])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Fragmentation/3/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 1 -f 0 --distance 1.55 --order 2], 0, [ignore], [ignore])
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 1 -f 0 --distance 1.55 --order 2], [ignore], [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 --select-molecule-by-id 0 -f ./BondFragment --distance 1.55 --order 2], [ignore], [ignore], [ignore])
 AT_CLEANUP

tests/regression/testsuite-graph.at

-              r06f4ef6
+              rb6da28
 AT_KEYWORDS([graph])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Graph/1/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 3 -D 2.], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -D 2.], 0, [stdout], [stderr])
 AT_CHECK([fgrep -c "No rings were detected in the molecular structure." stdout], 0, [1
 ], [ignore])
 …
 AT_KEYWORDS([graph])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Graph/2/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 3 -I], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 3 -I], 0, [stdout], [stderr])
 AT_CHECK([fgrep "I scanned 31 molecules." stdout], 0, [ignore], [ignore])
 AT_CLEANUP

tests/regression/testsuite-molecules.at

-              r06f4ef6
+              rb6da28
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/1/pre/test.* .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 4 -A test.dbond --molecule-by-id 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 4 --select-molecule-by-id 0 -A test.dbond], 0, [stdout], [stderr])
 AT_CHECK([fgrep "Looking for atoms 2 and 9." stdout], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/2/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 1 -j test.dbond --molecule-by-id 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 --select-molecule-by-id 0 -j test.dbond], 0, [stdout], [stderr])
 AT_CHECK([file=test.dbond; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -v 1 -J test.adj --molecule-by-id 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -v 1 --select-molecule-by-id 0 -J test.adj], 0, [stdout], [stderr])
 AT_CHECK([file=test.adj; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/2/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/3/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -S test.ekin --molecule-by-id 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -S test.ekin], 0, [stdout], [stderr])
 AT_CHECK([file=test.ekin; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/3/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/4/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -L teststep --start-step 0 --end-step 1 --molecule-by-id 0 --id-mapping 1], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -L teststep --start-step 0 --end-step 1 --id-mapping 1], 0, [stdout], [stderr])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/5/pre/test.* .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -P test.forces --molecule-by-id 0], 134, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -P test.forces], 0, [stdout], [stderr])
 #AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/5/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/6/pre/test.* .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -t 1. 1. 1. --molecule-by-id 0 --periodic 0], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -t "1., 1., 1." --periodic 0], 0, [stdout], [stderr])
 AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/6/post/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/6/pre/test2.* .], 0)
+AT_CHECK([../../molecuilder -i test2.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -t "-1., -1., -1." --periodic 0], 0, [stdout], [stderr])
+AT_CHECK([file=test2.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/6/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/7/pre/test.* .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -t 12. 12. 12. --molecule-by-id 0 --periodic 1], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -t "12., 12., 12." --periodic 1], 0, [stdout], [stderr])
 AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/7/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([Molecules])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/8/pre/test.* .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -m 1], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -m 0], 0, [stdout], [stderr])
 #AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Molecules/8/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP

tests/regression/testsuite-simple_configuration.at

-              r06f4ef6
+              rb6da28
 AT_KEYWORDS([configuration])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/2/pre/test.xyz .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -p test.xyz], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -o mpqc pcp xyz -p test.xyz], 0, [ignore], [ignore])
 AT_CHECK([fgrep "Ion_Type1_1" test.conf], 0, [Ion_Type1_1       10.000000000    10.000000000    10.000000000    0 # molecule nr 0
 ], [ignore])
 AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=test.conf.in; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=test.conf.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/2/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test.in; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/2/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/2/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 # 3. add atom
+# 3a. add atom
 AT_SETUP([Simple configuration - adding atom])
 AT_KEYWORDS([configuration])
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -a 1 --position 10. 10. 10.], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -o mpqc pcp xyz -a 1 --position "10., 10., 10."], 0, [ignore], [ignore])
 AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test.conf.in; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test.conf.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test.in; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/3/post/$file], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test2.conf -e ${abs_top_srcdir}/src/ -o mpqc pcp xyz -a 1 --position "0., 0., -1."], 134, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_SETUP([Simple configuration - Changing element])
 AT_KEYWORDS([configuration])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/pre/test.conf test.conf], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -E 0 --element 6], 0, [ignore], [ignore])
 AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/post/$file], 0, [ignore], [ignore])
+AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/pre/test.xyz test.xyz], 0)
+AT_CHECK([../../molecuilder -i test.xyz -e ${abs_top_srcdir}/src/ --select-atom-by-id 0 -E 6 ], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/4/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_KEYWORDS([configuration])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -r 0], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -o mpqc pcp xyz --select-atom-by-id 0 -r], 0, [ignore], [ignore])
 AT_CHECK([file=test.conf; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=test.conf.in; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=test.conf.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test.in; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/post/$file], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz; diff -I '.*Created by molecuilder.*' $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/5/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_SETUP([Simple configuration - invalid commands on empty configs])
 AT_KEYWORDS([configuration])
+AT_CHECK([../../molecuilder empty.conf -e ${abs_top_srcdir}/src/ -t -s -b -E -c -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "Not enough" stderr], 0, [1
+], [ignore])
+AT_CHECK([../../molecuilder -i empty.conf -e ${abs_top_srcdir}/src/ -t -s -b -E -c -b -a -U -T -u], 134, [ignore], [stderr])
 AT_CLEANUP
 …
 AT_KEYWORDS([configuration])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/7/pre/test.conf .], 0)
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -t], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -s -b -E -c -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -b -E -c -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -E -c -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -c -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -t], 134, [ignore], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -s -b -E -c -b -a -U -T -u], 134, [ignore], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -b -E -c -b -a -U -T -u], 134, [ignore], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -E -c -b -a -U -T -u], 134, [ignore], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -c -b -a -U -T -u], 134, [ignore], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -b -a -U -T -u], 134, [ignore], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -a -U -T -u], 134, [ignore], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -U -T -u], 134, [ignore], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -T -u], 134, [ignore], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -u], 134, [ignore], [stderr])
 AT_CLEANUP
 …
 AT_KEYWORDS([configuration])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/pre/test.* .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -R 7. --position 7.283585982 3.275186040 3.535886037], 0, [stdout], [stderr])
 AT_CHECK([sort -n test.conf.xyz | grep -v "Created by" >test.conf.xyz-sorted], 0, [ignore], [ignore])
 AT_CHECK([sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/test.conf.xyz  | grep -v "Created by" >${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/test.conf.xyz-sorted], 0, [ignore], [ignore])
 AT_CHECK([file=test.conf.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ -o xyz -R 7. --position "7.283585982, 3.275186040, 3.535886037"], 0, [stdout], [stderr])
+AT_CHECK([sort -n test.xyz | grep -v "Created by" >test.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([sort -n ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/test.xyz  | grep -v "Created by" >${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/test.xyz-sorted], 0, [ignore], [ignore])
+AT_CHECK([file=test.xyz-sorted; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Simple_configuration/8/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP

tests/regression/testsuite-specifics.at

r06f4ef6	rb6da28
4	4	AT_KEYWORDS([options])
5	5	AT_CHECK([pwd],[ignore],[ignore])
6		AT_CHECK([../../molecuilder test.conf -v 1 -M test], 0, [stdout], [ignore])
	6	AT_CHECK([../../molecuilder -i test.conf -v 1 -M test], 0, [stdout], [ignore])
7	7	AT_CHECK([fgrep "Setting MPQC basis to test." stdout], 0, [ignore], [ignore])
8	8	AT_CLEANUP

tests/regression/testsuite-standard_options.at

-              r06f4ef6
+              rb6da28
 AT_SETUP([Standard Options - no element database])
 AT_KEYWORDS([options])
+AT_CHECK([../../molecuilder -e], 255, [ignore], [stderr])
+AT_CHECK([fgrep "Not enough or invalid arguments" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder -e], 134, [ignore], [stderr])
 AT_CLEANUP
 …
 Helium  He      1       18      p       2       4.003   1.5     1.4
 ]])
 AT_CHECK([../../molecuilder test.conf -e ./], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ./], 0, [stdout], [stderr])
 AT_CHECK([grep -E "Using.*as elements database." stdout], 0, [ignore], [ignore])
 AT_CHECK([fgrep "Element list loaded successfully." stdout], 0, [ignore], [ignore])
 …
        0.      0.
 ]])
 AT_CHECK([../../molecuilder test.conf -g bondlength.db], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -g bondlength.db], 0, [stdout], [stderr])
 AT_CHECK([grep -E "Using.*as bond length table." stdout], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_SETUP([Standard Options - fast trajectories])
 AT_KEYWORDS([options])
 AT_CHECK([../../molecuilder test.conf -n 1], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -n 1], 0, [stdout], [stderr])
 AT_CHECK([fgrep "I won't parse trajectories" stdout], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_SETUP([Standard Options - molecule default name])
 AT_KEYWORDS([options])
 AT_CHECK([../../molecuilder test.conf -X test], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -X test], 0, [stdout], [stderr])
 AT_CHECK([fgrep "Default name of new molecules set to test." stdout], 0, [ignore], [ignore])
 AT_CLEANUP

tests/regression/testsuite-tesselation.at

-              r06f4ef6
+              rb6da28
 AT_KEYWORDS([Tesselation])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/1/pre/* .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -N 0 --sphere-radius 4. --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -N 4. --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
 AT_CHECK([file=NonConvexEnvelope.dat; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/1/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=NonConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/1/post/$file], 0, [ignore], [ignore])
+#AT_CHECK([file=NonConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/1/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_SETUP([Tesselation - Convex Envelope])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/2/pre/* .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -o 0 --convex-file ConvexEnvelope --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 --convex-envelope --convex-file ConvexEnvelope --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
 AT_CHECK([file=ConvexEnvelope.dat; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=ConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/2/post/$file], 0, [ignore], [ignore])
+#AT_CHECK([file=ConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([fgrep "tesselated volume area is 16.4016 angstrom^3" stdout], 0, [ignore], [ignore])
 AT_CHECK([diff ConvexEnvelope.dat NonConvexEnvelope.dat], 0, [ignore], [ignore])
 …
 AT_SETUP([Tesselation - Big non-Convex Envelope])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/3/pre/* .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -N 0 --sphere-radius 4. --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 -N 4. --nonconvex-file NonConvexEnvelope], 0, [stdout], [stderr])
 AT_CHECK([file=NonConvexEnvelope.dat; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/3/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=NonConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/3/post/$file], 0, [ignore], [ignore])
+#AT_CHECK([file=NonConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/3/post/$file], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 #AT_SETUP([Tesselation - big convex Envelope])
 #AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/4/pre/* .], 0)
 #AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -o ConvexEnvelope NonConvexEnvelope], 0, [stdout], [stderr])
+#AT_CHECK([../../molecuilder -i test.conf -e ${abs_top_srcdir}/src/ --select-molecule-by-id 0 --convex-envelope ConvexEnvelope NonConvexEnvelope], 0, [stdout], [stderr])
 #AT_CHECK([file=ConvexEnvelope.dat; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/4/post/$file], 0, [ignore], [ignore])
 #AT_CHECK([file=ConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/Tesselation/4/post/$file], 0, [ignore], [ignore])

Context Navigation

Changes in / [06f4ef6:b6da28]

Legend: