Diff [c39cc4a287829a1c0da6147754970a5045cfb269:bdb143247eccc7c91b16ff0f4b58e8e1946856d2] for / – MoleCuilder

configure.ac

-              rc39cc4
+              rbdb143
 # Boost libraries
 AX_BOOST_BASE([1.33.1])
 #AX_BOOST_PROGRAM_OPTIONS
+AX_BOOST_BASE([1.40])
+AX_BOOST_PROGRAM_OPTIONS
 #AX_BOOST_FOREACH
 #AX_BOOST_FILESYSTEM
 AX_BOOST_THREAD
-#AX_BOOST_PROGRAM_OPTIONS
 #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.
 …
 # test suite
+AC_CONFIG_TESTDIR(tests)
+AC_CONFIG_FILES([tests/atlocal tests/Makefile])
+AC_CONFIG_FILES([tests/Tesselations/Makefile tests/Tesselations/defs])
+AC_CONFIG_FILES([tests/molecuilder], [chmod +x tests/molecuilder])
+AC_CONFIG_FILES([doc/molecuilder.xml])
+AC_CONFIG_FILES([Makefile src/Makefile doc/Makefile src/unittests/Makefile])
+AC_CONFIG_TESTDIR(tests/regression)
+AC_CONFIG_FILES([
+        tests/Makefile
+        tests/regression/atlocal
+        tests/regression/Makefile])
+AC_CONFIG_FILES([tests/regression/molecuilder], [chmod +x tests/regression/molecuilder])
+AC_CONFIG_FILES([
+        tests/Tesselations/Makefile
+        tests/Tesselations/defs])
+AC_CONFIG_FILES([
+        doc/molecuilder.xml])
+AC_CONFIG_FILES([
+        Makefile
+        doc/Makefile
+        src/Makefile
+        src/Actions/Makefile
+        src/UIElements/Makefile
+        src/unittests/Makefile])
 AC_OUTPUT

doc/Doxyfile

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

doc/class structure.uxf

-              rc39cc4
+              rbdb143
 // 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

-              rc39cc4
+              rbdb143
  *      Author: crueger
  */
+#include "Helpers/MemDebug.hpp"
 #include <string>
 …
 using namespace std;
+Action::state_ptr getEmptyState() {
+  return Action::state_ptr(Memory::ignore(new ActionState()));
+}
 // An empty state to indicate success
 Action::state_ptr Action::success = Action::state_ptr(Memory::ignore(new ActionState()));
 Action::state_ptr Action::failure = Action::state_ptr(Memory::ignore(new ActionState()));
+Action::state_ptr Action::success = getEmptyState();
+Action::state_ptr Action::failure = getEmptyState();
 Action::Action(std::string _name,bool _doRegister) :

src/Actions/ActionHistory.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "ActionHistory.hpp"

src/Actions/ActionRegistry.cpp

-              rc39cc4
+              rbdb143
  *      Author: crueger
  */
+#include "Helpers/MemDebug.hpp"
 #include "Actions/ActionRegistry.hpp"
 …
 using namespace std;
+/** Constructor for class ActionRegistry.
+ */
 ActionRegistry::ActionRegistry()
+{
+}
+/** Destructor for class ActionRegistry.
+ */
 ActionRegistry::~ActionRegistry()
+{
 …
+}
+/** Returns pointer to an action named by \a name.
+ * \param name name of action
+ * \return pointer to Action
+ */
 Action* ActionRegistry::getActionByName(const std::string name){
   map<const string,Action*>::iterator iter;
 …
+}
+/** States whether action is present or not.
+ * \note This iss needed as ActionRegistry::getActionByName() ASSERT()s that action is in map.
+ * \param name name of action
+ * \return true - Action present, false - Action absent
+ */
+bool ActionRegistry::isActionByNamePresent(const std::string name){
+  map<const string,Action*>::iterator iter;
+  iter = actionMap.find(name);
+  return iter!=actionMap.end();
+}
+/** Registers an Action with the ActionRegistry.
+ * \param *action pointer to Action.
+ */
 void ActionRegistry::registerAction(Action* action){
   pair<map<const string,Action*>::iterator,bool> ret;
+  //cout << "Trying to register action with name " << action->getName() << "." << endl;
   ret = actionMap.insert(pair<const string,Action*>(action->getName(),action));
   ASSERT(ret.second,"Two actions with the same name added to registry");
+}
+/** Unregisters an Action.
+ * \param *action pointer to Action.
+ */
+void ActionRegistry::unregisterAction(Action* action){
+  //cout << "Unregistering action with name " << action->getName() << "." << endl;
+  actionMap.erase(action->getName());
+}
+/** Returns an iterator pointing to the start of the map of Action's.
+ * \return begin iterator
+ */
+std::map<const std::string,Action*>::iterator ActionRegistry::getBeginIter()
+{
+  return actionMap.begin();
+}
+/** Returns an iterator pointing to the end of the map of Action's.
+ * \return end iterator
+ */
+std::map<const std::string,Action*>::iterator ActionRegistry::getEndIter()
+{
+  return actionMap.end();
+}
+/** Returns a const iterator pointing to the start of the map of Action's.
+ * \return constant begin iterator
+ */
+std::map<const std::string,Action*>::const_iterator ActionRegistry::getBeginIter() const
+{
+  return actionMap.begin();
+}
+/** Returns a const iterator pointing to the end of the map of Action's.
+ * \return constant end iterator
+ */
+std::map<const std::string,Action*>::const_iterator ActionRegistry::getEndIter() const
+{
+  return actionMap.end();
+}
+/** Prints the contents of the ActionRegistry \a &m to \a &ost.
+ * \param &ost output stream
+ * \param &m reference to ActionRegistry
+ * \return reference to the above out stream for concatenation
+ */
+ostream& operator<<(ostream& ost, const ActionRegistry& m)
+{
+  ost << "ActionRegistry contains:" << endl;
+  for (std::map<const std::string,Action*>::const_iterator iter = m.getBeginIter(); iter != m.getEndIter(); ++iter) {
+    ost << "\t" << iter->first << " with pointer " << iter->second << endl;
+  }
+  return ost;
+};
 CONSTRUCT_SINGLETON(ActionRegistry)

src/Actions/ActionRegistry.hpp

-              rc39cc4
+              rbdb143
 #define ACTIONREGISTRY_HPP_
+#include <iostream>
 #include <string>
 #include <map>
 …
 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*>::const_iterator getBeginIter() const;
+  std::map<const std::string,Action*>::iterator getEndIter();
+  std::map<const std::string,Action*>::const_iterator getEndIter() const;
 private:
 …
 };
+std::ostream& operator<<(std::ostream& ost, const ActionRegistry& m);
 #endif /* ACTIONREGISTRY_HPP_ */

src/Actions/ActionSequence.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Actions/ActionSequence.hpp"

src/Actions/ErrorAction.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <iostream>

src/Actions/MakroAction.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <string>

src/Actions/ManipulateAtomsProcess.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "ManipulateAtomsProcess.hpp"

src/Actions/MethodAction.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <iostream>

src/Actions/Process.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include "Process.hpp"
 …
 Process::Process(int _maxSteps, std::string _name, bool _doRegister) :
   Action(_name,_doRegister),
+  Observable("Process"),
   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/Descriptors/AtomDescriptor.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include "Descriptors/AtomDescriptor.hpp"
 #include "Descriptors/AtomDescriptor_impl.hpp"
 #include "World.hpp"
 #include "atom.hpp"
 #include <boost/bind.hpp>
+#include <cassert>
 #include <iostream>

src/Descriptors/AtomIdDescriptor.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "AtomIdDescriptor.hpp"

src/Descriptors/AtomTypeDescriptor.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Descriptors/AtomTypeDescriptor.hpp"

src/Descriptors/MoleculeDescriptor.cpp

-              rc39cc4
+              rbdb143
  *      Author: crueger
  */
+#include "Helpers/MemDebug.hpp"
 #include "Descriptors/MoleculeDescriptor.hpp"
 …
 #include <boost/bind.hpp>
-#include <cassert>
 #include <iostream>

src/Descriptors/MoleculeIdDescriptor.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "MoleculeIdDescriptor.hpp"

src/Exceptions/CustomException.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "CustomException.hpp"

src/Exceptions/LinearDependenceException.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "LinearDependenceException.hpp"

src/Exceptions/MathException.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "MathException.hpp"

src/Exceptions/SkewException.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "SkewException.hpp"

src/Exceptions/ZeroVectorException.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "ZeroVectorException.hpp"

src/Hbondangle.db

rc39cc4	rbdb143
	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

rc39cc4	rbdb143
	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

-              rc39cc4
+              rbdb143
  *      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;
 …
 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";
 …
+{
   if(!res){
     cout << "Assertion " << condition << " failed in file " << filename << " at line " << line << endl;
+    cout << "Assertion \"" << condition << "\" failed in file " << filename << " at line " << line << endl;
     cout << "Assertion Message: " << message << std::endl;
     while(true){
 …
   return ActionNames[defaultAction];
+}
+#endif

src/Helpers/MemDebug.cpp

-              rc39cc4
+              rbdb143
  */
+#ifndef NDEBUG
+#ifndef NO_MEMDEBUG
 #include <iostream>
 #include <cstdlib>
 …
 #include <boost/thread.hpp>
+#ifdef __GNUC__
+#include <execinfo.h>
+#include <cxxabi.h>
+#endif
 using namespace std;
+#ifndef NDBEGUG
+#ifndef NO_MEMDEBUG
+// we need our own low level mutexex, since we cannot assure the time of construction and destruction
+// otherwise
+#if defined(unix) || defined(__unix)
+#include <pthread.h>
+#include <cassert>
+#define mutex_t    pthread_mutex_t
+#define mutex_init PTHREAD_MUTEX_INITIALIZER
+#define mutex_lock(mtx) \
+  do{\
+    int res = pthread_mutex_lock(&(mtx));\
+    assert(!res && "Could not lock mutex!");\
+  }while(0)
+#define mutex_unlock(mtx) \
+  do{\
+    int res = pthread_mutex_unlock(&(mtx));\
+    assert(!res && "Could not unlock mutex!");\
+  }while(0)
+#else
+# error "No thread structure defined for this plattform..."
+#endif
 namespace Memory {
 …
       char file[length+1];
       int line;
+#ifdef __GNUC__  // function tracking only works with GCC
+      // function names can get looooong
+      enum {length2 = 256};
+      char function[length2+1];
+#endif
       size_t nbytes;
       bool isUsed;
 …
   };
+  boost::mutex memorylock;
+  mutex_t memorylock = mutex_init;
   // start and end of the doubly-linked list
 …
     for(entry_t *pos=begin;pos;pos=pos->next){
       cout << "\nChunk of " << pos->info.nbytes << " bytes" << " still available" << endl;
+#ifdef __GNUC__
+      cout << "Chunk reserved at: " << pos->info.function
+           << " (" << pos->info.file << ":" << pos->info.line  << ")" << endl;
+#else
       cout << "Chunk reserved at: " << pos->info.file << ":" << pos->info.line << endl;
+    }
+#endif
+    }
+  }
+  // Adds an entry to the linked list
+  void addEntry(entry_t *entry){
+    // check if the entry is already in the list
+    if(!entry->isIgnored)
+      return;
+    mutex_lock(Memory::memorylock);
+    entry->next=0;            // the created block is last in the list
+    entry->prev=Memory::end;  // the created block is last in the list
+    if(!Memory::begin){
+      // the list was empty... start a new one
+      Memory::begin=entry;
+    }
+    else {
+      // other blocks present... we can add to the last one
+      Memory::end->next=entry;
+    }
+    Memory::end=entry;
+    // update some global info
+    Memory::state  += entry->info.nbytes;
+    if(Memory::state>Memory::max){
+        Memory::max = Memory::state;
+    }
+    ++Memory::allocs;
+    // done with the list... it is safe to unlock now
+    mutex_unlock(Memory::memorylock);
+    entry->isIgnored = false;
+  }
 …
       return;
+    mutex_lock(memorylock);
     if(entry->prev){
       entry->prev->next = entry->next;
 …
       end = entry->prev;
+    }
+    Memory::state  -= entry->info.nbytes;
+    mutex_unlock(memorylock);
     entry->isIgnored = true;
+    Memory::state  -= entry->info.nbytes;
+  }
 …
     deleteEntry(entry);
+  }
+}
+void *operator new(size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
+  // we need to lock, so that no one changes the linked list while we are here
+  boost::mutex::scoped_lock guard(Memory::memorylock);
+#ifdef __GNUC__
+  // this function let's us find the caller's name
+  char* getCaller(){
+    // stack looks like this:
+    // getCaller();
+    // operator new();
+    // function_we_are_looking_for(); <-
+    const size_t max_depth = 3;
+    void* stack_addrs[max_depth];
+    size_t stack_depth;
+    char **stack_strings=0;
+    const char *func_name=0;
+    const char *toplevel = "Global scope";
+    char *retval=0;
+    // get the backtrace, depth three
+    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(entry_t::info_t::length2));
+    if(!dm_function){
+      // malloc failed... we are out of luck
+      throw std::bad_alloc();
+    }
+    // see if we found our function name
+    if(stack_depth==max_depth){
+      // find the mangled function name
+      char *begin = stack_strings[max_depth-1];
+      // 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
+        size_t sz = entry_t::info_t::length2;
+        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[max_depth-1];
+      }
+    }
+    else{
+      func_name = toplevel;
+    }
+    // now we copy the desired function name
+    if((retval = static_cast<char*>(malloc(strlen(func_name)+1)))){
+      // we know that the string will fit, so strcpy is safe here
+      strcpy(retval,func_name);
+    }
+    else{
+      free(stack_strings); // malloc()ed by backtrace_symbols
+      free(dm_function);
+      // uh-uh ... seems we are out of luck for allocations now
+      throw std::bad_alloc();
+    }
+    free(dm_function);
+    free(stack_strings); // malloc()ed by backtrace_symbols
+    return retval;
+  }
+#endif
+}
+#ifdef __GNUC__
+void *operator new(size_t nbytes,const char* file, int line, const char* func) throw(std::bad_alloc) {
   // to avoid allocations of 0 bytes if someone screws up
 …
+  }
+  // we got the space, so update the global info
+  Memory::state += nbytes;
+  if(Memory::state>Memory::max){
+    Memory::max = Memory::state;
+  }
+  Memory::allocs++;
+  // build the entry in front of the space
+  Memory::entry_t *entry = (Memory::entry_t*) res;
+  memset(res,0,entrySpace);
+  entry->info.nbytes = nbytes;
+  entry->info.isUsed = true;
+  strncpy(entry->info.file,file,Memory::entry_t::info_t::length);
+  entry->info.file[Memory::entry_t::info_t::length] = '\0';
+  entry->info.line=line;
+  strncpy(entry->info.function,func,Memory::entry_t::info_t::length2);
+  entry->info.function[Memory::entry_t::info_t::length2] = '\0';
+  // the space starts behind the info
+  entry->info.location = (char*)res + entrySpace;
+  // mark the block as not in the list (will be changed by addEntry)
+  entry->isIgnored = true;
+  Memory::addEntry(entry);
+  // get the checksum...
+  entry->checksum = Memory::calcChecksum(&entry->info);
+  // ok, space is prepared... the user can have it.
+  // the rest (constructor, deleting when something is thrown etc)
+  // is handled automatically
+  return entry->info.location;
+}
+#else
+void *operator new(size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
+  // to avoid allocations of 0 bytes if someone screws up
+  // allocation with 0 byte size are undefined behavior, so we are
+  // free to handle it this way
+  if(!nbytes) {
+    nbytes = 1;
+  }
+  // get the size of the entry, including alignment
+  static const size_t entrySpace = Memory::doAlign(sizeof(Memory::entry_t));
+  void *res;
+  if(!(res=malloc(entrySpace + nbytes))){
+    // new must throw, when space is low
+    throw std::bad_alloc();
+  }
   // build the entry in front of the space
 …
   entry->info.location = (char*)res + entrySpace;
+  // add the entry at the end of the list
+  entry->next=0;            // the created block is last in the list
+  entry->prev=Memory::end;  // the created block is last in the list
+  if(!Memory::begin){
+    // the list was empty... start a new one
+    Memory::begin=entry;
+  }
+  else {
+    // other blocks present... we can add to the last one
+    Memory::end->next=entry;
+  }
+  Memory::end=entry;
+  // mark the block as not in the list (will be changed by addEntry)
+  entry->isIgnored = true;
+  Memory::addEntry(entry);
   // get the checksum...
 …
+}
+#endif
 void *operator new(size_t nbytes) throw(std::bad_alloc) {
   // Just forward to the other operator, when we do not know from
   // where the allocation came
+#ifdef __GNUC__
+  // this might throw bad_alloc
+  char *caller = Memory::getCaller();
+  void* retval = 0;
+  // if this throws, we have to clean up the caller anyway
+  try{
+    retval = operator new(nbytes,"Unknown",0,caller);
+  }
+  catch(...)
+  {
+    free(caller); // malloc()ed by Memory::getCaller();
+    throw;
+  }
+  free(caller); // malloc()ed by Memory::getCaller();
+  return retval;
+#else
   return operator new(nbytes,"Unknown",0);
+}
+#endif
+}
+#ifdef __GNUC__
+void *operator new[] (size_t nbytes,const char* file, int line, const char* func) throw(std::bad_alloc) {
+  // The difference between new and new[] is just for compiler bookkeeping.
+  return operator new(nbytes,file,line,func);
+}
+#else
 void *operator new[] (size_t nbytes,const char* file, int line) throw(std::bad_alloc) {
 …
+}
+#endif
 void *operator new[] (size_t nbytes) throw(std::bad_alloc) {
   // Forward again
+#ifdef __GNUC__
+  // this might throw bad_alloc
+    char *caller = Memory::getCaller();
+    void *retval=0;
+    // if this throws, we have to clean up the caller anyway
+    try{
+      retval = operator new[] (nbytes,"Unknown",0,caller);
+    }
+    catch(...)
+    {
+      free(caller); // malloc()ed by Memory::getCaller();
+      throw;
+    }
+    free(caller); // malloc()ed by Memory::getCaller();
+    return retval;
+#else
   return operator new[] (nbytes,"Unknown",0);
+#endif
+}
 …
     return;
+  }
-  // we need to lock, so the linked list does not changed while we are in here
-  boost::mutex::scoped_lock guard(Memory::memorylock);
   // get the size for the entry, including alignment

src/Helpers/MemDebug.hpp

-              rc39cc4
+              rbdb143
 #endif
+#include <new>
+// some light header files, that do weird new stuff and therefore need
+// to be loaded before the define
+#include <string>
+#include <boost/optional.hpp>
+#include <boost/shared_ptr.hpp>
+#include <boost/function.hpp>
+#include <boost/program_options.hpp>
 namespace Memory {
 …
+  }
+}
+#ifdef __GNUC__
+void *operator new   (size_t nbytes,const char* file, int line, const char* func) throw(std::bad_alloc);
+void *operator new[] (size_t nbytes,const char* file, int line, const char* func) throw(std::bad_alloc);
+#else
 void *operator new   (size_t nbytes,const char* file, int line) throw(std::bad_alloc);
 void *operator new[] (size_t nbytes,const char* file, int line) throw(std::bad_alloc);
+#endif
 void operator delete   (void *ptr,const char*, int) throw();
 void operator delete[] (void *ptr,const char*, int) throw();
 /**
 …
  * version that allows tracking.
  */
+#ifdef __GNUC__
+#define new new(__FILE__,__LINE__,__PRETTY_FUNCTION__)
+#else
 #define new new(__FILE__,__LINE__)
+#endif
 #endif
 #endif
+#ifdef NDEBUG
+#undef MEMDEBUG
+#endif
 #ifndef MEMDEBUG

src/Legacy/oldmenu.cpp

-              rc39cc4
+              rbdb143
+ *
  */
+#include "Helpers/MemDebug.hpp"
 #include "Legacy/oldmenu.hpp"
 …
 #include "Menu/DisplayMenuItem.hpp"
 #include "Menu/SubMenuItem.hpp"
+#include "Actions/MapOfActions.hpp"
 #include "Actions/MethodAction.hpp"
 #include "Actions/ErrorAction.hpp"
 …
         Dialog *dialog = UIFactory::getInstance().makeDialog();
         first = World::getInstance().createAtom();
+        std::vector<element *> elements;
         dialog->queryVector("Please enter coordinates: ",&first->x,World::getInstance().getDomain(), false);
         dialog->queryElement("Please choose element: ",&first->type);
+        dialog->queryElement("Please choose element: ",&elements);
         if(dialog->display()){
+          mol->AddAtom(first);  // add to molecule
+          if (elements.size() == 1) {
+            first->type = elements.at(0);
+            mol->AddAtom(first);  // add to molecule
+          } else {
+            DoeLog(1) && (eLog() << Verbose(1) << "Unequal to one element given for element of new atom." << endl);
+          }
+        }
         else{
 …
 void oldmenu::RemoveAtoms(molecule *mol)
+{
   atom *first, *second;
+  atom *second;
   int axis;
   double tmp1, tmp2;
 …
       break;
     case 'b':
       second = mol->AskAtom("Enter number of atom as reference point: ");
       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(second->x) > tmp1*tmp1) // distance to first above radius ...
           mol->RemoveAtom(first);
+      {
+        second = mol->AskAtom("Enter number of atom as reference point: ");
+        Log() << Verbose(0) << "Enter radius: ";
+        cin >> tmp1;
+        molecule::iterator runner;
+        for (molecule::iterator iter = mol->begin(); iter != mol->end(); ) {
+          runner = iter++;
+          if ((*runner)->x.DistanceSquared((*runner)->x) > tmp1*tmp1) // distance to first above radius ...
+            mol->RemoveAtom((*runner));
+        }
+      }
       break;
 …
       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[axis] < tmp1) || (first->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);
+      molecule::iterator runner;
+      for (molecule::iterator iter = mol->begin(); iter != mol->end(); ) {
+        runner = iter++;
+        if (((*runner)->x[axis] < tmp1) || ((*runner)->x[axis] > tmp2)) {// out of boundary ...
+          //Log() << Verbose(0) << "Atom " << *(*runner) << " with " << (*runner)->x.x[axis] << " on axis " << axis << " is out of bounds [" << tmp1 << "," << tmp2 << "]." << endl;
+          mol->RemoveAtom((*runner));
+        }
+      }
 …
         min[i] = 0.;
+      second = mol->start;
+      while ((second->next != mol->end)) {
+        second = second->next; // advance
+        Z = second->type->Z;
+      for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+        Z = (*iter)->type->Z;
         tmp1 = 0.;
         if (first != second) {
           x = first->x - second->x;
+        if (first != (*iter)) {
+          x = first->x - (*iter)->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;
+        //Log() << Verbose(0) << "Bond length between Atom " << first->nr << " and " << ((*iter)->nr << ": " << tmp1 << " a.u." << endl;
+      }
       for (int i=MAX_ELEMENTS;i--;)
 …
+{
   int Order1;
+  std::string path;
   clock_t start, end;
 …
   Log() << Verbose(0) << "What's the desired bond order: ";
   cin >> Order1;
+  if (mol->first->next != mol->last) {  // there are bonds
+  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;
 …
     Log() << Verbose(0) << "State the factor: ";
     cin >> faktor;
+    mol->CountAtoms(); // recount atoms
+    if (mol->AtomCount != 0) {  // if there is more than none
+      count = mol->AtomCount;  // is changed becausing of adding, thus has to be stored away beforehand
+    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 const 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;
+      for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+        Elements[j] = (*iter)->type;
+        vectors[j] = &(*iter)->x;
         j++;
+      }
 …
+        }
+      }
       if (mol->first->next != mol->last) // if connect matrix is present already, redo it
+      if (mol->hasBondStructure())
         mol->CreateAdjacencyList(mol->BondDistance, configuration->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
       // free memory
 …
   molecule *srcmol = NULL, *destmol = NULL;
   Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryMolecule("Enter index of destination molecule: ",&destmol, molecules);
   dialog->queryMolecule("Enter index of source molecule to add from: ",&srcmol, molecules);
+  dialog->queryMolecule("molecule-by-id",&destmol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  dialog->queryMolecule("molecule-by-id",&srcmol, MapOfActions::getInstance().getDescription("molecule-by-id"));
   if(dialog->display()) {
     molecules->SimpleAdd(srcmol, destmol);
 …
   molecule *srcmol = NULL, *destmol = NULL;
   Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryMolecule("Enter index of matrix molecule (the variable one): ",&srcmol,molecules);
   dialog->queryMolecule("Enter index of molecule to merge into (the fixed one): ",&destmol,molecules);
+  dialog->queryMolecule("molecule-by-id",&destmol, MapOfActions::getInstance().getDescription("molecule-by-id"));
+  dialog->queryMolecule("molecule-by-id",&srcmol, MapOfActions::getInstance().getDescription("molecule-by-id"));
   if(dialog->display()) {
     molecules->EmbedMerge(destmol, srcmol);
 …
     return;
+  }
-  atom *Walker = mol->start;
   // generate some KeySets
   Log() << Verbose(0) << "Generating KeySets." << endl;
   KeySet TestSets[mol->AtomCount+1];
+  KeySet TestSets[mol->getAtomCount()+1];
   i=1;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
     for (int j=0;j<i;j++) {
       TestSets[j].insert(Walker->nr);
+      TestSets[j].insert((*iter)->nr);
+    }
     i++;
 …
   Log() << Verbose(0) << "Testing insertion of already present item in KeySets." << endl;
   KeySetTestPair test;
+  test = TestSets[mol->AtomCount-1].insert(Walker->nr);
+  if (test.second) {
+    Log() << Verbose(1) << "Insertion worked?!" << endl;
+  molecule::const_iterator iter = mol->begin();
+  if (iter != mol->end()) {
+    test = TestSets[mol->getAtomCount()-1].insert((*iter)->nr);
+    if (test.second) {
+      Log() << Verbose(1) << "Insertion worked?!" << endl;
+    } else {
+      Log() << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl;
+    }
   } else {
+    Log() << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl;
+  }
+  TestSets[mol->AtomCount].insert(mol->end->previous->nr);
+  TestSets[mol->AtomCount].insert(mol->end->previous->previous->previous->nr);
+    eLog() << Verbose(1) << "No atoms to test double insertion." << endl;
+  }
   // constructing Graph structure
 …
   // insert KeySets into Subgraphs
   Log() << Verbose(0) << "Inserting KeySets into Subgraph class." << endl;
   for (int j=0;j<mol->AtomCount;j++) {
+  for (int j=0;j<mol->getAtomCount();j++) {
     Subgraphs.insert(GraphPair (TestSets[j],pair<int, double>(counter++, 1.)));
+  }
   Log() << Verbose(0) << "Testing insertion of already present item in Subgraph." << endl;
   GraphTestPair test2;
   test2 = Subgraphs.insert(GraphPair (TestSets[mol->AtomCount],pair<int, double>(counter++, 1.)));
+  test2 = Subgraphs.insert(GraphPair (TestSets[mol->getAtomCount()],pair<int, double>(counter++, 1.)));
   if (test2.second) {
     Log() << Verbose(1) << "Insertion worked?!" << endl;

src/Line.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Line.hpp"

src/Makefile.am

-              rc39cc4
+              rbdb143
+# PLEASE adhere to the alphabetical ordering in this Makefile!
+# Also indentation by a single tab
+SUBDIRS = Actions UIElements
 # this includes source files that need to be present at multiple points
+HELPERSOURCE =  Helpers/Assert.cpp \
+                                Helpers/MemDebug.cpp
+HELPERSOURCE =  \
+  Helpers/Assert.cpp \
+  Helpers/MemDebug.cpp
+ATOMSOURCE = atom.cpp atom_atominfo.cpp atom_bondedparticle.cpp atom_bondedparticleinfo.cpp atom_graphnode.cpp atom_graphnodeinfo.cpp atom_particleinfo.cpp atom_trajectoryparticle.cpp atom_trajectoryparticleinfo.cpp
+ATOMHEADER = atom.hpp atom_atominfo.hpp atom_bondedparticle.hpp atom_bondedparticleinfo.hpp atom_graphnode.hpp atom_graphnodeinfo.hpp atom_particleinfo.hpp atom_trajectoryparticle.hpp atom_trajectoryparticleinfo.hpp
+LINALGSOURCE = ${HELPERSOURCE} \
+               gslmatrix.cpp \
+                           gslvector.cpp \
+                           linearsystemofequations.cpp \
+                           Space.cpp \
+                           vector.cpp
+ATOMSOURCE = \
+  atom.cpp \
+  atom_atominfo.cpp \
+  atom_bondedparticle.cpp \
+  atom_bondedparticleinfo.cpp \
+  atom_graphnode.cpp \
+  atom_graphnodeinfo.cpp \
+  atom_particleinfo.cpp \
+  atom_trajectoryparticle.cpp \
+  atom_trajectoryparticleinfo.cpp
+ATOMHEADER = \
+  atom.hpp \
+  atom_atominfo.hpp \
+  atom_bondedparticle.hpp \
+  atom_bondedparticleinfo.hpp \
+  atom_graphnode.hpp \
+  atom_graphnodeinfo.hpp \
+  atom_particleinfo.hpp \
+  atom_trajectoryparticle.hpp \
+  atom_trajectoryparticleinfo.hpp
+LINALGSOURCE = \
+  ${HELPERSOURCE} \
+  gslmatrix.cpp \
+  gslvector.cpp \
+  linearsystemofequations.cpp \
+  Space.cpp \
+  vector.cpp
 LINALGHEADER = gslmatrix.hpp \
                            gslvector.hpp \
                            linearsystemofequations.hpp \
                            Space.hpp \
                            vector.hpp
+  gslvector.hpp \
+  linearsystemofequations.hpp \
+  Space.hpp \
+  vector.hpp
+ANALYSISSOURCE = analysis_bonds.cpp analysis_correlation.cpp
+ANALYSISHEADER = analysis_bonds.hpp analysis_correlation.hpp
+ACTIONSSOURCE = Actions/Action.cpp \
+                                Actions/ActionHistory.cpp \
+                                Actions/ActionRegistry.cpp \
+                                Actions/ActionSequence.cpp \
+                                Actions/ErrorAction.cpp \
+                                Actions/MakroAction.cpp \
+                                Actions/ManipulateAtomsProcess.cpp \
+                                Actions/MethodAction.cpp \
+                Actions/Process.cpp \
+                Actions/small_actions.cpp
+ACTIONSHEADER = Actions/Action.hpp \
+                                Actions/ActionHistory.hpp \
+                                Actions/ActionRegistry.hpp \
+                                Actions/ActionSequence.hpp \
+                            Actions/Calculation.hpp \
+                            Actions/Calculation_impl.hpp \
+                            Actions/ErrorAction.hpp \
+                            Actions/MakroAction.hpp \
+                            Actions/ManipulateAtomsProcess.hpp \
+                            Actions/MethodAction.hpp \
+                            Actions/Process.hpp \
+                            Actions/small_actions.hpp
+PATTERNSOURCE = Patterns/Observer.cpp
+PATTERNHEADER = Patterns/Cacheable.hpp \
+                                Patterns/Observer.hpp \
+                Patterns/Singleton.hpp
+VIEWSOURCE = Views/View.cpp Views/StringView.cpp Views/MethodStringView.cpp Views/StreamStringView.cpp
+VIEWHEADER = Views/View.hpp Views/StringView.hpp Views/MethodStringView.hpp Views/StreamStringView.hpp
+MENUSOURCE = Menu/Menu.cpp Menu/TextMenu.cpp Menu/MenuItem.cpp Menu/SubMenuItem.cpp Menu/ActionMenuItem.cpp Menu/SeperatorItem.cpp Menu/DisplayMenuItem.cpp
+MENUHEADER = Menu/Menu.hpp Menu/TextMenu.hpp Menu/MenuItem.hpp Menu/SubMenuItem.hpp Menu/ActionMenuItem.hpp Menu/SeperatorItem.hpp Menu/DisplayMenuItem.hpp
+UISOURCE = ${ACTIONSSOURCE} ${VIEWSOURCE} ${MENUSOURCE} UIElements/UIFactory.cpp UIElements/TextUIFactory.cpp UIElements/MainWindow.cpp UIElements/TextWindow.cpp UIElements/TextStatusIndicator.cpp UIElements/Dialog.cpp UIElements/TextDialog.cpp
+UIHEADER = ${ACTIONSHEADER} ${VIEWHEADER} ${MENUHEADER} UIElements/UIFactory.hpp UIElements/TextUIFactory.hpp UIElements/MainWindow.hpp UIElements/TextWindow.hpp UIElements/TextStatusIndicator.hpp UIElements/Dialog.hpp UIElements/TextDialog.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
+ANALYSISSOURCE = \
+  analysis_bonds.cpp \
+  analysis_correlation.cpp
+ANALYSISHEADER = \
+  analysis_bonds.hpp \
+  analysis_correlation.hpp
+ACTIONSSOURCE = \
+  Actions/Action.cpp \
+  Actions/ActionHistory.cpp \
+  Actions/ActionRegistry.cpp \
+  Actions/ActionSequence.cpp \
+  Actions/ErrorAction.cpp \
+  Actions/MakroAction.cpp \
+  Actions/ManipulateAtomsProcess.cpp \
+  Actions/MethodAction.cpp \
+  Actions/Process.cpp
+ACTIONSHEADER = \
+  Actions/Action.hpp \
+  Actions/ActionHistory.hpp \
+  Actions/ActionRegistry.hpp \
+  Actions/ActionSequence.hpp \
+  Actions/Calculation.hpp \
+  Actions/Calculation_impl.hpp \
+  Actions/ErrorAction.hpp \
+  Actions/MakroAction.hpp \
+  Actions/ManipulateAtomsProcess.hpp \
+  Actions/MapOfActions.hpp \
+  Actions/MethodAction.hpp \
+  Actions/Process.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
+PATTERNSOURCE = \
+  Patterns/Observer.cpp
+PATTERNHEADER = \
+  Patterns/Cacheable.hpp \
+  Patterns/Observer.hpp \
+  Patterns/Singleton.hpp
+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
+QTUIMOC_TARGETS = QTMainWindow.moc.cpp \
+                      QTMenu.moc.cpp\
+                      QTDialog.moc.cpp \
+                      QTWorldView.moc.cpp \
+                      GLMoleculeView.moc.cpp \
+                      QTMoleculeView.moc.cpp \
+                      QTStatusBar.moc.cpp
 DESCRIPTORSOURCE = Descriptors/AtomDescriptor.cpp \
+                                   Descriptors/AtomIdDescriptor.cpp \
+                                   Descriptors/AtomTypeDescriptor.cpp \
+                                   Descriptors/MoleculeDescriptor.cpp \
+                                   Descriptors/MoleculeIdDescriptor.cpp
+  Descriptors/AtomIdDescriptor.cpp \
+  Descriptors/AtomTypeDescriptor.cpp \
+  Descriptors/MoleculeDescriptor.cpp \
+  Descriptors/MoleculeIdDescriptor.cpp \
+  Descriptors/MoleculeNameDescriptor.cpp \
+  Descriptors/MoleculePtrDescriptor.cpp
+DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp \
+  Descriptors/AtomIdDescriptor.hpp \
+  Descriptors/AtomTypeDescriptor.hpp \
+  Descriptors/MoleculeDescriptor.hpp \
+  Descriptors/MoleculeIdDescriptor.hpp \
+  Descriptors/MoleculeNameDescriptor.hpp \
+  Descriptors/MoleculePtrDescriptor.hpp
-DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp \
-                                   Descriptors/AtomIdDescriptor.hpp \
-                                   Descriptors/AtomTypeDescriptor.hpp \
-                                   Descriptors/MoleculeDescriptor.hpp \
-                                   Descriptors/MoleculeIdDescriptor.hpp
 EXCEPTIONSOURCE = Exceptions/CustomException.cpp \
                                   Exceptions/LinearDependenceException.cpp \
 …
                                   Exceptions/SkewException.hpp \
                                   Exceptions/ZeroVectorException.hpp
+SOURCE = ${ANALYSISSOURCE} \
+                 ${ATOMSOURCE} \
+                 ${PATTERNSOURCE} \
+                 ${UISOURCE} \
+                 ${DESCRIPTORSOURCE} \
+                 ${HELPERSOURCE} \
+                 ${LEGACYSOURCE} \
+                 ${EXCEPTIONSOURCE} \
+                 bond.cpp \
+                 bondgraph.cpp \
+                 boundary.cpp \
+                 config.cpp \
+                 element.cpp \
+                 ellipsoid.cpp \
+                 errorlogger.cpp \
+                 graph.cpp \
+                 helpers.cpp \
+                 info.cpp \
+                 leastsquaremin.cpp \
+                 Line.cpp \
+                 linkedcell.cpp \
+                 lists.cpp \
+                 log.cpp \
+                 logger.cpp \
+                 memoryusageobserver.cpp \
+                 moleculelist.cpp \
+                 molecule.cpp \
+                 molecule_dynamics.cpp \
+                 molecule_fragmentation.cpp \
+                 molecule_geometry.cpp \
+                 molecule_graph.cpp \
+                 molecule_pointcloud.cpp \
+                 parser.cpp \
+                 periodentafel.cpp \
+                 Plane.cpp \
+                 tesselation.cpp \
+                 tesselationhelpers.cpp \
+                 triangleintersectionlist.cpp \
+                 verbose.cpp \
+                 vector_ops.cpp \
+                 World.cpp
+QTUISOURCE = ${QTUIMOC_TARGETS} \
+                         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 = \
+  ${ANALYSISSOURCE} \
+  ${ACTIONSSOURCE} \
+  ${ATOMSOURCE} \
+  ${PATTERNSOURCE} \
+  ${PARSERSOURCE} \
+  ${DESCRIPTORSOURCE} \
+  ${HELPERSOURCE} \
+  ${EXCEPTIONSOURCE} \
+  bond.cpp \
+  bondgraph.cpp \
+  boundary.cpp \
+  CommandLineParser.cpp \
+  config.cpp \
+  ConfigFileBuffer.cpp \
+  element.cpp \
+  elements_db.cpp \
+  ellipsoid.cpp \
+  errorlogger.cpp \
+  graph.cpp \
+  helpers.cpp \
+  info.cpp \
+  leastsquaremin.cpp \
+  Line.cpp \
+  linkedcell.cpp \
+  log.cpp \
+  logger.cpp \
+  moleculelist.cpp \
+  molecule.cpp \
+  molecule_dynamics.cpp \
+  molecule_fragmentation.cpp \
+  molecule_geometry.cpp \
+  molecule_graph.cpp \
+  molecule_pointcloud.cpp \
+  parser.cpp \
+  periodentafel.cpp \
+  Plane.cpp \
+  Space.cpp \
+  tesselation.cpp \
+  tesselationhelpers.cpp \
+  ThermoStatContainer.cpp \
+  triangleintersectionlist.cpp \
+  vector.cpp \
+  vector_ops.cpp \
+  verbose.cpp \
+  World.cpp
 HEADER = \
+          ${ANALYSISHEADER} \
+          ${ATOMHEADER} \
+          ${PATTERNHEADER} \
+          ${UIHEADER} \
+          ${DESCRIPTORHEADER} \
+          ${EXCEPTIONHEADER} \
+          ${LEGACYHEADER} \
+          bond.hpp \
+          bondgraph.hpp \
+          boundary.hpp \
+          config.hpp \
+          defs.hpp \
+          element.hpp \
+          ellipsoid.hpp \
+          errorlogger.hpp \
+          graph.hpp \
+          helpers.hpp \
+          info.hpp \
+          leastsquaremin.hpp \
+          Line.hpp \
+          linkedcell.hpp \
+          lists.hpp \
+          log.hpp \
+          logger.hpp \
+          memoryallocator.hpp \
+          memoryusageobserver.hpp \
+          molecule.hpp \
+          molecule_template.hpp \
+          parser.hpp \
+          periodentafel.hpp \
+          Plane.hpp \
+          stackclass.hpp \
+          tesselation.hpp \
+          tesselationhelpers.hpp \
+          triangleintersectionlist.hpp \
+          verbose.hpp \
+          vector_ops.hpp \
+          World.hpp
+  ${ANALYSISHEADER} \
+  ${ACTIONSHEADER} \
+  ${ATOMHEADER} \
+  ${PARSERHEADER} \
+  ${PATTERNHEADER} \
+  ${DESCRIPTORHEADER} \
+  ${EXCEPTIONHEADER} \
+  bond.hpp \
+  bondgraph.hpp \
+  boundary.hpp \
+  CommandLineParser.hpp \
+  config.hpp \
+  ConfigFileBuffer.hpp \
+  defs.hpp \
+  element.hpp \
+  elements_db.hpp \
+  ellipsoid.hpp \
+  errorlogger.hpp \
+  graph.hpp \
+  helpers.hpp \
+  info.hpp \
+  leastsquaremin.hpp \
+  Line.hpp \
+  linkedcell.hpp \
+  lists.hpp \
+  log.hpp \
+  logger.hpp \
+  molecule.hpp \
+  molecule_template.hpp \
+  parser.hpp \
+  periodentafel.hpp \
+  Plane.hpp \
+  stackclass.hpp \
+  tesselation.hpp \
+  tesselationhelpers.hpp \
+  ThermoStatContainer.hpp \
+  triangleintersectionlist.hpp \
+  verbose.hpp \
+  vector_ops.hpp \
+  World.hpp
+# the following files are no longer used:
+#  memoryallocator.hpp \
+#  memoryallocator.cpp \
+#  memoryusageobserver.hpp \
+#  memoryusageobserver.cpp
 BOOST_LIB = $(BOOST_LDFLAGS) $(BOOST_MPL_LIB)
+INCLUDES = -I$(top_srcdir)/src/unittests
+noinst_LIBRARIES = libmolecuilder.a libgslwrapper.a
+bin_PROGRAMS = molecuilder joiner analyzer
+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 libmenu.a libparser.a
+bin_PROGRAMS = molecuilder molecuildergui joiner analyzer
 molecuilderdir = ${bindir}
 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 = libmolecuilder.a libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_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 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 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}
 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}
+#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
+${QTUIMOC_TARGETS}: ${QTUIMOC_HEADER}
+        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; \
+        done;
+MOSTLYCLEANFILES = ${QTUIMOC_TARGETS}
 #EXTRA_DIST = ${molecuilder_DATA}
 …
         echo "const char *ESPACKVersion = \"$(PACKAGE_NAME) -- git version: "`cat $(srcdir)/.git-version`"\";" > $@
+molecuilder_SOURCES += $(srcdir)/version.c

src/Patterns/Cacheable.hpp

-              rc39cc4
+              rbdb143
         owner(_owner)
         {}
       virtual T getValue()=0;
+      virtual T& getValue()=0;
       virtual void invalidate()=0;
       virtual bool isValid()=0;
 …
         return busy;
+      }
+    virtual std::string getName()=0;
     protected:
       bool busy;
 …
         {}
       virtual T getValue(){
+      virtual T& getValue(){
         // set the state to valid
         State::owner->switchState(State::owner->validState);
 …
         // nothing to do when entering this
+      }
+      virtual std::string getName(){
+        return "invalid";
+      }
     };
 …
         {}
       virtual T getValue(){
+      virtual T& getValue(){
         return content;
+      }
 …
         State::busy = false;
+      }
+      virtual std::string getName(){
+        return "valid";
+      }
     private:
       T content;
 …
         {}
       virtual T getValue(){
+      virtual T& getValue(){
         ASSERT(0,"Cannot get a value from a Cacheable after it's Observable has died");
         // we have to return a grossly invalid reference, because no value can be produced anymore
 …
         // nothing to do when entering this state
+      }
+      virtual std::string getName(){
+        return "destroyed";
+      }
     };
 …
   public:
     Cacheable(Observable *_owner, boost::function<T()> _recalcMethod);
+    Cacheable(Observable *_owner, boost::function<T()> _recalcMethod, std::string name);
     virtual ~Cacheable();
 …
     void subjectKilled(Observable *subject);
   private:
     void switchState(state_ptr newState);
 …
     Observable *owner;
     boost::function<T()> recalcMethod;
 …
   template<typename T>
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod, std::string name) :
+    Observer(name + "(Cached)"),
     owner(_owner),
     recalcMethod(_recalcMethod)
 …
   void Cacheable<T>::switchState(state_ptr newState){
     ASSERT(!state->isBusy(),"LOOP DETECTED: Cacheable state switched while recalculating.\nDid the recalculation trigger the Observable?");
+#ifdef LOG_OBSERVER
+    observerLog().addMessage() << "## Cacheable " << observerLog().getName(this) << " changed state (" << state->getName()
+                               << "->" << newState->getName() << ")" << std::endl;
+#endif
     state = newState;
     state->enter();
 …
+  {
   public:
     Cacheable(Observable *_owner, boost::function<T()> _recalcMethod);
+    Cacheable(Observable *_owner, boost::function<T()> _recalcMethod,std::string name);
     virtual ~Cacheable();
 …
   template<typename T>
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
+  Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod, std::string name) :
+    Observer(name),
     recalcMethod(_recalcMethod)
   {}

src/Patterns/Observer.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include "Observer.hpp"
 …
 #include "Helpers/Assert.hpp"
+#include "Helpers/MemDebug.hpp"
 using namespace std;
 …
   // if no entry for this observable is found, an new one is created
   // by the STL and initialized to 0 (see STL documentation)
+#ifdef LOG_OBSERVER
+  observerLog().addMessage(depth[publisher]) << ">> Locking " << observerLog().getName(publisher) << endl;
+#endif
   depth[publisher]++;
+}
 …
   // if zero is reached all observed blocks are done and we can
   // start to notify our observers
+  if(--(depth[publisher])){}
+  --depth[publisher];
+#ifdef LOG_OBSERVER
+  observerLog().addMessage(depth[publisher]) << "<< Unlocking " << observerLog().getName(publisher) << endl;
+#endif
+  if(depth[publisher]){}
   else{
     publisher->notifyAll();
 …
 Observable::_Observable_protector::_Observable_protector(Observable *_protege) :
   protege(_protege)
+{
+  start_observer_internal(protege);
+}
+Observable::_Observable_protector::_Observable_protector(const _Observable_protector &dest) :
+    protege(dest.protege)
+{
   start_observer_internal(protege);
 …
       callees_t::iterator iter;
       for(iter=callees.begin();iter!=callees.end();++iter){
+#ifdef LOG_OBSERVER
+        observerLog().addMessage() << "-> Sending update from " << observerLog().getName(this)
+                                   << " to " << observerLog().getName((*iter).second)
+                                   << " (priority=" << (*iter).first << ")"<< endl;
+#endif
         (*iter).second->update(this);
+      }
 …
     // we do not need to publish all the changes at each time we are called
     if(depth.find(this)==depth.end()) {
+#ifdef LOG_OBSERVER
+      observerLog().addMessage() << "-* Update from " << observerLog().getName(publisher)
+                                 << " propagated by " << observerLog().getName(this) << endl;
+#endif
       notifyAll();
+    }
+    else{
+#ifdef LOG_OBSERVER
+      observerLog().addMessage() << "-| Update from " <<  observerLog().getName(publisher)
+                                 << " not propagated by " << observerLog().getName(this) << endl;
+#endif
+    }
+  }
 …
 void Observable::signOn(Observer *target,int priority) {
   ASSERT(priority>=-20 && priority<=+20, "Priority out of range [-20:+20] when signing on Observer");
+#ifdef LOG_OBSERVER
+  observerLog().addMessage() << "@@ Signing on " << observerLog().getName(target) << " to " << observerLog().getName(this) << endl;
+#endif
   bool res = false;
   callees_t &callees = callTable[this];
 …
 void Observable::signOff(Observer *target) {
   ASSERT(callTable.count(this),"SignOff called for an Observable without Observers.");
+#ifdef LOG_OBSERVER
+  observerLog().addMessage() << "** Signing off " << observerLog().getName(target) << " from " << observerLog().getName(this) << endl;
+#endif
   callees_t &callees = callTable[this];
   callees_t::iterator iter;
   callees_t::iterator deliter;
 …
 /** Constructor for class Observable.
  */
+Observable::Observable()
+{}
+Observable::Observable(string name) :
+  Observer(Observer::BaseConstructor())
+{
+#ifdef LOG_OBSERVER
+  observerLog().addName(this,name);
+  observerLog().addMessage() << "++ Creating Observable " << observerLog().getName(this) << endl;
+#endif
+}
 /** Destructor for class Observable.
 …
 Observable::~Observable()
+{
+#ifdef LOG_OBSERVER
+  observerLog().addMessage() << "-- Destroying Observable " << observerLog().getName(this) << endl;
+#endif
   if(callTable.count(this)) {
     // delete all entries for this observable
 …
 /** Constructor for class Observer.
  */
+Observer::Observer()
+{}
+Observer::Observer(string name)
+{
+#ifdef LOG_OBSERVER
+  observerLog().addName(this,name);
+  observerLog().addMessage() << "++ Creating Observer " << observerLog().getName(this) << endl;
+#endif
+}
+/**
+ * Base Constructor for class Observer
+ *
+ * only called from Observable Constructor
+ */
+Observer::Observer(Observer::BaseConstructor){
+#ifdef LOG_OBSERVER
+  observerLog().addObservable(this);
+#endif
+}
 /** Destructor for class Observer.
  */
 Observer::~Observer()
+{}
+{
+#ifdef LOG_OBSERVER
+  if(!observerLog().isObservable(this)){
+    observerLog().addMessage() << "-- Destroying Observer " << observerLog().getName(this) << endl;
+  }
+#endif
+}
 /**
 …
+  }
+}
+#ifdef LOG_OBSERVER
+/************************* Methods to do logging of the Observer Mechanism *********/
+// The log needs to exist fairly early, so we make it construct on first use,
+// and never destroy it
+ObserverLog &observerLog(){
+  // yes, this memory is never freed... we need it around for the whole programm,
+  // so no freeing is possible
+  static ObserverLog *theLog = Memory::ignore(new ObserverLog());
+  return *theLog;
+}
+ObserverLog::ObserverLog() :
+  count (0)
+{}
+ObserverLog::~ObserverLog(){}
+string ObserverLog::getLog(){return log.str();}
+std::string ObserverLog::getName(void* obj){
+  return names[obj];
+}
+bool ObserverLog::isObservable(void* obj){
+  return observables.count(obj);
+}
+void ObserverLog::addName(void* obj , string name){
+  stringstream sstr;
+  sstr << name << "_" << count++;
+  names[obj] = sstr.str();
+}
+void ObserverLog::addObservable(void* obj){
+  observables.insert(obj);
+}
+void ObserverLog::deleteName(void* obj){
+  names.erase(obj);
+}
+void ObserverLog::deleteObservable(void* obj){
+  observables.erase(obj);
+}
+stringstream &ObserverLog::addMessage(int depth){
+  for(int i=depth;i--;)
+    log << "  ";
+  return log;
+}
+#endif

src/Patterns/Observer.hpp

-              rc39cc4
+              rbdb143
 #include <map>
 #include <set>
+#include <string>
+#include <sstream>
 /**
 …
  */
+// Deactivate any logging when we are not in debug mode
+#ifdef NDEBUG
+#undef LOG_OBSERVER
+#endif
 class Observable;
 class Notification;
 …
 // identification process
 typedef Notification *const Notification_ptr;
+template<class _Set>
+class ObservedIterator;
 /**
 …
   friend class Observable;
   friend class Notification;
+public:
+  Observer();
+  template<class> friend class ObservedIterator;
+  // indicates the constructor called from Observables
+  struct BaseConstructor{};
+public:
+  Observer(BaseConstructor);
+  Observer(std::string);
   virtual ~Observer();
 …
 class Observable : public Observer {
 public:
   Observable();
+  Observable(std::string _name);
   virtual ~Observable();
 …
   static std::set<Observable*> busyObservables;
   //! @cond
   // Structure for RAII-Style notification
 …
   public:
     _Observable_protector(Observable *);
+    _Observable_protector(const _Observable_protector&);
     ~_Observable_protector();
   private:
 …
 };
+#ifdef LOG_OBSERVER
+/**
+ * This class is used to log the working of the observer mechanism
+ *
+ * TODO: make this conditional dependent on compiler Flag.
+ */
+class ObserverLog{
+  friend class Observable;
+  friend class Observer;
+  template <typename> friend class Cacheable;
+public:
+  ObserverLog();
+  ~ObserverLog();
+  std::string getLog();                        // get everything that has been logged
+  std::string getName(void*);                  // get the name of an actor
+  bool isObservable(void*);
+private:
+  int count;                                   // number to reference each actor in this framework
+  std::map<void*,std::string> names;           // List of names assigned to actors
+  std::set<void*> observables;                 // List of pointers to Observables. Needed to distinguish Observers and Observables
+  void addName(void*, std::string);            // Assign a name to an Actor
+  void addObservable(void*);
+  void deleteName(void*);                      // delete the name of an Actor
+  void deleteObservable(void*);
+  std::stringstream &addMessage(int depth=0);  // Add a Message to the logging
+  std::stringstream log;                       // The internal log object
+};
+ObserverLog &observerLog();
+#endif
 // extra macro is necessary to work with __LINE__
 #define PASTE(a,b) PASTE_HELPER(a,b)

src/Patterns/Singleton.hpp

-              rc39cc4
+              rbdb143
 #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

-              rc39cc4
+              rbdb143
 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.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Plane.hpp"

src/Space.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "Space.hpp"

src/UIElements/Dialog.cpp

-              rc39cc4
+              rbdb143
  */
+#include <cassert>
+#include "UIElements/Dialog.hpp"
+#include "Helpers/MemDebug.hpp"
+#include "Dialog.hpp"
+#include "atom.hpp"
+#include "element.hpp"
+#include "molecule.hpp"
 #include "vector.hpp"
 …
 bool Dialog::display(){
+  if(checkAll()){
+    setAll();
+    return true;
+  }
+  else{
+    return false;
+  }
+}
+bool Dialog::checkAll(){
   list<Query*>::iterator iter;
   bool retval = true;
 …
     retval &= (*iter)->handle();
     // if any query fails (is canceled), we can end the handling process
+    if(!retval)
+    if(!retval) {
+      DoeLog(1) && (eLog() << Verbose(1) << "The following query failed: " << (**iter).getTitle() << "." << endl);
       break;
+  }
-  if (retval){
-    // if all queries succeeded we can set the targets to appropriate values
-    for(iter=queries.begin(); iter!=queries.end(); iter++) {
-      (*iter)->setResult();
+    }
+  }
 …
+}
+void Dialog::setAll(){
+  list<Query*>::iterator iter;
+  for(iter=queries.begin(); iter!=queries.end(); iter++) {
+    (*iter)->setResult();
+  }
+}
 /****************** Query types Infrastructure **************************/
 // Base class
+Dialog::Query::Query(string _title) :
+    title(_title)
+Dialog::Query::Query(string _title, string _description) :
+    title(_title),
+    description(_description)
 {}
 …
+}
+const std::string Dialog::Query::getDescription() const{
+  return description;
+}
+// empty Queries
+Dialog::EmptyQuery::EmptyQuery(string title, std::string description) :
+    Query(title, description)
+{}
+Dialog::EmptyQuery::~EmptyQuery() {}
+void Dialog::EmptyQuery::setResult() {
+}
 // Int Queries
 Dialog::IntQuery::IntQuery(string title,int *_target) :
     Query(title), target(_target)
+Dialog::IntQuery::IntQuery(string title,int *_target, std::string description) :
+    Query(title, description), target(_target)
 {}
 …
+}
+// Int Queries
+Dialog::BooleanQuery::BooleanQuery(string title,bool *_target, std::string description) :
+    Query(title, description), target(_target)
+{}
+Dialog::BooleanQuery::~BooleanQuery() {}
+void Dialog::BooleanQuery::setResult() {
+  *target = tmp;
+}
 // String Queries
 Dialog::StringQuery::StringQuery(string title,string *_target) :
     Query(title), target(_target)
+Dialog::StringQuery::StringQuery(string title,string *_target, std::string _description) :
+    Query(title, _description), target(_target)
 {}
 …
 // Double Queries
 Dialog::DoubleQuery::DoubleQuery(string title,double *_target) :
     Query(title), target(_target)
+Dialog::DoubleQuery::DoubleQuery(string title,double *_target, std::string _description) :
+    Query(title, _description), target(_target)
 {}
 …
+// Atom Queries
+Dialog::AtomQuery::AtomQuery(string title, atom **_target, std::string _description) :
+    Query(title, _description),
+    tmp(0),
+    target(_target)
+{}
+Dialog::AtomQuery::~AtomQuery() {}
+void Dialog::AtomQuery::setResult() {
+  *target = tmp;
+}
 // Molecule Queries
 Dialog::MoleculeQuery::MoleculeQuery(string title, molecule **_target, MoleculeListClass *_molecules) :
     Query(title),
+Dialog::MoleculeQuery::MoleculeQuery(string title, molecule **_target, std::string _description) :
+    Query(title, _description),
     tmp(0),
-    molecules(_molecules),
     target(_target)
 …
 // Vector Queries
 Dialog::VectorQuery::VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check) :
   Query(title),
+Dialog::VectorQuery::VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check, std::string _description) :
+  Query(title, _description),
   cellSize(_cellSize),
   check(_check),
   target(_target)
+{
 tmp = new Vector();
+  tmp = new Vector();
+}
 …
+}
+// 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()
+{
+  delete[] tmp;
+}
+void Dialog::BoxQuery::setResult() {
+  for (int i=0;i<6;i++) {
+    (*target)[i] = tmp[i];
+  }
+}
 // Element Queries
+Dialog::ElementQuery::ElementQuery(std::string title, const element **_target) :
+  Query(title),
+  tmp(0),
+Dialog::ElementQuery::ElementQuery(std::string title, std::vector<element *> *_target, std::string _description) :
+  Query(title, _description),
   target(_target)
   {}
 …
 void Dialog::ElementQuery::setResult(){
   *target=tmp;
+}
+  *target=elements;
+}

src/UIElements/Dialog.hpp

-              rc39cc4
+              rbdb143
 #include<string>
 #include<list>
+#include<vector>
+class MoleculeListClass;
+class atom;
+class element;
 class molecule;
 class Vector;
-class element;
 class Dialog
 …
   virtual ~Dialog();
+  virtual void queryInt(const char *, int *)=0;
+  virtual void queryDouble(const char*,double *)=0;
+  virtual void queryString(const char*, std::string *)=0;
+  virtual void queryMolecule(const char*,molecule**,MoleculeListClass*)=0;
+  virtual void queryVector(const char*,Vector *,const double *const,bool)=0;
+  virtual void queryElement(const char*,const element **)=0;
+  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 bool display();
+  virtual bool checkAll();
+  virtual void setAll();
 protected:
 …
   //base class for all queries
   class Query {
+    friend class Dialog;
   public:
     Query(std::string _title);
+    Query(std::string _title, std::string _description = "");
     virtual ~Query();
     virtual bool handle()=0;
 …
   protected:
     const std::string getTitle() const;
+    const std::string getDescription() const;
   private:
+    std::string title;
+    std::string title;  //!< short title of the query
+    std::string description; //!< longer description for tooltips or for help
+  };
+  // Empty Query is just meant for showing text, such as version, help, initial message or alike
+  class EmptyQuery : public Query {
+  public:
+    EmptyQuery(std::string title, std::string _description = "");
+    virtual ~EmptyQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
   };
   //Specialized classes for certain types. GUI-Types are not specialized at this time
+  class BooleanQuery : public Query {
+  public:
+    BooleanQuery(std::string title,bool *_target, std::string _description = "");
+    virtual ~BooleanQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    bool tmp;
+  private:
+    bool *target;
+  };
   class IntQuery : public Query {
   public:
     IntQuery(std::string title,int *_target);
+    IntQuery(std::string title,int *_target, std::string _description = "");
     virtual ~IntQuery();
     virtual bool handle()=0;
 …
   class DoubleQuery : public Query {
   public:
     DoubleQuery(std::string title,double *_target);
+    DoubleQuery(std::string title,double *_target, std::string _description = "");
     virtual ~DoubleQuery();
     virtual bool handle()=0;
 …
   class StringQuery : public Query {
   public:
     StringQuery(std::string title,std::string *_target);
+    StringQuery(std::string title,std::string *_target, std::string _description = "");
     virtual ~StringQuery();
     virtual bool handle()=0;
 …
   };
   class MoleculeQuery : public Query {
   public:
     MoleculeQuery(std::string title, molecule **_target, MoleculeListClass *_molecules);
+    MoleculeQuery(std::string title, molecule **_target, std::string _description = "");
     virtual ~MoleculeQuery();
     virtual bool handle()=0;
 …
   protected:
     molecule *tmp;
-    MoleculeListClass *molecules;
   private:
     molecule **target;
   };
+  class AtomQuery : public Query {
+  public:
+    AtomQuery(std::string title, atom **_target, std::string _description = "");
+    virtual ~AtomQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    atom *tmp;
+  private:
+    atom **target;
+  };
   class VectorQuery : public Query {
   public:
       VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check);
+      VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check, std::string _description = "");
       virtual ~VectorQuery();
       virtual bool handle()=0;
 …
   };
+  class BoxQuery : public Query {
+  public:
+      BoxQuery(std::string title,double ** const _cellSize, std::string _description = "");
+      virtual ~BoxQuery();
+      virtual bool handle()=0;
+      virtual void setResult();
+    protected:
+      double *tmp;
+    private:
+      double **target;
+  };
   class ElementQuery : public Query {
   public:
     ElementQuery(std::string title, const element**_target);
+    ElementQuery(std::string title, std::vector<element *> *_target, std::string _description = "");
     virtual ~ElementQuery();
     virtual bool handle()=0;
     virtual void setResult();
   protected:
     const element *tmp;
+    std::vector<element *> elements;
   private:
     const element **target;
+    std::vector<element *> * const target;
   };
 …
 };
 #endif /* DIALOG_HPP_ */

src/UIElements/MainWindow.cpp

-              rc39cc4
+              rbdb143
  */
+#include "UIElements/MainWindow.hpp"
+#include "Helpers/MemDebug.hpp"
+#include "MainWindow.hpp"
 MainWindow::MainWindow()
+{
+  // TODO Auto-generated constructor stub
+}
+{}
 MainWindow::~MainWindow()
+{
+  // TODO Auto-generated destructor stub
+}
+{}

src/UIElements/MainWindow.hpp

-              rc39cc4
+              rbdb143
 };
-/**
- * The type of menuPopulators
- */
-typedef void (*MenuMaker)(Menu*,MoleculeListClass*, config*, periodentafel*);
-/**
- * This contains all Functions that are used to create the menus.
- * Needs a specific funtion for each menu. All populators will be called
- * by the UIFactory upon creation of the main menu. Thus the actuall construction
- * of the Menus can be kept independent of the concrete type of UI that is being
- * built.
- */
-struct menuPopulaters{
-  MenuMaker MakeEditMoleculesMenu;
-};
 #endif /* MAINWINDOW_HPP_ */

src/UIElements/UIFactory.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include <cassert>
+#include <utility>
 #include "Patterns/Singleton_impl.hpp"
 #include "UIElements/UIFactory.hpp"
+#include "Helpers/Assert.hpp"
+#include "Helpers/MemDebug.hpp"
+// all factories that can be used:
+#include "UIElements/TextUIFactory.hpp"
+using namespace std;
+std::map<std::string,boost::shared_ptr<UIFactory::factoryDescription> > UIFactory::factories;
 UIFactory::UIFactory()
+{
+  // TODO Auto-generated constructor stub
+{}
+UIFactory::~UIFactory()
+{}
+void UIFactory::makeUserInterface(std::string type) {
+  ASSERT(factories.count(type),"Selected factory was not registered before creation.");
+  // call the factory factory
+  setInstance(factories[type]->makeFactory());
+}
+UIFactory::~UIFactory()
+{
+  // TODO Auto-generated destructor stub
+}
+void UIFactory::makeUserInterface(InterfaceTypes type) {
+  switch(type) {
+    case Text :
+      setInstance(new TextUIFactory());
+      break;
+    default:
+      assert(0 && "No such Factory in stock");
+      break;
+  }
+void UIFactory::registerFactory(factoryDescription *factoryDesc) {
+  ASSERT(!factories.count(factoryDesc->name),"Trying to re-register an already registered factory.");
+  factories.insert(make_pair(factoryDesc->name,
+                             boost::shared_ptr<factoryDescription>(factoryDesc)));
+}
 CONSTRUCT_SINGLETON(UIFactory)
+UIFactory::factoryDescription::factoryDescription(string _name) :
+  name(_name)
+{}
+UIFactory::factoryDescription::~factoryDescription()
+{}

src/UIElements/UIFactory.hpp

-              rc39cc4
+              rbdb143
 class MainWindow;
 class Dialog;
+class MoleculeListClass;
+class config;
+class periodentafel;
+struct menuPopulaters;
+class DialogDescription;
 #include "Patterns/Singleton.hpp"
+#include <string>
+#include <map>
+#include <boost/smart_ptr.hpp>
 /**
 …
 class UIFactory : public Singleton<UIFactory,false>
+{
+  friend class Singleton<UIFactory,false>;
 public:
-  enum InterfaceTypes {Text};
-  virtual ~UIFactory();
   /**
    * Produce some kind of main window, of whichever type was chosen when the factory was created
    */
   virtual MainWindow* makeMainWindow(menuPopulaters,MoleculeListClass *, config *, periodentafel *, char *)=0;
+  virtual MainWindow* makeMainWindow()=0;
   /**
 …
 protected:
   UIFactory();
+  virtual ~UIFactory();
 public:
+  struct factoryDescription {
+    factoryDescription(std::string _name);
+    virtual ~factoryDescription();
+    const std::string name;
+    // yes this method really is a factory factory, to allow insertion of
+    // arbitrary factories
+    virtual UIFactory* makeFactory()=0;
+  };
   /**
    * create a Factory of a certain type. From that moment on only those UIElements can be produced by the factory
    */
+  static void makeUserInterface(InterfaceTypes type);
+  static void makeUserInterface(std::string type);
+  static void registerFactory(factoryDescription *factoryDesc);
+protected:
+private:
+  static std::map<std::string,boost::shared_ptr<factoryDescription> > factories;
 };

src/World.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include "World.hpp"
 #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 "Patterns/Singleton_impl.hpp"
 …
+}
+config *&World::getConfig(){
+  return configuration;
+}
 // Atoms
 …
+}
+std::vector<molecule*> World::getAllMolecules(){
+  return getAllMolecules(AllMolecules());
+}
 int World::numMolecules(){
   return molecules_deprecated->ListOfMolecules.size();
 …
+}
 char * World::getDefaultName() {
+std::string World::getDefaultName() {
   return defaultName;
+}
+void World::setDefaultName(char * name)
+{
+  delete[](defaultName);
+  const int length = strlen(name);
+  defaultName = new char[length+2];
+  if (length < MAXSTRINGSIZE)
+    strncpy(defaultName, name, length);
+  else
+    strcpy(defaultName, "none");
+void World::setDefaultName(std::string name)
+{
+  defaultName = name;
 };
+class ThermoStatContainer * World::getThermostats()
+{
+  return Thermostats;
+}
+int World::getExitFlag() {
+  return ExitFlag;
+}
+void World::setExitFlag(int flag) {
+  if (ExitFlag < flag)
+    ExitFlag = flag;
+}
 /******************** Methods to change World state *********************/
 …
   molecule *mol = NULL;
   mol = NewMolecule();
   assert(!molecules.count(currMoleculeId));
+  ASSERT(!molecules.count(currMoleculeId),"currMoleculeId did not specify an unused ID");
   mol->setId(currMoleculeId++);
   // store the molecule by ID
 …
   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;
-char *World::defaultName = NULL;
 atom *World::createAtom(){
 …
   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);
+  }
 …
 World::World() :
+    Observable("World"),
     periode(new periodentafel),
+    configuration(new config),
+    Thermostats(new ThermoStatContainer),
+    ExitFlag(0),
     atoms(),
     currAtomId(0),
 …
   cell_size[4] = 0.;
   cell_size[5] = 20.;
+  defaultName = new char[MAXSTRINGSIZE];
+  strcpy(defaultName, "none");
+  defaultName = "none";
   molecules_deprecated->signOn(this);
+}
 …
   molecules_deprecated->signOff(this);
   delete[] cell_size;
-  delete[] defaultName;
   delete molecules_deprecated;
   delete periode;
+  delete configuration;
+  delete Thermostats;
   MoleculeSet::iterator molIter;
   for(molIter=molecules.begin();molIter!=molecules.end();++molIter){

src/World.hpp

-              rc39cc4
+              rbdb143
 // forward declarations
-class periodentafel;
-class MoleculeListClass;
 class atom;
-class molecule;
 class AtomDescriptor;
 class AtomDescriptor_impl;
+template<typename T> class AtomsCalculation;
+class config;
+class ManipulateAtomsProcess;
+class molecule;
 class MoleculeDescriptor;
 class MoleculeDescriptor_impl;
 class ManipulateAtomsProcess;
+template<typename T>
 class AtomsCalculation;
+class MoleculeListClass;
+class periodentafel;
+class ThermoStatContainer;
 /****************************************** forward declarations *****************************/
 …
   /**
+   * returns the configuration for the world.
+   */
+  config *&getConfig();
+  /**
    * returns the first atom that matches a given descriptor.
    * Do not rely on ordering for descriptors that match more than one atom.
 …
    */
   std::vector<molecule*> getAllMolecules(MoleculeDescriptor descriptor);
+  std::vector<molecule*> getAllMolecules();
   /**
 …
    * get the default name
    */
   char * getDefaultName();
+  std::string getDefaultName();
   /**
    * set the default name
    */
+  void setDefaultName(char * name);
+  void setDefaultName(std::string name);
+  /**
+   * get pointer to World's ThermoStatContainer
+   */
+  ThermoStatContainer * getThermostats();
+  /*
+   * get the ExitFlag
+   */
+  int getExitFlag();
+  /*
+   * set the ExitFlag
+   */
+  void setExitFlag(int flag);
   /***** Methods to work with the World *****/
 …
   periodentafel *periode;
+  config *configuration;
   static double *cell_size;
+  static char *defaultName;
+  std::string defaultName;
+  class ThermoStatContainer *Thermostats;
+  int ExitFlag;
 public:
   AtomSet atoms;

src/analysis_bonds.cpp

-              rc39cc4
+              rbdb143
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include "analysis_bonds.hpp"
 …
   Mean = 0.;
-  atom *Walker = mol->start;
   int AtomCount = 0;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    const int count = Walker->ListOfBonds.size();
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    const int count = (*iter)->ListOfBonds.size();
     if (Max < count)
       Max = count;
 …
  * \param &Max maximum distance on return, 0 if no bond between the two elements
  */
 void MinMeanMaxBondDistanceBetweenElements(const molecule *mol, element *type1, element *type2, double &Min, double &Mean, double &Max)
+void MinMeanMaxBondDistanceBetweenElements(const molecule *mol, const element *type1, const element *type2, double &Min, double &Mean, double &Max)
+{
   Min = 2e+6;
 …
   int AtomNo = 0;
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    if (Walker->type == type1)
+      for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++)
+        if ((*BondRunner)->GetOtherAtom(Walker)->type == type2) {
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((*iter)->type == type1)
+      for (BondList::const_iterator BondRunner = (*iter)->ListOfBonds.begin(); BondRunner != (*iter)->ListOfBonds.end(); BondRunner++)
+        if ((*BondRunner)->GetOtherAtom((*iter))->type == type2) {
           const double distance = (*BondRunner)->GetDistanceSquared();
           if (Min > distance)
 …
 int CountHydrogenBridgeBonds(MoleculeListClass *molecules, const element * InterfaceElement = NULL, const element * Interface2Element = NULL)
+{
-  atom *Walker = NULL;
-  atom *Runner = NULL;
   int count = 0;
   int OtherHydrogens = 0;
 …
   bool Interface2Flag = false;
   bool OtherHydrogenFlag = true;
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
+    Walker = (*MolWalker)->start;
+    while (Walker->next != (*MolWalker)->end) {
+      Walker = Walker->next;
+      for (MoleculeList::const_iterator MolRunner = molecules->ListOfMolecules.begin();MolRunner != molecules->ListOfMolecules.end(); MolRunner++) {
+        Runner = (*MolRunner)->start;
+        while (Runner->next != (*MolRunner)->end) {
+          Runner = Runner->next;
+          if ((Walker->type->Z  == 8) && (Runner->type->Z  == 8)) {
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); ++MolWalker) {
+    molecule::iterator Walker = (*MolWalker)->begin();
+    for(;Walker!=(*MolWalker)->end();++Walker){
+      for (MoleculeList::const_iterator MolRunner = molecules->ListOfMolecules.begin();MolRunner != molecules->ListOfMolecules.end(); ++MolRunner) {
+        molecule::iterator Runner = (*MolRunner)->begin();
+        for(;Runner!=(*MolRunner)->end();++Runner){
+          if (((*Walker)->type->Z  == 8) && ((*Runner)->type->Z  == 8)) {
             // check distance
             const double distance = Runner->x.DistanceSquared(Walker->x);
+            const double distance = (*Runner)->x.DistanceSquared((*Walker)->x);
             if ((distance > MYEPSILON) && (distance < HBRIDGEDISTANCE*HBRIDGEDISTANCE)) { // distance >0 means  different atoms
               // on other atom(Runner) we check for bond to interface element and
 …
               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);
+              for (BondList::const_iterator BondRunner = (*Runner)->ListOfBonds.begin(); BondRunner != (*Runner)->ListOfBonds.end(); BondRunner++) {
+                atom * const OtherAtom = (*BondRunner)->GetOtherAtom(*Runner);
                 // if hydrogen, check angle to be greater(!) than 30 degrees
                 if (OtherAtom->type->Z == 1) {
                   const double angle = CalculateAngle(&OtherAtom->x, &Runner->x, &Walker->x);
+                  const double angle = CalculateAngle(&OtherAtom->x, &(*Runner)->x, &(*Walker)->x);
                   OtherHydrogenFlag = OtherHydrogenFlag && (angle > M_PI*(30./180.) + MYEPSILON);
                   Otherangle += angle;
 …
               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++) {
                   atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
+                for (BondList::const_iterator BondRunner = (*Walker)->ListOfBonds.begin(); BondRunner != (*Walker)->ListOfBonds.end(); BondRunner++) {
+                  atom * const OtherAtom = (*BondRunner)->GetOtherAtom(*Walker);
                   if (OtherAtom->type->Z == 1) {
                     // check angle
                     if (CheckHydrogenBridgeBondAngle(Walker, OtherAtom, Runner)) {
                       DoLog(1) && (Log() << Verbose(1) << Walker->getName() << ", " << OtherAtom->getName() << " and " << Runner->getName() << " has a hydrogen bridge bond with distance " << sqrt(distance) << " and angle " << CalculateAngle(&OtherAtom->x, &Walker->x, &Runner->x)*(180./M_PI) << "." << endl);
+                    if (CheckHydrogenBridgeBondAngle(*Walker, OtherAtom, *Runner)) {
+                      DoLog(1) && (Log() << Verbose(1) << (*Walker)->getName() << ", " << OtherAtom->getName() << " and " << (*Runner)->getName() << " has a hydrogen bridge bond with distance " << sqrt(distance) << " and angle " << CalculateAngle(&OtherAtom->x, &(*Walker)->x, &(*Runner)->x)*(180./M_PI) << "." << endl);
                       count++;
                       break;
 …
 int CountBondsOfTwo(MoleculeListClass * const molecules, const element * const first, const element * const second)
+{
-  atom *Walker = NULL;
   int count = 0;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
     Walker = (*MolWalker)->start;
     while (Walker->next != (*MolWalker)->end) {
       Walker = Walker->next;
       if ((Walker->type == first) || (Walker->type == second)) {  // first element matches
         for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
           atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
           if (((OtherAtom->type == first) || (OtherAtom->type == second)) && (Walker->nr < OtherAtom->nr)) {
+    molecule::iterator Walker = (*MolWalker)->begin();
+    for(;Walker!=(*MolWalker)->end();++Walker){
+      atom * theAtom = *Walker;
+      if ((theAtom->type == first) || (theAtom->type == second)) {  // first element matches
+        for (BondList::const_iterator BondRunner = theAtom->ListOfBonds.begin(); BondRunner != theAtom->ListOfBonds.end(); BondRunner++) {
+          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(theAtom);
+          if (((OtherAtom->type == first) || (OtherAtom->type == second)) && (theAtom->nr < OtherAtom->nr)) {
             count++;
             DoLog(1) && (Log() << Verbose(1) << first->name << "-" << second->name << " bond found between " << *Walker << " and " << *OtherAtom << "." << endl);
 …
   bool MatchFlag[2];
   bool result = false;
-  atom *Walker = NULL;
   const element * ElementArray[2];
   ElementArray[0] = first;
 …
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin();MolWalker != molecules->ListOfMolecules.end(); MolWalker++) {
     Walker = (*MolWalker)->start;
     while (Walker->next != (*MolWalker)->end) {
       Walker = Walker->next;
       if (Walker->type == second) {  // first element matches
+    molecule::iterator Walker = (*MolWalker)->begin();
+    for(;Walker!=(*MolWalker)->end();++Walker){
+      atom *theAtom = *Walker;
+      if (theAtom->type == second) {  // first element matches
         for (int i=0;i<2;i++)
           MatchFlag[i] = false;
         for (BondList::const_iterator BondRunner = Walker->ListOfBonds.begin(); BondRunner != Walker->ListOfBonds.end(); BondRunner++) {
           atom * const OtherAtom = (*BondRunner)->GetOtherAtom(Walker);
+        for (BondList::const_iterator BondRunner = theAtom->ListOfBonds.begin(); BondRunner != theAtom->ListOfBonds.end(); BondRunner++) {
+          atom * const OtherAtom = (*BondRunner)->GetOtherAtom(theAtom);
           for (int i=0;i<2;i++)
             if ((!MatchFlag[i]) && (OtherAtom->type == ElementArray[i])) {

src/analysis_bonds.hpp

rc39cc4	rbdb143
31	31
32	32	void GetMaxMinMeanBondCount(const molecule * const mol, double &Min, double &Mean, double &Max);
33		void MinMeanMaxBondDistanceBetweenElements(const molecule mol, ~~element type1,~~ element *type2, double &Min, double &Mean, double &Max);
	33	void MinMeanMaxBondDistanceBetweenElements(const molecule mol, const element type1, const element *type2, double &Min, double &Mean, double &Max);
34	34
35	35	int CountHydrogenBridgeBonds(MoleculeListClass * const molecules, const element * InterfaceElement, const element * Interface2Element);

src/analysis_correlation.cpp

-              rc39cc4
+              rbdb143
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include <iostream>
 …
 /** Calculates the pair correlation between given elements.
  * Note given element order is unimportant (i.e. g(Si, O) === g(O, Si))
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type1 first element or NULL (if any element)
+ * \param *type2 second element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \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 element * const type1, const element * const type2 )
+PairCorrelationMap *PairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements)
+{
   Info FunctionInfo(__func__);
   PairCorrelationMap *outmap = NULL;
   double distance = 0.;
+  double *domain = World::getInstance().getDomain();
   if (molecules->ListOfMolecules.empty()) {
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    (*MolWalker)->doCountAtoms();
+  // create all possible pairs of elements
+  set <pair<element *, element *> > PairsOfElements;
+  if (elements.size() >= 2) {
+    for (vector<element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
+      for (vector<element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
+        if (type1 != type2) {
+          PairsOfElements.insert( pair<element *, element*>(*type1,*type2) );
+          DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << (*type1)->symbol << " and " << (*type2)->symbol << "." << endl);
+        }
+  } else if (elements.size() == 1) { // one to all are valid
+    element *elemental = *elements.begin();
+    PairsOfElements.insert( pair<element *, element*>(elemental,(element *)NULL) );
+    PairsOfElements.insert( pair<element *, element*>((element *)NULL,elemental) );
+  } else { // all elements valid
+    PairsOfElements.insert( pair<element *, element*>((element *)NULL, (element *)NULL) );
+  }
   outmap = new PairCorrelationMap;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  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);
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
+        if ((type1 == NULL) || (Walker->type == type1)) {
+          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);
+              atom *OtherWalker = (*MolOtherWalker)->start;
+              while (OtherWalker->next != (*MolOtherWalker)->end) { // only go up to Walker
+                OtherWalker = OtherWalker->next;
+                DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << *OtherWalker << "." << endl);
+                if (Walker->nr < OtherWalker->nr)
+                  if ((type2 == NULL) || (OtherWalker->type == type2)) {
+                    distance = Walker->node->PeriodicDistance(*OtherWalker->node, World::getInstance().getDomain());
+                    //Log() << Verbose(1) <<"Inserting " << *Walker << " and " << *OtherWalker << endl;
+                    outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
+      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)) ) );
+                  }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
   return outmap;
 };
 …
 /** Calculates the pair correlation between given elements.
  * Note given element order is unimportant (i.e. g(Si, O) === g(O, Si))
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type1 first element or NULL (if any element)
+ * \param *type2 second element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \param &elements vector of elements to correlate
  * \param ranges[NDIM] interval boundaries for the periodic images to scan also
  * \return Map of doubles with values the pair of the two atoms.
  */
 PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const element * const type1, const element * const type2, const int ranges[NDIM] )
+PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    (*MolWalker)->doCountAtoms();
+  // create all possible pairs of elements
+  set <pair<element *, element *> > PairsOfElements;
+  if (elements.size() >= 2) {
+    for (vector<element *>::const_iterator type1 = elements.begin(); type1 != elements.end(); ++type1)
+      for (vector<element *>::const_iterator type2 = elements.begin(); type2 != elements.end(); ++type2)
+        if (type1 != type2) {
+          PairsOfElements.insert( pair<element *, element*>(*type1,*type2) );
+          DoLog(1) && (Log() << Verbose(1) << "Creating element pair " << (*type1)->symbol << " and " << (*type2)->symbol << "." << endl);
+        }
+  } else if (elements.size() == 1) { // one to all are valid
+    element *elemental = *elements.begin();
+    PairsOfElements.insert( pair<element *, element*>(elemental,(element *)NULL) );
+    PairsOfElements.insert( pair<element *, element*>((element *)NULL,elemental) );
+  } else { // all elements valid
+    PairsOfElements.insert( pair<element *, element*>((element *)NULL, (element *)NULL) );
+  }
   outmap = new PairCorrelationMap;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+  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);
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
+        if ((type1 == NULL) || (Walker->type == type1)) {
+          periodicX = *(Walker->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);
+                    atom *OtherWalker = (*MolOtherWalker)->start;
+                    while (OtherWalker->next != (*MolOtherWalker)->end) { // only go up to Walker
+                      OtherWalker = OtherWalker->next;
+                      DoLog(3) && (Log() << Verbose(3) << "Current otheratom is " << *OtherWalker << "." << endl);
+                      if (Walker->nr < OtherWalker->nr)
+                        if ((type2 == NULL) || (OtherWalker->type == type2)) {
+                          periodicOtherX = *(OtherWalker->node);
+      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
 …
                                 checkOtherX.MatrixMultiplication(FullMatrix);
                                 distance = checkX.distance(checkOtherX);
                                 //Log() << Verbose(1) <<"Inserting " << *Walker << " and " << *OtherWalker << endl;
                                 outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> (Walker, OtherWalker) ) );
+                                //Log() << Verbose(1) <<"Inserting " << *(*iter) << " and " << *(*runner) << endl;
+                                outmap->insert ( pair<double, pair <atom *, atom*> > (distance, pair<atom *, atom*> ((*iter), (*runner)) ) );
+                              }
+                        }
+                    }
+                  }
+                }
+              }
+            }
+        }
+      }
       Free(&FullMatrix);
       Free(&FullInverseMatrix);
+    }
+      }
+      delete[](FullMatrix);
+      delete[](FullInverseMatrix);
+    }
+  }
   return outmap;
 …
 /** Calculates the distance (pair) correlation between a given element and a point.
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \param &elements vector of elements to correlate with point
  * \param *point vector to the correlation point
  * \return Map of dobules with values as pairs of atom and the vector
  */
 CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &molecules, const element * const type, const Vector *point )
+CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &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()) {
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.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);
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
+        if ((type == NULL) || (Walker->type == type)) {
+          distance = Walker->node->PeriodicDistance(*point, World::getInstance().getDomain());
+          DoLog(4) && (Log() << Verbose(4) << "Current distance is " << distance << "." << endl);
+          outmap->insert ( pair<double, pair<atom *, const Vector*> >(distance, pair<atom *, const Vector*> (Walker, point) ) );
+        }
+      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) ) );
+          }
+      }
+    }
 …
 /** Calculates the distance (pair) correlation between a given element, all its periodic images and a point.
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \param &elements vector of elements to correlate to point
  * \param *point vector to the correlation point
  * \param ranges[NDIM] interval boundaries for the periodic images to scan also
  * \return Map of dobules with values as pairs of atom and the vector
  */
 CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const element * const type, const Vector *point, const int ranges[NDIM] )
+CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Vector *point, const int ranges[NDIM] )
+{
   Info FunctionInfo(__func__);
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToPointMap;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
 …
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
+        if ((type == NULL) || (Walker->type == type)) {
+          periodicX = *(Walker->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*> (Walker, point) ) );
+              }
+        }
+      }
+      Free(&FullMatrix);
+      Free(&FullInverseMatrix);
+      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);
+    }
 …
 /** Calculates the distance (pair) correlation between a given element and a surface.
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \param &elements vector of elements to correlate to surface
  * \param *Surface pointer to Tesselation class surface
  * \param *LC LinkedCell structure to quickly find neighbouring atoms
  * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
  */
 CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC )
+CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const std::vector<element *> &elements, const Tesselation * const Surface, const LinkedCell *LC )
+{
   Info FunctionInfo(__func__);
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.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);
+      atom *Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        //Log() << Verbose(1) << "Current atom is " << *Walker << "." << endl;
+        if ((type == NULL) || (Walker->type == type)) {
+          TriangleIntersectionList Intersections(Walker->node,Surface,LC);
+          distance = Intersections.GetSmallestDistance();
+          triangle = Intersections.GetClosestTriangle();
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> (Walker, triangle) ) );
+        }
+      }
+    } else
+      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);
+    }
   return outmap;
 …
  * axis an integer from [ -ranges[i], ranges[i] ] onto it and multiply with the domain matrix to bring it back into
  * the real space. Then, we Tesselation::FindClosestTriangleToPoint() and DistanceToTrianglePlane().
+ * \param *out output stream for debugging
+ * \param *molecules list of molecules structure
+ * \param *type element or NULL (if any element)
+ * \param *molecules list of molecules structure
+ * \param &elements vector of elements to correlate to surface
  * \param *Surface pointer to Tesselation class surface
  * \param *LC LinkedCell structure to quickly find neighbouring atoms
 …
  * \return Map of doubles with values as pairs of atom and the BoundaryTriangleSet that's closest
  */
 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC, 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] )
+{
   Info FunctionInfo(__func__);
 …
     return outmap;
+  }
+  for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
+    (*MolWalker)->doCountAtoms();
   outmap = new CorrelationToSurfaceMap;
   double ShortestDistance = 0.;
 …
       double * FullInverseMatrix = InverseMatrix(FullMatrix);
       DoLog(2) && (Log() << Verbose(2) << "Current molecule is " << *MolWalker << "." << endl);
       atom *Walker = (*MolWalker)->start;
       while (Walker->next != (*MolWalker)->end) {
         Walker = Walker->next;
         DoLog(3) && (Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl);
         if ((type == NULL) || (Walker->type == type)) {
           periodicX = *(Walker->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 (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;
+                  }
+                }
+              }
+          // insert
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (Walker, ShortestTriangle) ) );
+          //Log() << Verbose(1) << "INFO: Inserting " << Walker << " with distance " << ShortestDistance << " to " << *ShortestTriangle << "." << endl;
+        }
+      }
+      Free(&FullMatrix);
+      Free(&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;
+          }
+      }
+      delete[](FullMatrix);
+      delete[](FullInverseMatrix);
+    }

src/analysis_correlation.hpp

-              rc39cc4
+              rbdb143
 /********************************************** declarations *******************************/
 PairCorrelationMap *PairCorrelation(MoleculeListClass * const &molecules, const element * const type1, const element * const  type2 );
 CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &molecules, const element * const type, const Vector *point );
 CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC );
 PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const element * const type1, const element * const  type2, const int ranges[NDIM] );
 CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const element * const type, const Vector *point, const int ranges[NDIM] );
 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] );
+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] );
 int GetBin ( const double value, const double BinWidth, const double BinStart );
 void OutputCorrelation( ofstream * const file, const BinPairMap * const map );

src/analyzer.cpp

-              rc39cc4
+              rbdb143
 //============================ INCLUDES ===========================
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
     return 1;
   } else {
     dir = Malloc<char>(strlen(argv[2]) + 2, "main: *dir");
+    dir = new char[strlen(argv[2]) + 2];
     strcpy(dir, "/");
     strcat(dir, argv[2]);
 …
   if (argc > 4) {
     DoLog(0) && (Log() << Verbose(0) << "Loading periodentafel." << endl);
     periode = Malloc<periodentafel>(1, "main - periode");
+    periode = new periodentafel;
     periode->LoadPeriodentafel(argv[4]);
+  }
 …
   // ++++++++++++++++ exit ++++++++++++++++++++++++++++++++++
   delete(periode);
   Free(&dir);
+  delete[](dir);
   DoLog(0) && (Log() << Verbose(0) << "done." << endl);
   return 0;

src/atom.cpp

-              rc39cc4
+              rbdb143
+ *
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 …
 #include "vector.hpp"
 #include "World.hpp"
+#include "molecule.hpp"
 /************************************* Functions for class atom *************************************/
 …
  */
 atom::atom() :
   previous(NULL), next(NULL), father(this), sort(&nr)
+  father(this), sort(&nr), mol(0)
+{
   node = &x;  // TesselPoint::x can only be referenced from here
 …
  */
 atom::atom(atom *pointer) :
+    ParticleInfo(pointer),
+    previous(NULL), next(NULL), father(pointer), sort(&nr)
+    ParticleInfo(pointer),father(pointer), sort(&nr)
+{
   type = pointer->type;  // copy element of atom
 …
   FixedIon = pointer->FixedIon;
   node = &x;
+  mol = 0;
 };
 atom *atom::clone(){
   atom *res = new atom(this);
-  res->previous=0;
-  res->next=0;
   res->father = this;
   res->sort = &res->nr;
 …
   res->FixedIon = FixedIon;
   res->node = &x;
+  res->mol = 0;
   World::getInstance().registerAtom(res);
   return res;
 …
 atom::~atom()
+{
+  unlink(this);
+  removeFromMolecule();
+  for(BondList::iterator iter=ListOfBonds.begin(); iter!=ListOfBonds.end();){
+    // deleting the bond will invalidate the iterator !!!
+    bond *bond =*(iter++);
+    delete(bond);
+  }
 };
 …
   * \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 int *ElementNo, int *AtomNo, const char *comment) const
+{
   AtomNo[type->Z]++;  // increment number
 …
  * \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;
 …
+{
   if (ComponentNr != NULL)
     Free(&ComponentNr);
   ComponentNr = Malloc<int>(ListOfBonds.size()+1, "atom::InitComponentNumbers: *ComponentNr");
+    delete[](ComponentNr);
+  ComponentNr = new int[ListOfBonds.size()+1];
   for (int i=ListOfBonds.size()+1;i--;)
     ComponentNr[i] = -1;
 …
+}
 atomId_t atom::getId() {
+atomId_t atom::getId() const {
   return id;
+}
+void atom::setMolecule(molecule *_mol){
+  // take this atom from the old molecule
+  removeFromMolecule();
+  mol = _mol;
+  if(!mol->containsAtom(this)){
+    mol->AddAtom(this);
+  }
+}
+void atom::removeFromMolecule(){
+  if(mol){
+    if(mol->containsAtom(this)){
+      mol->erase(this);
+    }
+    mol=0;
+  }
+}
 atom* NewAtom(atomId_t _id){

src/atom.hpp

-              rc39cc4
+              rbdb143
 class Vector;
 class World;
+class molecule;
 /********************************************** declarations *******************************/
 …
   friend void  DeleteAtom(atom*);
   public:
-    atom *previous; //!< previous atom in molecule list
-    atom *next;     //!< next atom in molecule list
     atom *father;   //!< In many-body bond order fragmentations points to originating atom
     int *sort;      //!< sort criteria
 …
   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 int *ElementNo, 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 setWorld(World*);
   virtual atomId_t getId();
+  virtual atomId_t getId() const;
   virtual bool changeId(atomId_t newId);
 …
    virtual void setId(atomId_t);
+   void setMolecule(molecule*);
+   void removeFromMolecule();
   protected:
     /**
      * Protected constructor to ensure construction of atoms through the world.
 …
     virtual ~atom();
   private:
+    molecule *mol; // !< the molecule this atom belongs to
     World* world;
     atomId_t id;

src/atom_atominfo.cpp

rc39cc4	rbdb143
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "periodentafel.hpp"

src/atom_bondedparticle.cpp

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

src/atom_bondedparticle.hpp

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

src/atom_bondedparticleinfo.cpp

rc39cc4	rbdb143
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "atom_bondedparticleinfo.hpp"

src/atom_graphnode.cpp

rc39cc4	rbdb143
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "atom_graphnode.hpp"

src/atom_graphnodeinfo.cpp

-              rc39cc4
+              rbdb143
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom_graphnodeinfo.hpp"
 …
 GraphNodeInfo::~GraphNodeInfo()
+{
   Free<int>(&ComponentNr, "atom::~atom: *ComponentNr");
+  delete[](ComponentNr);
 };

src/atom_particleinfo.cpp

rc39cc4	rbdb143
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "atom_particleinfo.hpp"

src/atom_trajectoryparticle.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 #include "atom_trajectoryparticle.hpp"
 #include "config.hpp"
 #include "element.hpp"
+#include "info.hpp"
 #include "log.hpp"
 #include "parser.hpp"
+#include "ThermoStatContainer.hpp"
 #include "verbose.hpp"
 …
 void TrajectoryParticle::ResizeTrajectory(int MaxSteps)
+{
+  Info FunctionInfo(__func__);
   if (Trajectory.R.size() <= (unsigned int)(MaxSteps)) {
     //Log() << Verbose(0) << "Increasing size for trajectory array of " << keyword << " to " << (MaxSteps+1) << "." << endl;
+    DoLog(0) && (Log() << Verbose(0) << "Increasing size for trajectory array of " << nr << " from " << Trajectory.R.size() << " to " << (MaxSteps+1) << "." << endl);
     Trajectory.R.resize(MaxSteps+1);
     Trajectory.U.resize(MaxSteps+1);
 …
 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_trajectoryparticleinfo.cpp

rc39cc4	rbdb143
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "atom_trajectoryparticleinfo.hpp"

src/atom_trajectoryparticleinfo.hpp

-              rc39cc4
+              rbdb143
 #include "vector.hpp"
+#include "VectorSet.hpp"
 /********************************************** declarations *******************************/
 …
   struct
+  {
     vector<Vector> R;  //!< position vector
     vector<Vector> U;  //!< velocity vector
     vector<Vector> F;  //!< last force vector
+    VectorSet<vector<Vector> > R;  //!< position vector
+    VectorSet<vector<Vector> > U;  //!< velocity vector
+    VectorSet<vector<Vector> > F;  //!< last force vector
   } Trajectory;
   int FixedIon;   //!< config variable that states whether forces act on the ion or not

src/bond.cpp

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

src/bondgraph.cpp

-              rc39cc4
+              rbdb143
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include <iostream>
 …
+{
   Info FunctionInfo(__func__);
 bool status = true;
+  bool status = true;
   if (mol->start->next == mol->end) // only construct if molecule is not empty
+  if (mol->empty()) // only construct if molecule is not empty
     return false;
 …
   max_distance = 0.;
+  atom *Runner = mol->start;
+  while (Runner->next != mol->end) {
+    Runner = Runner->next;
+    if (Runner->type->CovalentRadius > max_distance)
+      max_distance = Runner->type->CovalentRadius;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((*iter)->type->CovalentRadius > max_distance)
+      max_distance = (*iter)->type->CovalentRadius;
+  }
   max_distance *= 2.;

src/bondgraph.hpp

rc39cc4	rbdb143
27	27
28	28	class molecule;
29		class ~~periodentafel~~;
	29	class BondedParticle;
30	30	class MatrixContainer;
31	31

src/boundary.cpp

-              rc39cc4
+              rbdb143
  * Implementations and super-function for envelopes
  */
+#include "Helpers/MemDebug.hpp"
 #include "World.hpp"
 …
+{
         Info FunctionInfo(__func__);
-  atom *Walker = NULL;
   PointMap PointsOnBoundary;
   LineMap LinesOnBoundary;
 …
     // 3b. construct set of all points, transformed into cylindrical system and with left and right neighbours
+    Walker = mol->start;
+    while (Walker->next != mol->end) {
+      Walker = Walker->next;
+      ProjectedVector = Walker->x - (*MolCenter);
+    for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+      ProjectedVector = (*iter)->x - (*MolCenter);
       ProjectedVector.ProjectOntoPlane(AxisVector);
 …
         angle = 2. * M_PI - angle;
+      }
       DoLog(1) && (Log() << Verbose(1) << "Inserting " << *Walker << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl);
       BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, Walker)));
+    DoLog(1) && (Log() << Verbose(1) << "Inserting " << **iter << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl);
+      BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, (*iter))));
       if (!BoundaryTestPair.second) { // same point exists, check first r, then distance of original vectors to center of gravity
         DoLog(2) && (Log() << Verbose(2) << "Encountered two vectors whose projection onto axis " << axis << " is equal: " << endl);
         DoLog(2) && (Log() << Verbose(2) << "Present vector: " << *BoundaryTestPair.first->second.second << endl);
         DoLog(2) && (Log() << Verbose(2) << "New vector: " << *Walker << endl);
+        DoLog(2) && (Log() << Verbose(2) << "New vector: " << **iter << endl);
         const double ProjectedVectorNorm = ProjectedVector.NormSquared();
         if ((ProjectedVectorNorm - BoundaryTestPair.first->second.first) > MYEPSILON) {
           BoundaryTestPair.first->second.first = ProjectedVectorNorm;
           BoundaryTestPair.first->second.second = Walker;
+          BoundaryTestPair.first->second.second = (*iter);
           DoLog(2) && (Log() << Verbose(2) << "Keeping new vector due to larger projected distance " << ProjectedVectorNorm << "." << endl);
         } else if (fabs(ProjectedVectorNorm - BoundaryTestPair.first->second.first) < MYEPSILON) {
+          helper = Walker->x - (*MolCenter);
+          helper = (*iter)->x;
+          helper -= *MolCenter;
           const double oldhelperNorm = helper.NormSquared();
           helper = BoundaryTestPair.first->second.second->x - (*MolCenter);
           if (helper.NormSquared() < oldhelperNorm) {
             BoundaryTestPair.first->second.second = Walker;
+            BoundaryTestPair.first->second.second = (*iter);
             DoLog(2) && (Log() << Verbose(2) << "Keeping new vector due to larger distance to molecule center " << helper.NormSquared() << "." << endl);
           } else {
 …
     do { // do as long as we still throw one out per round
       flag = false;
+      Boundaries::iterator left = BoundaryPoints[axis].end();
+      Boundaries::iterator right = BoundaryPoints[axis].end();
+      for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
+      Boundaries::iterator left = BoundaryPoints[axis].begin();
+      Boundaries::iterator right = BoundaryPoints[axis].begin();
+      Boundaries::iterator runner = BoundaryPoints[axis].begin();
+      bool LoopOnceDone = false;
+      while (!LoopOnceDone) {
+        runner = right;
+        right++;
         // set neighbours correctly
         if (runner == BoundaryPoints[axis].begin()) {
 …
+        }
         left--;
-        right = runner;
-        right++;
         if (right == BoundaryPoints[axis].end()) {
           right = BoundaryPoints[axis].begin();
+          LoopOnceDone = true;
+        }
         // check distance
 …
             DoLog(1) && (Log() << Verbose(1) << "Throwing out " << *runner->second.second << "." << endl);
             BoundaryPoints[axis].erase(runner);
+            runner = right;
             flag = true;
+          }
 …
   // 4. Store triangles in tecplot file
+  if (filename != NULL) {
+    if (DoTecplotOutput) {
+      string OutputName(filename);
+      OutputName.append("_intermed");
+      OutputName.append(TecplotSuffix);
+      ofstream *tecplot = new ofstream(OutputName.c_str());
+      WriteTecplotFile(tecplot, TesselStruct, mol, 0);
+      tecplot->close();
+      delete(tecplot);
+    }
+    if (DoRaster3DOutput) {
+      string OutputName(filename);
+      OutputName.append("_intermed");
+      OutputName.append(Raster3DSuffix);
+      ofstream *rasterplot = new ofstream(OutputName.c_str());
+      WriteRaster3dFile(rasterplot, TesselStruct, mol);
+      rasterplot->close();
+      delete(rasterplot);
+    }
+  }
+  StoreTrianglesinFile(mol, TesselStruct, filename, "_intermed");
   // 3d. check all baselines whether the peaks of the two adjacent triangles with respect to center of baseline are convex, if not, make the baseline between the two peaks and baseline endpoints become the new peaks
 …
           TesselStruct->FlipBaseline(line);
           DoLog(1) && (Log() << Verbose(1) << "INFO: Correction of concave baselines worked." << endl);
+          LineRunner = TesselStruct->LinesOnBoundary.begin(); // LineRunner may have been erase if line was deleted from LinesOnBoundary
+        }
+      }
 …
   // 4. Store triangles in tecplot file
+  if (filename != NULL) {
+    if (DoTecplotOutput) {
+      string OutputName(filename);
+      OutputName.append(TecplotSuffix);
+      ofstream *tecplot = new ofstream(OutputName.c_str());
+      WriteTecplotFile(tecplot, TesselStruct, mol, 0);
+      tecplot->close();
+      delete(tecplot);
+    }
+    if (DoRaster3DOutput) {
+      string OutputName(filename);
+      OutputName.append(Raster3DSuffix);
+      ofstream *rasterplot = new ofstream(OutputName.c_str());
+      WriteRaster3dFile(rasterplot, TesselStruct, mol);
+      rasterplot->close();
+      delete(rasterplot);
+    }
+  }
+  StoreTrianglesinFile(mol, TesselStruct, filename, "");
   // free reference lists
 …
 /** Creates multiples of the by \a *mol given cluster and suspends them in water with a given final density.
  * We get cluster volume by VolumeOfConvexEnvelope() and its diameters by GetDiametersOfCluster()
+ * TODO: Here, we need a VolumeOfGeneralEnvelope (i.e. non-convex one)
  * \param *out output stream for debugging
  * \param *configuration needed for path to store convex envelope file
 …
   int repetition[NDIM] = { 1, 1, 1 };
   int TotalNoClusters = 1;
-  atom *Walker = NULL;
   double totalmass = 0.;
   double clustervolume = 0.;
 …
   GreatestDiameter = GetDiametersOfCluster(BoundaryPoints, mol, TesselStruct, IsAngstroem);
   BoundaryPoints = GetBoundaryPoints(mol, TesselStruct);
+  LinkedCell LCList(mol, 10.);
+  FindConvexBorder(mol, TesselStruct, &LCList, NULL);
+  LinkedCell *LCList = new LinkedCell(mol, 10.);
+  FindConvexBorder(mol, TesselStruct, (const LinkedCell *&)LCList, NULL);
+  delete (LCList);
   // some preparations beforehand
 …
   // sum up the atomic masses
+  Walker = mol->start;
+  while (Walker->next != mol->end) {
+      Walker = Walker->next;
+      totalmass += Walker->type->mass;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+      totalmass += (*iter)->type->mass;
+  }
   DoLog(0) && (Log() << Verbose(0) << "RESULT: The summed mass is " << setprecision(10) << totalmass << " atomicmassunit." << endl);
 …
   Vector Inserter;
   double FillIt = false;
-  atom *Walker = NULL;
   bond *Binder = NULL;
   double phi[NDIM];
 …
   for (MoleculeList::iterator ListRunner = List->ListOfMolecules.begin(); ListRunner != List->ListOfMolecules.end(); ListRunner++)
     if ((*ListRunner)->AtomCount > 0) {
+    if ((*ListRunner)->getAtomCount() > 0) {
       DoLog(1) && (Log() << Verbose(1) << "Pre-creating linked cell lists for molecule " << *ListRunner << "." << endl);
       LCList[(*ListRunner)] = new LinkedCell((*ListRunner), 10.); // get linked cell list
 …
   filler->CenterEdge(&Inserter);
   filler->Center.Zero();
+  const int FillerCount = filler->getAtomCount();
   DoLog(2) && (Log() << Verbose(2) << "INFO: Filler molecule has the following bonds:" << endl);
+  Binder = filler->first;
+  while(Binder->next != filler->last) {
+    Binder = Binder->next;
+    DoLog(2) && (Log() << Verbose(2) << "  " << *Binder << endl);
+  }
+  filler->CountAtoms();
+  atom * CopyAtoms[filler->AtomCount];
+  for(molecule::iterator AtomRunner = filler->begin(); AtomRunner != filler->end(); ++AtomRunner)
+    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner)
+        DoLog(2) && (Log() << Verbose(2) << "  " << *(*BondRunner) << endl);
+  atom * CopyAtoms[FillerCount];
   // calculate filler grid in [0,1]^3
 …
         // go through all atoms
         for (int i=0;i<filler->AtomCount;i++)
+        for (int i=0;i<FillerCount;i++)
           CopyAtoms[i] = NULL;
+        Walker = filler->start;
+        while (Walker->next != filler->end) {
+          Walker = Walker->next;
+        for(molecule::const_iterator iter = filler->begin(); iter !=filler->end();++iter){
           // create atomic random translation vector ...
 …
           // ... and put at new position
           Inserter = Walker->x;
+          Inserter = (*iter)->x;
           if (DoRandomRotation)
             Inserter.MatrixMultiplication(Rotations);
 …
             DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is outer point." << endl);
             // copy atom ...
             CopyAtoms[Walker->nr] = Walker->clone();
             CopyAtoms[Walker->nr]->x = Inserter;
             Filling->AddAtom(CopyAtoms[Walker->nr]);
             DoLog(4) && (Log() << Verbose(4) << "Filling atom " << *Walker << ", translated to " << AtomTranslations << ", at final position is " << (CopyAtoms[Walker->nr]->x) << "." << endl);
+            CopyAtoms[(*iter)->nr] = (*iter)->clone();
+            CopyAtoms[(*iter)->nr]->x = Inserter;
+            Filling->AddAtom(CopyAtoms[(*iter)->nr]);
+            DoLog(4) && (Log() << Verbose(4) << "Filling atom " << **iter << ", translated to " << AtomTranslations << ", at final position is " << (CopyAtoms[(*iter)->nr]->x) << "." << endl);
           } else {
             DoLog(1) && (Log() << Verbose(1) << "INFO: Position at " << Inserter << " is inner point, within boundary or outside of MaxDistance." << endl);
             CopyAtoms[Walker->nr] = NULL;
+            CopyAtoms[(*iter)->nr] = NULL;
             continue;
+          }
+        }
         // go through all bonds and add as well
+        Binder = filler->first;
+        while(Binder->next != filler->last) {
+          Binder = Binder->next;
+          if ((CopyAtoms[Binder->leftatom->nr] != NULL) && (CopyAtoms[Binder->rightatom->nr] != NULL)) {
+            Log()  << Verbose(3) << "Adding Bond between " << *CopyAtoms[Binder->leftatom->nr] << " and " << *CopyAtoms[Binder->rightatom->nr]<< "." << endl;
+            Filling->AddBond(CopyAtoms[Binder->leftatom->nr], CopyAtoms[Binder->rightatom->nr], Binder->BondDegree);
+          }
+        }
+        for(molecule::iterator AtomRunner = filler->begin(); AtomRunner != filler->end(); ++AtomRunner)
+          for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+            if ((*BondRunner)->leftatom == *AtomRunner) {
+              Binder = (*BondRunner);
+              if ((CopyAtoms[Binder->leftatom->nr] != NULL) && (CopyAtoms[Binder->rightatom->nr] != NULL)) {
+                Log()  << Verbose(3) << "Adding Bond between " << *CopyAtoms[Binder->leftatom->nr] << " and " << *CopyAtoms[Binder->rightatom->nr]<< "." << endl;
+                Filling->AddBond(CopyAtoms[Binder->leftatom->nr], CopyAtoms[Binder->rightatom->nr], Binder->BondDegree);
+              }
+            }
+      }
   Free(&M);
   Free(&MInverse);
+  delete[](M);
+  delete[](MInverse);
   return Filling;
 …
   bool TesselationFailFlag = false;
+  mol->getAtomCount();
   if (TesselStruct == NULL) {
     DoLog(1) && (Log() << Verbose(1) << "Allocating Tesselation struct ..." << endl);
 …
 //  // look whether all points are inside of the convex envelope, otherwise add them via degenerated triangles
 //  //->InsertStraddlingPoints(mol, LCList);
 //  mol->GoToFirst();
+//  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
 //  class TesselPoint *Runner = NULL;
+//  while (!mol->IsEnd()) {
+//    Runner = mol->GetPoint();
+//    Runner = *iter;
 //    Log() << Verbose(1) << "Checking on " << Runner->Name << " ... " << endl;
 //    if (!->IsInnerPoint(Runner, LCList)) {
 …
 //      Log() << Verbose(2) << Runner->Name << " is inside of or on envelope." << endl;
 //    }
-//    mol->GoToNext();
 //  }
 …
 //  status = CheckListOfBaselines(TesselStruct);
+  cout << "before correction" << endl;
   // store before correction
   StoreTrianglesinFile(mol, (const Tesselation *&)TesselStruct, filename, "");
+  StoreTrianglesinFile(mol, TesselStruct, filename, "");
 //  // correct degenerated polygons
 …
   // write final envelope
   CalculateConcavityPerBoundaryPoint(TesselStruct);
+  StoreTrianglesinFile(mol, (const Tesselation *&)TesselStruct, filename, "");
+  cout << "after correction" << endl;
+  StoreTrianglesinFile(mol, TesselStruct, filename, "");
   if (freeLC)

src/builder.cpp

-              rc39cc4
+              rbdb143
 /** \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 "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 "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/MethodAction.hpp"
+#include "Actions/small_actions.hpp"
+#include "World.hpp"
+#include "Actions/MapOfActions.hpp"
+#include "Parser/ChangeTracker.hpp"
+#include "Parser/FormatParserStorage.hpp"
+#include "UIElements/UIFactory.hpp"
+#include "UIElements/TextUI/TextUIFactory.hpp"
+#include "UIElements/CommandLineUI/CommandLineUIFactory.hpp"
+#include "UIElements/MainWindow.hpp"
+#include "UIElements/Dialog.hpp"
 #include "version.h"
-#include "World.hpp"
-#include "Helpers/MemDebug.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->AtomCount != 0) {  // if there is more than none
-          count = mol->AtomCount;  // 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->AtomCount+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->AtomCount-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->AtomCount].insert(mol->end->previous->nr);
-  TestSets[mol->AtomCount].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->AtomCount;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->AtomCount],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.
- * \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
- * \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)
+{
-  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");
-  int verbosity = 0;
-  strncpy(configuration.databasepath, LocalPath, MAXSTRINGSIZE-1);
-  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 '?':
-            DoLog(0) && (Log() << Verbose(0) << "MoleCuilder suite" << endl << "==================" << endl << endl);
-            DoLog(0) && (Log() << Verbose(0) << "Usage: " << argv[0] << "[config file] [-{acefpsthH?vfrp}] [further arguments]" << endl);
-            DoLog(0) && (Log() << Verbose(0) << "or simply " << argv[0] << " without arguments for interactive session." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-a Z x1 x2 x3\tAdd new atom of element Z at coordinates (x1,x2,x3)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-A <source>\tCreate adjacency list from bonds parsed from 'dbond'-style file." <<endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-b xx xy xz yy yz zz\tCenter atoms in domain with given symmetric matrix of (xx,xy,xz,yy,yz,zz)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-B xx xy xz yy yz zz\tBound atoms by domain with given symmetric matrix of (xx,xy,xz,yy,yz,zz)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-c x1 x2 x3\tCenter atoms in domain with a minimum distance to boundary of (x1,x2,x3)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-C <type> [params] <output> <bin output> <BinWidth> <BinStart> <BinEnd>\tPair Correlation analysis." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-d x1 x2 x3\tDuplicate cell along each axis by given factor." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-D <bond distance>\tDepth-First-Search Analysis of the molecule, giving cycles and tree/back edges." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-e <file>\tSets the databases path to be parsed (default: ./)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-E <id> <Z>\tChange atom <id>'s element to <Z>, <id> begins at 0." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-f <dist> <order>\tFragments the molecule in BOSSANOVA manner (with/out rings compressed) and stores config files in same dir as config (return code 0 - fragmented, 2 - no fragmentation necessary)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-F <xyz of filler> <dist_x> <dist_y> <dist_z> <epsilon> <randatom> <randmol> <DoRotate>\tFilling Box with water molecules." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-FF <MaxDistance> <xyz of filler> <dist_x> <dist_y> <dist_z> <epsilon> <randatom> <randmol> <DoRotate>\tFilling Box with water molecules." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-g <file>\tParses a bond length table from the given file." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-h/-?\tGive this help screen." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-H\tCount Hydrogen bridge bonds." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-I\t Dissect current system of molecules into a set of disconnected (subgraphs of) molecules." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-j\t<path> Store all bonds to file." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-J\t<path> Store adjacency per atom to file." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-L <step0> <step1> <prefix>\tStore a linear interpolation between two configurations <step0> and <step1> into single config files with prefix <prefix> and as Trajectories into the current config file." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-m <0/1>\tCalculate (0)/ Align in(1) PAS with greatest EV along z axis." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-M <basis>\tSetting basis to store to MPQC config files." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-n\tFast parsing (i.e. no trajectories are looked for)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-N <radius> <file>\tGet non-convex-envelope." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-o <out>\tGet volume of the convex envelope (and store to tecplot file)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-O\tCenter atoms in origin." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-p <file>\tParse given xyz file and create raw config file from it." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-P <file>\tParse given forces file and append as an MD step to config file via Verlet." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-r <id>\t\tRemove an atom with given id." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-R <id> <radius>\t\tRemove all atoms out of sphere around a given one." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-s x1 x2 x3\tScale all atom coordinates by this vector (x1,x2,x3)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-S <file> Store temperatures from the config file in <file>." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-t x1 x2 x3\tTranslate all atoms by this vector (x1,x2,x3)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-T x1 x2 x3\tTranslate periodically all atoms by this vector (x1,x2,x3)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-u rho\tsuspend in water solution and output necessary cell lengths, average density rho and repetition." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-v\t\tsets verbosity (more is more)." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-V\t\tGives version information." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "\t-X\t\tset default name of a molecule." << endl);
-            DoLog(0) && (Log() << Verbose(0) << "Note: config files must not begin with '-' !" << endl);
-            return (1);
-            break;
-          case 'v':
-            while (argv[argptr-1][verbosity+1] == 'v') {
-              verbosity++;
+            }
-            setVerbosity(verbosity);
-            DoLog(0) && (Log() << Verbose(0) << "Setting verbosity to " << verbosity << "." << endl);
-            break;
-          case 'V':
-            DoLog(0) && (Log() << Verbose(0) << argv[0] << " " << VERSIONSTRING << endl);
-            DoLog(0) && (Log() << Verbose(0) << "Build your own molecule position set." << endl);
-            return (1);
-            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 {
-              SaveFlag = true;
-              j = -1;
-              DoLog(1) && (Log() << Verbose(1) << "Centering atoms in config file within given simulation box." << endl);
-              double * const cell_size = World::getInstance().getDomain();
-              for (int i=0;i<6;i++) {
-                cell_size[i] = atof(argv[argptr+i]);
+              }
-              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 {
-              DoLog(0) && (Log() << Verbose(0) << "Using " << argv[argptr] << " as elements database." << endl);
-              strncpy (configuration.databasepath, argv[argptr], MAXSTRINGSIZE-1);
-              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 {
-              BondGraphFileName = argv[argptr];
-              DoLog(0) && (Log() << Verbose(0) << "Using " << BondGraphFileName << " as bond length table." << endl);
-              argptr+=1;
+            }
-            break;
-          case 'n':
-            DoLog(0) && (Log() << Verbose(0) << "I won't parse trajectories." << endl);
-            configuration.FastParsing = true;
-            break;
-          case 'X':
+            {
-              World::getInstance().setDefaultName(argv[argptr]);
-              DoLog(0) && (Log() << Verbose(0) << "Default name of new molecules set to " << *World::getInstance().getDefaultName() << "." << endl);
+            }
-            break;
-          default:   // no match? Step on
-            argptr++;
-            break;
+        }
-      } else
-        argptr++;
-    } while (argptr < argc);
-    // 3a. Parse the element database
-    if (periode->LoadPeriodentafel(configuration.databasepath)) {
-      DoLog(0) && (Log() << Verbose(0) << "Element list loaded successfully." << endl);
-      //periode->Output();
-    } else {
-      DoLog(0) && (Log() << Verbose(0) << "Element list loading failed." << endl);
-      return 1;
+    }
-    // 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);
-          ConfigFileName = argv[1];
-          configPresent = empty;
-          output.close();
+        }
-      } else {
-        test.close();
-        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);
+     }
-     if (configuration.BG == NULL) {
-       configuration.BG = new BondGraph(configuration.GetIsAngstroem());
-       if ((!BondGraphFileName.empty()) && (configuration.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);
+       }
+     }
-    // 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 >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3]))) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments for adding atom: -a <element> <x> <y> <z>" << endl);
-                performCriticalExit();
-              } else {
-                SaveFlag = true;
-                Log() << Verbose(1) << "Adding new atom with element " << argv[argptr] << " at (" << argv[argptr+1] << "," << argv[argptr+2] << "," << argv[argptr+3] << "), ";
-                first = World::getInstance().createAtom();
-                first->type = periode->FindElement(atoi(argv[argptr]));
-                if (first->type != NULL)
-                  DoLog(2) && (Log() << Verbose(2) << "found element " << first->type->name << endl);
-                for (int i=NDIM;i--;)
-                  first->x[i] = atof(argv[argptr+1+i]);
-                if (first->type != NULL) {
-                  mol->AddAtom(first);  // add to molecule
-                  if ((configPresent == empty) && (mol->AtomCount != 0))
-                    configPresent = present;
-                } else
-                  DoeLog(1) && (eLog()<< Verbose(1) << "Could not find the specified element." << endl);
-                argptr+=4;
+              }
-              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 'M':
-              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for setting MPQC basis: -B <basis name>" << endl);
-                performCriticalExit();
-              } else {
-                configuration.basis = argv[argptr];
-                DoLog(1) && (Log() << Verbose(1) << "Setting MPQC basis to " << configuration.basis << "." << endl);
-                argptr+=1;
+              }
-              break;
-            case 'D':
-              if (ExitFlag == 0) ExitFlag = 1;
+              {
-                DoLog(1) && (Log() << Verbose(1) << "Depth-First-Search Analysis." << endl);
-                MoleculeLeafClass *Subgraphs = NULL;      // list of subgraphs from DFS analysis
-                int *MinimumRingSize = new int[mol->AtomCount];
-                atom ***ListOfLocalAtoms = NULL;
-                class StackClass<bond *> *BackEdgeStack = NULL;
-                class StackClass<bond *> *LocalBackEdgeStack = NULL;
-                mol->CreateAdjacencyList(atof(argv[argptr]), configuration.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++)
-                    Free(&ListOfLocalAtoms[i]);
-                  Free(&ListOfLocalAtoms);
+                }
-                delete(BackEdgeStack);
-                delete[](MinimumRingSize);
+              }
-              //argptr+=1;
-              break;
-            case 'I':
-              DoLog(1) && (Log() << Verbose(1) << "Dissecting molecular system into a set of disconnected subgraphs ... " << endl);
-              // @TODO rather do the dissection afterwards
-              molecules->DissectMoleculeIntoConnectedSubgraphs(periode, &configuration);
-              mol = NULL;
-              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) && (!molecules->ListOfMolecules.empty())) {
-                mol = *(molecules->ListOfMolecules.begin());
-                if (mol != NULL)
-                  mol->ActiveFlag = true;
+              }
-              break;
-            case 'H':
-              if ((argptr+1 >= argc) || (argv[argptr][0] == '-') || (argv[argptr+1][0] == '-')) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for calculating hydrogen bridge bonds: -H <Z1> <Z2>" << endl);
-                performCriticalExit();
-              } else {
-                if (ExitFlag == 0) ExitFlag = 1;
-                const element *elemental = periode->FindElement((const int) atoi(argv[argptr]));
-                const element *elemental2 = periode->FindElement((const int) atoi(argv[argptr+1]));
-                cout << endl << "There are " << CountHydrogenBridgeBonds(molecules, elemental, elemental2) << " hydrogen bridges with connections to " << (elemental != 0 ? elemental->name : "None") << " and " << (elemental2 != 0 ? elemental2->name : "None") << "." << endl;
-                argptr+=1;
+              }
-              break;
-            case 'C':
+              {
-                int ranges[3] = {1, 1, 1};
-                bool periodic = (argv[argptr-1][2] =='p');
-                if (ExitFlag == 0) ExitFlag = 1;
-                if ((argptr >= 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':
+                      {
-                        if ((argptr+6 >= argc) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+5])) || (!IsValidNumber(argv[argptr+6])) || (!IsValidNumber(argv[argptr+2])) || (argv[argptr+1][0] == '-') || (argv[argptr+2][0] == '-') || (argv[argptr+3][0] == '-') || (argv[argptr+4][0] == '-')) {
-                          ExitFlag = 255;
-                          DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for pair correlation analysis: -C E <Z1> <Z2> <output> <bin output>" << endl);
-                          performCriticalExit();
-                        } else {
-                          ofstream output(argv[argptr+3]);
-                          ofstream binoutput(argv[argptr+4]);
-                          const double BinStart = atof(argv[argptr+5]);
-                          const double BinEnd = atof(argv[argptr+6]);
-                          const element *elemental = periode->FindElement((const int) atoi(argv[argptr+1]));
-                          const element *elemental2 = periode->FindElement((const int) atoi(argv[argptr+2]));
-                          PairCorrelationMap *correlationmap = NULL;
-                          if (periodic)
-                            correlationmap = PeriodicPairCorrelation(molecules, elemental, elemental2, ranges);
-                          else
-                            correlationmap = PairCorrelation(molecules, elemental, elemental2);
-                          //OutputCorrelationToSurface(&output, correlationmap);
-                          BinPairMap *binmap = BinData( correlationmap, 0.5, BinStart, BinEnd );
-                          OutputCorrelation ( &binoutput, binmap );
-                          output.close();
-                          binoutput.close();
-                          delete(binmap);
-                          delete(correlationmap);
-                          argptr+=7;
+                        }
+                      }
-                      break;
-                    case 'P':
+                      {
-                        if ((argptr+8 >= argc) || (!IsValidNumber(argv[argptr+1])) ||  (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3])) || (!IsValidNumber(argv[argptr+4])) || (!IsValidNumber(argv[argptr+7])) || (!IsValidNumber(argv[argptr+8])) || (argv[argptr+1][0] == '-') || (argv[argptr+2][0] == '-') || (argv[argptr+3][0] == '-') || (argv[argptr+4][0] == '-') || (argv[argptr+5][0] == '-') || (argv[argptr+6][0] == '-')) {
-                          ExitFlag = 255;
-                          DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for pair correlation analysis: -C P <Z1> <x> <y> <z> <output> <bin output>" << endl);
-                          performCriticalExit();
-                        } else {
-                          ofstream output(argv[argptr+5]);
-                          ofstream binoutput(argv[argptr+6]);
-                          const double BinStart = atof(argv[argptr+7]);
-                          const double BinEnd = atof(argv[argptr+8]);
-                          const element *elemental = periode->FindElement((const int) atoi(argv[argptr+1]));
-                          Vector *Point = new Vector((const double) atof(argv[argptr+1]),(const double) atof(argv[argptr+2]),(const double) atof(argv[argptr+3]));
-                          CorrelationToPointMap *correlationmap = NULL;
-                          if (periodic)
-                            correlationmap  = PeriodicCorrelationToPoint(molecules, elemental, Point, ranges);
-                          else
-                            correlationmap = CorrelationToPoint(molecules, elemental, Point);
-                          //OutputCorrelationToSurface(&output, correlationmap);
-                          BinPairMap *binmap = BinData( correlationmap, 0.5, BinStart, BinEnd );
-                          OutputCorrelation ( &binoutput, binmap );
-                          output.close();
-                          binoutput.close();
-                          delete(Point);
-                          delete(binmap);
-                          delete(correlationmap);
-                          argptr+=9;
+                        }
+                      }
-                      break;
-                    case 'S':
+                      {
-                        if ((argptr+6 >= argc) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+4])) || (!IsValidNumber(argv[argptr+5])) || (!IsValidNumber(argv[argptr+6])) || (argv[argptr+1][0] == '-') || (argv[argptr+2][0] == '-') || (argv[argptr+3][0] == '-')) {
-                          ExitFlag = 255;
-                          DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for pair correlation analysis: -C S <Z> <output> <bin output> <BinWidth> <BinStart> <BinEnd>" << endl);
-                          performCriticalExit();
-                        } else {
-                          ofstream output(argv[argptr+2]);
-                          ofstream binoutput(argv[argptr+3]);
-                          const double radius = 4.;
-                          const double BinWidth = atof(argv[argptr+4]);
-                          const double BinStart = atof(argv[argptr+5]);
-                          const double BinEnd = atof(argv[argptr+6]);
-                          double LCWidth = 20.;
-                          if (BinEnd > 0) {
-                            if (BinEnd > 2.*radius)
-                                LCWidth = BinEnd;
-                            else
-                              LCWidth = 2.*radius;
+                          }
-                          // get the boundary
-                          class molecule *Boundary = NULL;
-                          class Tesselation *TesselStruct = NULL;
-                          const LinkedCell *LCList = NULL;
-                          // find biggest molecule
-                          int counter  = 0;
-                          for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
-                            if ((Boundary == NULL) || (Boundary->AtomCount < (*BigFinder)->AtomCount)) {
-                              Boundary = *BigFinder;
+                            }
-                            counter++;
+                          }
-                          bool *Actives = Malloc<bool>(counter, "ParseCommandLineOptions() - case C -- *Actives");
-                          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);
-                          const element *elemental = periode->FindElement((const int) atoi(argv[argptr+1]));
-                          FindNonConvexBorder(Boundary, TesselStruct, LCList, radius, NULL);
-                          CorrelationToSurfaceMap *surfacemap = NULL;
-                          if (periodic)
-                            surfacemap = PeriodicCorrelationToSurface( molecules, elemental, TesselStruct, LCList, ranges);
-                          else
-                            surfacemap = CorrelationToSurface( molecules, elemental, 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);
+                          }
-                          BinPairMap *binmap = BinData( surfacemap, BinWidth, BinStart, BinEnd );
-                          OutputCorrelation ( &binoutput, binmap );
-                          output.close();
-                          binoutput.close();
-                          for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++)
-                            (*BigFinder)->ActiveFlag = Actives[counter++];
-                          Free(&Actives);
-                          delete(LCList);
-                          delete(TesselStruct);
-                          delete(binmap);
-                          delete(surfacemap);
-                          argptr+=7;
+                        }
+                      }
-                      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+1 >= argc) || (!IsValidNumber(argv[argptr])) || (argv[argptr+1][0] == '-')) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for changing element: -E <atom nr.> <element>" << endl);
-                performCriticalExit();
-              } else {
-                SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Changing atom " << argv[argptr] << " to element " << argv[argptr+1] << "." << endl);
-                first = mol->FindAtom(atoi(argv[argptr]));
-                first->type = periode->FindElement(atoi(argv[argptr+1]));
-                argptr+=2;
+              }
-              break;
-            case 'F':
-              if (ExitFlag == 0) ExitFlag = 1;
-              MaxDistance = -1;
-              if (argv[argptr-1][2] == 'F') { // option is -FF?
-                // fetch first argument as max distance to surface
-                MaxDistance = atof(argv[argptr++]);
-                DoLog(0) && (Log() << Verbose(0) << "Filling with maximum layer distance of " << MaxDistance << "." << endl);
+              }
-              if ((argptr+7 >=argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) || (!IsValidNumber(argv[argptr+3])) || (!IsValidNumber(argv[argptr+4])) || (!IsValidNumber(argv[argptr+5])) || (!IsValidNumber(argv[argptr+6])) || (!IsValidNumber(argv[argptr+7]))) {
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for filling box with water: -F <xyz of filler> <dist_x> <dist_y> <dist_z> <boundary> <randatom> <randmol> <DoRotate>" << endl);
-                performCriticalExit();
-              } else {
-                SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Filling Box with water molecules." << endl);
-                // construct water molecule
-                molecule *filler = World::getInstance().createMolecule();
-                if (!filler->AddXYZFile(argv[argptr])) {
-                  DoeLog(0) && (eLog()<< Verbose(0) << "Could not parse filler molecule from " << argv[argptr] << "." << endl);
+                }
-                filler->SetNameFromFilename(argv[argptr]);
-                configuration.BG->ConstructBondGraph(filler);
-                molecule *Filling = NULL;
-                atom *second = NULL, *third = NULL;
-                first = World::getInstance().createAtom();
-                first->type = periode->FindElement(1);
-                first->x = Vector(0.441, -0.143, 0.);
-                filler->AddAtom(first);
-                second = World::getInstance().createAtom();
-                second->type = periode->FindElement(1);
-                second->x = Vector(-0.464, 1.137, 0.0);
-                filler->AddAtom(second);
-                third = World::getInstance().createAtom();
-                third->type = periode->FindElement(8);
-                third->x = Vector(-0.464, 0.177, 0.);
-                filler->AddAtom(third);
-                filler->AddBond(first, third, 1);
-                filler->AddBond(second, third, 1);
-                // call routine
-                double distance[NDIM];
-                for (int i=0;i<NDIM;i++)
-                  distance[i] = atof(argv[argptr+i+1]);
-                Filling = FillBoxWithMolecule(molecules, filler, configuration, MaxDistance, distance, atof(argv[argptr+4]), atof(argv[argptr+5]), atof(argv[argptr+6]), atoi(argv[argptr+7]));
-                if (Filling != NULL) {
-                  Filling->ActiveFlag = false;
-                  molecules->insert(Filling);
+                }
-                World::getInstance().destroyMolecule(filler);
-                argptr+=6;
+              }
-              break;
-            case 'A':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag =255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Missing source file for bonds in molecule: -A <bond sourcefile>" << endl);
-                performCriticalExit();
-              } else {
-                DoLog(0) && (Log() << Verbose(0) << "Parsing bonds from " << argv[argptr] << "." << endl);
-                ifstream *input = new ifstream(argv[argptr]);
-                mol->CreateAdjacencyListFromDbondFile(input);
-                input->close();
-                argptr+=1;
+              }
-              break;
-            case 'J':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag =255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Missing path of adjacency file: -j <path>" << endl);
-                performCriticalExit();
-              } else {
-                DoLog(0) && (Log() << Verbose(0) << "Storing adjacency to path " << argv[argptr] << "." << endl);
-                configuration.BG->ConstructBondGraph(mol);
-                mol->StoreAdjacencyToFile(NULL, argv[argptr]);
-                argptr+=1;
+              }
-              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>" << endl);
-                performCriticalExit();
-              } else {
-                DoLog(0) && (Log() << Verbose(0) << "Storing bonds to path " << argv[argptr] << "." << endl);
-                configuration.BG->ConstructBondGraph(mol);
-                mol->StoreBondsToFile(NULL, argv[argptr]);
-                argptr+=1;
+              }
-              break;
-            case 'N':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+1 >= argc) || (argv[argptr+1][0] == '-')){
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for non-convex envelope: -o <radius> <tecplot output file>" << endl);
-                performCriticalExit();
-              } else {
-                class Tesselation *T = NULL;
-                class Tesselation *Convex = NULL;
-                const LinkedCell *LCList = NULL;
-                const LinkedCell *LCListConvex = NULL;
-                molecule * Boundary = NULL;
-                //string filename(argv[argptr+1]);
-                //filename.append(".csv");
-                DoLog(0) && (Log() << Verbose(0) << "Evaluating non-convex envelope of biggest molecule.");
-                DoLog(1) && (Log() << Verbose(1) << "Using rolling ball of radius " << atof(argv[argptr]) << " and storing tecplot data in " << argv[argptr+1] << "." << endl);
-                // find biggest molecule
-                int counter  = 0;
-                for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
-                  (*BigFinder)->CountAtoms();
-                  if ((Boundary == NULL) || (Boundary->AtomCount < (*BigFinder)->AtomCount)) {
-                    Boundary = *BigFinder;
+                  }
-                  counter++;
+                }
-                DoLog(1) && (Log() << Verbose(1) << "Biggest molecule has " << Boundary->AtomCount << " atoms." << endl);
-                start = clock();
-                LCList = new LinkedCell(Boundary, atof(argv[argptr])*2.);
-                if (!FindNonConvexBorder(Boundary, T, LCList, atof(argv[argptr]), argv[argptr+1]))
-                  ExitFlag = 255;
-                const double ConvexRadius = 20.;
-                LCListConvex = new LinkedCell(Boundary, 2.*ConvexRadius);
-//                setVerbosity(3);
-                if (!FindNonConvexBorder(Boundary, Convex, LCListConvex, ConvexRadius, "ConvexEnvelope"))
-                  ExitFlag = 255;
-                CalculateConstrictionPerBoundaryPoint(T, Convex);
-                StoreTrianglesinFile(mol, (const Tesselation *&)T, argv[argptr+1], "");
-                //FindDistributionOfEllipsoids(T, &LCList, N, number, filename.c_str());
-                end = clock();
-                DoLog(0) && (Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl);
-                delete(LCList);
-                delete(T);
-                argptr+=2;
+              }
-              break;
-            case 'S':
-              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 storing tempature: -S <temperature file>" << endl);
-                performCriticalExit();
-              } else {
-                DoLog(1) && (Log() << Verbose(1) << "Storing temperatures in " << argv[argptr] << "." << endl);
-                ofstream *output = new ofstream(argv[argptr], 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);
-                argptr+=1;
+              }
-              break;
-            case 'L':
-              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 storing tempature: -L <step0> <step1> <prefix> <identity mapping?>" << endl);
-                performCriticalExit();
-              } else {
-                SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Linear interpolation between configuration " << argv[argptr] << " and " << argv[argptr+1] << "." << endl);
-                if (atoi(argv[argptr+3]) == 1)
-                  DoLog(1) && (Log() << Verbose(1) << "Using Identity for the permutation map." << endl);
-                if (!mol->LinearInterpolationBetweenConfiguration(atoi(argv[argptr]), atoi(argv[argptr+1]), argv[argptr+2], configuration, atoi(argv[argptr+3])) == 1 ? true : false)
-                  DoLog(2) && (Log() << Verbose(2) << "Could not store " << argv[argptr+2] << " files." << endl);
-                else
-                  DoLog(2) && (Log() << Verbose(2) << "Steps created and " << argv[argptr+2] << " files stored." << endl);
-                argptr+=4;
+              }
-              break;
-            case 'P':
-              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 parsing and integrating forces: -P <forces file>" << endl);
-                performCriticalExit();
-              } else {
-                SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Parsing forces file and Verlet integrating." << endl);
-                if (!mol->VerletForceIntegration(argv[argptr], configuration))
-                  DoLog(2) && (Log() << Verbose(2) << "File not found." << endl);
-                else
-                  DoLog(2) && (Log() << Verbose(2) << "File found and parsed." << endl);
-                argptr+=1;
+              }
-              break;
-            case 'R':
-              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 removing atoms: -R <id> <distance>" << endl);
-                performCriticalExit();
-              } else {
-                SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Removing atoms around " << argv[argptr] << " with radius " << argv[argptr+1] << "." << endl);
-                double tmp1 = atof(argv[argptr+1]);
-                atom *third = mol->FindAtom(atoi(argv[argptr]));
-                atom *first = mol->start;
-                if ((third != NULL) && (first != mol->end)) {
-                  atom *second = first->next;
-                  while(second != mol->end) {
-                    first = second;
-                    second = first->next;
-                    if (first->x.DistanceSquared(third->x) > tmp1*tmp1) // distance to first above radius ...
-                      mol->RemoveAtom(first);
+                  }
-                } else {
-                  DoeLog(1) && (eLog()<< Verbose(1) << "Removal failed due to missing atoms on molecule or wrong id." << endl);
+                }
-                argptr+=2;
+              }
-              break;
-            case 't':
-              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 translation: -t <x> <y> <z>" << endl);
-                performCriticalExit();
-              } else {
-                if (ExitFlag == 0) ExitFlag = 1;
-                SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Translating all ions by given vector." << endl);
-                for (int i=NDIM;i--;)
-                  x[i] = atof(argv[argptr+i]);
-                mol->Translate((const Vector *)&x);
-                argptr+=3;
+              }
-              break;
-            case 'T':
-              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 periodic translation: -T <x> <y> <z>" << endl);
-                performCriticalExit();
-              } else {
-                if (ExitFlag == 0) ExitFlag = 1;
-                SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Translating all ions periodically by given vector." << endl);
-                for (int i=NDIM;i--;)
-                  x[i] = atof(argv[argptr+i]);
-                mol->TranslatePeriodically((const Vector *)&x);
-                argptr+=3;
+              }
-              break;
-            case 's':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr >= 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 {
-                SaveFlag = true;
-                j = -1;
-                DoLog(1) && (Log() << Verbose(1) << "Scaling all ion positions by factor." << endl);
-                factor = new double[NDIM];
-                factor[0] = atof(argv[argptr]);
-                factor[1] = atof(argv[argptr+1]);
-                factor[2] = atof(argv[argptr+2]);
-                mol->Scale((const double ** const)&factor);
-                double * const cell_size = World::getInstance().getDomain();
-                for (int i=0;i<NDIM;i++) {
-                  j += i+1;
-                  x[i] = atof(argv[NDIM+i]);
-                  cell_size[j]*=factor[i];
+                }
-                delete[](factor);
-                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 {
-                SaveFlag = true;
-                j = -1;
-                DoLog(1) && (Log() << Verbose(1) << "Centering atoms in config file within given simulation box." << endl);
-                double * const cell_size = World::getInstance().getDomain();
-                for (int i=0;i<6;i++) {
-                  cell_size[i] = atof(argv[argptr+i]);
+                }
-                // center
-                mol->CenterInBox();
-                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 {
-                SaveFlag = true;
-                j = -1;
-                DoLog(1) && (Log() << Verbose(1) << "Centering atoms in config file within given simulation box." << endl);
-                double * const cell_size = World::getInstance().getDomain();
-                for (int i=0;i<6;i++) {
-                  cell_size[i] = atof(argv[argptr+i]);
+                }
-                // center
-                mol->BoundInBox();
-                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 {
-                SaveFlag = true;
-                j = -1;
-                DoLog(1) && (Log() << Verbose(1) << "Centering atoms in config file within given additional boundary." << endl);
-                // make every coordinate positive
-                mol->CenterEdge(&x);
-                // update Box of atoms by boundary
-                mol->SetBoxDimension(&x);
-                // translate each coordinate by boundary
-                double * const cell_size = World::getInstance().getDomain();
-                j=-1;
-                for (int i=0;i<NDIM;i++) {
-                  j += i+1;
-                  x[i] = atof(argv[argptr+i]);
-                  cell_size[j] += x[i]*2.;
+                }
-                mol->Translate((const Vector *)&x);
-                argptr+=3;
+              }
-              break;
-            case 'O':
-              if (ExitFlag == 0) ExitFlag = 1;
-              SaveFlag = true;
-              DoLog(1) && (Log() << Verbose(1) << "Centering atoms on edge and setting box dimensions." << endl);
-              x.Zero();
-              mol->CenterEdge(&x);
-              mol->SetBoxDimension(&x);
-              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 {
-                SaveFlag = true;
-                DoLog(1) && (Log() << Verbose(1) << "Removing atom " << argv[argptr] << "." << endl);
-                atom *first = mol->FindAtom(atoi(argv[argptr]));
-                mol->RemoveAtom(first);
-                argptr+=1;
+              }
-              break;
-            case 'f':
-              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 for fragmentation: -f <max. bond distance> <bond order>" << endl);
-                performCriticalExit();
-              } else {
-                DoLog(0) && (Log() << Verbose(0) << "Fragmenting molecule with bond distance " << argv[argptr] << " angstroem, order of " << argv[argptr+1] << "." << endl);
-                DoLog(0) && (Log() << Verbose(0) << "Creating connection matrix..." << endl);
-                start = clock();
-                mol->CreateAdjacencyList(atof(argv[argptr]), configuration.GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
-                DoLog(0) && (Log() << Verbose(0) << "Fragmenting molecule with current connection matrix ..." << endl);
-                if (mol->first->next != mol->last) {
-                  ExitFlag = mol->FragmentMolecule(atoi(argv[argptr+1]), &configuration);
+                }
-                end = clock();
-                DoLog(0) && (Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl);
-                argptr+=2;
+              }
-              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);
-              } else
-                DoLog(0) && (Log() << Verbose(0) << "Evaluating prinicipal axis." << endl);
-              mol->PrincipalAxisSystem((bool)j);
-              break;
-            case 'o':
-              if (ExitFlag == 0) ExitFlag = 1;
-              if ((argptr+1 >= argc) || (argv[argptr][0] == '-')){
-                ExitFlag = 255;
-                DoeLog(0) && (eLog()<< Verbose(0) << "Not enough or invalid arguments given for convex envelope: -o <convex output file> <non-convex output file>" << endl);
-                performCriticalExit();
-              } else {
-                class Tesselation *TesselStruct = NULL;
-                const LinkedCell *LCList = NULL;
-                DoLog(0) && (Log() << Verbose(0) << "Evaluating volume of the convex envelope.");
-                DoLog(1) && (Log() << Verbose(1) << "Storing tecplot convex data in " << argv[argptr] << "." << endl);
-                DoLog(1) && (Log() << Verbose(1) << "Storing tecplot non-convex data in " << argv[argptr+1] << "." << endl);
-                LCList = new LinkedCell(mol, 10.);
-                //FindConvexBorder(mol, LCList, argv[argptr]);
-                FindNonConvexBorder(mol, TesselStruct, LCList, 5., argv[argptr+1]);
-//                RemoveAllBoundaryPoints(TesselStruct, mol, argv[argptr]);
-                double volumedifference = ConvexizeNonconvexEnvelope(TesselStruct, mol, argv[argptr]);
-                double clustervolume = VolumeOfConvexEnvelope(TesselStruct, &configuration);
-                DoLog(0) && (Log() << Verbose(0) << "The tesselated volume area is " << clustervolume << " " << (configuration.GetIsAngstroem() ? "angstrom" : "atomiclength") << "^3." << endl);
-                DoLog(0) && (Log() << Verbose(0) << "The non-convex tesselated volume area is " << clustervolume-volumedifference << " " << (configuration.GetIsAngstroem() ? "angstrom" : "atomiclength") << "^3." << endl);
-                delete(TesselStruct);
-                delete(LCList);
-                argptr+=2;
+              }
-              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 {
-                double density;
-                SaveFlag = true;
-                DoLog(0) && (Log() << Verbose(0) << "Evaluating necessary cell volume for a cluster suspended in water.");
-                density = atof(argv[argptr++]);
-                if (density < 1.0) {
-                  DoeLog(1) && (eLog()<< Verbose(1) << "Density must be greater than 1.0g/cm^3 !" << endl);
-                  density = 1.3;
+                }
-//                for(int i=0;i<NDIM;i++) {
-//                  repetition[i] = atoi(argv[argptr++]);
-//                  if (repetition[i] < 1)
-//                    DoeLog(1) && (eLog()<< Verbose(1) << "repetition value must be greater 1!" << endl);
-//                  repetition[i] = 1;
-//                }
-                PrepareClustersinWater(&configuration, mol, volume, density);  // if volume == 0, will calculate from ConvexEnvelope
+              }
-              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 {
-                SaveFlag = true;
-                double * const cell_size = World::getInstance().getDomain();
-                for (int axis = 1; axis <= NDIM; axis++) {
-                  int faktor = atoi(argv[argptr++]);
-                  int count;
-                  const element ** Elements;
-                  Vector ** vectors;
-                  if (faktor < 1) {
-                    DoeLog(1) && (eLog()<< Verbose(1) << "Repetition factor mus be greater than 1!" << endl);
-                    faktor = 1;
+                  }
-                  mol->CountAtoms();  // recount atoms
-                  if (mol->AtomCount != 0) {  // if there is more than none
-                    count = mol->AtomCount;   // is changed becausing of adding, thus has to be stored away beforehand
-                    Elements = new const 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[abs(axis)-1] = cell_size[(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 += y; // per factor one cell width further
-                      for (int k=count;k--;) { // go through every atom of the original cell
-                        first = World::getInstance().createAtom(); // create a new body
-                        first->x = (*vectors[k]) + x;
-                        first->type = Elements[k];  // insert original element
-                        mol->AddAtom(first);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
+                      }
+                    }
-                    // free memory
-                    delete[](Elements);
-                    delete[](vectors);
-                    // correct cell size
-                    if (axis < 0) { // if sign was negative, we have to translate everything
-                      x =(-(faktor-1)) * y;
-                      mol->Translate(&x);
+                    }
-                    cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+                  }
+                }
+              }
-              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);
-};
-/***************************************** Functions used to build all menus **********************/
-void populateEditMoleculesMenu(Menu* editMoleculesMenu,MoleculeListClass *molecules, config *configuration, periodentafel *periode){
-  // 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 ChangeMoleculeNameAction(molecules);
-  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);
+}
 /********************************************** Main routine **************************************/
+void cleanUp(config *configuration){
+  UIFactory::purgeInstance();
+void cleanUp(){
+  FormatParserStorage::purgeInstance();
+  ChangeTracker::purgeInstance();
   World::purgeInstance();
-  delete(configuration);
-  Log() << Verbose(0) <<  "Maximum of allocated memory: "
-    << MemoryUsageObserver::getInstance()->getMaximumUsedMemory() << endl;
-  Log() << Verbose(0) <<  "Remaining non-freed memory: "
-    << MemoryUsageObserver::getInstance()->getUsedMemorySize() << endl;
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
   errorLogger::purgeInstance();
+  UIFactory::purgeInstance();
+  MapOfActions::purgeInstance();
+  CommandLineParser::purgeInstance();
   ActionRegistry::purgeInstance();
   ActionHistory::purgeInstance();
+#ifdef LOG_OBSERVER
+  cout << observerLog().getLog();
+#endif
   Memory::getState();
+}
 …
 int main(int argc, char **argv)
+{
+    molecule *mol = NULL;
+    config *configuration = new config;
+    Vector x, y, z, n;
+    ifstream test;
+    ofstream output;
+    string line;
+    char *ConfigFileName = NULL;
+    int j;
+  // while we are non interactive, we want to abort from asserts
+  //ASSERT_DO(Assert::Abort);
+  string line;
+  char **Arguments = NULL;
+  int ArgcSize = 0;
+  int ExitFlag = 0;
+  bool ArgumentsCopied = false;
+  std::string BondGraphFileName("\n");
+  FormatParserStorage::getInstance().addMpqc();
+  FormatParserStorage::getInstance().addPcp();
+  FormatParserStorage::getInstance().addXyz();
+    cout << ESPACKVersion << endl;
+  // 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();
+    /* structure of ParseCommandLineOptions will be refactored later */
+    j = ParseCommandLineOptions(argc, argv,  World::getInstance().getMolecules(), World::getInstance().getPeriode(), *configuration, ConfigFileName);
+    switch (j){
+        case 255:
+        case 2:
+        case 1:
+            cleanUp(configuration);
+            return (j == 1 ? 0 : j);
+        default:
+            break;
+  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
+  {
+    // 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);
+      }
+    }
+    if(World::getInstance().numMolecules() == 0){
+        mol = World::getInstance().createMolecule();
+        World::getInstance().getMolecules()->insert(mol);
+        cout << "Molecule created" << endl;
+        if(World::getInstance().getDomain()[0] == 0.){
+            Log() << Verbose(0) << "enter lower tridiagonal form of basis matrix" << endl << endl;
+            for(int i = 0;i < 6;i++){
+                Log() << Verbose(1) << "Cell size" << i << ": ";
+                cin >> World::getInstance().getDomain()[i];
+            }
+        }
+        mol->ActiveFlag = true;
+    // handle remaining arguments by CommandLineParser
+    if (argc>1) {
+      MapOfActions::getInstance().AddOptionsToParser();
+      map <std::string, std::string> ShortFormToActionMap = MapOfActions::getInstance().getShortFormToActionMap();
+      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 {
+      #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
+    }
+  }
+    {
+      cout << ESPACKVersion << endl;
+  {
+    MainWindow *mainWindow = UIFactory::getInstance().makeMainWindow();
+    mainWindow->display();
+    delete mainWindow;
+  }
+      setVerbosity(0);
+  FormatParserStorage::getInstance().SaveAll();
+  ChangeTracker::getInstance().saveStatus();
+      menuPopulaters populaters;
+      populaters.MakeEditMoleculesMenu = populateEditMoleculesMenu;
+  // free the new argv
+  if (ArgumentsCopied) {
+    for (int i=0; i<ArgcSize;i++)
+      delete[](Arguments[i]);
+    delete[](Arguments);
+  }
+  //delete[](ConfigFileName);
+      UIFactory::makeUserInterface(UIFactory::Text);
+      MainWindow *mainWindow = UIFactory::getInstance().makeMainWindow(populaters,World::getInstance().getMolecules(), configuration, World::getInstance().getPeriode(), ConfigFileName);
+      mainWindow->display();
+      delete mainWindow;
+    }
+    if(World::getInstance().getPeriode()->StorePeriodentafel(configuration->databasepath))
+        Log() << Verbose(0) << "Saving of elements.db successful." << endl;
+    else
+        Log() << Verbose(0) << "Saving of elements.db failed." << endl;
+  cleanUp(configuration);
+  return (0);
+  ExitFlag = World::getInstance().getExitFlag();
+  return (ExitFlag == 1 ? 0 : ExitFlag);
+}

src/config.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include <stdio.h>
 #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 "log.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 = Malloc<char*>(NoLines, "ConfigFileBuffer::ConfigFileBuffer: **buffer");
-  // scan each line and put into buffer
-  int lines=0;
-  int i;
-  do {
-    buffer[lines] = Malloc<char>(MAXSTRINGSIZE, "ConfigFileBuffer::ConfigFileBuffer: *buffer[]");
-    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)
-    Free(&buffer[i]);
-  Free(&buffer);
-  Free(&LineMapping);
+}
-/** Create trivial mapping.
- */
-void ConfigFileBuffer::InitMapping()
+{
-  LineMapping = Malloc<int>(NoLines, "ConfigFileBuffer::InitMapping: *LineMapping");
-  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();
+    }
+  }
+}
 /************************************* 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),
 …
     MaxLevel(5), RiemannTensor(0), LevRFactor(0), RiemannLevel(0), Lev0Factor(2), RTActualUse(0), AddPsis(0), RCut(20.), StructOpt(0), IsAngstroem(1), RelativeCoord(0),
     MaxTypes(0) {
   mainname = Malloc<char>(MAXSTRINGSIZE,"config constructor: mainname");
   defaultpath = Malloc<char>(MAXSTRINGSIZE,"config constructor: defaultpath");
   pseudopotpath = Malloc<char>(MAXSTRINGSIZE,"config constructor: pseudopotpath");
   databasepath = Malloc<char>(MAXSTRINGSIZE,"config constructor: databasepath");
   configpath = Malloc<char>(MAXSTRINGSIZE,"config constructor: configpath");
   configname = Malloc<char>(MAXSTRINGSIZE,"config constructor: configname");
+  mainname = new char[MAXSTRINGSIZE];
+  defaultpath = new char[MAXSTRINGSIZE];
+  pseudopotpath = new char[MAXSTRINGSIZE];
+  databasepath = 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();
 };
 …
 config::~config()
+{
+  Free(&mainname);
+  Free(&defaultpath);
+  Free(&pseudopotpath);
+  Free(&databasepath);
+  Free(&configpath);
+  Free(&configname);
+  Free(&ThermostatImplemented);
+  for (int j=0;j<MaxThermostats;j++)
+    Free(&ThermostatNames[j]);
+  Free(&ThermostatNames);
+  delete[](mainname);
+  delete[](defaultpath);
+  delete[](pseudopotpath);
+  delete[](databasepath);
+  delete[](configname);
+  if (Thermostats != NULL)
+    delete(Thermostats);
   if (BG != NULL)
     delete(BG);
 };
-/** Initialises variables in class config for Thermostats.
- */
-void config::InitThermostats()
+{
-  ThermostatImplemented = Malloc<int>(MaxThermostats, "config constructor: *ThermostatImplemented");
-  ThermostatNames = Malloc<char*>(MaxThermostats, "config constructor: *ThermostatNames");
-  for (int j=0;j<MaxThermostats;j++)
-    ThermostatNames[j] = Malloc<char>(12, "config constructor: ThermostatNames[]");
-  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 = Malloc<char>(12, "IonsInitRead: thermo");
-  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;
+  }
-  Free(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))
 …
     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;
 …
     *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 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;
 …
   int AtomNo = -1;
   int MolNo = 0;
-  atom *Walker = NULL;
   FILE *f = NULL;
 …
   fprintf(f, "# Created by MoleCuilder\n");
+  for (MoleculeList::const_iterator Runner = MolList->ListOfMolecules.begin(); Runner != MolList->ListOfMolecules.end(); Runner++) {
+    Walker = (*Runner)->start;
+    int *elementNo = Calloc<int>(MAX_ELEMENTS, "config::SavePDB - elementNo");
+  for (MoleculeList::const_iterator MolRunner = MolList->ListOfMolecules.begin(); MolRunner != MolList->ListOfMolecules.end(); MolRunner++) {
+    int *elementNo = new int[MAX_ELEMENTS];
+    for (int i=0;i<MAX_ELEMENTS;i++)
+      elementNo[i] = 0;
     AtomNo = 0;
+    while (Walker->next != (*Runner)->end) {
+      Walker = Walker->next;
+      sprintf(name, "%2s%2d",Walker->type->symbol, elementNo[Walker->type->Z]);
+      elementNo[Walker->type->Z] = (elementNo[Walker->type->Z]+1) % 100;   // confine to two digits
+    for (molecule::const_iterator iter = (*MolRunner)->begin(); iter != (*MolRunner)->end(); ++iter) {
+      sprintf(name, "%2s%2d",(*iter)->type->symbol, elementNo[(*iter)->type->Z]);
+      elementNo[(*iter)->type->Z] = (elementNo[(*iter)->type->Z]+1) % 100;   // confine to two digits
       fprintf(f,
              "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
              Walker->nr,                /* atom serial number */
+             (*iter)->nr,                /* atom serial number */
              name,         /* atom name */
              (*Runner)->name,      /* residue name */
+             (*MolRunner)->name,      /* residue name */
              'a'+(unsigned char)(AtomNo % 26),           /* letter for chain */
              MolNo,         /* residue sequence number */
              Walker->node->at(0),                 /* position X in Angstroem */
              Walker->node->at(1),                 /* position Y in Angstroem */
              Walker->node->at(2),                 /* position Z in Angstroem */
              (double)Walker->type->Valence,         /* occupancy */
              (double)Walker->type->NoValenceOrbitals,          /* temperature factor */
+             (*iter)->node->at(0),                 /* position X in Angstroem */
+             (*iter)->node->at(1),                 /* position Y in Angstroem */
+             (*iter)->node->at(2),                 /* position Z in Angstroem */
+             (double)(*iter)->type->Valence,         /* occupancy */
+             (double)(*iter)->type->NoValenceOrbitals,          /* temperature factor */
              "0",            /* segment identifier */
              Walker->type->symbol,    /* element symbol */
+             (*iter)->type->symbol,    /* element symbol */
              "0");           /* charge */
       AtomNo++;
+    }
     Free(&elementNo);
+    delete[](elementNo);
     MolNo++;
+  }
 …
+{
   int AtomNo = -1;
-  atom *Walker = NULL;
   FILE *f = NULL;
+  int *elementNo = Calloc<int>(MAX_ELEMENTS, "config::SavePDB - elementNo");
+  int *elementNo = new int[MAX_ELEMENTS];
+  for (int i=0;i<MAX_ELEMENTS;i++)
+    elementNo[i] = 0;
   char name[MAXSTRINGSIZE];
   strncpy(name, filename, MAXSTRINGSIZE-1);
 …
   if (f == NULL) {
     DoeLog(1) && (eLog()<< Verbose(1) << "Cannot open pdb output file:" << name << endl);
     Free(&elementNo);
+    delete[](elementNo);
     return false;
+  }
   fprintf(f, "# Created by MoleCuilder\n");
-  Walker = mol->start;
   AtomNo = 0;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    sprintf(name, "%2s%2d",Walker->type->symbol, elementNo[Walker->type->Z]);
+    elementNo[Walker->type->Z] = (elementNo[Walker->type->Z]+1) % 100;   // confine to two digits
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    sprintf(name, "%2s%2d",(*iter)->type->symbol, elementNo[(*iter)->type->Z]);
+    elementNo[(*iter)->type->Z] = (elementNo[(*iter)->type->Z]+1) % 100;   // confine to two digits
     fprintf(f,
            "ATOM %6u %-4s %4s%c%4u    %8.3f%8.3f%8.3f%6.2f%6.2f      %4s%2s%2s\n",
            Walker->nr,                /* atom serial number */
+           (*iter)->nr,                /* atom serial number */
            name,         /* atom name */
            mol->name,      /* residue name */
            'a'+(unsigned char)(AtomNo % 26),           /* letter for chain */
 ,         /* residue sequence number */
            Walker->node->at(0),                 /* position X in Angstroem */
            Walker->node->at(1),                 /* position Y in Angstroem */
            Walker->node->at(2),                 /* position Z in Angstroem */
            (double)Walker->type->Valence,         /* occupancy */
            (double)Walker->type->NoValenceOrbitals,          /* temperature factor */
+           (*iter)->node->at(0),                 /* position X in Angstroem */
+           (*iter)->node->at(1),                 /* position Y in Angstroem */
+           (*iter)->node->at(2),                 /* position Z in Angstroem */
+           (double)(*iter)->type->Valence,         /* occupancy */
+           (double)(*iter)->type->NoValenceOrbitals,          /* temperature factor */
            "0",            /* segment identifier */
            Walker->type->symbol,    /* element symbol */
+           (*iter)->type->symbol,    /* element symbol */
            "0");           /* charge */
     AtomNo++;
+  }
   fclose(f);
   Free(&elementNo);
+  delete[](elementNo);
   return true;
 …
 bool config::SaveTREMOLO(const char * const filename, const molecule * const mol) const
+{
-  atom *Walker = NULL;
   ofstream *output = NULL;
   stringstream * const fname = new stringstream;
 …
   // scan maximum number of neighbours
-  Walker = mol->start;
   int MaxNeighbours = 0;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    const int count = Walker->ListOfBonds.size();
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    const int count = (*iter)->ListOfBonds.size();
     if (MaxNeighbours < count)
       MaxNeighbours = count;
+  }
+  *output << "# ATOMDATA Id name resName resSeq x=3 charge type neighbors=" << MaxNeighbours << endl;
+  Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    *output << Walker->nr << "\t";
+    *output << Walker->getName() << "\t";
+  *output << "# ATOMDATA Id name resName resSeq x=3 Charge type neighbors=" << MaxNeighbours << endl;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    *output << (*iter)->nr << "\t";
+    *output << (*iter)->getName() << "\t";
     *output << mol->name << "\t";
     *output << 0 << "\t";
     *output << Walker->node->at(0) << "\t" << Walker->node->at(1) << "\t" << Walker->node->at(2) << "\t";
     *output << static_cast<double>(Walker->type->Valence) << "\t";
     *output << Walker->type->symbol << "\t";
     for (BondList::iterator runner = Walker->ListOfBonds.begin(); runner != Walker->ListOfBonds.end(); runner++)
       *output << (*runner)->GetOtherAtom(Walker)->nr << "\t";
     for(int i=Walker->ListOfBonds.size(); i < MaxNeighbours; i++)
+    *output << (*iter)->node->at(0) << "\t" << (*iter)->node->at(1) << "\t" << (*iter)->node->at(2) << "\t";
+    *output << static_cast<double>((*iter)->type->Valence) << "\t";
+    *output << (*iter)->type->symbol << "\t";
+    for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
+      *output << (*runner)->GetOtherAtom(*iter)->nr << "\t";
+    for(int i=(*iter)->ListOfBonds.size(); i < MaxNeighbours; i++)
       *output << "-\t";
     *output << endl;
 …
 bool config::SaveTREMOLO(const char * const filename, const MoleculeListClass * const MolList) const
+{
   atom *Walker = NULL;
+  Info FunctionInfo(__func__);
   ofstream *output = NULL;
   stringstream * const fname = new stringstream;
 …
   int MaxNeighbours = 0;
   for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
+    Walker = (*MolWalker)->start;
+    while (Walker->next != (*MolWalker)->end) {
+      Walker = Walker->next;
+      const int count = Walker->ListOfBonds.size();
+    for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+      const int count = (*iter)->ListOfBonds.size();
       if (MaxNeighbours < count)
         MaxNeighbours = count;
+    }
+  }
   *output << "# ATOMDATA Id name resName resSeq x=3 charge type neighbors=" << MaxNeighbours << endl;
+  *output << "# ATOMDATA Id name resName resSeq x=3 Charge type neighbors=" << MaxNeighbours << endl;
   // create global to local id map
   int **LocalNotoGlobalNoMap = Calloc<int *>(MolList->ListOfMolecules.size(), "config::SaveTREMOLO - **LocalNotoGlobalNoMap");
+  map<int, int> LocalNotoGlobalNoMap;
+  {
     int MolCounter = 0;
     int AtomNo = 0;
+    unsigned int MolCounter = 0;
+    int AtomNo = 1;
     for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
+      LocalNotoGlobalNoMap[MolCounter] = Calloc<int>(MolList->CountAllAtoms(), "config::SaveTREMOLO - *LocalNotoGlobalNoMap[]");
+      (*MolWalker)->SetIndexedArrayForEachAtomTo( LocalNotoGlobalNoMap[MolCounter], &atom::nr, IncrementalAbsoluteValue, &AtomNo);
+      for(molecule::iterator AtomRunner = (*MolWalker)->begin(); AtomRunner != (*MolWalker)->end(); ++AtomRunner) {
+        LocalNotoGlobalNoMap.insert( pair<int,int>((*AtomRunner)->getId(), AtomNo++) );
+      }
       MolCounter++;
+    }
+    ASSERT(MolCounter == MolList->ListOfMolecules.size(), "SaveTREMOLO: LocalNotoGlobalNoMap[] has not been correctly initialized for each molecule");
+  }
 …
     int AtomNo = 0;
     for (MoleculeList::const_iterator MolWalker = MolList->ListOfMolecules.begin(); MolWalker != MolList->ListOfMolecules.end(); MolWalker++) {
+      Walker = (*MolWalker)->start;
+      while (Walker->next != (*MolWalker)->end) {
+        Walker = Walker->next;
+        *output << AtomNo+1 << "\t";
+        *output << Walker->getName() << "\t";
+      for (molecule::const_iterator iter = (*MolWalker)->begin(); iter != (*MolWalker)->end(); ++iter) {
+        *output << LocalNotoGlobalNoMap[ (*iter)->getId() ] << "\t";
+        *output << (*iter)->getName() << "\t";
         *output << (*MolWalker)->name << "\t";
         *output << MolCounter+1 << "\t";
         *output << Walker->node->at(0) << "\t" << Walker->node->at(1) << "\t" << Walker->node->at(2) << "\t";
         *output << (double)Walker->type->Valence << "\t";
         *output << Walker->type->symbol << "\t";
         for (BondList::iterator runner = Walker->ListOfBonds.begin(); runner != Walker->ListOfBonds.end(); runner++)
           *output << LocalNotoGlobalNoMap[MolCounter][ (*runner)->GetOtherAtom(Walker)->nr ]+1 << "\t";
         for(int i=Walker->ListOfBonds.size(); i < MaxNeighbours; i++)
+        *output << (*iter)->node->at(0) << "\t" << (*iter)->node->at(1) << "\t" << (*iter)->node->at(2) << "\t";
+        *output << (double)(*iter)->type->Valence << "\t";
+        *output << (*iter)->type->symbol << "\t";
+        for (BondList::iterator runner = (*iter)->ListOfBonds.begin(); runner != (*iter)->ListOfBonds.end(); runner++)
+          *output << LocalNotoGlobalNoMap[ (*runner)->GetOtherAtom((*iter))->getId() ] << "\t";
+        for(int i=(*iter)->ListOfBonds.size(); i < MaxNeighbours; i++)
           *output << "-\t";
         *output << endl;
 …
   delete(output);
   delete(fname);
-  for(size_t i=0;i<MolList->ListOfMolecules.size(); i++)
-    Free(&LocalNotoGlobalNoMap[i]);
-  Free(&LocalNotoGlobalNoMap);
   return true;
 …
   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
 …
   if (output == NULL)
     strcpy(filename,"main_pcp_linux");
   Log() << Verbose(0) << "Saving as pdb input ";
+  Log() << Verbose(0) << "Saving as pdb input ... " << endl;
   if (SavePDB(filename, molecules))
     Log() << Verbose(0) << "done." << endl;
+    Log() << Verbose(0) << "\t... done." << endl;
   else
     Log() << Verbose(0) << "failed." << endl;
+    Log() << Verbose(0) << "\t... failed." << endl;
   // then save as tremolo data file
 …
   if (output == NULL)
     strcpy(filename,"main_pcp_linux");
   Log() << Verbose(0) << "Saving as tremolo data input ";
+  Log() << Verbose(0) << "Saving as tremolo data input ... " << endl;
   if (SaveTREMOLO(filename, molecules))
     Log() << Verbose(0) << "done." << endl;
+    Log() << Verbose(0) << "\t... done." << endl;
   else
     Log() << Verbose(0) << "failed." << endl;
+    Log() << Verbose(0) << "\t... 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.);
+  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->doCountAtoms();
+    mol->CountElements();
+    //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);
 …
   output.close();
   output.clear();
   Log() << Verbose(0) << "Saving of config file ";
+  Log() << Verbose(0) << "Saving of config file ... " << endl;
   if (Save(filename, periode, mol))
     Log() << Verbose(0) << "successful." << endl;
+    Log() << Verbose(0) << "\t... successful." << endl;
   else
     Log() << Verbose(0) << "failed." << endl;
+    Log() << Verbose(0) << "\t... failed." << endl;
   // and save to xyz file
 …
     output.open(filename, ios::trunc);
+  }
   Log() << Verbose(0) << "Saving of XYZ file ";
+  Log() << Verbose(0) << "Saving of XYZ file ... " << endl;
   if (mol->MDSteps <= 1) {
     if (mol->OutputXYZ(&output))
       Log() << Verbose(0) << "successful." << endl;
+      Log() << Verbose(0) << "\t... successful." << endl;
     else
       Log() << Verbose(0) << "failed." << endl;
+      Log() << Verbose(0) << "\t... failed." << endl;
   } else {
     if (mol->OutputTrajectoriesXYZ(&output))
       Log() << Verbose(0) << "successful." << endl;
+      Log() << Verbose(0) << "\t... successful." << endl;
     else
       Log() << Verbose(0) << "failed." << endl;
+      Log() << Verbose(0) << "\t... failed." << endl;
+  }
   output.close();
 …
   if (output == NULL)
     strcpy(filename,"main_pcp_linux");
   Log() << Verbose(0) << "Saving as mpqc input ";
+  Log() << Verbose(0) << "Saving as mpqc input .. " << endl;
   if (SaveMPQC(filename, mol))
     Log() << Verbose(0) << "done." << endl;
+    Log() << Verbose(0) << "\t... done." << endl;
   else
+    Log() << Verbose(0) << "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);
+    Log() << Verbose(0) << "\t... failed." << endl;
+  // don't destroy molecule as it contains all our atoms
+  //World::getInstance().destroyMolecule(mol);
 };
 …
   char *dummy1 = NULL;
   char *dummy = NULL;
   char * const free_dummy = Malloc<char>(256, "config::ParseForParameter: *free_dummy");    // pointers in the line that is read in per step
+  char free_dummy[MAXSTRINGSIZE];    // pointers in the line that is read in per step
   dummy1 = free_dummy;
 …
       if (file->eof()) {
         if ((critical) && (found == 0)) {
-          Free(free_dummy);
           //Error(InitReading, name);
           fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
 …
           file->clear();
           file->seekg(file_position, ios::beg);  // rewind to start position
-          Free(free_dummy);
           return 0;
+        }
 …
         dummy = strchr(dummy1, '\n'); // set on line end then (whole line = keyword)
         //fprintf(stderr,"Error: Cannot find tabs or spaces on line %i in search for %s\n", line, name);
-        //Free((void **)&free_dummy);
         //Error(FileOpenParams, NULL);
       } else {
 …
               if (file->eof()) {
                 if ((critical) && (found == 0)) {
-                  Free(free_dummy);
                   //Error(InitReading, name);
                   fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
 …
                   file->clear();
                   file->seekg(file_position, ios::beg);  // rewind to start position
-                  Free(free_dummy);
                   return 0;
+                }
 …
                   if (critical) {
                     if (verbose) fprintf(stderr,"Error: EoL at %i and still missing %i value(s) for parameter %s\n", line, yth-j, name);
-                    Free(free_dummy);
                     //return 0;
                     exit(255);
 …
                     file->clear();
                     file->seekg(file_position, ios::beg);  // rewind to start position
-                    Free(free_dummy);
                     return 0;
+                  }
 …
                   file->seekg(file_position, ios::beg);  // rewind to start position
+                }
-                Free(free_dummy);
                 return 0;
+              }
 …
   if ((type >= row_int) && (verbose))
     fprintf(stderr,"\n");
-  Free(free_dummy);
   if (!sequential) {
     file->clear();
 …
         dummy = strchr(dummy1, '\n'); // set on line end then (whole line = keyword)
         //fprintf(stderr,"Error: Cannot find tabs or spaces on line %i in search for %s\n", line, name);
-        //Free(&free_dummy);
         //Error(FileOpenParams, NULL);
       } else {
 …
   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

-              rc39cc4
+              rbdb143
 #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

rc39cc4	rbdb143
6	6
7	7	//============================ INCLUDES ===========================
	8
	9	#include "Helpers/MemDebug.hpp"
8	10
9	11	#include "datacreator.hpp"

src/defs.hpp

rc39cc4	rbdb143
82	82	#define STD_SEPERATOR_SPACER '-'
83	83
	84	#define MOLECUILDER_NAME "Molecuilder"
	85
84	86	#endif /DEFS_HPP_/

src/element.cpp

rc39cc4	rbdb143
4	4	*
5	5	*/
	6
	7	#include "Helpers/MemDebug.hpp"
6	8
7	9	#include <iomanip>

src/elements.db

Property mode changed from 100755 to 100644

-              rc39cc4
+              rbdb143
 #Element        Name    Symbol  Period  Group   Block   Atomic  Number  AtomicWeight    Covalent        Radius  vdW     Radius
 Hydrogen        H       1       1       s       1       1.008   0.23    1.09
 Helium  He      1       18      p       2       4.003   1.50    1.40
+Helium  He      1       18      p       2       4.003   1.5     1.4
 Lithium Li      2       1       s       3       6.941   0.68    1.82
 Beryllium       Be      2       2       s       4       9.012   0.35    2.00
 Boron   B       2       13      p       5       10.811  0.83    2.00
 Carbon  C       2       14      p       6       12.011  0.68    1.70
+Beryllium       Be      2       2       s       4       9.012   0.35    2
+Boron   B       2       13      p       5       10.811  0.83    2
+Carbon  C       2       14      p       6       12.011  0.68    1.7
 Nitrogen        N       2       15      p       7       14.007  0.68    1.55
 Oxygen  O       2       16      p       8       15.999  0.68    1.52
 Fluorine        F       2       17      p       9       18.998  0.64    1.47
 Neon    Ne      2       18      p       10      20.180  1.50    1.54
+Neon    Ne      2       18      p       10      20.18   1.5     1.54
 Sodium  Na      3       1       s       11      22.991  0.97    2.27
 Magnesium       Mg      3       2       s       12      24.305  1.10    1.73
 Aluminium       Al      3       13      p       13      26.982  1.35    2.00
 Silicon Si      3       14      p       14      28.086  1.20    2.10
 Phosphorus      P       3       15      p       15      30.974  1.05    1.80
 Sulphur S       3       16      p       16      32.066  1.02    1.80
+Magnesium       Mg      3       2       s       12      24.305  1.1     1.73
+Aluminium       Al      3       13      p       13      26.982  1.35    2
+Silicon Si      3       14      p       14      28.086  1.2     2.1
+Phosphorus      P       3       15      p       15      30.974  1.05    1.8
+Sulphur S       3       16      p       16      32.066  1.02    1.8
 Chlorine        Cl      3       17      p       17      35.453  0.99    1.75
 Argon   Ar      3       18      p       18      39.948  1.51    1.88
 Potassium       K       4       1       s       19      39.098  1.33    2.75
 Calcium Ca      4       2       s       20      40.078  0.99    2.00
 Scandium        Sc      4       3       d       21      44.956  1.44    2.00
 Titanium        Ti      4       4       d       22      47.867  1.47    2.00
 Vanadium        V       4       5       d       23      50.942  1.33    2.00
 Chromium        Cr      4       6       d       24      51.996  1.35    2.00
 Manganese       Mn      4       7       d       25      54.938  1.35    2.00
 Iron    Fe      4       8       d       26      55.845  1.34    2.00
 Cobalt  Co      4       9       d       27      58.933  1.33    2.00
 Nickel  Ni      4       10      d       28      58.693  1.50    1.63
 Copper  Cu      4       11      d       29      63.546  1.52    1.40
 Zinc    Zn      4       12      d       30      65.390  1.45    1.39
+Calcium Ca      4       2       s       20      40.078  0.99    2
+Scandium        Sc      4       3       d       21      44.956  1.44    2
+Titanium        Ti      4       4       d       22      47.867  1.47    2
+Vanadium        V       4       5       d       23      50.942  1.33    2
+Chromium        Cr      4       6       d       24      51.996  1.35    2
+Manganese       Mn      4       7       d       25      54.938  1.35    2
+Iron    Fe      4       8       d       26      55.845  1.34    2
+Cobalt  Co      4       9       d       27      58.933  1.33    2
+Nickel  Ni      4       10      d       28      58.693  1.5     1.63
+Copper  Cu      4       11      d       29      63.546  1.52    1.4
+Zinc    Zn      4       12      d       30      65.39   1.45    1.39
 Gallium Ga      4       13      p       31      69.723  1.22    1.87
 Germanium       Ge      4       14      p       32      72.610  1.17    2.00
+Germanium       Ge      4       14      p       32      72.61   1.17    2
 Arsenic As      4       15      p       33      74.922  1.21    1.85
 Selenium        Se      4       16      p       34      78.960  1.22    1.90
+Selenium        Se      4       16      p       34      78.96   1.22    1.9
 Bromine Br      4       17      p       35      79.904  1.21    1.85
 Krypton Kr      4       18      p       36      83.800  1.50    2.02
 Rubidium        Rb      5       1       s       37      85.468  1.47    2.00
 Strontium       Sr      5       2       s       38      87.620  1.12    2.00
 Yttrium Y       5       3       d       39      88.906  1.78    2.00
 Zirconium       Zr      5       4       d       40      91.224  1.56    2.00
 Niobium Nb      5       5       d       41      92.906  1.48    2.00
 Molybdenum      Mo      5       6       d       42      95.940  1.47    2.00
 Technetium      Tc      5       7       d       43      98      1.35    2.00
 Ruthenium       Ru      5       8       d       44      101.070 1.40    2.00
 Rhodium Rh      5       9       d       45      102.906 1.45    2.00
 Palladium       Pd      5       10      d       46      106.420 1.50    1.63
+Krypton Kr      4       18      p       36      83.8    1.5     2.02
+Rubidium        Rb      5       1       s       37      85.468  1.47    2
+Strontium       Sr      5       2       s       38      87.62   1.12    2
+Yttrium Y       5       3       d       39      88.906  1.78    2
+Zirconium       Zr      5       4       d       40      91.224  1.56    2
+Niobium Nb      5       5       d       41      92.906  1.48    2
+Molybdenum      Mo      5       6       d       42      95.94   1.47    2
+Technetium      Tc      5       7       d       43      98      1.35    2
+Ruthenium       Ru      5       8       d       44      101.07  1.4     2
+Rhodium Rh      5       9       d       45      102.906 1.45    2
+Palladium       Pd      5       10      d       46      106.42  1.5     1.63
 Silver  Ag      5       11      d       47      107.868 1.59    1.72
 Cadmium Cd      5       12      d       48      112.411 1.69    1.58
 Indium  In      5       13      p       49      114.818 1.63    1.93
 Tin     Sn      5       14      p       50      118.71  1.46    2.17
+Antimony        Sb      5       15      p       51      121.760 1.46    2.00
+Tellurium       Te      5       16      p       52      127.600 1.47    2.06
+Iodine  I       5       17      p       53      126.904 1.40    1.98
+Xenon   Xe      5       18      p       54      131.290 1.50    2.16
+Caesium Cs      6       1       s       55      132.905 1.67    2.00
+Barium  Ba      6       2       s       56      137.327 1.34    2.00
+Lutetium        Lu      6       3       d       71      174.967 1.72    2.00
+Hafnium Hf      6       4       d       72      178.490 1.57    2.00
+Tantalum        Ta      6       5       d       73      180.948 1.43    2.00
+Tungsten        W       6       6       d       74      183.840 1.37    2.00
+Rhenium Re      6       7       d       75      186.207 1.35    2.00
+Osmium  Os      6       8       d       76      190.230 1.37    2.00
+Iridium Ir      6       9       d       77      192.217 1.32    2.00
+Platinum        Pt      6       10      d       78      195.078 1.50    1.72
+Gold    Au      6       11      d       79      196.967 1.50    1.66
+Mercury Hg      6       12      d       80      200.590 1.70    1.55
+Antimony        Sb      5       15      p       51      121.76  1.46    2
+Tellurium       Te      5       16      p       52      127.6   1.47    2.06
+Iodine  I       5       17      p       53      126.904 1.4     1.98
+Xenon   Xe      5       18      p       54      131.29  1.5     2.16
+Caesium Cs      6       1       s       55      132.905 1.67    2
+Barium  Ba      6       2       s       56      137.327 1.34    2
+Lanthanum       La      6Lan    19      f       57      138.906 1.87    2
+Cerium  Ce      6Lan    19      f       58      140.116 1.83    2
+Praseodymium    Pr      6Lan    19      f       59      140.908 1.82    2
+Neodymium       Nd      6Lan    19      f       60      144.24  1.81    2
+Promethium      Pm      6Lan    19      f       61      145     1.8     2
+Samarium        Sm      6Lan    19      f       62      150.36  1.8     2
+Europium        Eu      6Lan    19      f       63      151.964 1.99    2
+Gadolinium      Gd      6Lan    19      f       64      157.25  1.79    2
+Terbium Tb      6Lan    19      f       65      158.925 1.76    2
+Dysprosium      Dy      6Lan    19      f       66      162.5   1.75    2
+Holmium Ho      6Lan    19      f       67      164.93  1.74    2
+Erbium  Er      6Lan    19      f       68      167.26  1.73    2
+Thulium Tm      6Lan    19      f       69      168.934 1.72    2
+Ytterbium       Yb      6Lan    19      f       70      173.04  1.94    2
+Lutetium        Lu      6       3       d       71      174.967 1.72    2
+Hafnium Hf      6       4       d       72      178.49  1.57    2
+Tantalum        Ta      6       5       d       73      180.948 1.43    2
+Tungsten        W       6       6       d       74      183.84  1.37    2
+Rhenium Re      6       7       d       75      186.207 1.35    2
+Osmium  Os      6       8       d       76      190.23  1.37    2
+Iridium Ir      6       9       d       77      192.217 1.32    2
+Platinum        Pt      6       10      d       78      195.078 1.5     1.72
+Gold    Au      6       11      d       79      196.967 1.5     1.66
+Mercury Hg      6       12      d       80      200.59  1.7     1.55
 Thallium        Tl      6       13      p       81      204.383 1.55    1.96
+Lead    Pb      6       14      p       82      207.200 1.54    2.02
+Bismuth Bi      6       15      p       83      208.980 1.54    2.00
+Polonium        Po      6       16      p       84      210     1.68    2.00
+Astatine        At      6       17      p       85      210     1.21    2.00
+Radon   Rn      6       18      p       86      222     1.50    2.00
+Cerium  Ce      6Lan    19      f       58      140.116 1.83    2.00
+Dysprosium      Dy      6Lan    19      f       66      162.500 1.75    2.00
+Erbium  Er      6Lan    19      f       68      167.260 1.73    2.00
+Europium        Eu      6Lan    19      f       63      151.964 1.99    2.00
+Gadolinium      Gd      6Lan    19      f       64      157.250 1.79    2.00
+Holmium Ho      6Lan    19      f       67      164.930 1.74    2.00
+Lanthanum       La      6Lan    19      f       57      138.906 1.87    2.00
+Neodymium       Nd      6Lan    19      f       60      144.240 1.81    2.00
+Promethium      Pm      6Lan    19      f       61      145     1.80    2.00
+Praseodymium    Pr      6Lan    19      f       59      140.908 1.82    2.00
+Samarium        Sm      6Lan    19      f       62      150.360 1.80    2.00
+Terbium Tb      6Lan    19      f       65      158.925 1.76    2.00
+Thulium Tm      6Lan    19      f       69      168.934 1.72    2.00
+Ytterbium       Yb      6Lan    19      f       70      173.040 1.94    2.00
+Francium        Fr      7       1       s       87      223     1.50    2.00
+Radium  Ra      7       2       s       88      226     1.90    2.00
+Lawrencium      Lr      7       3       d       103     262     1.50    2.00
+Rutherfordium   Rf      7       4       d       104     261     1.50    2.00
+Dubnium Db      7       5       d       105     262     1.50    2.00
+Seaborgium      Sg      7       6       d       106     266     1.50    2.00
+Bohrium Bh      7       7       d       107     264     1.50    2.00
+Hassium Hs      7       8       d       108     269     1.50    2.00
+Meitnerium      Mt      7       9       d       109     268     1.50    2.00
+Darmstadtium    Ds      7       10      d       110     271     1.50    2.00
+Actinium        Ac      7Act    20      f       89      227     1.88    2.00
+Americium       Am      7Act    20      f       95      243     1.51    2.00
+Berkelium       Bk      7Act    20      f       97      247     1.54    2.00
+Californium     Cf      7Act    20      f       98      251     1.83    2.00
+Curium  Cm      7Act    20      f       96      247     0.99    2.00
+Einsteinium     Es      7Act    20      f       99      252     1.50    2.00
+Fermium Fm      7Act    20      f       100     257     1.50    2.00
+Mendelevium     Md      7Act    20      f       101     258     1.50    2.00
+Nobelium        No      7Act    20      f       102     259     1.50    2.00
+Neptunium       Np      7Act    20      f       93      237     1.55    2.00
+Protactinium    Pa      7Act    20      f       91      231.036 1.61    2.00
+Plutonium       Pu      7Act    20      f       94      244     1.53    2.00
+Thorium Th      7Act    20      f       90      232.038 1.79    2.00
+Lead    Pb      6       14      p       82      207.2   1.54    2.02
+Bismuth Bi      6       15      p       83      208.98  1.54    2
+Polonium        Po      6       16      p       84      210     1.68    2
+Astatine        At      6       17      p       85      210     1.21    2
+Radon   Rn      6       18      p       86      222     1.5     2
+Francium        Fr      7       1       s       87      223     1.5     2
+Radium  Ra      7       2       s       88      226     1.9     2
+Actinium        Ac      7Act    20      f       89      227     1.88    2
+Thorium Th      7Act    20      f       90      232.038 1.79    2
+Protactinium    Pa      7Act    20      f       91      231.036 1.61    2
 Uranium U       7Act    20      f       92      238.029 1.58    1.86
+Neptunium       Np      7Act    20      f       93      237     1.55    2
+Plutonium       Pu      7Act    20      f       94      244     1.53    2
+Americium       Am      7Act    20      f       95      243     1.51    2
+Curium  Cm      7Act    20      f       96      247     0.99    2
+Berkelium       Bk      7Act    20      f       97      247     1.54    2
+Californium     Cf      7Act    20      f       98      251     1.83    2
+Einsteinium     Es      7Act    20      f       99      252     1.5     2
+Fermium Fm      7Act    20      f       100     257     1.5     2
+Mendelevium     Md      7Act    20      f       101     258     1.5     2
+Nobelium        No      7Act    20      f       102     259     1.5     2
+Lawrencium      Lr      7       3       d       103     262     1.5     2
+Rutherfordium   Rf      7       4       d       104     261     1.5     2
+Dubnium Db      7       5       d       105     262     1.5     2
+Seaborgium      Sg      7       6       d       106     266     1.5     2
+Bohrium Bh      7       7       d       107     264     1.5     2
+Hassium Hs      7       8       d       108     269     1.5     2
+Meitnerium      Mt      7       9       d       109     268     1.5     2
+Darmstadtium    Ds      7       10      d       110     271     1.5     2

src/ellipsoid.cpp

rc39cc4	rbdb143
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <gsl/gsl_multimin.h>

src/errorlogger.cpp

rc39cc4	rbdb143
5	5	* Author: metzler
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <fstream>

src/graph.cpp

rc39cc4	rbdb143
4	4	*
5	5	*/
	6
	7	#include "Helpers/MemDebug.hpp"
6	8
7	9	using namespace std;

src/gslmatrix.cpp

rc39cc4	rbdb143
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	using namespace std;

src/gslvector.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include <cassert>
 #include <cmath>
 …
 #include "gslvector.hpp"
 #include "defs.hpp"
+#include "vector.hpp"
 /** Constructor of class GSLVector.
 …
   gsl_vector_memcpy (vector, &m.vector);
 };
+/**
+ * This function sets the GSLvector from an ordinary vector.
+ *
+ * Takes access to the internal gsl_vector and copies it
+ */
+void GSLVector::SetFromVector(Vector &v){
+  gsl_vector_memcpy (vector, v.get());
+}
 /** This function returns the i-th element of a vector.

src/gslvector.hpp

-              rc39cc4
+              rbdb143
 class GSLVector;
+class Vector;
 /********************************************** declarations *******************************/
 …
   // Accessing
   void SetFromDoubleArray(double *x);
+  void SetFromVector(Vector &v);
   double Get(size_t m) const;
   void Set(size_t m, double x);

src/helpers.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include "helpers.hpp"
 …
 int CountLinesinFile(ifstream &InputFile)
+{
   char *buffer = Malloc<char>(MAXSTRINGSIZE, "CountLinesinFile: *buffer");
+  char *buffer = new char[MAXSTRINGSIZE];
   int lines=0;
 …
+  }
   InputFile.seekg(PositionMarker, ios::beg);
   Free(&buffer);
+  delete[](buffer);
   return lines;
 };
 …
+  }
   // allocate string
   returnstring = Malloc<char>(order + 2, "FixedDigitNumber: *returnstring");
+  returnstring = new char[order + 2];
   // terminate  and fill string array from end backward
   returnstring[order] = '\0';
 …
 double * ReturnFullMatrixforSymmetric(const double * const symm)
+{
   double *matrix = Malloc<double>(NDIM * NDIM, "molecule::ReturnFullMatrixforSymmetric: *matrix");
+  double *matrix = new double[NDIM * NDIM];
   matrix[0] = symm[0];
   matrix[1] = symm[1];
 …
 double * InverseMatrix( const double * const A)
+{
   double *B = Malloc<double>(NDIM * NDIM, "Vector::InverseMatrix: *B");
+  double *B = new double[NDIM * NDIM];
   double detA = RDET3(A);
   double detAReci;
 …
-/** Allocates a memory range using malloc().
- * Prints the provided error message in case of a failure.
+ *
- * \param number of memory slices of type X to allocate
- * \param failure message which is printed if the allocation fails
- * \return pointer to the allocated memory range, will be NULL if a failure occurred
- */
-template <> char* Malloc<char>(size_t size, const char* output)
+{
-  char* buffer = NULL;
-  buffer = (char*) malloc(sizeof(char) * (size + 1));
-  for (size_t i = size; i--;)
-    buffer[i] = (i % 2 == 0) ? 'p': 'c';
-  buffer[size] = '\0';
-  if (buffer != NULL) {
-    MemoryUsageObserver::getInstance()->addMemory(buffer, size);
-  } else {
-    Log() << Verbose(0) << "Malloc for datatype " << typeid(char).name()
-      << " failed - pointer is NULL: " << output << endl;
+  }
-  return buffer;
-};
 /**
  * Frees all memory registered by the memory observer and calls exit(225) afterwards.
+ * Calls exit(255).
  */
 void performCriticalExit() {
-  map<void*, size_t> pointers = MemoryUsageObserver::getInstance()->getPointersToAllocatedMemory();
-  for (map<void*, size_t>::iterator runner = pointers.begin(); runner != pointers.end(); runner++) {
-    Free(((void**) &runner->first));
+  }
   exit(255);
+}

src/helpers.hpp

-              rc39cc4
+              rbdb143
   if (LookupTable != NULL) {
     DoLog(0) && (Log() << Verbose(0) << "Pointer for Lookup table is not NULL! Aborting ..." <<endl);
+    DoeLog(0) && (eLog() << Verbose(0) << "Pointer for Lookup table is not NULL! Aborting ..." <<endl);
     return false;
+  }
 …
+  }
   if (count <= 0) {
     DoLog(0) && (Log() << Verbose(0) << "Count of lookup list is 0 or less." << endl);
+    DoeLog(1) && (eLog() << Verbose(1) << "Count of lookup list is 0 or less." << endl);
     return false;
+  }
   // allocate and fill
   LookupTable = Calloc<T*>(count, "CreateFatherLookupTable - **LookupTable");
+  LookupTable = new T*[count];
   if (LookupTable == NULL) {
     DoeLog(0) && (eLog()<< Verbose(0) << "LookupTable memory allocation failed!" << endl);
 …
         LookupTable[AtomNo] = Walker;
       } else {
         DoLog(0) && (Log() << Verbose(0) << "Walker " << *Walker << " exceeded range of nuclear ids [0, " << count << ")." << endl);
+        DoeLog(2) && (eLog() << Verbose(2) << "Walker " << *Walker << " exceeded range of nuclear ids [0, " << count << ")." << endl);
         status = false;
         break;
 …
   return status;
 };
 /** Frees a two-dimensional array.

src/info.cpp

rc39cc4	rbdb143
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "info.hpp"

src/joiner.cpp

-              rc39cc4
+              rbdb143
 //============================ INCLUDES ===========================
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
     return 1;
   } else {
     dir = Malloc<char>(strlen(argv[2]) + 2, "main: *dir");
+    dir = new char[strlen(argv[2]) + 2];
     strcpy(dir, "/");
     strcat(dir, argv[2]);
 …
   // exit
   delete(periode);
   Free(&dir);
+  delete[](dir);
   DoLog(0) && (Log() << Verbose(0) << "done." << endl);
   return 0;

src/leastsquaremin.cpp

rc39cc4	rbdb143
5	5	* Author: heber
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <iostream>

src/linearsystemofequations.cpp

-              rc39cc4
+              rbdb143
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include "defs.hpp"
 …
+{
   assert ( columns == NDIM && "Vector class is always three-dimensional, unlike this LEqS!");
   b->SetFromDoubleArray(x->get());
+  b->SetFromVector(*x);
 };

src/linkedcell.cpp

rc39cc4	rbdb143
5	5	*/
6	6
	7	#include "Helpers/MemDebug.hpp"
7	8
8	9	#include "atom.hpp"

src/lists.hpp

-              rc39cc4
+              rbdb143
 };
-/** Returns the first marker in a chain list.
- * \param *me one arbitrary item in chain list
- * \return poiner to first marker
- */
-template <typename X> X *GetFirst(X *me)
+{
-  X *Binder = me;
-  while(Binder->previous != 0)
-    Binder = Binder->previous;
-  return Binder;
-};
-/** Returns the last marker in a chain list.
- * \param *me one arbitrary item in chain list
- * \return poiner to last marker
- */
-template <typename X> X *GetLast(X *me)
+{
-  X *Binder = me;
-  while(Binder->next != 0)
-    Binder = Binder->next;
-  return Binder;
-};
 #endif /* LISTS_HPP_ */

src/log.cpp

rc39cc4	rbdb143
5	5	* Author: metzler
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "logger.hpp"

src/logger.cpp

rc39cc4	rbdb143
5	5	* Author: metzler
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include <fstream>

src/memoryusageobserver.cpp

rc39cc4	rbdb143
4	4	* This class represents a Singleton for observing memory usage.
5	5	*/
	6
	7	#include "Helpers/MemDebug.hpp"
6	8
7	9	#include <cstdlib>

src/molecule.cpp

-              rc39cc4
+              rbdb143
+ *
  */
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
  * Initialises molecule list with correctly referenced start and end, and sets molecule::last_atom to zero.
  */
+molecule::molecule(const periodentafel * const teil) : elemente(teil), start(World::getInstance().createAtom()), end(World::getInstance().createAtom()),
+  first(new bond(start, end, 1, -1)), last(new bond(start, end, 1, -1)), MDSteps(0), AtomCount(0),
+  BondCount(0), ElementCount(0), NoNonHydrogen(0), NoNonBonds(0), NoCyclicBonds(0), BondDistance(0.),
+  ActiveFlag(false), IndexNr(-1),
+  formula(this,boost::bind(&molecule::calcFormula,this)),
+  last_atom(0),
+  InternalPointer(start)
+{
+  // init atom chain list
+  start->father = NULL;
+  end->father = NULL;
+  link(start,end);
+  // init bond chain list
+  link(first,last);
+molecule::molecule(const periodentafel * const teil) :
+  Observable("molecule"),
+  elemente(teil),  MDSteps(0),  BondCount(0), ElementCount(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(atoms.begin())
+{
   // other stuff
   for(int i=MAX_ELEMENTS;i--;)
     ElementsInMolecule[i] = 0;
   strcpy(name,World::getInstance().getDefaultName());
+  strcpy(name,World::getInstance().getDefaultName().c_str());
 };
 …
+{
   CleanupMolecule();
-  delete(first);
-  delete(last);
-  end->getWorld()->destroyAtom(end);
-  start->getWorld()->destroyAtom(start);
 };
 …
+}
+int molecule::getAtomCount() const{
+  return *AtomCount;
+}
 void molecule::setName(const std::string _name){
   OBSERVE;
+  cout << "Set name of molecule " << getId() << " to " << _name << endl;
   strncpy(name,_name.c_str(),MAXSTRINGSIZE);
+}
 …
   stringstream sstr;
   periodentafel *periode = World::getInstance().getPeriode();
   for(atom *Walker = start; Walker != end; Walker = Walker->next) {
     counts[Walker->type->getNumber()]++;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    counts[(*iter)->type->getNumber()]++;
+  }
   std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
 …
+}
+/************************** Access to the List of Atoms ****************/
+molecule::iterator molecule::begin(){
+  return molecule::iterator(atoms.begin(),this);
+}
+molecule::const_iterator molecule::begin() const{
+  return atoms.begin();
+}
+molecule::iterator molecule::end(){
+  return molecule::iterator(atoms.end(),this);
+}
+molecule::const_iterator molecule::end() const{
+  return atoms.end();
+}
+bool molecule::empty() const
+{
+  return (begin() == end());
+}
+size_t molecule::size() const
+{
+  size_t counter = 0;
+  for (molecule::const_iterator iter = begin(); iter != end (); ++iter)
+    counter++;
+  return counter;
+}
+molecule::const_iterator molecule::erase( const_iterator loc )
+{
+  molecule::const_iterator iter = loc;
+  iter--;
+  atom* atom = *loc;
+  atomIds.erase( atom->getId() );
+  atoms.remove( atom );
+  atom->removeFromMolecule();
+  return iter;
+}
+molecule::const_iterator molecule::erase( atom * key )
+{
+  molecule::const_iterator iter = find(key);
+  if (iter != end()){
+    atomIds.erase( key->getId() );
+    atoms.remove( key );
+    key->removeFromMolecule();
+  }
+  return iter;
+}
+molecule::const_iterator molecule::find ( atom * key ) const
+{
+  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<atomIdSet::iterator,bool> res = atomIds.insert(key->getId());
+  if (res.second) { // push atom if went well
+    atoms.push_back(key);
+    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 (find(key) != end());
+}
 /** Adds given atom \a *pointer from molecule list.
 …
 bool molecule::AddAtom(atom *pointer)
+{
-  bool retval = false;
   OBSERVE;
   if (pointer != NULL) {
     pointer->sort = &pointer->nr;
-    pointer->nr = last_atom++;  // increase number within molecule
-    AtomCount++;
     if (pointer->type != NULL) {
       if (ElementsInMolecule[pointer->type->Z] == 0)
 …
+      }
+    }
+    retval = add(pointer, end);
+  }
+  return retval;
+    insert(pointer);
+    pointer->setMolecule(this);
+  }
+  return true;
 };
 …
   if (pointer != NULL) {
     atom *walker = pointer->clone();
+    stringstream sstr;
+    sstr << pointer->getName();
+    walker->setName(sstr.str());
+    walker->setName(pointer->getName());
     walker->nr = last_atom++;  // increase number within molecule
     add(walker, end);
+    insert(walker);
     if ((pointer->type != NULL) && (pointer->type->Z != 1))
       NoNonHydrogen++;
-    AtomCount++;
     retval=walker;
+  }
 …
     Orthovector1.MatrixMultiplication(matrix);
     InBondvector -= Orthovector1; // subtract just the additional translation
     Free(&matrix);
+    delete[](matrix);
     bondlength = InBondvector.Norm();
 //    Log() << Verbose(4) << "Corrected InBondvector is now: ";
 …
   InBondvector.Normalize();
   // get typical bond length and store as scale factor for later
+  ASSERT(TopOrigin->type != NULL, "AddHydrogenReplacementAtom: element of TopOrigin is not given.");
   BondRescale = TopOrigin->type->HBondDistance[TopBond->BondDegree-1];
   if (BondRescale == -1) {
 …
       break;
+  }
   Free(&matrix);
+  delete[](matrix);
 //  Log() << Verbose(3) << "End of AddHydrogenReplacementAtom." << endl;
 …
   // copy all bonds
   bond *Binder = first;
+  bond *Binder = NULL;
   bond *NewBond = NULL;
+  while(Binder->next != last) {
+    Binder = Binder->next;
+    // 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);
+    NewBond->Cyclic = Binder->Cyclic;
+    if (Binder->Cyclic)
+      copy->NoCyclicBonds++;
+    NewBond->Type = Binder->Type;
+  }
+  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);
+        // 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);
+        NewBond->Cyclic = Binder->Cyclic;
+        if (Binder->Cyclic)
+          copy->NoCyclicBonds++;
+        NewBond->Type = Binder->Type;
+      }
   // correct fathers
   ActOnAllAtoms( &atom::CorrectFather );
   // copy values
-  copy->CountAtoms();
   copy->CountElements();
   if (first->next != last) {  // if adjaceny list is present
+  if (hasBondStructure()) {  // if adjaceny list is present
     copy->BondDistance = BondDistance;
+  }
 …
 bond * molecule::AddBond(atom *atom1, atom *atom2, int degree)
+{
+  OBSERVE;
   bond *Binder = NULL;
+  if ((atom1 != NULL) && (FindAtom(atom1->nr) != NULL) && (atom2 != NULL) && (FindAtom(atom2->nr) != NULL)) {
+    Binder = new bond(atom1, atom2, degree, BondCount++);
+    atom1->RegisterBond(Binder);
+    atom2->RegisterBond(Binder);
+    if ((atom1->type != NULL) && (atom1->type->Z != 1) && (atom2->type != NULL) && (atom2->type->Z != 1))
+      NoNonBonds++;
+    add(Binder, last);
+  } else {
+    DoeLog(1) && (eLog()<< Verbose(1) << "Could not add bond between " << atom1->getName() << " and " << atom2->getName() << " as one or both are not present in the molecule." << endl);
+  }
+  // some checks to make sure we are able to create the bond
+  ASSERT(atom1, "First atom in bond-creation was an invalid pointer");
+  ASSERT(atom2, "Second atom in bond-creation was an invalid pointer");
+  ASSERT(FindAtom(atom1->nr),"First atom in bond-creation was not part of molecule");
+  ASSERT(FindAtom(atom2->nr),"Second atom in bond-creation was not parto of molecule");
+  Binder = new bond(atom1, atom2, degree, BondCount++);
+  atom1->RegisterBond(Binder);
+  atom2->RegisterBond(Binder);
+  if ((atom1->type != NULL) && (atom1->type->Z != 1) && (atom2->type != NULL) && (atom2->type->Z != 1))
+    NoNonBonds++;
   return Binder;
 };
 …
+{
   //DoeLog(1) && (eLog()<< Verbose(1) << "molecule::RemoveBond: Function not implemented yet." << endl);
+  pointer->leftatom->RegisterBond(pointer);
+  pointer->rightatom->RegisterBond(pointer);
+  removewithoutcheck(pointer);
+  delete(pointer);
   return true;
 };
 …
   else
     length = strlen(molname) - strlen(endname);
+  cout << "Set name of molecule " << getId() << " to " << molname << endl;
   strncpy(name, molname, length);
   name[length]='\0';
 …
 bool molecule::RemoveAtom(atom *pointer)
+{
+  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
-    AtomCount--;
   } 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);
 …
     ElementCount--;
   RemoveBonds(pointer);
+  return remove(pointer, start, end);
+  erase(pointer);
+  return true;
 };
 …
   if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
     ElementCount--;
   unlink(pointer);
+  erase(pointer);
   return true;
 };
 …
 bool molecule::CleanupMolecule()
+{
+  return (cleanup(first,last) && cleanup(start,end));
+  for (molecule::iterator iter = begin(); !empty(); iter = begin())
+      erase(iter);
+  return empty();
 };
 …
  * \return pointer to atom or NULL
  */
+atom * molecule::FindAtom(int Nr)  const{
+  atom * walker = find(&Nr, start,end);
+  if (walker != NULL) {
+atom * molecule::FindAtom(int Nr)  const
+{
+  molecule::const_iterator iter = begin();
+  for (; iter != end(); ++iter)
+    if ((*iter)->nr == Nr)
+      break;
+  if (iter != end()) {
     //Log() << Verbose(0) << "Found Atom Nr. " << walker->nr << endl;
     return walker;
+    return (*iter);
   } else {
     DoLog(0) && (Log() << Verbose(0) << "Atom not found in list." << endl);
 …
         ElementNo[i] = current++;
+    }
     ActOnAllAtoms( &atom::OutputArrayIndexed, output, (const int *)ElementNo, (int *)AtomNo, (const char *) NULL );
+    ActOnAllAtoms( &atom::OutputArrayIndexed, (ostream * const) output, (const int *)ElementNo, (int *)AtomNo, (const char *) NULL );
     return true;
+  }
 …
     now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
     for (int step=0;step<MDSteps;step++) {
       *output << AtomCount << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
+      *output << getAtomCount() << "\n\tCreated by molecuilder, step " << step << ", on " << ctime(&now);
       ActOnAllAtoms( &atom::OutputTrajectoryXYZ, output, step );
+    }
 …
   if (output != NULL) {
     now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
     *output << AtomCount << "\n\tCreated by molecuilder on " << ctime(&now);
+    *output << getAtomCount() << "\n\tCreated by molecuilder on " << ctime(&now);
     ActOnAllAtoms( &atom::OutputXYZLine, output );
     return true;
 …
  * \param *out output stream for debugging
  */
+void molecule::CountAtoms()
+{
+int molecule::doCountAtoms()
+{
+  int res = size();
   int i = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+  NoNonHydrogen = 0;
+  for (molecule::const_iterator iter = atoms.begin(); iter != atoms.end(); ++iter) {
+    (*iter)->nr = i;   // update number in molecule (for easier referencing in FragmentMolecule lateron)
+    if ((*iter)->type->Z != 1) // count non-hydrogen atoms whilst at it
+      NoNonHydrogen++;
+    stringstream sstr;
+    sstr << (*iter)->type->symbol << (*iter)->nr+1;
+    (*iter)->setName(sstr.str());
+    DoLog(3) && (Log() << Verbose(3) << "Naming atom nr. " << (*iter)->nr << " " << (*iter)->getName() << "." << endl);
     i++;
+  }
+  if ((AtomCount == 0) || (i != AtomCount)) {
+    DoLog(3) && (Log() << Verbose(3) << "Mismatch in AtomCount " << AtomCount << " and recounted number " << i << ", renaming all." << endl);
+    AtomCount = i;
+    // count NonHydrogen atoms and give each atom a unique name
+    if (AtomCount != 0) {
+      i=0;
+      NoNonHydrogen = 0;
+      Walker = start;
+      while (Walker->next != end) {
+        Walker = Walker->next;
+        Walker->nr = i;   // update number in molecule (for easier referencing in FragmentMolecule lateron)
+        if (Walker->type->Z != 1) // count non-hydrogen atoms whilst at it
+          NoNonHydrogen++;
+        stringstream sstr;
+        sstr << Walker->type->symbol << Walker->nr+1;
+        Walker->setName(sstr.str());
+        DoLog(3) && (Log() << Verbose(3) << "Naming atom nr. " << Walker->nr << " " << Walker->getName() << "." << endl);
+        i++;
+      }
+    } else
+      DoLog(3) && (Log() << Verbose(3) << "AtomCount is still " << AtomCount << ", thus counting nothing." << endl);
+  }
+  return res;
 };
 …
   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;
 };
 …
   /// first count both their atoms and elements and update lists thereby ...
   //Log() << Verbose(0) << "Counting atoms, updating list" << endl;
-  CountAtoms();
-  OtherMolecule->CountAtoms();
   CountElements();
   OtherMolecule->CountElements();
 …
   /// -# AtomCount
   if (result) {
     if (AtomCount != OtherMolecule->AtomCount) {
       DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl);
+    if (getAtomCount() != OtherMolecule->getAtomCount()) {
+      DoLog(4) && (Log() << Verbose(4) << "AtomCounts don't match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl);
       result = false;
     } else Log() << Verbose(4) << "AtomCounts match: " << AtomCount << " == " << OtherMolecule->AtomCount << endl;
+    } else Log() << Verbose(4) << "AtomCounts match: " << getAtomCount() << " == " << OtherMolecule->getAtomCount() << endl;
+  }
   /// -# ElementCount
 …
   if (result) {
     DoLog(5) && (Log() << Verbose(5) << "Calculating distances" << endl);
     Distances = Calloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: Distances");
     OtherDistances = Calloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: OtherDistances");
+    Distances = new double[getAtomCount()];
+    OtherDistances = new double[getAtomCount()];
     SetIndexedArrayForEachAtomTo ( Distances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
     SetIndexedArrayForEachAtomTo ( OtherDistances, &atom::nr, &atom::DistanceSquaredToVector, (const Vector &)CenterOfGravity);
+    for(int i=0;i<getAtomCount();i++) {
+      Distances[i] = 0.;
+      OtherDistances[i] = 0.;
+    }
     /// ... sort each list (using heapsort (o(N log N)) from GSL)
     DoLog(5) && (Log() << Verbose(5) << "Sorting distances" << endl);
+    PermMap = Calloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermMap");
+    OtherPermMap = Calloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
+    gsl_heapsort_index (PermMap, Distances, AtomCount, sizeof(double), CompareDoubles);
+    gsl_heapsort_index (OtherPermMap, OtherDistances, AtomCount, sizeof(double), CompareDoubles);
+    PermutationMap = Calloc<int>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermutationMap");
+    PermMap = new size_t[getAtomCount()];
+    OtherPermMap = new size_t[getAtomCount()];
+    for(int i=0;i<getAtomCount();i++) {
+      PermMap[i] = 0;
+      OtherPermMap[i] = 0;
+    }
+    gsl_heapsort_index (PermMap, Distances, getAtomCount(), sizeof(double), CompareDoubles);
+    gsl_heapsort_index (OtherPermMap, OtherDistances, getAtomCount(), sizeof(double), CompareDoubles);
+    PermutationMap = new int[getAtomCount()];
+    for(int i=0;i<getAtomCount();i++)
+      PermutationMap[i] = 0;
     DoLog(5) && (Log() << Verbose(5) << "Combining Permutation Maps" << endl);
     for(int i=AtomCount;i--;)
+    for(int i=getAtomCount();i--;)
       PermutationMap[PermMap[i]] = (int) OtherPermMap[i];
 …
     DoLog(4) && (Log() << Verbose(4) << "Comparing distances" << endl);
     flag = 0;
     for (int i=0;i<AtomCount;i++) {
+    for (int i=0;i<getAtomCount();i++) {
       DoLog(5) && (Log() << Verbose(5) << "Distances squared: |" << Distances[PermMap[i]] << " - " << OtherDistances[OtherPermMap[i]] << "| = " << fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) << " ?<? " <<  threshold << endl);
       if (fabs(Distances[PermMap[i]] - OtherDistances[OtherPermMap[i]]) > threshold*threshold)
 …
     // free memory
     Free(&PermMap);
     Free(&OtherPermMap);
     Free(&Distances);
     Free(&OtherDistances);
+    delete[](PermMap);
+    delete[](OtherPermMap);
+    delete[](Distances);
+    delete[](OtherDistances);
     if (flag) { // if not equal
       Free(&PermutationMap);
+      delete[](PermutationMap);
       result = false;
+    }
 …
 int * molecule::GetFatherSonAtomicMap(molecule *OtherMolecule)
+{
-  atom *Walker = NULL, *OtherWalker = NULL;
   DoLog(3) && (Log() << Verbose(3) << "Begin of GetFatherAtomicMap." << endl);
   int *AtomicMap = Malloc<int>(AtomCount, "molecule::GetAtomicMap: *AtomicMap");
   for (int i=AtomCount;i--;)
+  int *AtomicMap = new int[getAtomCount()];
+  for (int i=getAtomCount();i--;)
     AtomicMap[i] = -1;
   if (OtherMolecule == this) {  // same molecule
     for (int i=AtomCount;i--;) // no need as -1 means already that there is trivial correspondence
+    for (int i=getAtomCount();i--;) // no need as -1 means already that there is trivial correspondence
       AtomicMap[i] = i;
     DoLog(4) && (Log() << Verbose(4) << "Map is trivial." << endl);
   } else {
     DoLog(4) && (Log() << Verbose(4) << "Map is ");
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+      if (Walker->father == NULL) {
+        AtomicMap[Walker->nr] = -2;
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+      if ((*iter)->father == NULL) {
+        AtomicMap[(*iter)->nr] = -2;
       } else {
+        OtherWalker = OtherMolecule->start;
+        while (OtherWalker->next != OtherMolecule->end) {
+          OtherWalker = OtherWalker->next;
+        for (molecule::const_iterator runner = OtherMolecule->begin(); runner != OtherMolecule->end(); ++runner) {
       //for (int i=0;i<AtomCount;i++) { // search atom
         //for (int j=0;j<OtherMolecule->AtomCount;j++) {
           //Log() << Verbose(4) << "Comparing father " << Walker->father << " with the other one " << OtherWalker->father << "." << endl;
           if (Walker->father == OtherWalker)
             AtomicMap[Walker->nr] = OtherWalker->nr;
+        //for (int j=0;j<OtherMolecule->getAtomCount();j++) {
+          //Log() << Verbose(4) << "Comparing father " << (*iter)->father << " with the other one " << (*runner)->father << "." << endl;
+          if ((*iter)->father == (*runner))
+            AtomicMap[(*iter)->nr] = (*runner)->nr;
+        }
+      }
       DoLog(0) && (Log() << Verbose(0) << AtomicMap[Walker->nr] << "\t");
+      DoLog(0) && (Log() << Verbose(0) << AtomicMap[(*iter)->nr] << "\t");
+    }
     DoLog(0) && (Log() << Verbose(0) << endl);
 …
 void molecule::SetIndexedArrayForEachAtomTo ( atom **array, int ParticleInfo::*index) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = Walker;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = (*iter);
+  }
 };

src/molecule.hpp

-              rc39cc4
+              rbdb143
 #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 "Descriptors/MoleculeDescriptor_impl.hpp"
 /****************************************** forward declarations *****************************/
 …
 };
-#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
 …
   friend molecule *NewMolecule();
   friend void DeleteMolecule(molecule *);
   public:
+    typedef std::list<atom*> atomSet;
+    typedef std::set<atomId_t> atomIdSet;
+    typedef ObservedIterator<atomSet> iterator;
+    typedef atomSet::const_iterator const_iterator;
     const periodentafel * const elemente; //!< periodic table with each element
+    atom *start;        //!< start of atom list
+    atom *end;          //!< end of atom list
+    bond *first;        //!< start of bond list
+    bond *last;         //!< end of bond list
+    // old deprecated atom handling
+    //atom *start;        //!< start of atom list
+    //atom *end;          //!< end of atom list
+    //bond *first;        //!< start of bond list
+    //bond *last;         //!< end of bond list
     int MDSteps;        //!< The number of MD steps in Trajectories
     int AtomCount;          //!< number of atoms, brought up-to-date by CountAtoms()
+    //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
 …
   private:
     Cacheable<string> formula;
+    Cacheable<int>    AtomCount;
     moleculeId_t id;
+    atomSet atoms; //<!list of atoms
+    atomIdSet atomIds; //<!set of atomic ids to check uniqueness of atoms
   protected:
+    //void CountAtoms();
+    /**
+     * this iterator type should be used for internal variables, \
+     * since it will not lock
+     */
+    typedef atomSet::iterator internal_iterator;
     molecule(const periodentafel * const teil);
     virtual ~molecule();
 …
   //getter and setter
   const std::string getName();
+  int getAtomCount() const;
+  int doCountAtoms();
   moleculeId_t getId();
   void setId(moleculeId_t);
 …
   std::string calcFormula();
+  iterator begin();
+  const_iterator begin() const;
+  iterator end();
+  const_iterator end() const;
+  bool empty() const;
+  size_t size() const;
+  const_iterator erase( const_iterator loc );
+  const_iterator erase( atom * key );
+  const_iterator find (  atom * key ) const;
+  pair<iterator,bool> insert ( atom * const key );
+  bool containsAtom(atom* key);
   // re-definition of virtual functions from PointCloud
 …
   Vector *GetCenter() const ;
   TesselPoint *GetPoint() const ;
-  TesselPoint *GetTerminalPoint() const ;
   int GetMaxId() const;
   void GoToNext() const ;
-  void GoToPrevious() const ;
   void GoToFirst() const ;
-  void GoToLast() const ;
   bool IsEmpty() const ;
   bool IsEnd() const ;
 …
   bool RemoveBond(bond *pointer);
   bool RemoveBonds(atom *BondPartner);
+  bool hasBondStructure();
+  unsigned int CountBonds() const;
   /// Find atoms.
 …
   /// Count and change present atoms' coordination.
-  void CountAtoms();
   void CountElements();
-  void CalculateOrbitals(class config &configuration);
   bool CenterInBox();
   bool BoundInBox();
 …
   Vector * DetermineCenterOfGravity();
   Vector * DetermineCenterOfAll() const;
+  Vector * DetermineCenterOfBox() const;
   void SetNameFromFilename(const char *filename);
   void SetBoxDimension(Vector *dim);
 …
   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;
 …
   /// 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);
   void BreadthFirstSearchAdd(molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem);
   /// -# BOSSANOVA
 …
   private:
   int last_atom;      //!< number given to last atom
   mutable atom *InternalPointer;  //!< internal pointer for PointCloud
+  mutable internal_iterator InternalPointer;  //!< internal pointer for PointCloud
 };
 …
   ~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);

src/molecule_dynamics.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include "World.hpp"
 #include "atom.hpp"
 #include "config.hpp"
 #include "element.hpp"
+#include "info.hpp"
 #include "log.hpp"
 #include "memoryallocator.hpp"
 …
 #include "parser.hpp"
 #include "Plane.hpp"
+#include "ThermoStatContainer.hpp"
 /************************************* Functions for class molecule *********************************/
 …
   gsl_matrix *A = gsl_matrix_alloc(NDIM,NDIM);
   gsl_vector *x = gsl_vector_alloc(NDIM);
-  atom * Runner = mol->start;
   atom *Sprinter = NULL;
   Vector trajectory1, trajectory2, normal, TestVector;
   double Norm1, Norm2, tmp, result = 0.;
+  while (Runner->next != mol->end) {
+    Runner = Runner->next;
+    if (Runner == Walker) // hence, we only go up to the Walker, not beyond (similar to i=0; i<j; i++)
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((*iter) == Walker) // hence, we only go up to the Walker, not beyond (similar to i=0; i<j; i++)
       break;
     // determine normalized trajectories direction vector (n1, n2)
 …
     trajectory1.Normalize();
     Norm1 = trajectory1.Norm();
     Sprinter = Params.PermutationMap[Runner->nr];   // find second target point
     trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - Runner->Trajectory.R.at(Params.startstep);
+    Sprinter = Params.PermutationMap[(*iter)->nr];   // find second target point
+    trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - (*iter)->Trajectory.R.at(Params.startstep);
     trajectory2.Normalize();
     Norm2 = trajectory1.Norm();
     // check whether either is zero()
     if ((Norm1 < MYEPSILON) && (Norm2 < MYEPSILON)) {
       tmp = Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.startstep));
+      tmp = Walker->Trajectory.R.at(Params.startstep).distance((*iter)->Trajectory.R.at(Params.startstep));
     } else if (Norm1 < MYEPSILON) {
       Sprinter = Params.PermutationMap[Walker->nr];   // find first target point
       trajectory1 = Sprinter->Trajectory.R.at(Params.endstep) - Runner->Trajectory.R.at(Params.startstep);
+      trajectory1 = Sprinter->Trajectory.R.at(Params.endstep) - (*iter)->Trajectory.R.at(Params.startstep);
       trajectory2 *= trajectory1.ScalarProduct(trajectory2); // trajectory2 is scaled to unity, hence we don't need to divide by anything
       trajectory1 -= trajectory2;   // project the part in norm direction away
       tmp = trajectory1.Norm();  // remaining norm is distance
     } else if (Norm2 < MYEPSILON) {
       Sprinter = Params.PermutationMap[Runner->nr];   // find second target point
+      Sprinter = Params.PermutationMap[(*iter)->nr];   // find second target point
       trajectory2 = Sprinter->Trajectory.R.at(Params.endstep) - Walker->Trajectory.R.at(Params.startstep);  // copy second offset
       trajectory1 *= trajectory2.ScalarProduct(trajectory1); // trajectory1 is scaled to unity, hence we don't need to divide by anything
 …
   //        Log() << Verbose(0) << " and ";
   //        Log() << Verbose(0) << trajectory2;
       tmp = Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.startstep));
+      tmp = Walker->Trajectory.R.at(Params.startstep).distance((*iter)->Trajectory.R.at(Params.startstep));
   //        Log() << Verbose(0) << " with distance " << tmp << "." << endl;
     } else { // determine distance by finding minimum distance
   //        Log() << Verbose(3) << "Both trajectories of " << *Walker << " and " << *Runner << " are linear independent ";
+  //        Log() << Verbose(3) << "Both trajectories of " << *Walker << " and " << *(*iter) << " are linear independent ";
   //        Log() << Verbose(0) << endl;
   //        Log() << Verbose(0) << "First Trajectory: ";
 …
         gsl_matrix_set(A, 1, i, trajectory2[i]);
         gsl_matrix_set(A, 2, i, normal[i]);
         gsl_vector_set(x,i, (Walker->Trajectory.R.at(Params.startstep)[i] - Runner->Trajectory.R.at(Params.startstep)[i]));
+        gsl_vector_set(x,i, (Walker->Trajectory.R.at(Params.startstep)[i] - (*iter)->Trajectory.R.at(Params.startstep)[i]));
+      }
       // solve the linear system by Householder transformations
 …
       trajectory2.Scale(gsl_vector_get(x,1));
       normal.Scale(gsl_vector_get(x,2));
       TestVector = Runner->Trajectory.R.at(Params.startstep) + trajectory2 + normal
+      TestVector = (*iter)->Trajectory.R.at(Params.startstep) + trajectory2 + normal
                    - (Walker->Trajectory.R.at(Params.startstep) + trajectory1);
       if (TestVector.Norm() < MYEPSILON) {
 …
+{
   double result = 0.;
+  atom * Runner = mol->start;
+  while (Runner->next != mol->end) {
+    Runner = Runner->next;
+    if ((Params.PermutationMap[Walker->nr] == Params.PermutationMap[Runner->nr]) && (Walker->nr < Runner->nr)) {
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    if ((Params.PermutationMap[Walker->nr] == Params.PermutationMap[(*iter)->nr]) && (Walker->nr < (*iter)->nr)) {
   //    atom *Sprinter = PermutationMap[Walker->nr];
   //        Log() << Verbose(0) << *Walker << " and " << *Runner << " are heading to the same target at ";
+  //        Log() << Verbose(0) << *Walker << " and " << *(*iter) << " are heading to the same target at ";
   //        Log() << Verbose(0) << Sprinter->Trajectory.R.at(endstep);
   //        Log() << Verbose(0) << ", penalting." << endl;
 …
   // go through every atom
   atom *Runner = NULL;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     // first term: distance to target
     Runner = Params.PermutationMap[Walker->nr];   // find target point
     tmp = (Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)));
+    Runner = Params.PermutationMap[(*iter)->nr];   // find target point
+    tmp = ((*iter)->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)));
     tmp *= Params.IsAngstroem ? 1. : 1./AtomicLengthToAngstroem;
     result += Params.PenaltyConstants[0] * tmp;
 …
     // second term: sum of distances to other trajectories
     result += SumDistanceOfTrajectories(Walker, this, Params);
+    result += SumDistanceOfTrajectories((*iter), this, Params);
     // third term: penalty for equal targets
     result += PenalizeEqualTargets(Walker, this, Params);
+    result += PenalizeEqualTargets((*iter), this, Params);
+  }
 …
+{
   stringstream zeile1, zeile2;
+  int *DoubleList = Calloc<int>(AtomCount, "PrintPermutationMap: *DoubleList");
+  int *DoubleList = new int[AtomCount];
+  for(int i=0;i<AtomCount;i++)
+    DoubleList[i] = 0;
   int doubles = 0;
   zeile1 << "PermutationMap: ";
 …
   if (doubles >0)
     DoLog(2) && (Log() << Verbose(2) << "Found " << doubles << " Doubles." << endl);
   Free(&DoubleList);
+  delete[](DoubleList);
 //  Log() << Verbose(2) << zeile1.str() << endl << zeile2.str() << endl;
 };
 …
 void FillDistanceList(molecule *mol, struct EvaluatePotential &Params)
+{
   for (int i=mol->AtomCount; i--;) {
+  for (int i=mol->getAtomCount(); i--;) {
     Params.DistanceList[i] = new DistanceMap;    // is the distance sorted target list per atom
     Params.DistanceList[i]->clear();
+  }
+  atom *Runner = NULL;
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    Runner = mol->start;
+    while(Runner->next != mol->end) {
+      Runner = Runner->next;
+      Params.DistanceList[Walker->nr]->insert( DistancePair(Walker->Trajectory.R.at(Params.startstep).distance(Runner->Trajectory.R.at(Params.endstep)), Runner) );
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    for (molecule::const_iterator runner = mol->begin(); runner != mol->end(); ++runner) {
+      Params.DistanceList[(*iter)->nr]->insert( DistancePair((*iter)->Trajectory.R.at(Params.startstep).distance((*runner)->Trajectory.R.at(Params.endstep)), (*runner)) );
+    }
+  }
 …
 void CreateInitialLists(molecule *mol, struct EvaluatePotential &Params)
+{
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    Params.StepList[Walker->nr] = Params.DistanceList[Walker->nr]->begin();    // stores the step to the next iterator that could be a possible next target
+    Params.PermutationMap[Walker->nr] = Params.DistanceList[Walker->nr]->begin()->second;   // always pick target with the smallest distance
+    Params.DoubleList[Params.DistanceList[Walker->nr]->begin()->second->nr]++;            // increase this target's source count (>1? not injective)
+    Params.DistanceIterators[Walker->nr] = Params.DistanceList[Walker->nr]->begin();    // and remember which one we picked
+    DoLog(2) && (Log() << Verbose(2) << *Walker << " starts with distance " << Params.DistanceList[Walker->nr]->begin()->first << "." << endl);
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    Params.StepList[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin();    // stores the step to the next iterator that could be a possible next target
+    Params.PermutationMap[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin()->second;   // always pick target with the smallest distance
+    Params.DoubleList[Params.DistanceList[(*iter)->nr]->begin()->second->nr]++;            // increase this target's source count (>1? not injective)
+    Params.DistanceIterators[(*iter)->nr] = Params.DistanceList[(*iter)->nr]->begin();    // and remember which one we picked
+    DoLog(2) && (Log() << Verbose(2) << **iter << " starts with distance " << Params.DistanceList[(*iter)->nr]->begin()->first << "." << endl);
+  }
 };
 …
 void MakeInjectivePermutation(molecule *mol, struct EvaluatePotential &Params)
+{
   atom *Walker = mol->start;
+  molecule::const_iterator iter = mol->begin();
   DistanceMap::iterator NewBase;
   double Potential = fabs(mol->ConstrainedPotential(Params));
+  if (mol->empty()) {
+    eLog() << Verbose(1) << "Molecule is empty." << endl;
+    return;
+  }
   while ((Potential) > Params.PenaltyConstants[2]) {
     PrintPermutationMap(mol->AtomCount, Params);
     Walker = Walker->next;
     if (Walker == mol->end) // round-robin at the end
       Walker = mol->start->next;
     if (Params.DoubleList[Params.DistanceIterators[Walker->nr]->second->nr] <= 1)  // no need to make those injective that aren't
+    PrintPermutationMap(mol->getAtomCount(), Params);
+    iter++;
+    if (iter == mol->end()) // round-robin at the end
+      iter = mol->begin();
+    if (Params.DoubleList[Params.DistanceIterators[(*iter)->nr]->second->nr] <= 1)  // no need to make those injective that aren't
       continue;
     // now, try finding a new one
     Potential = TryNextNearestNeighbourForInjectivePermutation(mol, Walker, Potential, Params);
+  }
   for (int i=mol->AtomCount; i--;) // now each single entry in the DoubleList should be <=1
+    Potential = TryNextNearestNeighbourForInjectivePermutation(mol, (*iter), Potential, Params);
+  }
+  for (int i=mol->getAtomCount(); i--;) // now each single entry in the DoubleList should be <=1
     if (Params.DoubleList[i] > 1) {
       DoeLog(0) && (eLog()<< Verbose(0) << "Failed to create an injective PermutationMap!" << endl);
 …
   double Potential, OldPotential, OlderPotential;
   struct EvaluatePotential Params;
   Params.PermutationMap = Calloc<atom*>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.**PermutationMap");
   Params.DistanceList = Malloc<DistanceMap*>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.**DistanceList");
   Params.DistanceIterators = Malloc<DistanceMap::iterator>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*DistanceIterators");
   Params.DoubleList = Calloc<int>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*DoubleList");
   Params.StepList = Malloc<DistanceMap::iterator>(AtomCount, "molecule::MinimiseConstrainedPotential: Params.*StepList");
+  Params.PermutationMap = new atom *[getAtomCount()];
+  Params.DistanceList = new DistanceMap *[getAtomCount()];
+  Params.DistanceIterators = new DistanceMap::iterator[getAtomCount()];
+  Params.DoubleList = new int[getAtomCount()];
+  Params.StepList = new DistanceMap::iterator[getAtomCount()];
   int round;
   atom *Walker = NULL, *Runner = NULL, *Sprinter = NULL;
+  atom *Sprinter = NULL;
   DistanceMap::iterator Rider, Strider;
+  // set to zero
+  for (int i=0;i<getAtomCount();i++) {
+    Params.PermutationMap[i] = NULL;
+    Params.DoubleList[i] = 0;
+  }
   /// Minimise the potential
 …
   DoLog(1) && (Log() << Verbose(1) << "Making the PermutationMap injective ... " << endl);
   MakeInjectivePermutation(this, Params);
   Free(&Params.DoubleList);
+  delete[](Params.DoubleList);
   // argument minimise the constrained potential in this injective PermutationMap
 …
     DoLog(2) && (Log() << Verbose(2) << "Starting round " << ++round << ", at current potential " << OldPotential << " ... " << endl);
     OlderPotential = OldPotential;
+    molecule::const_iterator iter;
     do {
+      Walker = start;
+      while (Walker->next != end) { // pick one
+        Walker = Walker->next;
+        PrintPermutationMap(AtomCount, Params);
+        Sprinter = Params.DistanceIterators[Walker->nr]->second;   // store initial partner
+        Strider = Params.DistanceIterators[Walker->nr];  //remember old iterator
+        Params.DistanceIterators[Walker->nr] = Params.StepList[Walker->nr];
+        if (Params.DistanceIterators[Walker->nr] == Params.DistanceList[Walker->nr]->end()) {// stop, before we run through the list and still on
+          Params.DistanceIterators[Walker->nr] == Params.DistanceList[Walker->nr]->begin();
+      iter = begin();
+      for (; iter != end(); ++iter) {
+        PrintPermutationMap(getAtomCount(), Params);
+        Sprinter = Params.DistanceIterators[(*iter)->nr]->second;   // store initial partner
+        Strider = Params.DistanceIterators[(*iter)->nr];  //remember old iterator
+        Params.DistanceIterators[(*iter)->nr] = Params.StepList[(*iter)->nr];
+        if (Params.DistanceIterators[(*iter)->nr] == Params.DistanceList[(*iter)->nr]->end()) {// stop, before we run through the list and still on
+          Params.DistanceIterators[(*iter)->nr] == Params.DistanceList[(*iter)->nr]->begin();
           break;
+        }
         //Log() << Verbose(2) << "Current Walker: " << *Walker << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[Walker->nr]->second << "." << endl;
+        //Log() << Verbose(2) << "Current Walker: " << *(*iter) << " with old/next candidate " << *Sprinter << "/" << *DistanceIterators[(*iter)->nr]->second << "." << endl;
         // find source of the new target
         Runner = start->next;
         while(Runner != end) { // find the source whose toes we might be stepping on (Walker's new target should be in use by another already)
           if (Params.PermutationMap[Runner->nr] == Params.DistanceIterators[Walker->nr]->second) {
             //Log() << Verbose(2) << "Found the corresponding owner " << *Runner << " to " << *PermutationMap[Runner->nr] << "." << endl;
+        molecule::const_iterator runner = begin();
+        for (; runner != end(); ++runner) { // find the source whose toes we might be stepping on (Walker's new target should be in use by another already)
+          if (Params.PermutationMap[(*runner)->nr] == Params.DistanceIterators[(*iter)->nr]->second) {
+            //Log() << Verbose(2) << "Found the corresponding owner " << *(*runner) << " to " << *PermutationMap[(*runner)->nr] << "." << endl;
             break;
+          }
-          Runner = Runner->next;
+        }
         if (Runner != end) { // we found the other source
+        if (runner != end()) { // we found the other source
           // then look in its distance list for Sprinter
           Rider = Params.DistanceList[Runner->nr]->begin();
           for (; Rider != Params.DistanceList[Runner->nr]->end(); Rider++)
+          Rider = Params.DistanceList[(*runner)->nr]->begin();
+          for (; Rider != Params.DistanceList[(*runner)->nr]->end(); Rider++)
             if (Rider->second == Sprinter)
               break;
           if (Rider != Params.DistanceList[Runner->nr]->end()) { // if we have found one
             //Log() << Verbose(2) << "Current Other: " << *Runner << " with old/next candidate " << *PermutationMap[Runner->nr] << "/" << *Rider->second << "." << endl;
+          if (Rider != Params.DistanceList[(*runner)->nr]->end()) { // if we have found one
+            //Log() << Verbose(2) << "Current Other: " << *(*runner) << " with old/next candidate " << *PermutationMap[(*runner)->nr] << "/" << *Rider->second << "." << endl;
             // exchange both
             Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second; // put next farther distance into PermutationMap
             Params.PermutationMap[Runner->nr] = Sprinter;  // and hand the old target to its respective owner
             PrintPermutationMap(AtomCount, Params);
+            Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second; // put next farther distance into PermutationMap
+            Params.PermutationMap[(*runner)->nr] = Sprinter;  // and hand the old target to its respective owner
+            PrintPermutationMap(getAtomCount(), Params);
             // calculate the new potential
             //Log() << Verbose(2) << "Checking new potential ..." << endl;
 …
             if (Potential > OldPotential) { // we made everything worse! Undo ...
               //Log() << Verbose(3) << "Nay, made the potential worse: " << Potential << " vs. " << OldPotential << "!" << endl;
               //Log() << Verbose(3) << "Setting " << *Runner << "'s source to " << *Params.DistanceIterators[Runner->nr]->second << "." << endl;
+              //Log() << Verbose(3) << "Setting " << *(*runner) << "'s source to " << *Params.DistanceIterators[(*runner)->nr]->second << "." << endl;
               // Undo for Runner (note, we haven't moved the iteration yet, we may use this)
               Params.PermutationMap[Runner->nr] = Params.DistanceIterators[Runner->nr]->second;
+              Params.PermutationMap[(*runner)->nr] = Params.DistanceIterators[(*runner)->nr]->second;
               // Undo for Walker
               Params.DistanceIterators[Walker->nr] = Strider;  // take next farther distance target
               //Log() << Verbose(3) << "Setting " << *Walker << "'s source to " << *Params.DistanceIterators[Walker->nr]->second << "." << endl;
               Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second;
+              Params.DistanceIterators[(*iter)->nr] = Strider;  // take next farther distance target
+              //Log() << Verbose(3) << "Setting " << *(*iter) << "'s source to " << *Params.DistanceIterators[(*iter)->nr]->second << "." << endl;
+              Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second;
             } else {
               Params.DistanceIterators[Runner->nr] = Rider;  // if successful also move the pointer in the iterator list
+              Params.DistanceIterators[(*runner)->nr] = Rider;  // if successful also move the pointer in the iterator list
               DoLog(3) && (Log() << Verbose(3) << "Found a better permutation, new potential is " << Potential << " vs." << OldPotential << "." << endl);
               OldPotential = Potential;
 …
             //Log() << Verbose(0) << endl;
           } else {
             DoeLog(1) && (eLog()<< Verbose(1) << *Runner << " was not the owner of " << *Sprinter << "!" << endl);
+            DoeLog(1) && (eLog()<< Verbose(1) << **runner << " was not the owner of " << *Sprinter << "!" << endl);
             exit(255);
+          }
         } else {
           Params.PermutationMap[Walker->nr] = Params.DistanceIterators[Walker->nr]->second; // new target has no source!
+          Params.PermutationMap[(*iter)->nr] = Params.DistanceIterators[(*iter)->nr]->second; // new target has no source!
+        }
         Params.StepList[Walker->nr]++; // take next farther distance target
+        Params.StepList[(*iter)->nr]++; // take next farther distance target
+      }
     } while (Walker->next != end);
+    } while (++iter != end());
   } while ((OlderPotential - OldPotential) > 1e-3);
   DoLog(1) && (Log() << Verbose(1) << "done." << endl);
 …
   /// free memory and return with evaluated potential
   for (int i=AtomCount; i--;)
+  for (int i=getAtomCount(); i--;)
     Params.DistanceList[i]->clear();
   Free(&Params.DistanceList);
   Free(&Params.DistanceIterators);
+  delete[](Params.DistanceList);
+  delete[](Params.DistanceIterators);
   return ConstrainedPotential(Params);
 };
 …
  * \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;
 …
   // Get the Permutation Map by MinimiseConstrainedPotential
   atom **PermutationMap = NULL;
   atom *Walker = NULL, *Sprinter = NULL;
+  atom *Sprinter = NULL;
   if (!MapByIdentity)
     MinimiseConstrainedPotential(PermutationMap, startstep, endstep, configuration.GetIsAngstroem());
   else {
     PermutationMap = Malloc<atom *>(AtomCount, "molecule::LinearInterpolationBetweenConfiguration: **PermutationMap");
+    PermutationMap = new atom *[getAtomCount()];
     SetIndexedArrayForEachAtomTo( PermutationMap, &atom::nr );
+  }
 …
     mol = World::getInstance().createMolecule();
     MoleculePerStep->insert(mol);
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
       // add to molecule list
       Sprinter = mol->AddCopyAtom(Walker);
+      Sprinter = mol->AddCopyAtom((*iter));
       for (int n=NDIM;n--;) {
         Sprinter->x[n] = Walker->Trajectory.R.at(startstep)[n] + (PermutationMap[Walker->nr]->Trajectory.R.at(endstep)[n] - Walker->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
+        Sprinter->x[n] = (*iter)->Trajectory.R.at(startstep)[n] + (PermutationMap[(*iter)->nr]->Trajectory.R.at(endstep)[n] - (*iter)->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
         // add to Trajectories
         //Log() << Verbose(3) << step << ">=" << MDSteps-1 << endl;
         if (step < MaxSteps) {
           Walker->Trajectory.R.at(step)[n] = Walker->Trajectory.R.at(startstep)[n] + (PermutationMap[Walker->nr]->Trajectory.R.at(endstep)[n] - Walker->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
           Walker->Trajectory.U.at(step)[n] = 0.;
           Walker->Trajectory.F.at(step)[n] = 0.;
+          (*iter)->Trajectory.R.at(step)[n] = (*iter)->Trajectory.R.at(startstep)[n] + (PermutationMap[(*iter)->nr]->Trajectory.R.at(endstep)[n] - (*iter)->Trajectory.R.at(startstep)[n])*((double)step/(double)MaxSteps);
+          (*iter)->Trajectory.U.at(step)[n] = 0.;
+          (*iter)->Trajectory.F.at(step)[n] = 0.;
+        }
+      }
 …
   // store the list to single step files
   int *SortIndex = Malloc<int>(AtomCount, "molecule::LinearInterpolationBetweenConfiguration: *SortIndex");
   for (int i=AtomCount; i--; )
+  int *SortIndex = new int[getAtomCount()];
+  for (int i=getAtomCount(); i--; )
     SortIndex[i] = i;
+  status = MoleculePerStep->OutputConfigForListOfFragments(&configuration, SortIndex);
+  status = MoleculePerStep->OutputConfigForListOfFragments(prefix, SortIndex);
+  delete[](SortIndex);
   // free and return
   Free(&PermutationMap);
+  delete[](PermutationMap);
   delete(MoleculePerStep);
   return status;
 …
 bool molecule::VerletForceIntegration(char *file, config &configuration)
+{
+  Info FunctionInfo(__func__);
   ifstream input(file);
   string token;
 …
       return false;
+    }
     if (Force.RowCounter[0] != AtomCount) {
       DoeLog(0) && (eLog()<< Verbose(0) << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << AtomCount << "." << endl);
+    if (Force.RowCounter[0] != getAtomCount()) {
+      DoeLog(0) && (eLog()<< Verbose(0) << "Mismatch between number of atoms in file " << Force.RowCounter[0] << " and in molecule " << getAtomCount() << "." << endl);
       performCriticalExit();
       return false;
 …
     // correct Forces
     Velocity.Zero();
     for(int i=0;i<AtomCount;i++)
+    for(int i=0;i<getAtomCount();i++)
       for(int d=0;d<NDIM;d++) {
         Velocity[d] += Force.Matrix[0][i][d+5];
+      }
     for(int i=0;i<AtomCount;i++)
+    for(int i=0;i<getAtomCount();i++)
       for(int d=0;d<NDIM;d++) {
         Force.Matrix[0][i][d+5] -= Velocity[d]/(double)AtomCount;
+        Force.Matrix[0][i][d+5] -= Velocity[d]/static_cast<double>(getAtomCount());
+      }
     // solve a constrained potential if we are meant to
 …
       ConstrainedPotentialEnergy = MinimiseConstrainedPotential(PermutationMap,configuration.DoConstrainedMD, 0, configuration.GetIsAngstroem());
       EvaluateConstrainedForces(configuration.DoConstrainedMD, 0, PermutationMap, &Force);
       Free(&PermutationMap);
+      delete[](PermutationMap);
+    }
     // and perform Verlet integration for each atom with position, velocity and force vector
     // check size of vectors
     ActOnAllAtoms( &atom::ResizeTrajectory, MDSteps+10 );
     ActOnAllAtoms( &atom::VelocityVerletUpdate, MDSteps, &configuration, &Force);
+    //ActOnAllAtoms( &atom::ResizeTrajectory, MDSteps+10 );
+    ActOnAllAtoms( &atom::VelocityVerletUpdate, MDSteps+1, &configuration, &Force);
+  }
   // correct velocities (rather momenta) so that center of mass remains motionless
   Velocity.Zero();
   IonMass = 0.;
   ActOnAllAtoms ( &atom::SumUpKineticEnergy, MDSteps, &IonMass, &Velocity );
+  ActOnAllAtoms ( &atom::SumUpKineticEnergy, MDSteps+1, &IonMass, &Velocity );
   // correct velocities (rather momenta) so that center of mass remains motionless
   Velocity.Scale(1./IonMass);
   ActualTemp = 0.;
   ActOnAllAtoms ( &atom::CorrectVelocity, &ActualTemp, MDSteps, &Velocity );
+  ActOnAllAtoms ( &atom::CorrectVelocity, &ActualTemp, MDSteps+1, &Velocity );
   Thermostats(configuration, ActualTemp, Berendsen);
   MDSteps++;
 …
   // 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.*AtomCount+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

-              rc39cc4
+              rbdb143
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
   int FragmentCount;
   // get maximum bond degree
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    c = (Walker->ListOfBonds.size() > c) ? Walker->ListOfBonds.size() : c;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    c = ((*iter)->ListOfBonds.size() > c) ? (*iter)->ListOfBonds.size() : c;
+  }
   FragmentCount = NoNonHydrogen*(1 << (c*order));
 …
  * -# 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 = Malloc<char>(MAXSTRINGSIZE, "molecule::ParseKeySetFile - filename");
+  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 = Malloc<char>(MAXSTRINGSIZE, "molecule::ParseKeySetFile - *buffer");
+    char buffer[MAXSTRINGSIZE];
     // 1. parse keysets and insert into temp. graph
     while (!InputFile.eof()) {
 …
     InputFile.close();
     InputFile.clear();
+    Free(&buffer);
+    DoLog(1) && (Log() << Verbose(1) << "done." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t ... done." << endl);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "File " << filename << " not found." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t ... File " << filename << " not found." << endl);
     status = false;
+  }
-  Free(&filename);
   return status;
 };
 …
   int NumberOfFragments = 0;
   double TEFactor;
   char *filename = Malloc<char>(MAXSTRINGSIZE, "molecule::ParseTEFactorsFile - filename");
+  char filename[MAXSTRINGSIZE];
   if (FragmentList == NULL) { // check list pointer
 …
+  }
-  // free memory
-  Free(&filename);
   return status;
 };
 /** 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> >;
   int No = 0, FragOrder = 0;
   double Value = 0.;
+  char *buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::CheckOrderAtSite: *buffer");
+  sprintf(buffer, "%s/%s%s.dat", path, FRAGMENTPREFIX, ENERGYPERFRAGMENT);
+  ifstream InputFile(buffer, ios::in);
+  char buffer[MAXSTRINGSIZE];
+  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) {
 …
     InputFile.clear();
+  }
-  Free(&buffer);
   return AdaptiveCriteriaList;
 …
 map<double, pair<int,int> >  * ReMapAdaptiveCriteriaListToValue(map<int, pair<double,int> > *AdaptiveCriteriaList, molecule *mol)
+{
   atom *Walker = mol->start;
+  atom *Walker = NULL;
   map<double, pair<int,int> > *FinalRootCandidates = new map<double, pair<int,int> > ;
   DoLog(1) && (Log() << Verbose(1) << "Root candidate list is: " << endl);
 …
 bool MarkUpdateCandidates(bool *AtomMask, map<double, pair<int,int> > &FinalRootCandidates, int Order, molecule *mol)
+{
   atom *Walker = mol->start;
+  atom *Walker = NULL;
   int No = -1;
   bool status = false;
 …
 /** 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)
+{
+  atom *Walker = start;
+bool molecule::CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, std::string path)
+{
   bool status = false;
   // initialize mask list
   for(int i=AtomCount;i--;)
+  for(int i=getAtomCount();i--;)
     AtomMask[i] = false;
   if (Order < 0) { // adaptive increase of BondOrder per site
     if (AtomMask[AtomCount] == true)  // break after one step
+    if (AtomMask[getAtomCount()] == true)  // break after one step
       return false;
 …
     if (AdaptiveCriteriaList->empty()) {
       DoeLog(2) && (eLog()<< Verbose(2) << "Unable to parse file, incrementing all." << endl);
+      while (Walker->next != end) {
+        Walker = Walker->next;
+      for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     #ifdef ADDHYDROGEN
         if (Walker->type->Z != 1) // skip hydrogen
+        if ((*iter)->type->Z != 1) // skip hydrogen
     #endif
+        {
           AtomMask[Walker->nr] = true;  // include all (non-hydrogen) atoms
+          AtomMask[(*iter)->nr] = true;  // include all (non-hydrogen) atoms
           status = true;
+        }
 …
     MarkUpdateCandidates(AtomMask, *FinalRootCandidates, Order, this);
     Free(&IndexKeySetList);
     Free(&AdaptiveCriteriaList);
     Free(&FinalRootCandidates);
+    delete[](IndexKeySetList);
+    delete[](AdaptiveCriteriaList);
+    delete[](FinalRootCandidates);
   } else { // global increase of Bond Order
+    while (Walker->next != end) {
+      Walker = Walker->next;
+    for(molecule::const_iterator iter = begin(); iter != end(); ++iter) {
   #ifdef ADDHYDROGEN
       if (Walker->type->Z != 1) // skip hydrogen
+      if ((*iter)->type->Z != 1) // skip hydrogen
   #endif
+      {
         AtomMask[Walker->nr] = true;  // include all (non-hydrogen) atoms
         if ((Order != 0) && (Walker->AdaptiveOrder < Order)) // && (Walker->AdaptiveOrder < MinimumRingSize[Walker->nr]))
+        AtomMask[(*iter)->nr] = true;  // include all (non-hydrogen) atoms
+        if ((Order != 0) && ((*iter)->AdaptiveOrder < Order)) // && ((*iter)->AdaptiveOrder < MinimumRingSize[(*iter)->nr]))
           status = true;
+      }
+    }
     if ((Order == 0) && (AtomMask[AtomCount] == false))  // single stepping, just check
+    if ((!Order) && (!AtomMask[getAtomCount()]))  // single stepping, just check
       status = true;
 …
+  }
   PrintAtomMask(AtomMask, AtomCount); // for debugging
+  PrintAtomMask(AtomMask, getAtomCount()); // for debugging
   return status;
 …
     return false;
+  }
   SortIndex = Malloc<int>(AtomCount, "molecule::CreateMappingLabelsToConfigSequence: *SortIndex");
   for(int i=AtomCount;i--;)
+  SortIndex = new int[getAtomCount()];
+  for(int i=getAtomCount();i--;)
     SortIndex[i] = -1;
 …
   return true;
+};
+/** Creates a lookup table for true father's Atom::Nr -> atom ptr.
+ * \param *start begin of list (STL iterator, i.e. first item)
+ * \paran *end end of list (STL iterator, i.e. one past last item)
+ * \param **Lookuptable pointer to return allocated lookup table (should be NULL on start)
+ * \param count optional predetermined size for table (otherwise we set the count to highest true father id)
+ * \return true - success, false - failure
+ */
+bool molecule::CreateFatherLookupTable(atom **&LookupTable, int count)
+{
+  bool status = true;
+  int AtomNo;
+  if (LookupTable != NULL) {
+    Log() << Verbose(0) << "Pointer for Lookup table is not NULL! Aborting ..." <<endl;
+    return false;
+  }
+  // count them
+  if (count == 0) {
+    for (molecule::iterator iter = begin(); iter != end(); ++iter) { // create a lookup table (Atom::nr -> atom) used as a marker table lateron
+      count = (count < (*iter)->GetTrueFather()->nr) ? (*iter)->GetTrueFather()->nr : count;
+    }
+  }
+  if (count <= 0) {
+    Log() << Verbose(0) << "Count of lookup list is 0 or less." << endl;
+    return false;
+  }
+  // allocate and fill
+  LookupTable = new atom *[count];
+  if (LookupTable == NULL) {
+    eLog() << Verbose(0) << "LookupTable memory allocation failed!" << endl;
+    performCriticalExit();
+    status = false;
+  } else {
+    for (int i=0;i<count;i++)
+      LookupTable[i] = NULL;
+    for (molecule::iterator iter = begin(); iter != end(); ++iter) {
+      AtomNo = (*iter)->GetTrueFather()->nr;
+      if ((AtomNo >= 0) && (AtomNo < count)) {
+        //*out << "Setting LookupTable[" << AtomNo << "] to " << *(*iter) << endl;
+        LookupTable[AtomNo] = (*iter);
+      } else {
+        Log() << Verbose(0) << "Walker " << *(*iter) << " exceeded range of nuclear ids [0, " << count << ")." << endl;
+        status = false;
+        break;
+      }
+    }
+  }
+  return status;
 };
 …
  * 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;
+  int *SortIndex = NULL;
+  int *MinimumRingSize = new int[AtomCount];
+  int *MinimumRingSize = new int[getAtomCount()];
   int FragmentCounter;
   MoleculeLeafClass *MolecularWalker = NULL;
 …
   // create lookup table for Atom::nr
   FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(start, end, ListOfAtoms, AtomCount);
+  FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(ListOfAtoms, getAtomCount());
   // === compare it with adjacency file ===
   FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(configuration->configpath, ListOfAtoms);
   Free(&ListOfAtoms);
+  FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(prefix, ListOfAtoms);
+  delete[](ListOfAtoms);
   // ===== 2. perform a DFS analysis to gather info on cyclic structure and a list of disconnected subgraphs =====
 …
   // analysis of the cycles (print rings, get minimum cycle length) for each subgraph
   for(int i=AtomCount;i--;)
     MinimumRingSize[i] = AtomCount;
+  for(int i=getAtomCount();i--;)
+    MinimumRingSize[i] = getAtomCount();
   MolecularWalker = Subgraphs;
   FragmentCounter = 0;
 …
 //    // check the list of local atoms for debugging
 //    Log() << Verbose(0) << "ListOfLocalAtoms for this subgraph is:" << endl;
 //    for (int i=0;i<AtomCount;i++)
+//    for (int i=0;i<getAtomCount();i++)
 //      if (ListOfLocalAtoms[FragmentCounter][i] == NULL)
 //        Log() << Verbose(0) << "\tNULL";
 …
   // ===== 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 ===============================
 …
   // ===== 6b. prepare and go into the adaptive (Order<0), single-step (Order==0) or incremental (Order>0) cycle
   KeyStack *RootStack = new KeyStack[Subgraphs->next->Count()];
   AtomMask = new bool[AtomCount+1];
   AtomMask[AtomCount] = false;
+  AtomMask = new bool[getAtomCount()+1];
+  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[AtomCount] = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
+    AtomMask[getAtomCount()] = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
     // ===== 6b. fill RootStack for each subgraph (second adaptivity check) =====
     Subgraphs->next->FillRootStackForSubgraphs(RootStack, AtomMask, (FragmentCounter = 0));
 …
       DoLog(1) && (Log() << Verbose(1) << "Fragmenting subgraph " << MolecularWalker << "." << endl);
       //MolecularWalker->Leaf->OutputListOfBonds(out);  // output atom::ListOfBonds for debugging
       if (MolecularWalker->Leaf->first->next != MolecularWalker->Leaf->last) {
+      if (MolecularWalker->Leaf->hasBondStructure()) {
         // call BOSSANOVA method
         DoLog(0) && (Log() << Verbose(0) << endl << " ========== BOND ENERGY of subgraph " << FragmentCounter << " ========================= " << endl);
 …
     delete(Subgraphs);
+  }
   Free(&FragmentList);
+  delete[](FragmentList);
   // ===== 8b. gather keyset lists (graphs) from all subgraphs and transform into MoleculeListClass =====
 …
     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++;
+  }
 …
   if (BondFragments->ListOfMolecules.size() != 0) {
     // create the SortIndex from BFS labels to order in the config file
+    int *SortIndex = NULL;
     CreateMappingLabelsToConfigSequence(SortIndex);
     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);
+    // store Adjacency file
+    char *filename = Malloc<char> (MAXSTRINGSIZE, "molecule::FragmentMolecule - *filename");
+    strcpy(filename, FRAGMENTPREFIX);
+    strcat(filename, ADJACENCYFILE);
+    StoreAdjacencyToFile(configuration->configpath, filename);
+    Free(&filename);
+    StoreKeySetFile(TotalGraph, prefix);
+    {
+      // store Adjacency file
+      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
     DoLog(1) && (Log() << Verbose(1) << "Freeing bond memory" << endl);
+    Free(&FragmentList); // remove bond molecule from memory
+    Free(&SortIndex);
+    delete[](SortIndex);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "FragmentList is zero on return, splitting failed." << endl);
 …
 /** 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)
+{
   unsigned char *OrderArray = Calloc<unsigned char>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
   bool *MaxArray = Calloc<bool>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
+bool molecule::ParseOrderAtSiteFromFile(std::string &path)
+{
+  unsigned char *OrderArray = new unsigned char[getAtomCount()];
+  bool *MaxArray = new bool[getAtomCount()];
   bool status;
   int AtomNr, value;
   stringstream line;
+  string line;
   ifstream file;
+  for(int i=0;i<getAtomCount();i++) {
+    OrderArray[i] = 0;
+    MaxArray[i] = false;
+  }
   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;
 …
     SetAtomValueToIndexedArray( MaxArray, &atom::nr, &atom::MaxOrder );
     DoLog(1) && (Log() << Verbose(1) << "done." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t ... done." << endl);
     status = true;
   } else {
     DoLog(1) && (Log() << Verbose(1) << "failed to open file " << line.str() << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t ... failed to open file " << line << "." << endl);
     status = false;
+  }
   Free(&OrderArray);
   Free(&MaxArray);
+  delete[](OrderArray);
+  delete[](MaxArray);
   DoLog(1) && (Log() << Verbose(1) << "End of ParseOrderAtSiteFromFile" << endl);
 …
   atom *OtherFather = NULL;
   atom *FatherOfRunner = NULL;
+  Leaf->CountAtoms();
+  atom *Runner = Leaf->start;
+  while (Runner->next != Leaf->end) {
+    Runner = Runner->next;
+#ifdef ADDHYDROGEN
+  molecule::const_iterator runner;
+#endif
+  // we increment the iter just before skipping the hydrogen
+  for (molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end();) {
     LonelyFlag = true;
+    FatherOfRunner = Runner->father;
+    FatherOfRunner = (*iter)->father;
+    ASSERT(FatherOfRunner,"Atom without father found");
     if (SonList[FatherOfRunner->nr] != NULL)  {  // check if this, our father, is present in list
       // create all bonds
 …
 //            Log() << Verbose(3) << "Adding Bond: ";
 //            Log() << Verbose(0) <<
             Leaf->AddBond(Runner, SonList[OtherFather->nr], (*BondRunner)->BondDegree);
+            Leaf->AddBond((*iter), SonList[OtherFather->nr], (*BondRunner)->BondDegree);
 //            Log() << Verbose(0) << "." << endl;
             //NumBonds[Runner->nr]++;
+            //NumBonds[(*iter)->nr]++;
           } else {
 //            Log() << Verbose(3) << "Not adding bond, labels in wrong order." << endl;
 …
 //          Log() << Verbose(0) << ", who has no son in this fragment molecule." << endl;
 #ifdef ADDHYDROGEN
           //Log() << Verbose(3) << "Adding Hydrogen to " << Runner->Name << " and a bond in between." << endl;
           if(!Leaf->AddHydrogenReplacementAtom((*BondRunner), Runner, FatherOfRunner, OtherFather, IsAngstroem))
+          //Log() << Verbose(3) << "Adding Hydrogen to " << (*iter)->Name << " and a bond in between." << endl;
+          if(!Leaf->AddHydrogenReplacementAtom((*BondRunner), (*iter), FatherOfRunner, OtherFather, IsAngstroem))
             exit(1);
 #endif
           //NumBonds[Runner->nr] += Binder->BondDegree;
+          //NumBonds[(*iter)->nr] += Binder->BondDegree;
+        }
+      }
     } else {
+      DoeLog(1) && (eLog()<< Verbose(1) << "Son " << Runner->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->nr] << "!" << endl);
+    }
+    if ((LonelyFlag) && (Leaf->AtomCount > 1)) {
+      DoLog(0) && (Log() << Verbose(0) << *Runner << "has got bonds only to hydrogens!" << endl);
+    }
+    DoeLog(1) && (eLog()<< Verbose(1) << "Son " << (*iter)->getName() << " has father " << FatherOfRunner->getName() << " but its entry in SonList is " << SonList[FatherOfRunner->nr] << "!" << endl);
+    }
+    if ((LonelyFlag) && (Leaf->getAtomCount() > 1)) {
+      DoLog(0) && (Log() << Verbose(0) << **iter << "has got bonds only to hydrogens!" << endl);
+    }
+    ++iter;
 #ifdef ADDHYDROGEN
+    while ((Runner->next != Leaf->end) && (Runner->next->type->Z == 1)) // skip added hydrogen
+      Runner = Runner->next;
+    while ((iter != Leaf->end()) && ((*iter)->type->Z == 1)){ // skip added hydrogen
+      iter++;
+    }
 #endif
+  }
 …
 molecule * molecule::StoreFragmentFromKeySet(KeySet &Leaflet, bool IsAngstroem)
+{
   atom **SonList = Calloc<atom*>(AtomCount, "molecule::StoreFragmentFromStack: **SonList");
+  atom **SonList = new atom*[getAtomCount()];
   molecule *Leaf = World::getInstance().createMolecule();
+  for(int i=0;i<getAtomCount();i++)
+    SonList[i] = NULL;
 //  Log() << Verbose(1) << "Begin of StoreFragmentFromKeyset." << endl;
 …
   //Leaflet->Leaf->ScanForPeriodicCorrection(out);
   Free(&SonList);
+  delete[](SonList);
 //  Log() << Verbose(1) << "End of StoreFragmentFromKeyset." << endl;
   return Leaf;
 …
   int bits, TouchedIndex, SubSetDimension, SP, Added;
   int SpaceLeft;
+  int *TouchedList = Malloc<int>(SubOrder + 1, "molecule::SPFragmentGenerator: *TouchedList");
+  bond **BondsList = NULL;
+  int *TouchedList = new int[SubOrder + 1];
   KeySetTestPair TestKeySetInsert;
 …
           // then allocate and fill the list
           BondsList = Malloc<bond*>(SubSetDimension, "molecule::SPFragmentGenerator: **BondsList");
+          bond *BondsList[SubSetDimension];
           SubSetDimension = FillBondsList(BondsList, FragmentSearch->BondsPerSPList[2*SP], FragmentSearch->BondsPerSPList[2*SP+1], TouchedList, TouchedIndex);
 …
           Log() << Verbose(2+verbosity) << "Calling subset generator " << SP << " away from root " << *FragmentSearch->Root << " with sub set dimension " << SubSetDimension << "." << endl;
           SPFragmentGenerator(FragmentSearch, SP, BondsList, SubSetDimension, SubOrder-bits);
-          Free(&BondsList);
+        }
       } else {
 …
+    }
+  }
   Free(&TouchedList);
+  delete[](TouchedList);
   Log() << Verbose(1+verbosity) << "End of SPFragmentGenerator, " << RootDistance << " away from Root " << *FragmentSearch->Root << " and SubOrder is " << SubOrder << "." << endl;
 };
 …
 void InitialiseSPList(int Order, struct UniqueFragments &FragmentSearch)
+{
   FragmentSearch.BondsPerSPList = Malloc<bond*>(Order * 2, "molecule::PowerSetGenerator: ***BondsPerSPList");
   FragmentSearch.BondsPerSPCount = Malloc<int>(Order, "molecule::PowerSetGenerator: *BondsPerSPCount");
+  FragmentSearch.BondsPerSPList = new bond* [Order * 2];
+  FragmentSearch.BondsPerSPCount = new int[Order];
   for (int i=Order;i--;) {
     FragmentSearch.BondsPerSPList[2*i] = new bond();    // start node
 …
 void FreeSPList(int Order, struct UniqueFragments &FragmentSearch)
+{
   Free(&FragmentSearch.BondsPerSPCount);
+  delete[](FragmentSearch.BondsPerSPCount);
   for (int i=Order;i--;) {
     delete(FragmentSearch.BondsPerSPList[2*i]);
     delete(FragmentSearch.BondsPerSPList[2*i+1]);
+  }
   Free(&FragmentSearch.BondsPerSPList);
+  delete[](FragmentSearch.BondsPerSPList);
 };
 …
 int molecule::PowerSetGenerator(int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet)
+{
-  bond **BondsList = NULL;
   int Counter = FragmentSearch.FragmentCounter; // mark current value of counter
 …
     // prepare the subset and call the generator
+    BondsList = Calloc<bond*>(FragmentSearch.BondsPerSPCount[0], "molecule::PowerSetGenerator: **BondsList");
+    bond* BondsList[FragmentSearch.BondsPerSPCount[0]];
+    for(int i=0;i<FragmentSearch.BondsPerSPCount[0];i++)
+      BondsList[i] = NULL;
     BondsList[0] = FragmentSearch.BondsPerSPList[0]->next;  // on SP level 0 there's only the root bond
     SPFragmentGenerator(&FragmentSearch, 0, BondsList, FragmentSearch.BondsPerSPCount[0], Order);
-    Free(&BondsList);
   } else {
     DoLog(0) && (Log() << Verbose(0) << "Not enough total number of edges to build " << Order << "-body fragments." << endl);
 …
+      }
+    }
     Free(&FragmentLowerOrdersList[RootNr]);
+    delete[](FragmentLowerOrdersList[RootNr]);
     RootNr++;
+  }
   Free(&FragmentLowerOrdersList);
+  delete[](FragmentLowerOrdersList);
 };
 …
   // FragmentLowerOrdersList is a 2D-array of pointer to MoleculeListClass objects, one dimension represents the ANOVA expansion of a single order (i.e. 5)
   // with all needed lower orders that are subtracted, the other dimension is the BondOrder (i.e. from 1 to 5)
+  NumMoleculesOfOrder = Calloc<int>(UpgradeCount, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
+  FragmentLowerOrdersList = Calloc<Graph**>(UpgradeCount, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
+  NumMoleculesOfOrder = new int[UpgradeCount];
+  FragmentLowerOrdersList = new Graph**[UpgradeCount];
+  for(int i=0;i<UpgradeCount;i++) {
+    NumMoleculesOfOrder[i] = 0;
+    FragmentLowerOrdersList[i] = NULL;
+  }
   // initialise the fragments structure
 …
   FragmentSearch.FragmentSet = new KeySet;
   FragmentSearch.Root = FindAtom(RootKeyNr);
   FragmentSearch.ShortestPathList = Malloc<int>(AtomCount, "molecule::PowerSetGenerator: *ShortestPathList");
   for (int i=AtomCount;i--;) {
+  FragmentSearch.ShortestPathList = new int[getAtomCount()];
+  for (int i=getAtomCount();i--;) {
     FragmentSearch.ShortestPathList[i] = -1;
+  }
   // Construct the complete KeySet which we need for topmost level only (but for all Roots)
-  atom *Walker = start;
   KeySet CompleteMolecule;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    CompleteMolecule.insert(Walker->GetTrueFather()->nr);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    CompleteMolecule.insert((*iter)->GetTrueFather()->nr);
+  }
 …
     RootKeyNr = RootStack.front();
     RootStack.pop_front();
     Walker = FindAtom(RootKeyNr);
+    atom *Walker = FindAtom(RootKeyNr);
     // check cyclic lengths
     //if ((MinimumRingSize[Walker->GetTrueFather()->nr] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->nr])) {
 …
       // allocate memory for all lower level orders in this 1D-array of ptrs
       NumLevels = 1 << (Order-1); // (int)pow(2,Order);
+      FragmentLowerOrdersList[RootNr] = Calloc<Graph*>(NumLevels, "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
+      FragmentLowerOrdersList[RootNr] = new Graph*[NumLevels];
+      for (int i=0;i<NumLevels;i++)
+        FragmentLowerOrdersList[RootNr][i] = NULL;
       // create top order where nothing is reduced
 …
   // cleanup FragmentSearch structure
   Free(&FragmentSearch.ShortestPathList);
+  delete[](FragmentSearch.ShortestPathList);
   delete(FragmentSearch.FragmentSet);
 …
   CombineAllOrderListIntoOne(FragmentList, FragmentLowerOrdersList, RootStack, this);
   FreeAllOrdersList(FragmentLowerOrdersList, RootStack, this);
   Free(&NumMoleculesOfOrder);
+  delete[](NumMoleculesOfOrder);
   DoLog(0) && (Log() << Verbose(0) << "End of FragmentBOSSANOVA." << endl);
 …
   Vector Translationvector;
   //class StackClass<atom *> *CompStack = NULL;
   class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
+  class StackClass<atom *> *AtomStack = new StackClass<atom *>(getAtomCount());
   bool flag = true;
   DoLog(2) && (Log() << Verbose(2) << "Begin of ScanForPeriodicCorrection." << endl);
+  ColorList = Calloc<enum Shading>(AtomCount, "molecule::ScanForPeriodicCorrection: *ColorList");
+  ColorList = new enum Shading[getAtomCount()];
+  for (int i=0;i<getAtomCount();i++)
+    ColorList[i] = (enum Shading)0;
   while (flag) {
     // remove bonds that are beyond bonddistance
     Translationvector.Zero();
     // scan all bonds
-    Binder = first;
     flag = false;
+    while ((!flag) && (Binder->next != last)) {
+      Binder = Binder->next;
+      for (int i=NDIM;i--;) {
+        tmp = fabs(Binder->leftatom->x[i] - Binder->rightatom->x[i]);
+        //Log() << Verbose(3) << "Checking " << i << "th distance of " << *Binder->leftatom << " to " << *Binder->rightatom << ": " << tmp << "." << endl;
+        if (tmp > BondDistance) {
+          OtherBinder = Binder->next; // note down binding partner for later re-insertion
+          unlink(Binder);   // unlink bond
+          DoLog(2) && (Log() << Verbose(2) << "Correcting at bond " << *Binder << "." << endl);
+          flag = true;
+          break;
+    for(molecule::iterator AtomRunner = begin(); (!flag) && (AtomRunner != end()); ++AtomRunner)
+      for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); (!flag) && (BondRunner != (*AtomRunner)->ListOfBonds.end()); ++BondRunner) {
+        Binder = (*BondRunner);
+        for (int i=NDIM;i--;) {
+          tmp = fabs(Binder->leftatom->x[i] - Binder->rightatom->x[i]);
+          //Log() << Verbose(3) << "Checking " << i << "th distance of " << *Binder->leftatom << " to " << *Binder->rightatom << ": " << tmp << "." << endl;
+          if (tmp > BondDistance) {
+            OtherBinder = Binder->next; // note down binding partner for later re-insertion
+            unlink(Binder);   // unlink bond
+            DoLog(2) && (Log() << Verbose(2) << "Correcting at bond " << *Binder << "." << endl);
+            flag = true;
+            break;
+          }
+        }
+      }
+    }
     if (flag) {
       // create translation vector from their periodically modified distance
 …
       Log() << Verbose(0) << Translationvector <<  endl;
       // apply to all atoms of first component via BFS
       for (int i=AtomCount;i--;)
+      for (int i=getAtomCount();i--;)
         ColorList[i] = white;
       AtomStack->Push(Binder->leftatom);
 …
   // free allocated space from ReturnFullMatrixforSymmetric()
   delete(AtomStack);
   Free(&ColorList);
   Free(&matrix);
+  delete[](ColorList);
+  delete[](matrix);
   DoLog(2) && (Log() << Verbose(2) << "End of ScanForPeriodicCorrection." << endl);
 };

src/molecule_geometry.cpp

-              rc39cc4
+              rbdb143
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 …
 #include "World.hpp"
 #include "Plane.hpp"
+#include <boost/foreach.hpp>
 /************************************* Functions for class molecule *********************************/
 …
   bool status = true;
   const Vector *Center = DetermineCenterOfAll();
+  const Vector *CenterBox = DetermineCenterOfBox();
   double * const cell_size = World::getInstance().getDomain();
   double *M = ReturnFullMatrixforSymmetric(cell_size);
 …
   // go through all atoms
   ActOnAllVectors( &Vector::SubtractVector, *Center);
+  ActOnAllVectors( &Vector::SubtractVector, *CenterBox);
   ActOnAllVectors( &Vector::WrapPeriodically, (const double *)M, (const double *)Minv);
   Free(&M);
   Free(&Minv);
+  delete[](M);
+  delete[](Minv);
   delete(Center);
   return status;
 …
   ActOnAllVectors( &Vector::WrapPeriodically, (const double *)M, (const double *)Minv);
   Free(&M);
   Free(&Minv);
+  delete[](M);
+  delete[](Minv);
   return status;
 };
 …
 //  Log() << Verbose(3) << "Begin of CenterEdge." << endl;
   atom *ptr = start->next;  // start at first in list
   if (ptr != end) {   //list not empty?
+  molecule::const_iterator iter = begin();  // start at first in list
+  if (iter != end()) { //list not empty?
     for (int i=NDIM;i--;) {
+      max->at(i) = ptr->x[i];
+      min->at(i) = ptr->x[i];
+    }
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
+      //ptr->Output(1,1,out);
+      max->at(i) = (*iter)->x[i];
+      min->at(i) = (*iter)->x[i];
+    }
+    for (; iter != end(); ++iter) {// continue with second if present
+      //(*iter)->Output(1,1,out);
       for (int i=NDIM;i--;) {
         max->at(i) = (max->at(i) < ptr->x[i]) ? ptr->x[i] : max->at(i);
         min->at(i) = (min->at(i) > ptr->x[i]) ? ptr->x[i] : min->at(i);
+        max->at(i) = (max->at(i) < (*iter)->x[i]) ? (*iter)->x[i] : max->at(i);
+        min->at(i) = (min->at(i) > (*iter)->x[i]) ? (*iter)->x[i] : min->at(i);
+      }
+    }
 …
+{
   int Num = 0;
   atom *ptr = start;  // start at first in list
+  molecule::const_iterator iter = begin();  // start at first in list
   Center.Zero();
+  if (ptr->next != end) {   //list not empty?
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
+  if (iter != end()) {   //list not empty?
+    for (; iter != end(); ++iter) {  // continue with second if present
       Num++;
       Center += ptr->x;
+      Center += (*iter)->x;
+    }
     Center.Scale(-1./Num); // divide through total number (and sign for direction)
 …
 Vector * molecule::DetermineCenterOfAll() const
+{
+  atom *ptr = start->next;  // start at first in list
+  molecule::const_iterator iter = begin();  // start at first in list
+  Vector *a = new Vector();
+  double Num = 0;
+  a->Zero();
+  if (iter != end()) {   //list not empty?
+    for (; iter != end(); ++iter) {  // continue with second if present
+      Num++;
+      (*a) += (*iter)->x;
+    }
+    a->Scale(1./Num); // divide through total mass (and sign for direction)
+  }
+  return a;
+};
+/** Returns vector pointing to center of the domain.
+ * \return pointer to center of the domain
+ */
+Vector * molecule::DetermineCenterOfBox() const
+{
+  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);
+  return a;
+};
+/** Returns vector pointing to center of gravity.
+ * \param *out output stream for debugging
+ * \return pointer to center of gravity vector
+ */
+Vector * molecule::DetermineCenterOfGravity()
+{
+  molecule::const_iterator iter = begin();  // start at first in list
   Vector *a = new Vector();
   Vector tmp;
 …
   a->Zero();
+  if (ptr != end) {   //list not empty?
+    while (ptr->next != end) {  // continue with second if present
+      ptr = ptr->next;
+      Num += 1.;
+      tmp = ptr->x;
+  if (iter != end()) {   //list not empty?
+    for (; iter != end(); ++iter) {  // continue with second if present
+      Num += (*iter)->type->mass;
+      tmp = (*iter)->type->mass * (*iter)->x;
       (*a) += tmp;
+    }
     a->Scale(1./Num); // divide through total mass (and sign for direction)
+  }
-  return a;
-};
-/** Returns vector pointing to center of gravity.
- * \param *out output stream for debugging
- * \return pointer to center of gravity vector
- */
-Vector * molecule::DetermineCenterOfGravity()
+{
-  atom *ptr = start->next;  // start at first in list
-  Vector *a = new Vector();
-  Vector tmp;
-  double Num = 0;
-  a->Zero();
-  if (ptr != end) {   //list not empty?
-    while (ptr->next != end) {  // continue with second if present
-      ptr = ptr->next;
-      Num += ptr->type->mass;
-      tmp = ptr->type->mass * ptr->x;
-      (*a) += tmp;
+    }
-    a->Scale(-1./Num); // divide through total mass (and sign for direction)
+  }
 //  Log() << Verbose(1) << "Resulting center of gravity: ";
 …
 void molecule::Scale(const double ** const factor)
+{
+  atom *ptr = start;
+  while (ptr->next != end) {
+    ptr = ptr->next;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     for (int j=0;j<MDSteps;j++)
       ptr->Trajectory.R.at(j).ScaleAll(*factor);
     ptr->x.ScaleAll(*factor);
+      (*iter)->Trajectory.R.at(j).ScaleAll(*factor);
+    (*iter)->x.ScaleAll(*factor);
+  }
 };
 …
 void molecule::Translate(const Vector *trans)
+{
+  atom *ptr = start;
+  while (ptr->next != end) {
+    ptr = ptr->next;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
     for (int j=0;j<MDSteps;j++)
       ptr->Trajectory.R.at(j) += (*trans);
     ptr->x += (*trans);
+      (*iter)->Trajectory.R.at(j) += (*trans);
+    (*iter)->x += (*trans);
+  }
 };
 …
   // go through all atoms
   ActOnAllVectors( &Vector::SubtractVector, *trans);
+  ActOnAllVectors( &Vector::AddVector, *trans);
   ActOnAllVectors( &Vector::WrapPeriodically, (const double *)M, (const double *)Minv);
   Free(&M);
   Free(&Minv);
+  delete[](M);
+  delete[](Minv);
 };
 …
 void molecule::Mirror(const Vector *n)
+{
+  OBSERVE;
   Plane p(*n,0);
+  // TODO: replace with simpler construct (e.g. Boost::foreach)
+  // once the structure of the atom list is fully reworked
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Walker->node) = p.mirrorVector(*Walker->node);
+  BOOST_FOREACH( atom* iter, atoms ){
+    (*iter->node) = p.mirrorVector(*iter->node);
+  }
 };
 …
 void molecule::DeterminePeriodicCenter(Vector &center)
+{
-  atom *Walker = start;
   double * const cell_size = World::getInstance().getDomain();
   double *matrix = ReturnFullMatrixforSymmetric(cell_size);
   double *inversematrix = InverseMatrix(cell_size);
+  double *inversematrix = InverseMatrix(matrix);
   double tmp;
   bool flag;
 …
     Center.Zero();
     flag = true;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
 #ifdef ADDHYDROGEN
       if (Walker->type->Z != 1) {
+      if ((*iter)->type->Z != 1) {
 #endif
         Testvector = Walker->x;
+        Testvector = (*iter)->x;
         Testvector.MatrixMultiplication(inversematrix);
         Translationvector.Zero();
         for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
          if (Walker->nr < (*Runner)->GetOtherAtom(Walker)->nr) // otherwise we shift one to, the other fro and gain nothing
+        for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
+         if ((*iter)->nr < (*Runner)->GetOtherAtom((*iter))->nr) // otherwise we shift one to, the other fro and gain nothing
             for (int j=0;j<NDIM;j++) {
               tmp = Walker->x[j] - (*Runner)->GetOtherAtom(Walker)->x[j];
+              tmp = (*iter)->x[j] - (*Runner)->GetOtherAtom(*iter)->x[j];
               if ((fabs(tmp)) > BondDistance) {
                 flag = false;
                 DoLog(0) && (Log() << Verbose(0) << "Hit: atom " << Walker->getName() << " in bond " << *(*Runner) << " has to be shifted due to " << tmp << "." << endl);
+                DoLog(0) && (Log() << Verbose(0) << "Hit: atom " << (*iter)->getName() << " in bond " << *(*Runner) << " has to be shifted due to " << tmp << "." << endl);
                 if (tmp > 0)
                   Translationvector[j] -= 1.;
 …
 #ifdef ADDHYDROGEN
         // now also change all hydrogens
         for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
           if ((*Runner)->GetOtherAtom(Walker)->type->Z == 1) {
             Testvector = (*Runner)->GetOtherAtom(Walker)->x;
+        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 += Translationvector;
 …
+    }
   } while (!flag);
   Free(&matrix);
   Free(&inversematrix);
   Center.Scale(1./(double)AtomCount);
+  delete[](matrix);
+  delete[](inversematrix);
+  Center.Scale(1./static_cast<double>(getAtomCount()));
 };
 …
 void molecule::PrincipalAxisSystem(bool DoRotate)
+{
-  atom *ptr = start;  // start at first in list
   double InertiaTensor[NDIM*NDIM];
   Vector *CenterOfGravity = DetermineCenterOfGravity();
 …
   // sum up inertia tensor
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    Vector x = ptr->x;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    Vector x = (*iter)->x;
     //x.SubtractVector(CenterOfGravity);
     InertiaTensor[0] += ptr->type->mass*(x[1]*x[1] + x[2]*x[2]);
     InertiaTensor[1] += ptr->type->mass*(-x[0]*x[1]);
     InertiaTensor[2] += ptr->type->mass*(-x[0]*x[2]);
     InertiaTensor[3] += ptr->type->mass*(-x[1]*x[0]);
     InertiaTensor[4] += ptr->type->mass*(x[0]*x[0] + x[2]*x[2]);
     InertiaTensor[5] += ptr->type->mass*(-x[1]*x[2]);
     InertiaTensor[6] += ptr->type->mass*(-x[2]*x[0]);
     InertiaTensor[7] += ptr->type->mass*(-x[2]*x[1]);
     InertiaTensor[8] += ptr->type->mass*(x[0]*x[0] + x[1]*x[1]);
+    InertiaTensor[0] += (*iter)->type->mass*(x[1]*x[1] + x[2]*x[2]);
+    InertiaTensor[1] += (*iter)->type->mass*(-x[0]*x[1]);
+    InertiaTensor[2] += (*iter)->type->mass*(-x[0]*x[2]);
+    InertiaTensor[3] += (*iter)->type->mass*(-x[1]*x[0]);
+    InertiaTensor[4] += (*iter)->type->mass*(x[0]*x[0] + x[2]*x[2]);
+    InertiaTensor[5] += (*iter)->type->mass*(-x[1]*x[2]);
+    InertiaTensor[6] += (*iter)->type->mass*(-x[2]*x[0]);
+    InertiaTensor[7] += (*iter)->type->mass*(-x[2]*x[1]);
+    InertiaTensor[8] += (*iter)->type->mass*(x[0]*x[0] + x[1]*x[1]);
+  }
   // print InertiaTensor for debugging
 …
     // sum up inertia tensor
+    ptr = start;
+    while (ptr->next != end) {
+      ptr = ptr->next;
+      Vector x = ptr->x;
+      //x.SubtractVector(CenterOfGravity);
+      InertiaTensor[0] += ptr->type->mass*(x[1]*x[1] + x[2]*x[2]);
+      InertiaTensor[1] += ptr->type->mass*(-x[0]*x[1]);
+      InertiaTensor[2] += ptr->type->mass*(-x[0]*x[2]);
+      InertiaTensor[3] += ptr->type->mass*(-x[1]*x[0]);
+      InertiaTensor[4] += ptr->type->mass*(x[0]*x[0] + x[2]*x[2]);
+      InertiaTensor[5] += ptr->type->mass*(-x[1]*x[2]);
+      InertiaTensor[6] += ptr->type->mass*(-x[2]*x[0]);
+      InertiaTensor[7] += ptr->type->mass*(-x[2]*x[1]);
+      InertiaTensor[8] += ptr->type->mass*(x[0]*x[0] + x[1]*x[1]);
+    for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+      Vector x = (*iter)->x;
+      InertiaTensor[0] += (*iter)->type->mass*(x[1]*x[1] + x[2]*x[2]);
+      InertiaTensor[1] += (*iter)->type->mass*(-x[0]*x[1]);
+      InertiaTensor[2] += (*iter)->type->mass*(-x[0]*x[2]);
+      InertiaTensor[3] += (*iter)->type->mass*(-x[1]*x[0]);
+      InertiaTensor[4] += (*iter)->type->mass*(x[0]*x[0] + x[2]*x[2]);
+      InertiaTensor[5] += (*iter)->type->mass*(-x[1]*x[2]);
+      InertiaTensor[6] += (*iter)->type->mass*(-x[2]*x[0]);
+      InertiaTensor[7] += (*iter)->type->mass*(-x[2]*x[1]);
+      InertiaTensor[8] += (*iter)->type->mass*(x[0]*x[0] + x[1]*x[1]);
+    }
     // print InertiaTensor for debugging
 …
 void molecule::Align(Vector *n)
+{
-  atom *ptr = start;
   double alpha, tmp;
   Vector z_axis;
 …
   alpha = atan(-n->at(0)/n->at(2));
   DoLog(1) && (Log() << Verbose(1) << "Z-X-angle: " << alpha << " ... ");
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    tmp = ptr->x[0];
+    ptr->x[0] =  cos(alpha) * tmp + sin(alpha) * ptr->x[2];
+    ptr->x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x[2];
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    tmp = (*iter)->x[0];
+    (*iter)->x[0] =  cos(alpha) * tmp + sin(alpha) * (*iter)->x[2];
+    (*iter)->x[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->x[2];
     for (int j=0;j<MDSteps;j++) {
       tmp = ptr->Trajectory.R.at(j)[0];
       ptr->Trajectory.R.at(j)[0] =  cos(alpha) * tmp + sin(alpha) * ptr->Trajectory.R.at(j)[2];
       ptr->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * ptr->Trajectory.R.at(j)[2];
+      tmp = (*iter)->Trajectory.R.at(j)[0];
+      (*iter)->Trajectory.R.at(j)[0] =  cos(alpha) * tmp + sin(alpha) * (*iter)->Trajectory.R.at(j)[2];
+      (*iter)->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->Trajectory.R.at(j)[2];
+    }
+  }
 …
   // rotate on z-y plane
-  ptr = start;
   alpha = atan(-n->at(1)/n->at(2));
   DoLog(1) && (Log() << Verbose(1) << "Z-Y-angle: " << alpha << " ... ");
+  while (ptr->next != end) {
+    ptr = ptr->next;
+    tmp = ptr->x[1];
+    ptr->x[1] =  cos(alpha) * tmp + sin(alpha) * ptr->x[2];
+    ptr->x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x[2];
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    tmp = (*iter)->x[1];
+    (*iter)->x[1] =  cos(alpha) * tmp + sin(alpha) * (*iter)->x[2];
+    (*iter)->x[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->x[2];
     for (int j=0;j<MDSteps;j++) {
       tmp = ptr->Trajectory.R.at(j)[1];
       ptr->Trajectory.R.at(j)[1] =  cos(alpha) * tmp + sin(alpha) * ptr->Trajectory.R.at(j)[2];
       ptr->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * ptr->Trajectory.R.at(j)[2];
+      tmp = (*iter)->Trajectory.R.at(j)[1];
+      (*iter)->Trajectory.R.at(j)[1] =  cos(alpha) * tmp + sin(alpha) * (*iter)->Trajectory.R.at(j)[2];
+      (*iter)->Trajectory.R.at(j)[2] = -sin(alpha) * tmp + cos(alpha) * (*iter)->Trajectory.R.at(j)[2];
+    }
+  }
 …
   Vector a,b,c,d;
   struct lsq_params *par = (struct lsq_params *)params;
-  atom *ptr = par->mol->start;
   // initialize vectors
 …
   b[2] = gsl_vector_get(x,5);
   // go through all atoms
+  while (ptr != par->mol->end) {
+    ptr = ptr->next;
+    if (ptr->type == ((struct lsq_params *)params)->type) { // for specific type
+      c = ptr->x - a;
+  for (molecule::const_iterator iter = par->mol->begin(); iter != par->mol->end(); ++iter) {
+    if ((*iter)->type == ((struct lsq_params *)params)->type) { // for specific type
+      c = (*iter)->x - a;
       t = c.ScalarProduct(b);           // get direction parameter
       d = t*b;       // and create vector

src/molecule_graph.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
 #include "bondgraph.hpp"
 #include "config.hpp"
+#include "defs.hpp"
 #include "element.hpp"
 #include "helpers.hpp"
+#include "info.hpp"
 #include "linkedcell.hpp"
 #include "lists.hpp"
 …
 #include "World.hpp"
 #include "Helpers/fast_functions.hpp"
+#include "Helpers/Assert.hpp"
 struct BFSAccounting
 …
 void molecule::CreateAdjacencyListFromDbondFile(ifstream *input)
+{
+  Info FunctionInfo(__func__);
   // 1 We will parse bonds out of the dbond file created by tremolo.
   int atom1, atom2;
   atom *Walker, *OtherWalker;
+  if (!input) {
+    DoLog(1) && (Log() << Verbose(1) << "Opening silica failed \n");
+  char line[MAXSTRINGSIZE];
+  if (input->fail()) {
+    DoeLog(0) && (eLog() << Verbose(0) << "Opening of bond file failed \n");
+    performCriticalExit();
   };
+  *input >> ws >> atom1;
+  *input >> ws >> atom2;
+  DoLog(1) && (Log() << Verbose(1) << "Scanning file\n");
+  doCountAtoms();
+  // skip header
+  input->getline(line,MAXSTRINGSIZE);
+  DoLog(1) && (Log() << Verbose(1) << "Scanning file ... \n");
   while (!input->eof()) // Check whether we read everything already
+  {
+    *input >> ws >> atom1;
+    *input >> ws >> atom2;
+    input->getline(line,MAXSTRINGSIZE);
+    stringstream zeile(line);
+    zeile >> atom1;
+    zeile >> atom2;
+    DoLog(2) && (Log() << Verbose(2) << "Looking for atoms " << atom1 << " and " << atom2 << "." << endl);
     if (atom2 < atom1) //Sort indices of atoms in order
       flip(atom1, atom2);
     Walker = FindAtom(atom1);
+    ASSERT(Walker,"Could not find an atom with the ID given in dbond file");
     OtherWalker = FindAtom(atom2);
+    ASSERT(OtherWalker,"Could not find an atom with the ID given in dbond file");
     AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
+  }
 …
   atom *Walker = NULL;
   atom *OtherWalker = NULL;
-  atom **AtomMap = NULL;
   int n[NDIM];
   double MinDistance, MaxDistance;
 …
   DoLog(0) && (Log() << Verbose(0) << "Begin of CreateAdjacencyList." << endl);
   // remove every bond from the list
+  bond *Binder = NULL;
+  while (last->previous != first) {
+    Binder = last->previous;
+    Binder->leftatom->UnregisterBond(Binder);
+    Binder->rightatom->UnregisterBond(Binder);
+    removewithoutcheck(Binder);
+  }
+  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)
+        delete((*BondRunner));
   BondCount = 0;
   // count atoms in molecule = dimension of matrix (also give each unique name and continuous numbering)
+  CountAtoms();
+  DoLog(1) && (Log() << Verbose(1) << "AtomCount " << AtomCount << " and bonddistance is " << bonddistance << "." << endl);
+  if ((AtomCount > 1) && (bonddistance > 1.)) {
+  DoLog(1) && (Log() << Verbose(1) << "AtomCount " << getAtomCount() << " and bonddistance is " << bonddistance << "." << endl);
+  if ((getAtomCount() > 1) && (bonddistance > 1.)) {
     DoLog(2) && (Log() << Verbose(2) << "Creating Linked Cell structure ... " << endl);
     LC = new LinkedCell(this, bonddistance);
 …
     // create a list to map Tesselpoint::nr to atom *
     DoLog(2) && (Log() << Verbose(2) << "Creating TesselPoint to atom map ... " << endl);
+    AtomMap = Calloc<atom *> (AtomCount, "molecule::CreateAdjacencyList - **AtomCount");
     Walker = start;
     while (Walker->next != end) {
       Walker = Walker->next;
       AtomMap[Walker->nr] = Walker;
+    // set numbers for atoms that can later be used
+    int i=0;
+    for(internal_iterator iter = atoms.begin();iter!= atoms.end(); ++iter){
+      (*iter)->nr = i++;
+    }
 …
           if (List != NULL) {
             for (LinkedCell::LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+              Walker = AtomMap[(*Runner)->nr];
+//              Log() << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
+              Walker = dynamic_cast<atom*>(*Runner);
+              ASSERT(Walker,"Tesselpoint that was not an atom retrieved from LinkedNode");
+              //Log() << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
               // 3c. check for possible bond between each atom in this and every one in the 27 cells
               for (n[0] = -1; n[0] <= 1; n[0]++)
 …
                       for (LinkedCell::LinkedNodes::const_iterator OtherRunner = OtherList->begin(); OtherRunner != OtherList->end(); OtherRunner++) {
                         if ((*OtherRunner)->nr > Walker->nr) {
+                          OtherWalker = AtomMap[(*OtherRunner)->nr];
+//                          Log() << Verbose(0) << "Current other Atom is " << *OtherWalker << "." << endl;
+                          const double distance = OtherWalker->x.PeriodicDistanceSquared(Walker->x, cell_size);
+//                          Log() << Verbose(1) << "Checking distance " << distance << " against typical bond length of " << bonddistance*bonddistance << "." << endl;
+                          OtherWalker = dynamic_cast<atom*>(*OtherRunner);
+                          ASSERT(OtherWalker,"TesselPoint that was not an atom retrieved from LinkedNode");
+                          //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 bool status = (distance <= MaxDistance * MaxDistance) && (distance >= MinDistance * MinDistance);
 //                          Log() << Verbose(1) << "MinDistance is " << MinDistance << " and MaxDistance is " << MaxDistance << "." << endl;
 …
+          }
+        }
-    Free(&AtomMap);
     delete (LC);
     DoLog(1) && (Log() << Verbose(1) << "I detected " << BondCount << " bonds in the molecule with distance " << BondDistance << "." << endl);
 …
     ActOnAllAtoms( &atom::OutputBondOfAtom );
   } else
     DoLog(1) && (Log() << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "AtomCount is " << getAtomCount() << ", thus no bonds, no connections!." << endl);
   DoLog(0) && (Log() << Verbose(0) << "End of CreateAdjacencyList." << endl);
   if (free_BG)
 …
+;
+/** Checks for presence of bonds within atom list.
+ * TODO: more sophisticated check for bond structure (e.g. connected subgraph, ...)
+ * \return true - bonds present, false - no bonds
+ */
+bool molecule::hasBondStructure()
+{
+  for(molecule::iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    if (!(*AtomRunner)->ListOfBonds.empty())
+      return true;
+  return false;
+}
+/** Counts the number of present bonds.
+ * \return number of bonds
+ */
+unsigned int molecule::CountBonds() const
+{
+  unsigned int counter = 0;
+  for(molecule::const_iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::const_iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner)
+        counter++;
+  return counter;
+}
 /** Prints a list of all bonds to \a *out.
  * \param output stream
 …
+{
   DoLog(1) && (Log() << Verbose(1) << endl << "From contents of bond chain list:");
   bond *Binder = first;
   while (Binder->next != last) {
     Binder = Binder->next;
     DoLog(0) && (Log() << Verbose(0) << *Binder << "\t" << endl);
+  }
+  for(molecule::const_iterator AtomRunner = molecule::begin(); AtomRunner != molecule::end(); ++AtomRunner)
+    for(BondList::const_iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner) {
+        DoLog(0) && (Log() << Verbose(0) << *(*BondRunner) << "\t" << endl);
+      }
   DoLog(0) && (Log() << Verbose(0) << endl);
+}
 …
     DoLog(0) && (Log() << Verbose(0) << " done." << endl);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << AtomCount << " atoms." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "BondCount is " << BondCount << ", no bonds between any of the " << getAtomCount() << " atoms." << endl);
+  }
   DoLog(0) && (Log() << Verbose(0) << No << " bonds could not be corrected." << endl);
 …
   MoleculeLeafClass *Subgraphs = NULL;
   class StackClass<bond *> *BackEdgeStack = NULL;
+  bond *Binder = first;
+  if ((Binder->next != last) && (Binder->next->Type == Undetermined)) {
+    DoLog(0) && (Log() << Verbose(0) << "No Depth-First-Search analysis performed so far, calling ..." << endl);
+    Subgraphs = DepthFirstSearchAnalysis(BackEdgeStack);
+    while (Subgraphs->next != NULL) {
+      Subgraphs = Subgraphs->next;
+      delete (Subgraphs->previous);
+    }
+    delete (Subgraphs);
+    delete[] (MinimumRingSize);
+  }
+  while (Binder->next != last) {
+    Binder = Binder->next;
+    if (Binder->Cyclic)
+      NoCyclicBonds++;
+  }
+  for(molecule::iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    if ((!(*AtomRunner)->ListOfBonds.empty()) && ((*(*AtomRunner)->ListOfBonds.begin())->Type == Undetermined)) {
+      DoLog(0) && (Log() << Verbose(0) << "No Depth-First-Search analysis performed so far, calling ..." << endl);
+      Subgraphs = DepthFirstSearchAnalysis(BackEdgeStack);
+      while (Subgraphs->next != NULL) {
+        Subgraphs = Subgraphs->next;
+        delete (Subgraphs->previous);
+      }
+      delete (Subgraphs);
+      delete[] (MinimumRingSize);
+      break;
+    }
+  for(molecule::iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner)
+        if ((*BondRunner)->Cyclic)
+          NoCyclicBonds++;
   delete (BackEdgeStack);
   return NoCyclicBonds;
 …
 void DepthFirstSearchAnalysis_Init(struct DFSAccounting &DFS, const molecule * const mol)
+{
   DFS.AtomStack = new StackClass<atom *> (mol->AtomCount);
+  DFS.AtomStack = new StackClass<atom *> (mol->getAtomCount());
   DFS.CurrentGraphNr = 0;
   DFS.ComponentNumber = 0;
 …
   bond *Binder = NULL;
   if (AtomCount == 0)
+  if (getAtomCount() == 0)
     return SubGraphs;
   DoLog(0) && (Log() << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl);
   DepthFirstSearchAnalysis_Init(DFS, this);
   DFS.Root = start->next;
   while (DFS.Root != end) { // if there any atoms at all
+  for (molecule::const_iterator iter = begin(); iter != end();) {
+    DFS.Root = *iter;
     // (1) mark all edges unused, empty stack, set atom->GraphNr = -1 for all
     DFS.AtomStack->ClearStack();
 …
     // step on to next root
     while ((DFS.Root != end) && (DFS.Root->GraphNr != -1)) {
       //Log() << Verbose(1) << "Current next subgraph root candidate is " << Root->Name << "." << endl;
       if (DFS.Root->GraphNr != -1) // if already discovered, step on
         DFS.Root = DFS.Root->next;
+    while ((iter != end()) && ((*iter)->GraphNr != -1)) {
+      //Log() << Verbose(1) << "Current next subgraph root candidate is " << (*iter)->Name << "." << endl;
+      if ((*iter)->GraphNr != -1) // if already discovered, step on
+        iter++;
+    }
+  }
 …
+{
   NoCyclicBonds = 0;
+  bond *Binder = first;
+  while (Binder->next != last) {
+    Binder = Binder->next;
+    if (Binder->rightatom->LowpointNr == Binder->leftatom->LowpointNr) { // cyclic ??
+      Binder->Cyclic = true;
+      NoCyclicBonds++;
+    }
+  }
+  for(molecule::const_iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::const_iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner)
+        if ((*BondRunner)->rightatom->LowpointNr == (*BondRunner)->leftatom->LowpointNr) { // cyclic ??
+          (*BondRunner)->Cyclic = true;
+          NoCyclicBonds++;
+        }
+}
+;
 …
 void molecule::OutputGraphInfoPerBond() const
+{
+  bond *Binder = NULL;
   DoLog(1) && (Log() << Verbose(1) << "Final graph info for each bond is:" << endl);
+  bond *Binder = first;
+  while (Binder->next != last) {
+    Binder = Binder->next;
+    DoLog(2) && (Log() << Verbose(2) << ((Binder->Type == TreeEdge) ? "TreeEdge " : "BackEdge ") << *Binder << ": <");
+    DoLog(0) && (Log() << Verbose(0) << ((Binder->leftatom->SeparationVertex) ? "SP," : "") << "L" << Binder->leftatom->LowpointNr << " G" << Binder->leftatom->GraphNr << " Comp.");
+    Binder->leftatom->OutputComponentNumber();
+    DoLog(0) && (Log() << Verbose(0) << " ===  ");
+    DoLog(0) && (Log() << Verbose(0) << ((Binder->rightatom->SeparationVertex) ? "SP," : "") << "L" << Binder->rightatom->LowpointNr << " G" << Binder->rightatom->GraphNr << " Comp.");
+    Binder->rightatom->OutputComponentNumber();
+    DoLog(0) && (Log() << Verbose(0) << ">." << endl);
+    if (Binder->Cyclic) // cyclic ??
+      DoLog(3) && (Log() << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl);
+  }
+  for(molecule::const_iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::const_iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner) {
+        Binder = *BondRunner;
+        DoLog(2) && (Log() << Verbose(2) << ((Binder->Type == TreeEdge) ? "TreeEdge " : "BackEdge ") << *Binder << ": <");
+        DoLog(0) && (Log() << Verbose(0) << ((Binder->leftatom->SeparationVertex) ? "SP," : "") << "L" << Binder->leftatom->LowpointNr << " G" << Binder->leftatom->GraphNr << " Comp.");
+        Binder->leftatom->OutputComponentNumber();
+        DoLog(0) && (Log() << Verbose(0) << " ===  ");
+        DoLog(0) && (Log() << Verbose(0) << ((Binder->rightatom->SeparationVertex) ? "SP," : "") << "L" << Binder->rightatom->LowpointNr << " G" << Binder->rightatom->GraphNr << " Comp.");
+        Binder->rightatom->OutputComponentNumber();
+        DoLog(0) && (Log() << Verbose(0) << ">." << endl);
+        if (Binder->Cyclic) // cyclic ??
+          DoLog(3) && (Log() << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl);
+      }
+}
+;
 …
+{
   BFS.AtomCount = AtomCount;
   BFS.PredecessorList = Calloc<atom*> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: **PredecessorList");
   BFS.ShortestPathList = Malloc<int> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ShortestPathList");
   BFS.ColorList = Calloc<enum Shading> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ColorList");
+  BFS.PredecessorList = new atom*[AtomCount];
+  BFS.ShortestPathList = new int[AtomCount];
+  BFS.ColorList = new enum Shading[AtomCount];
   BFS.BFSStack = new StackClass<atom *> (AtomCount);
   for (int i = AtomCount; i--;)
+  for (int i = AtomCount; i--;) {
     BFS.ShortestPathList[i] = -1;
+    BFS.PredecessorList[i] = 0;
+  }
 };
 …
 void FinalizeBFSAccounting(struct BFSAccounting &BFS)
+{
   Free(&BFS.PredecessorList);
   Free(&BFS.ShortestPathList);
   Free(&BFS.ColorList);
+  delete[](BFS.PredecessorList);
+  delete[](BFS.ShortestPathList);
+  delete[](BFS.ColorList);
   delete (BFS.BFSStack);
   BFS.AtomCount = 0;
 …
   if (MinRingSize != -1) { // if rings are present
     // go over all atoms
+    Root = mol->start;
+    while (Root->next != mol->end) {
+      Root = Root->next;
+      if (MinimumRingSize[Root->GetTrueFather()->nr] == mol->AtomCount) { // check whether MinimumRingSize is set, if not BFS to next where it is
+    for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+      Root = *iter;
+      if (MinimumRingSize[Root->GetTrueFather()->nr] == mol->getAtomCount()) { // check whether MinimumRingSize is set, if not BFS to next where it is
         Walker = Root;
         //Log() << Verbose(1) << "---------------------------------------------------------------------------------------------------------" << endl;
         CyclicStructureAnalysis_BFSToNextCycle(Root, Walker, MinimumRingSize, mol->AtomCount);
+        CyclicStructureAnalysis_BFSToNextCycle(Root, Walker, MinimumRingSize, mol->getAtomCount());
+      }
 …
   int MinRingSize = -1;
   InitializeBFSAccounting(BFS, AtomCount);
+  InitializeBFSAccounting(BFS, getAtomCount());
   //Log() << Verbose(1) << "Back edge list - ";
 …
 void molecule::ResetAllBondsToUnused() const
+{
+  bond *Binder = first;
+  while (Binder->next != last) {
+    Binder = Binder->next;
+    Binder->ResetUsed();
+  }
+  for(molecule::const_iterator AtomRunner = begin(); AtomRunner != end(); ++AtomRunner)
+    for(BondList::const_iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner)
+        (*BondRunner)->ResetUsed();
+}
+;
 …
 /** 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);
   DoLog(1) && (Log() << Verbose(1) << "Saving adjacency list ... ");
   if (AdjacencyFile != NULL) {
+    line = filename;
+  AdjacencyFile.open(line.c_str(), ios::out);
+  DoLog(1) && (Log() << Verbose(1) << "Saving adjacency list ... " << endl);
+  if (AdjacencyFile.good()) {
     AdjacencyFile << "m\tn" << endl;
     ActOnAllAtoms(&atom::OutputAdjacency, &AdjacencyFile);
     AdjacencyFile.close();
     DoLog(1) && (Log() << Verbose(1) << "done." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t... done." << endl);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "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);
   DoLog(1) && (Log() << Verbose(1) << "Saving adjacency list ... ");
   if (BondFile != NULL) {
+    line = filename;
+  BondFile.open(line.c_str(), ios::out);
+  DoLog(1) && (Log() << Verbose(1) << "Saving adjacency list ... " << endl);
+  if (BondFile.good()) {
     BondFile << "m\tn" << endl;
     ActOnAllAtoms(&atom::OutputBonds, &BondFile);
     BondFile.close();
     DoLog(1) && (Log() << Verbose(1) << "done." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t... done." << endl);
   } else {
     DoLog(1) && (Log() << Verbose(1) << "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);
   DoLog(1) && (Log() << Verbose(1) << "Looking at bond structure stored in adjacency file and comparing to present one ... ");
   if (File == NULL)
+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.fail())
     return false;
   // allocate storage structure
+  CurrentBonds = Calloc<int> (8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
+  CurrentBonds = new int[8]; // contains parsed bonds of current atom
+  for(int i=0;i<8;i++)
+    CurrentBonds[i] = 0;
   return true;
+}
 …
   File.close();
   File.clear();
   Free(&CurrentBonds);
+  delete[](CurrentBonds);
+}
+;
 …
         NonMatchNumber++;
         status = false;
+        DoeLog(2) && (eLog() << Verbose(2) << id << " can not be found in list." << endl);
+      } else {
         //Log() << Verbose(0) << "[" << id << "]\t";
-      } else {
-        //Log() << Verbose(0) << id << "\t";
+      }
+    }
 …
  * \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;
   bool status = true;
   atom *Walker = NULL;
-  char *buffer = NULL;
   int *CurrentBonds = NULL;
   int NonMatchNumber = 0; // will number of atoms with differing bond structure
   size_t CurrentBondsOfAtom = -1;
+  const int AtomCount = getAtomCount();
   if (!CheckAdjacencyFileAgainstMolecule_Init(path, File, CurrentBonds)) {
 …
+  }
   buffer = Malloc<char> (MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
+  char buffer[MAXSTRINGSIZE];
   // Parse the file line by line and count the bonds
   while (!File.eof()) {
 …
       // compare against present bonds
       CheckAdjacencyFileAgainstMolecule_CompareBonds(status, NonMatchNumber, Walker, CurrentBondsOfAtom, AtomNr, CurrentBonds, ListOfAtoms);
+    }
+  }
+  Free(&buffer);
+    } else {
+      if (AtomNr != -1)
+        DoeLog(2) && (eLog() << Verbose(2) << AtomNr << " is not valid in the range of ids [" << 0 << "," << AtomCount << ")." << endl);
+    }
+  }
   CheckAdjacencyFileAgainstMolecule_Finalize(File, CurrentBonds);
 …
   BFS.AtomCount = AtomCount;
   BFS.BondOrder = BondOrder;
   BFS.PredecessorList = Calloc<atom*> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: **PredecessorList");
   BFS.ShortestPathList = Calloc<int> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ShortestPathList");
   BFS.ColorList = Malloc<enum Shading> (AtomCount, "molecule::BreadthFirstSearchAdd_Init: *ColorList");
+  BFS.PredecessorList = new atom*[AtomCount];
+  BFS.ShortestPathList = new int[AtomCount];
+  BFS.ColorList = new enum Shading[AtomCount];
   BFS.BFSStack = new StackClass<atom *> (AtomCount);
 …
   // initialise each vertex as white with no predecessor, empty queue, color Root lightgray
   for (int i = AtomCount; i--;) {
+    BFS.PredecessorList[i] = NULL;
     BFS.ShortestPathList[i] = -1;
     if ((AddedAtomList != NULL) && (AddedAtomList[i] != NULL)) // mark already present atoms (i.e. Root and maybe others) as visited
 …
       BFS.ColorList[i] = white;
+  }
   //BFS.ShortestPathList[Root->nr] = 0; //is set due to Calloc()
+  //BFS.ShortestPathList[Root->nr] = 0; // done by Calloc
+}
+;
 …
 void BreadthFirstSearchAdd_Free(struct BFSAccounting &BFS)
+{
   Free(&BFS.PredecessorList);
   Free(&BFS.ShortestPathList);
   Free(&BFS.ColorList);
+  delete[](BFS.PredecessorList);
+  delete[](BFS.ShortestPathList);
+  delete[](BFS.ColorList);
   delete (BFS.BFSStack);
   BFS.AtomCount = 0;
 …
     AddedAtomList[Root->nr] = Mol->AddCopyAtom(Root);
   BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, AtomCount, AddedAtomList);
+  BreadthFirstSearchAdd_Init(BFS, Root, BondOrder, getAtomCount(), AddedAtomList);
   // and go on ... Queue always contains all lightgray vertices
 …
+{
   // reset parent list
+  ParentList = Calloc<atom*> (AtomCount, "molecule::BuildInducedSubgraph_Init: **ParentList");
+  ParentList = new atom*[AtomCount];
+  for (int i=0;i<AtomCount;i++)
+    ParentList[i] = NULL;
   DoLog(3) && (Log() << Verbose(3) << "Resetting ParentList." << endl);
+}
 …
   // fill parent list with sons
   DoLog(3) && (Log() << Verbose(3) << "Filling Parent List." << endl);
+  atom *Walker = mol->start;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    ParentList[Walker->father->nr] = Walker;
+  for (molecule::const_iterator iter = mol->begin(); iter != mol->end(); ++iter) {
+    ParentList[(*iter)->father->nr] = (*iter);
     // Outputting List for debugging
+    DoLog(4) && (Log() << Verbose(4) << "Son[" << Walker->father->nr << "] of " << Walker->father << " is " << ParentList[Walker->father->nr] << "." << endl);
+  }
+}
+;
+    DoLog(4) && (Log() << Verbose(4) << "Son[" << (*iter)->father->nr << "] of " << (*iter)->father << " is " << ParentList[(*iter)->father->nr] << "." << endl);
+  }
+};
 void BuildInducedSubgraph_Finalize(atom **&ParentList)
+{
   Free(&ParentList);
+  delete[](ParentList);
+}
+;
 …
+{
   bool status = true;
-  atom *Walker = NULL;
   atom *OtherAtom = NULL;
   // check each entry of parent list and if ok (one-to-and-onto matching) create bonds
   DoLog(3) && (Log() << Verbose(3) << "Creating bonds." << endl);
+  Walker = Father->start;
+  while (Walker->next != Father->end) {
+    Walker = Walker->next;
+    if (ParentList[Walker->nr] != NULL) {
+      if (ParentList[Walker->nr]->father != Walker) {
+  for (molecule::const_iterator iter = Father->begin(); iter != Father->end(); ++iter) {
+    if (ParentList[(*iter)->nr] != NULL) {
+      if (ParentList[(*iter)->nr]->father != (*iter)) {
         status = false;
       } else {
         for (BondList::const_iterator Runner = Walker->ListOfBonds.begin(); Runner != Walker->ListOfBonds.end(); (++Runner)) {
           OtherAtom = (*Runner)->GetOtherAtom(Walker);
+        for (BondList::const_iterator Runner = (*iter)->ListOfBonds.begin(); Runner != (*iter)->ListOfBonds.end(); (++Runner)) {
+          OtherAtom = (*Runner)->GetOtherAtom((*iter));
           if (ParentList[OtherAtom->nr] != NULL) { // if otheratom is also a father of an atom on this molecule, create the bond
             DoLog(4) && (Log() << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[Walker->nr]->getName() << " and " << ParentList[OtherAtom->nr]->getName() << "." << endl);
             mol->AddBond(ParentList[Walker->nr], ParentList[OtherAtom->nr], (*Runner)->BondDegree);
+            DoLog(4) && (Log() << Verbose(4) << "Endpoints of Bond " << (*Runner) << " are both present: " << ParentList[(*iter)->nr]->getName() << " and " << ParentList[OtherAtom->nr]->getName() << "." << endl);
+            mol->AddBond(ParentList[(*iter)->nr], ParentList[OtherAtom->nr], (*Runner)->BondDegree);
+          }
+        }
 …
   bool status = true;
   atom **ParentList = NULL;
   DoLog(2) && (Log() << Verbose(2) << "Begin of BuildInducedSubgraph." << endl);
   BuildInducedSubgraph_Init(ParentList, Father->AtomCount);
+  BuildInducedSubgraph_Init(ParentList, Father->getAtomCount());
   BuildInducedSubgraph_FillParentList(this, Father, ParentList);
   status = BuildInducedSubgraph_CreateBondsFromParent(this, Father, ParentList);

src/molecule_pointcloud.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include "atom.hpp"
 #include "config.hpp"
+#include "info.hpp"
 #include "memoryallocator.hpp"
 #include "molecule.hpp"
 …
 };
+/** Return current atom in the list.
+ * \return pointer to atom or NULL if none present
+/** PointCloud implementation of GoPoint
+ * Uses atoms and STL stuff.
  */
 TesselPoint *molecule::GetPoint() const
+TesselPoint* molecule::GetPoint() const
+{
+  if ((InternalPointer != start) && (InternalPointer != end))
+    return InternalPointer;
+  else
+    return NULL;
+  return (*InternalPointer);
 };
+/** Return pointer to one after last atom in the list.
+ * \return pointer to end marker
+ */
+TesselPoint *molecule::GetTerminalPoint() const
+{
+  return end;
+};
+/** Return the greatest index of all atoms in the list.
+ * \return greatest index
+ */
+int molecule::GetMaxId() const
+{
+  return last_atom;
+};
+/** Go to next atom.
+ * Stops at last one.
+/** PointCloud implementation of GoToNext.
+ * Uses atoms and STL stuff.
  */
 void molecule::GoToNext() const
+{
   if (InternalPointer != end)
     InternalPointer = InternalPointer->next;
+  if (InternalPointer != atoms.end())
+    InternalPointer++;
 };
+/** Go to previous atom.
+ * Stops at first one.
+ */
+void molecule::GoToPrevious() const
+{
+  if (InternalPointer->previous != start)
+    InternalPointer = InternalPointer->previous;
+};
+/** Goes to first atom.
+/** PointCloud implementation of GoToFirst.
+ * Uses atoms and STL stuff.
  */
 void molecule::GoToFirst() const
+{
+  InternalPointer = start->next;
+  // 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));
 };
+/** Goes to last atom.
+ */
+void molecule::GoToLast() const
+{
+  InternalPointer = end->previous;
+};
+/** Checks whether we have any atoms in molecule.
+ * \return true - no atoms, false - not empty
+/** PointCloud implementation of IsEmpty.
+ * Uses atoms and STL stuff.
  */
 bool molecule::IsEmpty() const
+{
   return (start->next == end);
+  return (empty());
 };
 /** Checks whether we are at the last atom
  * \return true - current atom is last one, false - is not last one
+/** PointCloud implementation of IsLast.
+ * Uses atoms and STL stuff.
  */
 bool molecule::IsEnd() const
+{
   return (InternalPointer == end);
+  return (InternalPointer == atoms.end());
 };
+int molecule::GetMaxId() const {
+  return getAtomCount();
+}

src/molecule_template.hpp

-              rc39cc4
+              rbdb143
 template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() ) const
+    {
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)();
+  }
 };
 template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const ) const
+    {
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)();
+  }
 };
 …
 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t);
+  }
 };
 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t);
+  }
 };
 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T&), T &t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t);
+  }
 };
 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T&) const, T &t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t);
+  }
 };
 …
 template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t, u);
+  }
 };
 template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t, u);
+  }
 };
 …
 template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u, v);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t, u, v);
+  }
 };
 template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u, v);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (((*iter)->node)->*f)(t, u, v);
+  }
 };
 …
+{
   res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)();
+  }
   return result;
 …
+{
   res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)();
+  }
   return result;
 …
+{
   res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)(t);
+  }
   return result;
 …
+{
   res result = 0;
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    result += (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    result += ((*iter)->*f)(t);
+  }
   return result;
 …
 template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *)) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*f)((*iter));
+  }
 };
 template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*f)((*iter));
+  }
 };
 …
 template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (copy->*f)((*iter));
+  }
 };
 template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (copy->*f)((*iter));
+  }
 };
 …
 template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)())
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
+  }
 };
 template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () const ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)())
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
+  }
 };
 template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const , molecule *copy, bool (atom::*condition) () ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)())
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
+  }
 };
 template <typename res> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) () const ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)())
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)())
+      (copy->*f)((*iter));
+  }
 };
 …
 template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T) const, T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T), T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T) const, T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t))
+      (copy->*f)((*iter));
+  }
 };
 …
 template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U), T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u))
+      (copy->*f)((*iter));
+  }
 };
 …
 template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u,v))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u,v))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u,v))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
+  }
 };
 template <typename res, typename T, typename U, typename V> void molecule::ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) const, molecule *copy, bool (atom::*condition) (T, U, V) const, T t, U u, V v ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    if ((Walker->*condition)(t,u,v))
+      (copy->*f)(Walker);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    if (((*iter)->*condition)(t,u,v))
+      (copy->*f)((*iter));
+  }
 };
 …
 template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)()) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)();
+  }
 };
 template <typename res, typename typ> void molecule::ActOnAllAtoms( res (typ::*f)() const) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)();
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)();
+  }
 };
 …
 template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T), T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t);
+  }
 };
 template <typename res, typename typ, typename T> void molecule::ActOnAllAtoms( res (typ::*f)(T) const, T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t);
+  }
 };
 …
 template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U), T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u);
+  }
 };
 template <typename res, typename typ, typename T, typename U> void molecule::ActOnAllAtoms( res (typ::*f)(T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u);
+  }
 };
 …
 template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V), T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u, v);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, v);
+  }
 };
 template <typename res, typename typ, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V) const, T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u, v);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, v);
+  }
 };
 …
 template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W), T t, U u, V v, W w) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u, v, w);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, v, w);
+  }
 };
 template <typename res, typename typ, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (typ::*f)(T, U, V, W) const, T t, U u, V v, W w) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u, v, w);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    ((*iter)->*f)(t, u, v, w);
+  }
 };
 …
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *) ) const
+{
-  atom *Walker = start;
   int inc = 1;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->*index)], &inc);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->*index)], &inc);
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->*index)], &value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->*index)], &value);
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, void (*Setor)(T *, T *), T *value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->*index)], value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->*index)], value);
+  }
 };
 …
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *) ) const
+{
-  atom *Walker = start;
   int inc = 1;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->type->*index)], &inc);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->type->*index)], &inc);
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->type->*index)], &value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->type->*index)], &value);
+  }
 };
 template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T *), T *value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*Setor) (&array[(Walker->type->*index)], value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*Setor) (&array[((*iter)->type->*index)], value);
+  }
 };
 …
 template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ atom::*value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
+  }
 };
 template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ atom::*value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) ((*iter)->*value);
+  }
 };
 template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &), typ &vect ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (vect);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
+  }
 };
 template <typename T, typename typ> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int ParticleInfo::*index, T (atom::*Setor)(typ &) const, typ &vect ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (vect);
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    array[((*iter)->*index)] = ((*iter)->*Setor) (vect);
+  }
 };
 template <typename T, typename typ, typename typ2> void molecule::SetAtomValueToIndexedArray ( T *array, int typ::*index, T typ2::*value ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    Walker->*value = array[(Walker->*index)];
+    //Log() << Verbose(2) << *Walker << " gets " << (Walker->*value); << endl;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*iter)->*value = array[((*iter)->*index)];
+    //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*value); << endl;
+  }
 };
 …
 template <typename T, typename typ> void molecule::SetAtomValueToValue ( T value, T typ::*ptr ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    Walker->*ptr = value;
+    //Log() << Verbose(2) << *Walker << " gets " << (Walker->*ptr) << endl;
+  for (molecule::const_iterator iter = begin(); iter != end(); ++iter) {
+    (*iter)->*ptr = value;
+    //Log() << Verbose(2) << *(*iter) << " gets " << ((*iter)->*ptr) << endl;
+  }
 };

src/moleculelist.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
 #include "atom.hpp"
 #include "bond.hpp"
+#include "bondgraph.hpp"
 #include "boundary.hpp"
 #include "config.hpp"
 …
 #include "memoryallocator.hpp"
 #include "periodentafel.hpp"
+#include "World.hpp"
+#include "Helpers/Assert.hpp"
+#include "Helpers/Assert.hpp"
 /*********************************** Functions for class MoleculeListClass *************************/
 …
  */
 MoleculeListClass::MoleculeListClass(World *_world) :
+  Observable("MoleculeListClass"),
   world(_world)
+{
 …
 MoleculeListClass::~MoleculeListClass()
+{
+  DoLog(3) && (Log() << Verbose(3) << this << ": Freeing ListOfMolcules." << endl);
+  for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
+    DoLog(4) && (Log() << Verbose(4) << "ListOfMolecules: Freeing " << *ListRunner << "." << endl);
+    world->destroyMolecule(*ListRunner);
+  }
+  DoLog(4) && (Log() << Verbose(4) << "Freeing ListOfMolecules." << endl);
+  DoLog(4) && (Log() << Verbose(4) << "Clearing ListOfMolecules." << endl);
+  for(MoleculeList::iterator MolRunner = ListOfMolecules.begin(); MolRunner != ListOfMolecules.end(); ++MolRunner)
+    (*MolRunner)->signOff(this);
   ListOfMolecules.clear(); // empty list
 };
 …
 /** Insert a new molecule into the list and set its number.
  * \param *mol molecule to add to list.
- * \return true - add successful
  */
 void MoleculeListClass::insert(molecule *mol)
 …
 };
+/** Erases a molecule from the list.
+ * \param *mol molecule to add to list.
+ */
+void MoleculeListClass::erase(molecule *mol)
+{
+  OBSERVE;
+  mol->signOff(this);
+  ListOfMolecules.remove(mol);
+};
 /** Compare whether two molecules are equal.
  * \param *a molecule one
 …
   int Count, Counter, aCounter, bCounter;
   int flag;
-  atom *aWalker = NULL;
-  atom *bWalker = NULL;
   // sort each atom list and put the numbers into a list, then go through
   //Log() << Verbose(0) << "Comparing fragment no. " << *(molecule **)a << " to " << *(molecule **)b << "." << endl;
+  if ((**(molecule **) a).AtomCount < (**(molecule **) b).AtomCount) {
+  // Yes those types are awkward... but check it for yourself it checks out this way
+  molecule *const *mol1_ptr= static_cast<molecule *const *>(a);
+  molecule *mol1 = *mol1_ptr;
+  molecule *const *mol2_ptr= static_cast<molecule *const *>(b);
+  molecule *mol2 = *mol2_ptr;
+  if (mol1->getAtomCount() < mol2->getAtomCount()) {
     return -1;
   } else {
     if ((**(molecule **) a).AtomCount > (**(molecule **) b).AtomCount)
+    if (mol1->getAtomCount() > mol2->getAtomCount())
       return +1;
     else {
       Count = (**(molecule **) a).AtomCount;
+      Count = mol1->getAtomCount();
       aList = new int[Count];
       bList = new int[Count];
       // fill the lists
-      aWalker = (**(molecule **) a).start;
-      bWalker = (**(molecule **) b).start;
       Counter = 0;
       aCounter = 0;
       bCounter = 0;
+      while ((aWalker->next != (**(molecule **) a).end) && (bWalker->next != (**(molecule **) b).end)) {
+        aWalker = aWalker->next;
+        bWalker = bWalker->next;
+        if (aWalker->GetTrueFather() == NULL)
+      molecule::const_iterator aiter = mol1->begin();
+      molecule::const_iterator biter = mol2->begin();
+      for (;(aiter != mol1->end()) && (biter != mol2->end());
+          ++aiter, ++biter) {
+        if ((*aiter)->GetTrueFather() == NULL)
           aList[Counter] = Count + (aCounter++);
         else
           aList[Counter] = aWalker->GetTrueFather()->nr;
         if (bWalker->GetTrueFather() == NULL)
+          aList[Counter] = (*aiter)->GetTrueFather()->nr;
+        if ((*biter)->GetTrueFather() == NULL)
           bList[Counter] = Count + (bCounter++);
         else
           bList[Counter] = bWalker->GetTrueFather()->nr;
+          bList[Counter] = (*biter)->GetTrueFather()->nr;
         Counter++;
+      }
       // check if AtomCount was for real
       flag = 0;
       if ((aWalker->next == (**(molecule **) a).end) && (bWalker->next != (**(molecule **) b).end)) {
+      if ((aiter == mol1->end()) && (biter != mol2->end())) {
         flag = -1;
       } else {
         if ((aWalker->next != (**(molecule **) a).end) && (bWalker->next == (**(molecule **) b).end))
+        if ((aiter != mol1->end()) && (biter == mol2->end()))
           flag = 1;
+      }
 …
 void MoleculeListClass::Enumerate(ostream *out)
+{
-  atom *Walker = NULL;
   periodentafel *periode = World::getInstance().getPeriode();
   std::map<atomicNumber_t,unsigned int> counts;
 …
       // count atoms per element and determine size of bounding sphere
       size=0.;
+      Walker = (*ListRunner)->start;
+      while (Walker->next != (*ListRunner)->end) {
+        Walker = Walker->next;
+        counts[Walker->type->getNumber()]++;
+        if (Walker->x.DistanceSquared(Origin) > size)
+          size = Walker->x.DistanceSquared(Origin);
+      for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
+        counts[(*iter)->type->getNumber()]++;
+        if ((*iter)->x.DistanceSquared(Origin) > size)
+          size = (*iter)->x.DistanceSquared(Origin);
+      }
       // output Index, Name, number of atoms, chemical formula
       (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->AtomCount << "\t";
+      (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->getAtomCount() << "\t";
       std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
 …
   // put all molecules of src into mol
+  atom *Walker = srcmol->start;
+  atom *NextAtom = Walker->next;
+  while (NextAtom != srcmol->end) {
+    Walker = NextAtom;
+    NextAtom = Walker->next;
+  for (molecule::iterator iter = srcmol->begin(); !srcmol->empty(); iter=srcmol->begin()) {
+    atom * const Walker = *iter;
     srcmol->UnlinkAtom(Walker);
     mol->AddAtom(Walker);
 …
   // put all molecules of src into mol
+  atom *Walker = srcmol->start;
+  atom *NextAtom = Walker->next;
+  while (NextAtom != srcmol->end) {
+    Walker = NextAtom;
+    NextAtom = Walker->next;
+    Walker = mol->AddCopyAtom(Walker);
+  atom *Walker = NULL;
+  for (molecule::iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
+    Walker = mol->AddCopyAtom((*iter));
     Walker->father = Walker;
+  }
 …
     status = status && SimpleMerge(mol, srcmol);
+  }
+  insert(mol);
   return status;
 };
 …
   // prepare index list for bonds
+  srcmol->CountAtoms();
+  atom ** CopyAtoms = new atom*[srcmol->AtomCount];
+  for(int i=0;i<srcmol->AtomCount;i++)
+  atom ** CopyAtoms = new atom*[srcmol->getAtomCount()];
+  for(int i=0;i<srcmol->getAtomCount();i++)
     CopyAtoms[i] = NULL;
   // for each of the source atoms check whether we are in- or outside and add copy atom
-  atom *Walker = srcmol->start;
   int nr=0;
+  while (Walker->next != srcmol->end) {
+    Walker = Walker->next;
+    DoLog(2) && (Log() << Verbose(2) << "INFO: Current Walker is " << *Walker << "." << endl);
+    if (!TesselStruct->IsInnerPoint(Walker->x, LCList)) {
+      CopyAtoms[Walker->nr] = Walker->clone();
+      mol->AddAtom(CopyAtoms[Walker->nr]);
+  for (molecule::const_iterator iter = srcmol->begin(); iter != srcmol->end(); ++iter) {
+    DoLog(2) && (Log() << Verbose(2) << "INFO: Current Walker is " << **iter << "." << endl);
+    if (!TesselStruct->IsInnerPoint((*iter)->x, LCList)) {
+      CopyAtoms[(*iter)->nr] = (*iter)->clone();
+      mol->AddAtom(CopyAtoms[(*iter)->nr]);
       nr++;
     } else {
 …
+    }
+  }
   DoLog(1) && (Log() << Verbose(1) << nr << " of " << srcmol->AtomCount << " atoms have been merged.");
+  DoLog(1) && (Log() << Verbose(1) << nr << " of " << srcmol->getAtomCount() << " atoms have been merged.");
   // go through all bonds and add as well
   bond *Binder = srcmol->first;
   while(Binder->next != srcmol->last) {
     Binder = Binder->next;
     DoLog(3) && (Log() << Verbose(3) << "Adding Bond between " << *CopyAtoms[Binder->leftatom->nr] << " and " << *CopyAtoms[Binder->rightatom->nr]<< "." << endl);
     mol->AddBond(CopyAtoms[Binder->leftatom->nr], CopyAtoms[Binder->rightatom->nr], Binder->BondDegree);
+  }
+  for(molecule::iterator AtomRunner = srcmol->begin(); AtomRunner != srcmol->end(); ++AtomRunner)
+    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); BondRunner != (*AtomRunner)->ListOfBonds.end(); ++BondRunner)
+      if ((*BondRunner)->leftatom == *AtomRunner) {
+        DoLog(3) && (Log() << Verbose(3) << "Adding Bond between " << *CopyAtoms[(*BondRunner)->leftatom->nr] << " and " << *CopyAtoms[(*BondRunner)->rightatom->nr]<< "." << endl);
+        mol->AddBond(CopyAtoms[(*BondRunner)->leftatom->nr], CopyAtoms[(*BondRunner)->rightatom->nr], (*BondRunner)->BondDegree);
+      }
   delete(LCList);
   return true;
 …
  * 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)
+{
+  atom *Walker = NULL;
+  atom *Runner = NULL;
+ * \param &path path to file
+ */
+bool MoleculeListClass::AddHydrogenCorrection(std::string &path)
+{
   bond *Binder = NULL;
   double ***FitConstant = NULL, **correction = 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;
 …
   // 0b. allocate memory for constants
   FitConstant = Calloc<double**>(3, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
+  FitConstant = new double**[3];
   for (int k = 0; k < 3; k++) {
     FitConstant[k] = Calloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
+    FitConstant[k] = new double*[a];
     for (int i = a; i--;) {
+      FitConstant[k][i] = Calloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
+      FitConstant[k][i] = new double[b];
+      for (int j = b; j--;) {
+        FitConstant[k][i][j] = 0.;
+      }
+    }
+  }
 …
   // 0d. allocate final correction matrix
   correction = Calloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **correction");
+  correction = new double*[a];
   for (int i = a; i--;)
     correction[i] = Calloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *correction[]");
+    correction[i] = new double[b];
   // 1a. go through every molecule in the list
 …
         correction[k][j] = 0.;
     // 2. take every hydrogen that is a saturated one
+    Walker = (*ListRunner)->start;
+    while (Walker->next != (*ListRunner)->end) {
+      Walker = Walker->next;
+      //Log() << Verbose(1) << "Walker: " << *Walker << " with first bond " << *(Walker->ListOfBonds.begin()) << "." << endl;
+      if ((Walker->type->Z == 1) && ((Walker->father == NULL)
+          || (Walker->father->type->Z != 1))) { // if it's a hydrogen
+        Runner = (*ListRunner)->start;
+        while (Runner->next != (*ListRunner)->end) {
+          Runner = Runner->next;
+          //Log() << Verbose(2) << "Runner: " << *Runner << " with first bond " << *(Walker->ListOfBonds.begin()) << "." << endl;
+    for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
+      //Log() << Verbose(1) << "(*iter): " << *(*iter) << " with first bond " << *((*iter)->ListOfBonds.begin()) << "." << endl;
+      if (((*iter)->type->Z == 1) && (((*iter)->father == NULL)
+          || ((*iter)->father->type->Z != 1))) { // if it's a hydrogen
+        for (molecule::const_iterator runner = (*ListRunner)->begin(); runner != (*ListRunner)->end(); ++runner) {
+          //Log() << Verbose(2) << "Runner: " << *(*runner) << " with first bond " << *((*iter)->ListOfBonds.begin()) << "." << endl;
           // 3. take every other hydrogen that is the not the first and not bound to same bonding partner
           Binder = *(Runner->ListOfBonds.begin());
           if ((Runner->type->Z == 1) && (Runner->nr > Walker->nr) && (Binder->GetOtherAtom(Runner) != Binder->GetOtherAtom(Walker))) { // (hydrogens have only one bonding partner!)
+          Binder = *((*runner)->ListOfBonds.begin());
+          if (((*runner)->type->Z == 1) && ((*runner)->nr > (*iter)->nr) && (Binder->GetOtherAtom((*runner)) != Binder->GetOtherAtom((*iter)))) { // (hydrogens have only one bonding partner!)
             // 4. evaluate the morse potential for each matrix component and add up
             distance = Runner->x.distance(Walker->x);
             //Log() << Verbose(0) << "Fragment " << (*ListRunner)->name << ": " << *Runner << "<= " << distance << "=>" << *Walker << ":" << endl;
+            distance = (*runner)->x.distance((*iter)->x);
+            //Log() << Verbose(0) << "Fragment " << (*ListRunner)->name << ": " << *(*runner) << "<= " << distance << "=>" << *(*iter) << ":" << endl;
             for (int k = 0; k < a; k++) {
               for (int j = 0; j < b; j++) {
 …
     FragmentNumber = FixedDigitNumber(ListOfMolecules.size(), (*ListRunner)->IndexNr);
     line += FragmentNumber;
     delete (FragmentNumber);
+    delete[] (FragmentNumber);
     line += HCORRECTIONSUFFIX;
     output.open(line.c_str());
 …
     output.close();
+  }
+  for (int i = a; i--;)
+    delete[](correction[i]);
+  delete[](correction);
   line = path;
   line.append("/");
 …
   for (int k = 0; k < 3; k++) {
     for (int i = a; i--;) {
       Free(&FitConstant[k][i]);
+    }
     Free(&FitConstant[k]);
+  }
   Free(&FitConstant);
+      delete[](FitConstant[k][i]);
+    }
+    delete[](FitConstant[k]);
+  }
+  delete[](FitConstant);
   DoLog(0) && (Log() << Verbose(0) << "done." << endl);
   return true;
 …
 /** 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;
   atom *Walker = NULL;
+  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
+          Walker = (*ListRunner)->start;
+          while (Walker->next != (*ListRunner)->end) { // go through every atom of this element
+            Walker = Walker->next;
+            if (Walker->type->getNumber() == (*elemIter).first) {
+              if ((Walker->GetTrueFather() != NULL) && (Walker->GetTrueFather() != Walker)) {// if there is a rea
+        if ((*ListRunner)->ElementsInMolecule[(*elemIter).first]) { // if this element got atoms
+          for(molecule::iterator atomIter = (*ListRunner)->begin(); atomIter !=(*ListRunner)->end();++atomIter){
+            if ((*atomIter)->type->getNumber() == (*elemIter).first) {
+              if (((*atomIter)->GetTrueFather() != NULL) && ((*atomIter)->GetTrueFather() != (*atomIter))) {// if there is a rea
                 //Log() << Verbose(0) << "Walker is " << *Walker << " with true father " << *( Walker->GetTrueFather()) << ", it
                 ForcesFile << SortIndex[Walker->GetTrueFather()->nr] << "\t";
+                ForcesFile << SortIndex[(*atomIter)->GetTrueFather()->nr] << "\t";
               } else
                 // otherwise a -1 to indicate an added saturation hydrogen
 …
   } 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
- * \param DoPeriodic true - call ScanForPeriodicCorrection, false - don't
- * \param DoCentering true - call molecule::CenterEdge(), false - don't
  * \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;
   bool intermediateResult = true;
-  atom *Walker = NULL;
   Vector BoxDimension;
   char *FragmentNumber = NULL;
 …
   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)))
 …
     // list atoms in fragment for debugging
     DoLog(2) && (Log() << Verbose(2) << "Contained atoms: ");
+    Walker = (*ListRunner)->start;
+    while (Walker->next != (*ListRunner)->end) {
+      Walker = Walker->next;
+      DoLog(0) && (Log() << Verbose(0) << Walker->getName() << " ");
+    for (molecule::const_iterator iter = (*ListRunner)->begin(); iter != (*ListRunner)->end(); ++iter) {
+      DoLog(0) && (Log() << Verbose(0) << (*iter)->getName() << " ");
+    }
     DoLog(0) && (Log() << Verbose(0) << endl);
 …
     for (int k = 0; k < NDIM; k++) {
       j += k + 1;
       BoxDimension[k] = 2.5 * (configuration->GetIsAngstroem() ? 1. : 1. / AtomicLengthToAngstroem);
+      BoxDimension[k] = 2.5 * (World::getInstance().getConfig()->GetIsAngstroem() ? 1. : 1. / AtomicLengthToAngstroem);
       cell_size[j] = BoxDimension[k] * 2.;
+    }
 …
     // 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
 …
     //outputFragment.close();
     //outputFragment.clear();
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
+  }
   DoLog(0) && (Log() << Verbose(0) << " done." << endl);
 …
 void MoleculeListClass::DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration)
+{
+  // 0a. remove all present molecules
+  vector<molecule *> allmolecules = World::getInstance().getAllMolecules();
+  for (vector<molecule *>::iterator MolRunner = allmolecules.begin(); MolRunner != allmolecules.end(); ++MolRunner) {
+    erase(*MolRunner);
+    World::getInstance().destroyMolecule(*MolRunner);
+  }
+  // 0b. remove all bonds and construct a molecule with all atoms
   molecule *mol = World::getInstance().createMolecule();
+  atom *Walker = NULL;
+  atom *Advancer = NULL;
+  bond *Binder = NULL;
+  bond *Stepper = NULL;
+  // 0. gather all atoms into single molecule
+  for (MoleculeList::iterator MolRunner = ListOfMolecules.begin(); !ListOfMolecules.empty(); MolRunner = ListOfMolecules.begin()) {
+    // shift all atoms to new molecule
+    Advancer = (*MolRunner)->start->next;
+    while (Advancer != (*MolRunner)->end) {
+      Walker = Advancer;
+      Advancer = Advancer->next;
+      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << *Walker << "..." << endl);
+      unlink(Walker);
+      Walker->father = Walker;
+      mol->AddAtom(Walker);    // counting starts at 1
+    }
+    // remove all bonds
+    Stepper = (*MolRunner)->first->next;
+    while (Stepper != (*MolRunner)->last) {
+      Binder = Stepper;
+      Stepper = Stepper->next;
+      delete(Binder);
+    }
+    // remove the molecule
+    World::getInstance().destroyMolecule(*MolRunner);
+    ListOfMolecules.erase(MolRunner);
+  vector <atom *> allatoms = World::getInstance().getAllAtoms();
+  for(vector<atom *>::iterator AtomRunner = allatoms.begin(); AtomRunner != allatoms.end(); ++AtomRunner) {
+    for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
+      delete(*BondRunner);
+    mol->AddAtom(*AtomRunner);
+  }
   // 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;
+  }
 …
   const int MolCount = Subgraphs->next->Count();
   char number[MAXSTRINGSIZE];
+  molecule **molecules = Malloc<molecule *>(MolCount, "config::Load() - **molecules");
+  molecule **molecules = new molecule *[MolCount];
+  MoleculeLeafClass *MolecularWalker = Subgraphs;
   for (int i=0;i<MolCount;i++) {
+    MolecularWalker = MolecularWalker->next;
     molecules[i] = World::getInstance().createMolecule();
     molecules[i]->ActiveFlag = true;
 …
       strncat(molecules[i]->name, number, MAXSTRINGSIZE - strlen(mol->name) - 1);
+    }
+    DoLog(1) && (Log() << Verbose(1) << "MolName is " << molecules[i]->name << endl);
+    DoLog(1) && (Log() << Verbose(1) << "MolName is " << molecules[i]->name << ", id is " << molecules[i]->getId() << endl);
+    for (molecule::iterator iter = MolecularWalker->Leaf->begin(); iter != MolecularWalker->Leaf->end(); ++iter) {
+      DoLog(1) && (Log() << Verbose(1) << **iter << endl);
+    }
     insert(molecules[i]);
+  }
 …
   // 4b. create and fill map of which atom is associated to which connected molecule (note, counting starts at 1)
   int FragmentCounter = 0;
+  int *MolMap = Calloc<int>(mol->AtomCount, "config::Load() - *MolMap");
+  MoleculeLeafClass *MolecularWalker = Subgraphs;
+  Walker = NULL;
+  map<int, atom *> AtomToFragmentMap;
+  MolecularWalker = Subgraphs;
   while (MolecularWalker->next != NULL) {
     MolecularWalker = MolecularWalker->next;
+    Walker = MolecularWalker->Leaf->start;
+    while (Walker->next != MolecularWalker->Leaf->end) {
+      Walker = Walker->next;
+      MolMap[Walker->GetTrueFather()->nr] = FragmentCounter+1;
+    for (molecule::iterator iter = MolecularWalker->Leaf->begin(); !MolecularWalker->Leaf->empty(); iter = MolecularWalker->Leaf->begin()) {
+      atom * Walker = *iter;
+      DoLog(1) && (Log() << Verbose(1) << "Re-linking " << Walker << "..." << endl);
+      MolecularWalker->Leaf->erase(iter);
+      molecules[FragmentCounter]->AddAtom(Walker);    // counting starts at 1
+    }
     FragmentCounter++;
+  }
+  // 4c. relocate atoms to new molecules and remove from Leafs
+  Walker = NULL;
+  while (mol->start->next != mol->end) {
+    Walker = mol->start->next;
+    if ((Walker->nr <0) || (Walker->nr >= mol->AtomCount)) {
+      DoeLog(0) && (eLog()<< Verbose(0) << "Index of atom " << *Walker << " is invalid!" << endl);
+      performCriticalExit();
+    }
+    FragmentCounter = MolMap[Walker->nr];
+    if (FragmentCounter != 0) {
+      DoLog(3) && (Log() << Verbose(3) << "Re-linking " << *Walker << "..." << endl);
+      unlink(Walker);
+      molecules[FragmentCounter-1]->AddAtom(Walker);    // counting starts at 1
+    } else {
+      DoeLog(0) && (eLog()<< Verbose(0) << "Atom " << *Walker << " not associated to molecule!" << endl);
+      performCriticalExit();
+    }
+  }
+  World::getInstance().destroyMolecule(mol);
   // 4d. we don't need to redo bonds, as they are connected subgraphs and still maintain their ListOfBonds, but we have to remove them from first..last list
+  Binder = mol->first;
+  while (mol->first->next != mol->last) {
+    Binder = mol->first->next;
+    Walker = Binder->leftatom;
+    unlink(Binder);
+    link(Binder,molecules[MolMap[Walker->nr]-1]->last);   // counting starts at 1
+  }
+  // TODO: check whether this is really not needed anymore
   // 4e. free Leafs
   MolecularWalker = Subgraphs;
 …
+  }
   delete(MolecularWalker);
+  Free(&MolMap);
+  Free(&molecules);
+  delete[](molecules);
   DoLog(1) && (Log() << Verbose(1) << "I scanned " << FragmentCounter << " molecules." << endl);
 };
 …
 int MoleculeListClass::CountAllAtoms() const
+{
-  atom *Walker = NULL;
   int AtomNo = 0;
   for (MoleculeList::const_iterator MolWalker = ListOfMolecules.begin(); MolWalker != ListOfMolecules.end(); MolWalker++) {
+    Walker = (*MolWalker)->start;
+    while (Walker->next != (*MolWalker)->end) {
+      Walker = Walker->next;
+      AtomNo++;
+    }
+    AtomNo += (*MolWalker)->size();
+  }
   return AtomNo;
 …
 bool MoleculeLeafClass::FillBondStructureFromReference(const molecule * const reference, int &FragmentCounter, atom ***&ListOfLocalAtoms, bool FreeList)
+{
-  atom *Walker = NULL;
   atom *OtherWalker = NULL;
   atom *Father = NULL;
 …
   DoLog(1) && (Log() << Verbose(1) << "Begin of FillBondStructureFromReference." << endl);
   // fill ListOfLocalAtoms if NULL was given
   if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
+  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
     DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
     return false;
 …
     DoLog(1) && (Log() << Verbose(1) << "Creating adjacency list for subgraph " << Leaf << "." << endl);
     // remove every bond from the list
+    bond *Binder = NULL;
+    while (Leaf->last->previous != Leaf->first) {
+      Binder = Leaf->last->previous;
+      Binder->leftatom->UnregisterBond(Binder);
+      Binder->rightatom->UnregisterBond(Binder);
+      removewithoutcheck(Binder);
+    }
+    Walker = Leaf->start;
+    while (Walker->next != Leaf->end) {
+      Walker = Walker->next;
+      Father = Walker->GetTrueFather();
+    for(molecule::iterator AtomRunner = Leaf->begin(); AtomRunner != Leaf->end(); ++AtomRunner)
+      for(BondList::iterator BondRunner = (*AtomRunner)->ListOfBonds.begin(); !(*AtomRunner)->ListOfBonds.empty(); BondRunner = (*AtomRunner)->ListOfBonds.begin())
+        if ((*BondRunner)->leftatom == *AtomRunner)
+          delete((*BondRunner));
+    for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
+      Father = (*iter)->GetTrueFather();
       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(Walker->GetTrueFather())->nr]; // local copy of current bond partner of walker
+        OtherWalker = ListOfLocalAtoms[FragmentCounter][(*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr]; // local copy of current bond partner of walker
         if (OtherWalker != NULL) {
           if (OtherWalker->nr > Walker->nr)
             Leaf->AddBond(Walker, OtherWalker, (*Runner)->BondDegree);
+          if (OtherWalker->nr > (*iter)->nr)
+            Leaf->AddBond((*iter), OtherWalker, (*Runner)->BondDegree);
         } else {
           DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom(Walker->GetTrueFather())->nr << "] is NULL!" << endl);
+          DoLog(1) && (Log() << Verbose(1) << "OtherWalker = ListOfLocalAtoms[" << FragmentCounter << "][" << (*Runner)->GetOtherAtom((*iter)->GetTrueFather())->nr << "] is NULL!" << endl);
           status = false;
+        }
 …
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
     Free(&ListOfLocalAtoms[FragmentCounter]);
+    delete[](ListOfLocalAtoms[FragmentCounter]);
     if (FragmentCounter == 0) // first fragments frees the initial pointer to list
       Free(&ListOfLocalAtoms);
+      delete[](ListOfLocalAtoms);
+  }
   DoLog(1) && (Log() << Verbose(1) << "End of FillBondStructureFromReference." << endl);
 …
 bool MoleculeLeafClass::FillRootStackForSubgraphs(KeyStack *&RootStack, bool *AtomMask, int &FragmentCounter)
+{
   atom *Walker = NULL, *Father = NULL;
+  atom *Father = NULL;
   if (RootStack != NULL) {
 …
     if (&(RootStack[FragmentCounter]) != NULL) {
       RootStack[FragmentCounter].clear();
+      Walker = Leaf->start;
+      while (Walker->next != Leaf->end) { // go through all (non-hydrogen) atoms
+        Walker = Walker->next;
+        Father = Walker->GetTrueFather();
+      for(molecule::const_iterator iter = Leaf->begin(); iter != Leaf->end(); ++iter) {
+        Father = (*iter)->GetTrueFather();
         if (AtomMask[Father->nr]) // apply mask
 #ifdef ADDHYDROGEN
           if (Walker->type->Z != 1) // skip hydrogen
+          if ((*iter)->type->Z != 1) // skip hydrogen
 #endif
           RootStack[FragmentCounter].push_front(Walker->nr);
+          RootStack[FragmentCounter].push_front((*iter)->nr);
+      }
       if (next != NULL)
 …
     // allocate and set each field to NULL
     const int Counter = Count();
+    ListOfLocalAtoms = Calloc<atom**>(Counter, "MoleculeLeafClass::FillListOfLocalAtoms - ***ListOfLocalAtoms");
+    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 && CreateFatherLookupTable(Leaf->start, Leaf->end, ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
+    status = status && Leaf->CreateFatherLookupTable(ListOfLocalAtoms[FragmentCounter], GlobalAtomCount);
     FreeList = FreeList && true;
+  }
 …
   DoLog(1) && (Log() << Verbose(1) << "Begin of AssignKeySetsToFragment." << endl);
   // fill ListOfLocalAtoms if NULL was given
   if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->AtomCount, FreeList)) {
+  if (!FillListOfLocalAtoms(ListOfLocalAtoms, FragmentCounter, reference->getAtomCount(), FreeList)) {
     DoLog(1) && (Log() << Verbose(1) << "Filling of ListOfLocalAtoms failed." << endl);
     return false;
 …
   if (FragmentList == NULL) {
     KeySetCounter = Count();
+    FragmentList = Calloc<Graph*>(KeySetCounter, "MoleculeLeafClass::AssignKeySetsToFragment - **FragmentList");
+    FragmentList = new Graph*[KeySetCounter];
+    for (int i=0;i<KeySetCounter;i++)
+      FragmentList[i] = NULL;
     KeySetCounter = 0;
+  }
 …
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
     Free(&ListOfLocalAtoms[FragmentCounter]);
+    delete[](ListOfLocalAtoms[FragmentCounter]);
     if (FragmentCounter == 0) // first fragments frees the initial pointer to list
       Free(&ListOfLocalAtoms);
+      delete[](ListOfLocalAtoms);
+  }
   DoLog(1) && (Log() << Verbose(1) << "End of AssignKeySetsToFragment." << endl);

src/orbitals.db

rc39cc4	rbdb143
	1	# atomicnumber numberoforbitals
1	2	1 1
2	3	2 0

src/parser.cpp

-              rc39cc4
+              rbdb143
 // ======================================= INCLUDES ==========================================
+#include "Helpers/MemDebug.hpp"
 #include <cstring>
 …
 MatrixContainer::MatrixContainer() {
   Indices = NULL;
   Header = Malloc<char*>(1, "MatrixContainer::MatrixContainer: **Header");
   Matrix = Malloc<double**>(1, "MatrixContainer::MatrixContainer: ***Matrix"); // one more each for the total molecule
   RowCounter = Malloc<int>(1, "MatrixContainer::MatrixContainer: *RowCounter");
   ColumnCounter = Malloc<int>(1, "MatrixContainer::MatrixContainer: *ColumnCounter");
+  Header = new char*[1];
+  Matrix = new double**[1]; // one more each for the total molecule
+  RowCounter = new int[1];
+  ColumnCounter = new int[1];
   Header[0] = NULL;
   Matrix[0] = NULL;
 …
       if ((ColumnCounter != NULL) && (RowCounter != NULL)) {
           for(int j=RowCounter[i]+1;j--;)
             Free(&Matrix[i][j]);
         Free(&Matrix[i]);
+            delete[](Matrix[i][j]);
+          delete[](Matrix[i]);
+      }
+    }
     if ((ColumnCounter != NULL) && (RowCounter != NULL) && (Matrix[MatrixCounter] != NULL))
       for(int j=RowCounter[MatrixCounter]+1;j--;)
         Free(&Matrix[MatrixCounter][j]);
+        delete[](Matrix[MatrixCounter][j]);
     if (MatrixCounter != 0)
       Free(&Matrix[MatrixCounter]);
     Free(&Matrix);
+      delete[](Matrix[MatrixCounter]);
+    delete[](Matrix);
+  }
   if (Indices != NULL)
     for(int i=MatrixCounter+1;i--;) {
       Free(&Indices[i]);
+    }
   Free(&Indices);
+      delete[](Indices[i]);
+    }
+  delete[](Indices);
   if (Header != NULL)
     for(int i=MatrixCounter+1;i--;)
       Free(&Header[i]);
   Free(&Header);
   Free(&RowCounter);
   Free(&ColumnCounter);
+      delete[](Header[i]);
+  delete[](Header);
+  delete[](RowCounter);
+  delete[](ColumnCounter);
 };
 …
   if (Matrix == NULL) {
     DoLog(0) && (Log() << Verbose(0) << " with trivial mapping." << endl);
     Indices = Malloc<int*>(MatrixCounter + 1, "MatrixContainer::InitialiseIndices: **Indices");
+    Indices = new int*[MatrixCounter + 1];
     for(int i=MatrixCounter+1;i--;) {
       Indices[i] = Malloc<int>(RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
+      Indices[i] = new int[RowCounter[i]];
       for(int j=RowCounter[i];j--;)
         Indices[i][j] = j;
 …
     if (MatrixCounter != Matrix->MatrixCounter)
       return false;
     Indices = Malloc<int*>(MatrixCounter + 1, "MatrixContainer::InitialiseIndices: **Indices");
+    Indices = new int*[MatrixCounter + 1];
     for(int i=MatrixCounter+1;i--;) {
       if (RowCounter[i] != Matrix->RowCounter[i])
         return false;
       Indices[i] = Malloc<int>(Matrix->RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
+      Indices[i] = new int[Matrix->RowCounter[i]];
       for(int j=Matrix->RowCounter[i];j--;) {
         Indices[i][j] = Matrix->Indices[i][j];
 …
   // parse header
   Header[MatrixNr] = Malloc<char>(1024, "MatrixContainer::ParseMatrix: *Header[]");
+  Header[MatrixNr] = new char[1024];
   for (int m=skiplines+1;m--;)
     input.getline(Header[MatrixNr], 1023);
 …
   // allocate matrix if it's not zero dimension in one direction
   if ((ColumnCounter[MatrixNr] > 0) && (RowCounter[MatrixNr] > -1)) {
     Matrix[MatrixNr] = Malloc<double*>(RowCounter[MatrixNr] + 1, "MatrixContainer::ParseMatrix: **Matrix[]");
+    Matrix[MatrixNr] = new double*[RowCounter[MatrixNr] + 1];
     // parse in each entry for this matrix
 …
     strncpy(Header[MatrixNr], line.str().c_str(), 1023);
     for(int j=0;j<RowCounter[MatrixNr];j++) {
       Matrix[MatrixNr][j] = Malloc<double>(ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[][]");
+      Matrix[MatrixNr][j] = new double[ColumnCounter[MatrixNr]];
       input.getline(filename, 1023);
       stringstream lines(filename);
 …
         //Log() << Verbose(1) << " " << setprecision(2) << Matrix[MatrixNr][j][k] << endl;
+      }
       Matrix[MatrixNr][ RowCounter[MatrixNr] ] = Malloc<double>(ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[RowCounter[MatrixNr]][]");
+      Matrix[MatrixNr][ RowCounter[MatrixNr] ] = new double[ColumnCounter[MatrixNr]];
       for(int j=ColumnCounter[MatrixNr];j--;)
         Matrix[MatrixNr][ RowCounter[MatrixNr] ][j] = 0.;
 …
   DoLog(0) && (Log() << Verbose(0) << "Parsing through each fragment and retrieving " << prefix << suffix << "." << endl);
+  Header = ReAlloc<char*>(Header, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: **Header"); // one more each for the total molecule
+  Matrix = ReAlloc<double**>(Matrix, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: ***Matrix"); // one more each for the total molecule
+  RowCounter = ReAlloc<int>(RowCounter, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: *RowCounter");
+  ColumnCounter = ReAlloc<int>(ColumnCounter, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: *ColumnCounter");
+  delete[](Header);
+  delete[](Matrix);
+  delete[](RowCounter);
+  delete[](ColumnCounter);
+  Header = new char*[MatrixCounter + 1]; // one more each for the total molecule
+  Matrix = new double**[MatrixCounter + 1]; // one more each for the total molecule
+  RowCounter = new int[MatrixCounter + 1];
+  ColumnCounter = new int[MatrixCounter + 1];
   for(int i=MatrixCounter+1;i--;) {
     Matrix[i] = NULL;
 …
     if (!ParseMatrix(file.str().c_str(), skiplines, skipcolumns, i))
       return false;
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
+  }
   return true;
 …
+{
   MatrixCounter = MCounter;
   Header = Malloc<char*>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: *Header");
   Matrix = Malloc<double**>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: ***Matrix"); // one more each for the total molecule
   RowCounter = Malloc<int>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: *RowCounter");
   ColumnCounter = Malloc<int>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: *ColumnCounter");
+  Header = new char*[MatrixCounter + 1];
+  Matrix = new double**[MatrixCounter + 1]; // one more each for the total molecule
+  RowCounter = new int[MatrixCounter + 1];
+  ColumnCounter = new int[MatrixCounter + 1];
   for(int i=MatrixCounter+1;i--;) {
     Header[i] = Malloc<char>(1024, "MatrixContainer::AllocateMatrix: *Header[i]");
+    Header[i] = new char[1024];
     strncpy(Header[i], GivenHeader[i], 1023);
     RowCounter[i] = RCounter[i];
     ColumnCounter[i] = CCounter[i];
     Matrix[i] = Malloc<double*>(RowCounter[i] + 1, "MatrixContainer::AllocateMatrix: **Matrix[]");
+    Matrix[i] = new double*[RowCounter[i] + 1];
     for(int j=RowCounter[i]+1;j--;) {
       Matrix[i][j] = Malloc<double>(ColumnCounter[i], "MatrixContainer::AllocateMatrix: *Matrix[][]");
+      Matrix[i][j] = new double[ColumnCounter[i]];
       for(int k=ColumnCounter[i];k--;)
         Matrix[i][j][k] = 0.;
 …
     FragmentNumber = FixedDigitNumber(MatrixCounter, i);
     line << name << FRAGMENTPREFIX << FragmentNumber << "/" << prefix;
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
     output.open(line.str().c_str(), ios::out);
     if (output == NULL) {
 …
+{
   DoLog(0) && (Log() << Verbose(0) << "Parsing energy indices." << endl);
   Indices = Malloc<int*>(MatrixCounter + 1, "EnergyMatrix::ParseIndices: **Indices");
+  Indices = new int*[MatrixCounter + 1];
   for(int i=MatrixCounter+1;i--;) {
     Indices[i] = Malloc<int>(RowCounter[i], "EnergyMatrix::ParseIndices: *Indices[]");
+    Indices[i] = new int[RowCounter[i]];
     for(int j=RowCounter[i];j--;)
       Indices[i][j] = j;
 …
     // allocate last plus one matrix
     DoLog(0) && (Log() << Verbose(0) << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl);
     Matrix[MatrixCounter] = Malloc<double*>(RowCounter[MatrixCounter] + 1, "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    Matrix[MatrixCounter] = new double*[RowCounter[MatrixCounter] + 1];
     for(int j=0;j<=RowCounter[MatrixCounter];j++)
       Matrix[MatrixCounter][j] = Malloc<double>(ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = new double[ColumnCounter[MatrixCounter]];
     // try independently to parse global energysuffix file if present
 …
   DoLog(0) && (Log() << Verbose(0) << "Parsing force indices for " << MatrixCounter << " matrices." << endl);
   Indices = Malloc<int*>(MatrixCounter + 1, "ForceMatrix::ParseIndices: **Indices");
+  Indices = new int*[MatrixCounter + 1];
   line << name << FRAGMENTPREFIX << FORCESFILE;
   input.open(line.str().c_str(), ios::in);
 …
     line.str(filename);
     // parse the values
     Indices[i] = Malloc<int>(RowCounter[i], "ForceMatrix::ParseIndices: *Indices[]");
+    Indices[i] = new int[RowCounter[i]];
     FragmentNumber = FixedDigitNumber(MatrixCounter, i);
     //Log() << Verbose(0) << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
     for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
       line >> Indices[i][j];
 …
     //Log() << Verbose(0) << endl;
+  }
   Indices[MatrixCounter] = Malloc<int>(RowCounter[MatrixCounter], "ForceMatrix::ParseIndices: *Indices[]");
+  Indices[MatrixCounter] = new int[RowCounter[MatrixCounter]];
   for(int j=RowCounter[MatrixCounter];j--;) {
     Indices[MatrixCounter][j] = j;
 …
     // allocate last plus one matrix
     DoLog(0) && (Log() << Verbose(0) << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl);
     Matrix[MatrixCounter] = Malloc<double*>(RowCounter[MatrixCounter] + 1, "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    Matrix[MatrixCounter] = new double*[RowCounter[MatrixCounter] + 1];
     for(int j=0;j<=RowCounter[MatrixCounter];j++)
       Matrix[MatrixCounter][j] = Malloc<double>(ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = new double[ColumnCounter[MatrixCounter]];
     // try independently to parse global forcesuffix file if present
 …
   DoLog(0) && (Log() << Verbose(0) << "Parsing hessian indices for " << MatrixCounter << " matrices." << endl);
   Indices = Malloc<int*>(MatrixCounter + 1, "HessianMatrix::ParseIndices: **Indices");
+  Indices = new int*[MatrixCounter + 1];
   line << name << FRAGMENTPREFIX << FORCESFILE;
   input.open(line.str().c_str(), ios::in);
 …
     line.str(filename);
     // parse the values
     Indices[i] = Malloc<int>(RowCounter[i], "HessianMatrix::ParseIndices: *Indices[]");
+    Indices[i] = new int[RowCounter[i]];
     FragmentNumber = FixedDigitNumber(MatrixCounter, i);
     //Log() << Verbose(0) << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
     for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
       line >> Indices[i][j];
 …
     //Log() << Verbose(0) << endl;
+  }
   Indices[MatrixCounter] = Malloc<int>(RowCounter[MatrixCounter], "HessianMatrix::ParseIndices: *Indices[]");
+  Indices[MatrixCounter] = new int[RowCounter[MatrixCounter]];
   for(int j=RowCounter[MatrixCounter];j--;) {
     Indices[MatrixCounter][j] = j;
 …
     // allocate last plus one matrix
     DoLog(0) && (Log() << Verbose(0) << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl);
     Matrix[MatrixCounter] = Malloc<double*>(RowCounter[MatrixCounter] + 1, "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    Matrix[MatrixCounter] = new double*[RowCounter[MatrixCounter] + 1];
     for(int j=0;j<=RowCounter[MatrixCounter];j++)
       Matrix[MatrixCounter][j] = Malloc<double>(ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = new double[ColumnCounter[MatrixCounter]];
     // try independently to parse global forcesuffix file if present
 …
 KeySetsContainer::~KeySetsContainer() {
   for(int i=FragmentCounter;i--;)
     Free(&KeySets[i]);
+    delete[](KeySets[i]);
   for(int i=Order;i--;)
     Free(&OrderSet[i]);
   Free(&KeySets);
   Free(&OrderSet);
   Free(&AtomCounter);
   Free(&FragmentsPerOrder);
+    delete[](OrderSet[i]);
+  delete[](KeySets);
+  delete[](OrderSet);
+  delete[](AtomCounter);
+  delete[](FragmentsPerOrder);
 };
 …
   FragmentCounter = FCounter;
   DoLog(0) && (Log() << Verbose(0) << "Parsing key sets." << endl);
   KeySets = Malloc<int*>(FragmentCounter, "KeySetsContainer::ParseKeySets: **KeySets");
+  KeySets = new int*[FragmentCounter];
   for(int i=FragmentCounter;i--;)
     KeySets[i] = NULL;
 …
+  }
   AtomCounter = Malloc<int>(FragmentCounter, "KeySetsContainer::ParseKeySets: *RowCounter");
+  AtomCounter = new int[FragmentCounter];
   for(int i=0;(i<FragmentCounter) && (!input.eof());i++) {
     stringstream line;
     AtomCounter[i] = ACounter[i];
     // parse the values
     KeySets[i] = Malloc<int>(AtomCounter[i], "KeySetsContainer::ParseKeySets: *KeySets[]");
+    KeySets[i] = new int[AtomCounter[i]];
     for(int j=AtomCounter[i];j--;)
       KeySets[i][j] = -1;
     FragmentNumber = FixedDigitNumber(FragmentCounter, i);
     //Log() << Verbose(0) << FRAGMENTPREFIX << FragmentNumber << "[" << AtomCounter[i] << "]:";
     Free(&FragmentNumber);
+    delete[](FragmentNumber);
     input.getline(filename, 1023);
     line.str(filename);
 …
   // scan through all to determine fragments per order
   FragmentsPerOrder = Malloc<int>(Order, "KeySetsContainer::ParseManyBodyTerms: *FragmentsPerOrder");
+  FragmentsPerOrder = new int[Order];
   for(int i=Order;i--;)
     FragmentsPerOrder[i] = 0;
 …
   // scan through all to gather indices to each order set
   OrderSet = Malloc<int*>(Order, "KeySetsContainer::ParseManyBodyTerms: **OrderSet");
+  OrderSet = new int*[Order];
   for(int i=Order;i--;)
     OrderSet[i] = Malloc<int>(FragmentsPerOrder[i], "KeySetsContainer::ParseManyBodyTermsKeySetsContainer::ParseManyBodyTerms: *OrderSet[]");
+    OrderSet[i] = new int[FragmentsPerOrder[i]];
   for(int i=Order;i--;)
     FragmentsPerOrder[i] = 0;

src/periodentafel.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 using namespace std;
 #include <iomanip>
+#include <iostream>
 #include <fstream>
 #include <cstring>
+#include <cassert>
+#include "Helpers/Assert.hpp"
 #include "element.hpp"
+#include "elements_db.hpp"
 #include "helpers.hpp"
 #include "lists.hpp"
 …
  */
 periodentafel::periodentafel()
+{};
+{
+  {
+    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");
+  }
+};
 /** destructor for class periodentafel
  * Removes every element and afterwards deletes start and end of list.
+ * TODO: Handle when elements have changed and store databases then
  */
 periodentafel::~periodentafel()
 …
 /** Adds element to period table list
  * \param *pointer element to be added
  * \return true - succeeded, false - does not occur
+ * \return iterator to added element
  */
 periodentafel::iterator periodentafel::AddElement(element * const pointer)
+{
   atomicNumber_t Z = pointer->getNumber();
   assert(!elements.count(Z));
+  ASSERT(!elements.count(Z), "Element is already present.");
   pointer->sort = &pointer->Z;
   if (pointer->getNumber() < 1 && pointer->getNumber() >= MAX_ELEMENTS)
 …
 /** Removes element from list.
  * \param *pointer element to be removed
+ * \return true - succeeded, false - element not found
+ */
+void periodentafel::RemoveElement(element * const pointer)
+{
+  atomicNumber_t Z = pointer->getNumber();
+  elements.erase(Z);
+ */
+size_t periodentafel::RemoveElement(element * const pointer)
+{
+  return RemoveElement(pointer->getNumber());
+};
+/** Removes element from list.
+ * \param Z element to be removed
+ */
+size_t periodentafel::RemoveElement(atomicNumber_t Z)
+{
+  return elements.erase(Z);
 };
 /** Removes every element from the period table.
- * \return true - succeeded, false - does not occur
  */
 void periodentafel::CleanupPeriodtable()
 …
  * \return pointer to element or NULL if not found
  */
 const element * periodentafel::FindElement(atomicNumber_t Z) const
+element * const periodentafel::FindElement(atomicNumber_t Z) const
+{
   const_iterator res = elements.find(Z);
 …
  * \return pointer to element
  */
 const element * periodentafel::FindElement(const char * const shorthand) const
+element * const periodentafel::FindElement(const char * const shorthand) const
+{
   element *res = 0;
 …
 /** Asks for element number and returns pointer to element
+ */
+const element * periodentafel::AskElement() const
+{
+  const element *walker = NULL;
+ * \return desired element or NULL
+ */
+element * const periodentafel::AskElement() const
+{
+  element * walker = NULL;
   int Z;
   do {
 …
  * \return pointer to either present or newly created element
  */
+const element * periodentafel::EnterElement()
+{
+  const element *res = NULL;
+element * const periodentafel::EnterElement()
+{
   atomicNumber_t Z = 0;
   DoLog(0) && (Log() << Verbose(0) << "Atomic number: " << Z << endl);
   cin >> Z;
   res = FindElement(Z);
+  element * const res = FindElement(Z);
   if (!res) {
     // TODO: make this using the constructor
-    element *tmp;
     DoLog(0) && (Log() << Verbose(0) << "Element not found in database, please enter." << endl);
     tmp = new element;
+    element *tmp = new element;
     tmp->Z = Z;
     DoLog(0) && (Log() << Verbose(0) << "Mass: " << endl);
 …
     cin >> tmp->symbol;
     AddElement(tmp);
     res = tmp;
+    return tmp;
+  }
   return res;
 …
 bool periodentafel::LoadPeriodentafel(const char *path)
+{
+  ifstream infile;
+  element *ptr;
+  map<atomicNumber_t,element*> parsedElems;
+  ifstream input;
   bool status = true;
   bool otherstatus = true;
 …
   // fill elements DB
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDELEMENTSDB);
+  infile.open(filename);
+  if (infile != NULL) {
+    infile.getline(header1, MAXSTRINGSIZE);
+    infile.getline(header2, MAXSTRINGSIZE); // skip first two header lines
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDELEMENTSDB, MAXSTRINGSIZE-strlen(filename));
+  input.open(filename);
+  if (!input.fail())
+    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as elements database." << endl);
+  status = status && LoadElementsDatabase(&input);
+  input.close();
+  input.clear();
+  // fill valence DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDVALENCEDB, MAXSTRINGSIZE-strlen(filename));
+  input.open(filename);
+  if (!input.fail())
+    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as valence database." << endl);
+  otherstatus = otherstatus && LoadValenceDatabase(&input);
+  input.close();
+  input.clear();
+  // fill orbitals DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDORBITALDB, MAXSTRINGSIZE-strlen(filename));
+  input.open(filename);
+  if (!input.fail())
+    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as orbitals database." << endl);
+  otherstatus = otherstatus && LoadOrbitalsDatabase(&input);
+  input.close();
+  input.clear();
+  // fill H-BondAngle DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDHBONDANGLEDB, MAXSTRINGSIZE-strlen(filename));
+  input.open(filename);
+  if (!input.fail())
+    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as H bond angle database." << endl);
+  otherstatus = otherstatus && LoadHBondAngleDatabase(&input);
+  input.close();
+  input.clear();
+  // fill H-BondDistance DB per element
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDHBONDDISTANCEDB, MAXSTRINGSIZE-strlen(filename));
+  input.open(filename);
+  if (!input.fail())
+    DoLog(0) && (Log() << Verbose(0) << "Using " << filename << " as H bond length database." << endl);
+  otherstatus = otherstatus && LoadHBondLengthsDatabase(&input);
+  input.close();
+  input.clear();
+  if (!otherstatus){
+    DoeLog(2) && (eLog()<< Verbose(2) << "Something went wrong while parsing the other databases!" << endl);
+  }
+  return status;
+};
+/** load the element info.
+ * \param *input stream to parse from
+ * \return true - parsing successful, false - something went wrong
+ */
+bool periodentafel::LoadElementsDatabase(istream *input)
+{
+  bool status = true;
+  int counter = 0;
+  pair< std::map<atomicNumber_t,element*>::iterator, bool > InserterTest;
+  if (!(*input).fail()) {
+    (*input).getline(header1, MAXSTRINGSIZE);
+    (*input).getline(header2, MAXSTRINGSIZE); // skip first two header lines
     DoLog(0) && (Log() << Verbose(0) <<  "Parsed elements:");
     while (!infile.eof()) {
+    while (!(*input).eof()) {
       element *neues = new element;
+      infile >> neues->name;
+      //infile >> ws;
+      infile >> neues->symbol;
+      //infile >> ws;
+      infile >> neues->period;
+      //infile >> ws;
+      infile >> neues->group;
+      //infile >> ws;
+      infile >> neues->block;
+      //infile >> ws;
+      infile >> neues->Z;
+      //infile >> ws;
+      infile >> neues->mass;
+      //infile >> ws;
+      infile >> neues->CovalentRadius;
+      //infile >> ws;
+      infile >> neues->VanDerWaalsRadius;
+      //infile >> ws;
+      infile >> ws;
+      DoLog(0) && (Log() << Verbose(0) << " " << neues->symbol);
+      (*input) >> neues->name;
+      //(*input) >> ws;
+      (*input) >> neues->symbol;
+      //(*input) >> ws;
+      (*input) >> neues->period;
+      //(*input) >> ws;
+      (*input) >> neues->group;
+      //(*input) >> ws;
+      (*input) >> neues->block;
+      //(*input) >> ws;
+      (*input) >> neues->Z;
+      //(*input) >> ws;
+      (*input) >> neues->mass;
+      //(*input) >> ws;
+      (*input) >> neues->CovalentRadius;
+      //(*input) >> ws;
+      (*input) >> neues->VanDerWaalsRadius;
+      //(*input) >> ws;
+      (*input) >> ws;
       //neues->Output((ofstream *)&cout);
+      if ((neues->Z > 0) && (neues->Z < MAX_ELEMENTS))
+        parsedElems[neues->getNumber()] = neues;
+      else {
+        DoLog(0) && (Log() << Verbose(0) << "Could not parse element: ");
+        neues->Output((ofstream *)&cout);
+      if ((neues->getNumber() > 0) && (neues->getNumber() < MAX_ELEMENTS)) {
+        if (elements.count(neues->getNumber())) {// if element already present, remove and delete old one (i.e. replace it)
+          //cout << neues->symbol << " is present already." << endl;
+          element * const Elemental = FindElement(neues->getNumber());
+          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));
+          ASSERT(InserterTest.second, "Could not insert new element into periodentafel on LoadElementsDatabase().");
+        }
+        DoLog(0) && (Log() << Verbose(0) << " " << elements[neues->getNumber()]->symbol);
+        counter++;
+      } else {
+        DoeLog(2) && (eLog() << Verbose(2) << "Detected empty line or invalid element in elements db, discarding." << endl);
+        DoLog(0) && (Log() << Verbose(0) << " <?>");
         delete(neues);
+      }
+    }
     DoLog(0) && (Log() << Verbose(0) << endl);
+    infile.close();
+    infile.clear();
+  } else
+  } else {
+    DoeLog(1) && (eLog() << Verbose(1) << "Could not open the database." << endl);
     status = false;
+  // fill valence DB per element
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDVALENCEDB);
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+  }
+  if (counter == 0)
+    status = false;
+  return status;
+}
+/** load the valence info.
+ * \param *input stream to parse from
+ * \return true - parsing successful, false - something went wrong
+ */
+bool periodentafel::LoadValenceDatabase(istream *input)
+{
+  char dummy[MAXSTRINGSIZE];
+  if (!(*input).fail()) {
+    (*input).getline(dummy, MAXSTRINGSIZE);
+    while (!(*input).eof()) {
       atomicNumber_t Z;
+      infile >> Z;
+      infile >> ws;
+      infile >> parsedElems[Z]->Valence;
+      infile >> ws;
+      //Log() << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->Valence << " valence electrons." << endl;
+    }
+    infile.close();
+    infile.clear();
+  } else
+    otherstatus = false;
+  // fill valence DB per element
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDORBITALDB);
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+      (*input) >> Z;
+      ASSERT(elements.count(Z), "Element not present");
+      (*input) >> ws;
+      (*input) >> elements[Z]->Valence;
+      (*input) >> ws;
+      //Log() << Verbose(3) << "Element " << Z << " has " << FindElement(Z)->Valence << " valence electrons." << endl;
+    }
+    return true;
+  } else
+                return false;
+}
+/** load the orbitals info.
+ * \param *input stream to parse from
+ * \return true - parsing successful, false - something went wrong
+ */
+bool periodentafel::LoadOrbitalsDatabase(istream *input)
+{
+  char dummy[MAXSTRINGSIZE];
+  if (!(*input).fail()) {
+    (*input).getline(dummy, MAXSTRINGSIZE);
+    while (!(*input).eof()) {
       atomicNumber_t Z;
+      infile >> Z;
+      infile >> ws;
+      infile >> parsedElems[Z]->NoValenceOrbitals;
+      infile >> ws;
+      //Log() << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->NoValenceOrbitals << " number of singly occupied valence orbitals." << endl;
+    }
+    infile.close();
+    infile.clear();
+  } else
+    otherstatus = false;
+  // fill H-BondDistance DB per element
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDHBONDDISTANCEDB);
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+      (*input) >> Z;
+      ASSERT(elements.count(Z), "Element not present");
+      (*input) >> ws;
+      (*input) >> elements[Z]->NoValenceOrbitals;
+      (*input) >> ws;
+      //Log() << Verbose(3) << "Element " << Z << " has " << FindElement(Z)->NoValenceOrbitals << " number of singly occupied valence orbitals." << endl;
+    }
+    return true;
+  } else
+    return false;
+}
+/** load the hbond angles info.
+ * \param *input stream to parse from
+ * \return true - parsing successful, false - something went wrong
+ */
+bool periodentafel::LoadHBondAngleDatabase(istream *input)
+{
+  char dummy[MAXSTRINGSIZE];
+  if (!(*input).fail()) {
+    (*input).getline(dummy, MAXSTRINGSIZE);
+    while (!(*input).eof()) {
       atomicNumber_t Z;
+      infile >> Z;
+      ptr = parsedElems[Z];
+      infile >> ws;
+      infile >> ptr->HBondDistance[0];
+      infile >> ptr->HBondDistance[1];
+      infile >> ptr->HBondDistance[2];
+      infile >> ws;
+      (*input) >> Z;
+      ASSERT(elements.count(Z), "Element not present");
+      (*input) >> ws;
+      (*input) >> elements[Z]->HBondAngle[0];
+      (*input) >> elements[Z]->HBondAngle[1];
+      (*input) >> elements[Z]->HBondAngle[2];
+      (*input) >> ws;
+      //Log() << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->HBondAngle[0] << ", " << FindElement((int)tmp)->HBondAngle[1] << ", " << FindElement((int)tmp)->HBondAngle[2] << " degrees bond angle for one, two, three connected hydrogens." << endl;
+    }
+    return true;
+  } else
+                return false;
+}
+/** load the hbond lengths info.
+ * \param *input stream to parse from
+ * \return true - parsing successful, false - something went wrong
+ */
+bool periodentafel::LoadHBondLengthsDatabase(istream *input)
+{
+  char dummy[MAXSTRINGSIZE];
+  if (!(*input).fail()) {
+    (*input).getline(dummy, MAXSTRINGSIZE);
+    while (!(*input).eof()) {
+      atomicNumber_t Z;
+      (*input) >> Z;
+      ASSERT(elements.count(Z), "Element not present");
+      (*input) >> ws;
+      (*input) >> elements[Z]->HBondDistance[0];
+      (*input) >> elements[Z]->HBondDistance[1];
+      (*input) >> elements[Z]->HBondDistance[2];
+      (*input) >> ws;
       //Log() << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->HBondDistance[0] << " Angstrom typical distance to hydrogen." << endl;
+    }
+    infile.close();
+    infile.clear();
+  } else
+    otherstatus = false;
+  // fill H-BondAngle DB per element
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDHBONDANGLEDB);
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
+      atomicNumber_t Z;
+      infile >> Z;
+      ptr = parsedElems[Z];
+      infile >> ws;
+      infile >> ptr->HBondAngle[0];
+      infile >> ptr->HBondAngle[1];
+      infile >> ptr->HBondAngle[2];
+      infile >> ws;
+      //Log() << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->HBondAngle[0] << ", " << FindElement((int)tmp)->HBondAngle[1] << ", " << FindElement((int)tmp)->HBondAngle[2] << " degrees bond angle for one, two, three connected hydrogens." << endl;
+    }
+    infile.close();
+  } else
+    otherstatus = false;
+  if (otherstatus){
+    map<atomicNumber_t,element*>::iterator iter;
+    for(iter=parsedElems.begin();iter!=parsedElems.end();++iter){
+      AddElement((*iter).second);
+    }
+  }
+  else{
+    DoeLog(2) && (eLog()<< Verbose(2) << "Something went wrong while parsing the other databases!" << endl);
+    map<atomicNumber_t,element*>::iterator iter;
+    for(iter=parsedElems.begin();iter!=parsedElems.end();++iter){
+      AddElement((*iter).second);
+    }
+  }
+  return status;
+};
+    return true;
+  } else
+                return false;
+}
 /** Stores element list to file.
 …
   char filename[MAXSTRINGSIZE];
+  snprintf(filename,MAXSTRINGSIZE,"%s/%s",path,STANDARDELEMENTSDB);
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDELEMENTSDB, MAXSTRINGSIZE-strlen(filename));
   f.open(filename);
   if (f != NULL) {
 …
+    }
     f.close();
   } else
     result = false;
   return result;
 };
+    return true;
+  } else
+    return result;
+};

src/periodentafel.hpp

-              rc39cc4
+              rbdb143
 #include <iterator>
+#include "unittests/periodentafelTest.hpp"
 #include "defs.hpp"
 #include "types.hpp"
 …
 class periodentafel {
   /******* Types *********/
+  friend class periodentafelTest;
   private:
     typedef std::map<atomicNumber_t,element*> elementSet;
 …
   iterator AddElement(element * const pointer);
+  void RemoveElement(element * const pointer);
+  size_t RemoveElement(element * const pointer);
+  size_t RemoveElement(atomicNumber_t);
   void CleanupPeriodtable();
   const element *FindElement(atomicNumber_t) const;
   const element *FindElement(const char * const shorthand) const;
   const element *AskElement() const;
   const element *EnterElement();
+  element * const FindElement(atomicNumber_t) const;
+  element * const FindElement(const char * const shorthand) const;
+  element * const AskElement() const;
+  element * const EnterElement();
   const_iterator begin();
 …
   private:
+  bool LoadElementsDatabase(std::istream *input);
+  bool LoadValenceDatabase(std::istream *input);
+  bool LoadOrbitalsDatabase(std::istream *input);
+  bool LoadHBondAngleDatabase(std::istream *input);
+  bool LoadHBondLengthsDatabase(std::istream *input);
     elementSet elements;
 };

src/stackclass.hpp

-              rc39cc4
+              rbdb143
 template <typename T> StackClass<T>::StackClass(int dimension) : StackList(NULL), EntryCount(dimension), CurrentLastEntry(0), CurrentFirstEntry(0), NextFreeField(0)
+{
+  StackList = Calloc<T>(EntryCount, "StackClass::StackClass: **StackList");
+  StackList = new T[EntryCount];
+  for (int i=0;i<EntryCount;i++)
+    StackList[i] = NULL;
 };
 …
 template <typename T> StackClass<T>::~StackClass()
+{
   Free(&StackList);
+  delete[](StackList);
 };

src/tesselation.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include <fstream>
-#include <assert.h>
 #include "helpers.hpp"
 …
   // get ascending order of endpoints
   PointMap OrderMap;
   for (int i = 0; i < 3; i++)
+  for (int i = 0; i < 3; i++) {
     // for all three lines
     for (int j = 0; j < 2; j++) { // for both endpoints
 …
       // and we don't care whether insertion fails
+    }
+  }
   // set endpoints
   int Counter = 0;
 …
     Counter++;
+  }
+  if (Counter < 3) {
+    DoeLog(0) && (eLog() << Verbose(0) << "We have a triangle with only two distinct endpoints!" << endl);
+    performCriticalExit();
+  }
+}
+;
+  ASSERT(Counter >= 3,"We have a triangle with only two distinct endpoints!");
+};
 /** Destructor of BoundaryTriangleSet.
 …
+;
-/** PointCloud implementation of GetTerminalPoint.
- * Uses PointsOnBoundary and STL stuff.
- */
-TesselPoint * Tesselation::GetTerminalPoint() const
+{
-  Info FunctionInfo(__func__);
-  PointMap::const_iterator Runner = PointsOnBoundary.end();
-  Runner--;
-  return (Runner->second->node);
+}
+;
 /** PointCloud implementation of GoToNext.
  * Uses PointsOnBoundary and STL stuff.
 …
+;
-/** PointCloud implementation of GoToPrevious.
- * Uses PointsOnBoundary and STL stuff.
- */
-void Tesselation::GoToPrevious() const
+{
-  Info FunctionInfo(__func__);
-  if (InternalPointer != PointsOnBoundary.begin())
-    InternalPointer--;
+}
+;
 /** PointCloud implementation of GoToFirst.
  * Uses PointsOnBoundary and STL stuff.
 …
   Info FunctionInfo(__func__);
   InternalPointer = PointsOnBoundary.begin();
+}
+;
-/** PointCloud implementation of GoToLast.
- * Uses PointsOnBoundary and STL stuff.
- */
-void Tesselation::GoToLast() const
+{
-  Info FunctionInfo(__func__);
-  InternalPointer = PointsOnBoundary.end();
-  InternalPointer--;
+}
+;
 …
         RemoveTesselationLine(triangle->lines[i]);
       } else {
         DoLog(0) && (Log() << Verbose(0) << *triangle->lines[i] << " is still attached to another triangle: ");
+        DoLog(0) && (Log() << Verbose(0) << *triangle->lines[i] << " is still attached to another triangle: " << endl);
         OpenLines.insert(pair<BoundaryLineSet *, CandidateForTesselation *> (triangle->lines[i], NULL));
         for (TriangleMap::iterator TriangleRunner = triangle->lines[i]->triangles.begin(); TriangleRunner != triangle->lines[i]->triangles.end(); TriangleRunner++)
           DoLog(0) && (Log() << Verbose(0) << "[" << (TriangleRunner->second)->Nr << "|" << *((TriangleRunner->second)->endpoints[0]) << ", " << *((TriangleRunner->second)->endpoints[1]) << ", " << *((TriangleRunner->second)->endpoints[2]) << "] \t");
+          DoLog(0) && (Log() << Verbose(0) << "\t[" << (TriangleRunner->second)->Nr << "|" << *((TriangleRunner->second)->endpoints[0]) << ", " << *((TriangleRunner->second)->endpoints[1]) << ", " << *((TriangleRunner->second)->endpoints[2]) << "] \t");
         DoLog(0) && (Log() << Verbose(0) << endl);
         //        for (int j=0;j<2;j++) {
 …
     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);
 …
   // fill the set of neighbours
   TesselPointSet SetOfNeighbours;
   SetOfNeighbours.insert(CandidateLine.BaseLine->endpoints[1]->node);
   for (TesselPointList::iterator Runner = CandidateLine.pointlist.begin(); Runner != CandidateLine.pointlist.end(); Runner++)
 …
   OldBaseLineNr = Base->Nr;
   m = 0;
+  for (TriangleMap::iterator runner = Base->triangles.begin(); runner != Base->triangles.end(); runner++) {
+    DoLog(0) && (Log() << Verbose(0) << "INFO: Deleting triangle " << *(runner->second) << "." << endl);
+    OldTriangleNrs[m++] = runner->second->Nr;
+    RemoveTesselationTriangle(runner->second);
+  // first obtain all triangle to delete ... (otherwise we pull the carpet (Base) from under the for-loop's feet)
+  list <BoundaryTriangleSet *> TrianglesOfBase;
+  for (TriangleMap::iterator runner = Base->triangles.begin(); runner != Base->triangles.end(); ++runner)
+    TrianglesOfBase.push_back(runner->second);
+  // .. then delete each triangle (which deletes the line as well)
+  for (list <BoundaryTriangleSet *>::iterator runner = TrianglesOfBase.begin(); !TrianglesOfBase.empty(); runner = TrianglesOfBase.begin()) {
+    DoLog(0) && (Log() << Verbose(0) << "INFO: Deleting triangle " << *(*runner) << "." << endl);
+    OldTriangleNrs[m++] = (*runner)->Nr;
+    RemoveTesselationTriangle((*runner));
+    TrianglesOfBase.erase(runner);
+  }

src/tesselation.hpp

-              rc39cc4
+              rbdb143
   virtual Vector *GetCenter() const { return NULL; };
   virtual TesselPoint *GetPoint() const { return NULL; };
-  virtual TesselPoint *GetTerminalPoint() const { return NULL; };
   virtual int GetMaxId() const { return 0; };
   virtual void GoToNext() const {};
-  virtual void GoToPrevious() const {};
   virtual void GoToFirst() const {};
-  virtual void GoToLast() const {};
   virtual bool IsEmpty() const { return true; };
   virtual bool IsEnd() const { return true; };
 …
     virtual Vector *GetCenter(ofstream *out) const;
     virtual TesselPoint *GetPoint() const;
-    virtual TesselPoint *GetTerminalPoint() const;
     virtual void GoToNext() const;
-    virtual void GoToPrevious() const;
     virtual void GoToFirst() const;
-    virtual void GoToLast() const;
     virtual bool IsEmpty() const;
     virtual bool IsEnd() const;

src/tesselationhelpers.cpp

-              rc39cc4
+              rbdb143
  *      Author: heber
  */
+#include "Helpers/MemDebug.hpp"
 #include <fstream>
 …
       Walker = cloud->GetPoint();
       *rasterfile << "2" << endl << "  ";  // 2 is sphere type
+      for (i=0;i<NDIM;i++)
+        *rasterfile << Walker->node->at(i)-center->at(i) << " ";
+      for (int j=0;j<NDIM;j++) { // and for each node all NDIM coordinates
+        const double tmp = Walker->node->at(j)-center->at(j);
+        *rasterfile << ((fabs(tmp) < MYEPSILON) ? 0 : tmp) << " ";
+      }
       *rasterfile << "\t0.1\t1. 1. 1." << endl; // radius 0.05 and white as colour
       cloud->GoToNext();
 …
       *rasterfile << "1" << endl << "  ";  // 1 is triangle type
       for (i=0;i<3;i++) {  // print each node
+        for (int j=0;j<NDIM;j++)  // and for each node all NDIM coordinates
+          *rasterfile << TriangleRunner->second->endpoints[i]->node->node->at(j)-center->at(j) << " ";
+        for (int j=0;j<NDIM;j++) { // and for each node all NDIM coordinates
+          const double tmp = TriangleRunner->second->endpoints[i]->node->node->at(j)-center->at(j);
+          *rasterfile << ((fabs(tmp) < MYEPSILON) ? 0 : tmp) << " ";
+        }
         *rasterfile << "\t";
+      }
 …
+    }
     *tecplot << "\", N=" << TesselStruct->PointsOnBoundary.size() << ", E=" << TesselStruct->TrianglesOnBoundary.size() << ", DATAPACKING=POINT, ZONETYPE=FETRIANGLE" << endl;
     int i=cloud->GetMaxId();
     int *LookupList = new int[i];
     for (cloud->GoToFirst(), i=0; !cloud->IsEnd(); cloud->GoToNext(), i++)
+    const int MaxId=cloud->GetMaxId();
+    int *LookupList = new int[MaxId];
+    for (int i=0; i< MaxId ; i++){
       LookupList[i] = -1;
+    }
     // print atom coordinates
     int Counter = 1;
     TesselPoint *Walker = NULL;
     for (PointMap::const_iterator target = TesselStruct->PointsOnBoundary.begin(); target != TesselStruct->PointsOnBoundary.end(); target++) {
+    for (PointMap::const_iterator target = TesselStruct->PointsOnBoundary.begin(); target != TesselStruct->PointsOnBoundary.end(); ++target) {
       Walker = target->second->node;
       LookupList[Walker->nr] = Counter++;
+      *tecplot << Walker->node->at(0) << " " << Walker->node->at(1) << " " << Walker->node->at(2) << " " << target->second->value << endl;
+      for (int i=0;i<NDIM;i++) {
+        const double tmp = Walker->node->at(i);
+        *tecplot << ((fabs(tmp) < MYEPSILON) ? 0 : tmp) << " ";
+      }
+      *tecplot << target->second->value << endl;
+    }
     *tecplot << endl;

src/triangleintersectionlist.cpp

rc39cc4	rbdb143
8	8	* Author: heber
9	9	*/
	10
	11	#include "Helpers/MemDebug.hpp"
10	12
11	13	#include "triangleintersectionlist.hpp"

src/unittests/ActOnAllUnitTest.cpp

-              rc39cc4
+              rbdb143
   // Ref was copy constructed, hence has to be cleaned, too!
   Ref.EmptyList();
-  MemoryUsageObserver::purgeInstance();
 };
 …
   // scaling by three values
   double *factors = Malloc<double>(NDIM, "ActOnAllTest::ScaleTest - factors");
   double *inverses = Malloc<double>(NDIM, "ActOnAllTest::ScaleTest - inverses");
+  double *factors = new double[NDIM];
+  double *inverses = new double[NDIM];
   for (int i=0;i<NDIM;++i) {
     factors[i] = 2.;
 …
   VL.ActOnAll<Vector,void,const double*>(&Vector::ScaleAll, inverses );
   CPPUNIT_ASSERT_EQUAL( VL == Ref , true );
   Free(factors);
   Free(inverses);
+  delete[](factors);
+  delete[](inverses);
 };

src/unittests/AnalysisCorrelationToPointUnitTest.cpp

-              rc39cc4
+              rbdb143
 #include "AnalysisCorrelationToPointUnitTest.hpp"
-#include "World.hpp"
 #include "atom.hpp"
-#include "boundary.hpp"
 #include "element.hpp"
 #include "molecule.hpp"
 #include "linkedcell.hpp"
 #include "periodentafel.hpp"
-#include "tesselation.hpp"
 #include "World.hpp"
 …
   TestList = NULL;
   TestMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   pointmap = NULL;
   binmap = NULL;
   point = NULL;
+  // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  // construct element list
+  std::vector<element *> elements;
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  CPPUNIT_ASSERT(hydrogen != NULL && "hydrogen element not found");
+  elements.push_back(hydrogen);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::getInstance().createMolecule();
 …
   // check that TestMolecule was correctly constructed
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
   TestList = World::getInstance().getMolecules();
 …
   // init maps
   pointmap = CorrelationToPoint( (MoleculeListClass * const)TestList, (const element * const)hydrogen, (const Vector *)point );
+  pointmap = CorrelationToPoint( (MoleculeListClass * const)TestList, elements, (const Vector *)point );
   binmap = NULL;
 …
   delete(point);
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
 };

src/unittests/AnalysisCorrelationToPointUnitTest.hpp

-              rc39cc4
+              rbdb143
 class element;
-class LinkedCell;
 class molecule;
 class MoleculeListClass;
-class periodentafel;
-class Tesselation;
 class Vector;
 …
       molecule *TestMolecule;
       element *hydrogen;
-      periodentafel *tafel;
       CorrelationToPointMap *pointmap;

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

-              rc39cc4
+              rbdb143
 #include "AnalysisCorrelationToSurfaceUnitTest.hpp"
-#include "World.hpp"
 #include "atom.hpp"
 #include "boundary.hpp"
 …
 #include "tesselation.hpp"
 #include "World.hpp"
+#include "Helpers/Assert.hpp"
 #include "Helpers/Assert.hpp"
 …
 void AnalysisCorrelationToSurfaceUnitTest::setUp()
+{
   //ASSERT_DO(Assert::Throw);
+  ASSERT_DO(Assert::Throw);
   atom *Walker = NULL;
 …
   TestList = NULL;
   TestSurfaceMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   surfacemap = NULL;
   binmap = NULL;
 …
   LC = NULL;
+  // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  carbon = new element;
+  carbon->Z = 6;
+  strcpy(carbon->name, "carbon");
+  strcpy(carbon->symbol, "C");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  tafel->AddElement(carbon);
+  // prepare element list
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  CPPUNIT_ASSERT(hydrogen != NULL && "hydrogen element not found");
+  elements.clear();
   // construct molecule (tetraeder of hydrogens) base
   TestSurfaceMolecule = World::getInstance().createMolecule();
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   *Walker->node = Vector(1., 0., 1. );
+  TestSurfaceMolecule->AddAtom(Walker);
+  TestSurfaceMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   *Walker->node = Vector(0., 1., 1. );
   TestSurfaceMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   *Walker->node = Vector(1., 1., 0. );
   TestSurfaceMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
 …
   // check that TestMolecule was correctly constructed
   CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestSurfaceMolecule->getAtomCount(), 4 );
   TestList = World::getInstance().getMolecules();
 …
   // add outer atoms
+  carbon = World::getInstance().getPeriode()->FindElement(6);
   TestSurfaceMolecule = World::getInstance().createMolecule();
   Walker = World::getInstance().createAtom();
 …
   *Walker->node = Vector(4., 0., 4. );
   TestSurfaceMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   *Walker->node = Vector(0., 4., 4. );
   TestSurfaceMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   *Walker->node = Vector(4., 4., 0. );
   TestSurfaceMolecule->AddAtom(Walker);
   // add inner atoms
   Walker = World::getInstance().createAtom();
 …
   *Walker->node = Vector(0.5, 0.5, 0.5 );
   TestSurfaceMolecule->AddAtom(Walker);
   TestSurfaceMolecule->ActiveFlag = true;
   TestList->insert(TestSurfaceMolecule);
 …
   delete(LC);
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
 };
 …
 void AnalysisCorrelationToSurfaceUnitTest::SurfaceTest()
+{
   CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->AtomCount );
+  CPPUNIT_ASSERT_EQUAL( 4, TestSurfaceMolecule->getAtomCount() );
   CPPUNIT_ASSERT_EQUAL( (size_t)2, TestList->ListOfMolecules.size() );
   CPPUNIT_ASSERT_EQUAL( (size_t)4, Surface->PointsOnBoundary.size() );
 …
+{
   // do the pair correlation
+  surfacemap = CorrelationToSurface( TestList, hydrogen, Surface, LC );
+  elements.push_back(hydrogen);
+  surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   CPPUNIT_ASSERT( surfacemap != NULL );
 …
+{
   BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( TestList, hydrogen, Surface, LC );
+  elements.push_back(hydrogen);
+  surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
   // put pair correlation into bins and check with no range
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
 …
+{
   BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( TestList, hydrogen, Surface, LC );
+  elements.push_back(hydrogen);
+  surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // ... and check with [0., 2.] range
 …
+{
   BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( TestList, carbon, Surface, LC );
+  elements.push_back(carbon);
+  surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // put pair correlation into bins and check with no range
 …
+{
   BinPairMap::iterator tester;
+  surfacemap = CorrelationToSurface( TestList, carbon, Surface, LC );
+  elements.push_back(carbon);
+  surfacemap = CorrelationToSurface( TestList, elements, Surface, LC );
 //  OutputCorrelationToSurface ( (ofstream *)&cout, surfacemap );
   // ... and check with [0., 2.] range

src/unittests/AnalysisCorrelationToSurfaceUnitTest.hpp

rc39cc4	rbdb143
47	47	element *hydrogen;
48	48	element *carbon;
49		~~periodentafel *tafel~~;
	49	std::vector<element *> elements;
50	50
51	51	CorrelationToSurfaceMap *surfacemap;

src/unittests/AnalysisPairCorrelationUnitTest.cpp

-              rc39cc4
+              rbdb143
   TestList = NULL;
   TestMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   correlationmap = NULL;
   binmap = NULL;
+  // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  // construct element list
+  std::vector<element *> elements;
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  CPPUNIT_ASSERT(hydrogen != NULL && "hydrogen element not found");
+  elements.push_back(hydrogen);
+  elements.push_back(hydrogen);
   // construct molecule (tetraeder of hydrogens)
 …
   // check that TestMolecule was correctly constructed
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
   TestList = World::getInstance().getMolecules();
 …
   // init maps
   correlationmap = PairCorrelation( TestList, hydrogen, hydrogen );
+  correlationmap = PairCorrelation( TestList, elements);
   binmap = NULL;
 …
   // note that all the atoms are cleaned by TestMolecule
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
   errorLogger::purgeInstance();

src/unittests/AnalysisPairCorrelationUnitTest.hpp

-              rc39cc4
+              rbdb143
 class element;
-class LinkedCell;
 class molecule;
 class MoleculeListClass;
-class periodentafel;
-class Tesselation;
 class Vector;
 …
       molecule *TestMolecule;
       element *hydrogen;
-      periodentafel *tafel;
       PairCorrelationMap *correlationmap;

src/unittests/CacheableTest.cpp

-              rc39cc4
+              rbdb143
   threeNumbers(int _x,int _y, int _z) :
+    Observable("threeNumbers"),
     x(_x),y(_y),z(_z),
     sum(this,boost::bind(&threeNumbers::calcSum,this)),
+    sum(this,boost::bind(&threeNumbers::calcSum,this),"sum"),
     hasRecalced(false)
   {}
 …
   CPPUNIT_ASSERT_EQUAL( 9, *(numbers->sum));
   CPPUNIT_ASSERT_EQUAL( true, numbers->hasRecalced);
+  numbers->hasRecalced=false;
+  CPPUNIT_ASSERT_EQUAL( 9, *(numbers->sum));
+#ifndef NO_CACHING
+  CPPUNIT_ASSERT_EQUAL( false, numbers->hasRecalced);
+#else
+  CPPUNIT_ASSERT_EQUAL( true, numbers->hasRecalced);
+#endif
+}

src/unittests/CountBondsUnitTest.cpp

-              rc39cc4
+              rbdb143
 #include <stdio.h>
 #include <cstring>
+#include "Helpers/Assert.hpp"
 #include "analysis_bonds.hpp"
 …
+{
   atom *Walker = NULL;
-  BG = NULL;
-  filename = NULL;
-  // init private all pointers to zero
-  molecules = NULL;
-  TestMolecule1 = NULL;
-  TestMolecule2 = NULL;
-  hydrogen = NULL;
-  oxygen = NULL;
-  tafel = NULL;
   // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  hydrogen->CovalentRadius = 0.23;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  oxygen = new element;
+  oxygen->Z = 8;
+  oxygen->CovalentRadius = 0.68;
+  strcpy(oxygen->name, "oxygen");
+  strcpy(oxygen->symbol, "O");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  tafel->AddElement(oxygen);
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  oxygen = World::getInstance().getPeriode()->FindElement(8);
+  CPPUNIT_ASSERT(hydrogen != NULL && "could not find element hydrogen");
+  CPPUNIT_ASSERT(oxygen != NULL && "could not find element oxygen");
   // construct molecule (water molecule)
   TestMolecule1 = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(TestMolecule1 != NULL && "could not create first molecule");
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(-0.2418, 0.9350, 0. );
   TestMolecule1->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0.9658, 0., 0. );
   TestMolecule1->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = oxygen;
   *Walker->node = Vector(0., 0., 0. );
 …
   TestMolecule2 = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(TestMolecule2 != NULL && "could not create second molecule");
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(-0.2418, 0.9350, 0. );
   TestMolecule2->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0.9658, 0., 0. );
   TestMolecule2->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = oxygen;
   *Walker->node = Vector(0., 0., 0. );
 …
   molecules = World::getInstance().getMolecules();
+  CPPUNIT_ASSERT(molecules != NULL && "could not obtain list of molecules");
   molecules->insert(TestMolecule1);
   molecules->insert(TestMolecule2);
   // check that TestMolecule was correctly constructed
+  CPPUNIT_ASSERT_EQUAL( TestMolecule1->AtomCount, 3 );
+  Walker = TestMolecule1->start->next;
+  CPPUNIT_ASSERT( TestMolecule1->end != Walker );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule2->AtomCount, 3 );
+  Walker = TestMolecule2->start->next;
+  CPPUNIT_ASSERT( TestMolecule2->end != Walker );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule1->getAtomCount(), 3 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule2->getAtomCount(), 3 );
   // create a small file with table
   BG = new BondGraph(true);
+  CPPUNIT_ASSERT(BG != NULL && "could not create BondGraph");
   // construct bond graphs
 …
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
 };
 …
+{
   double *mirror = new double[3];
+  CPPUNIT_ASSERT(mirror != NULL && "could not create array of doubles");
   for (int i=0;i<3;i++)
     mirror[i] = -1.;

src/unittests/CountBondsUnitTest.hpp

-              rc39cc4
+              rbdb143
       molecule *TestMolecule1;
       molecule *TestMolecule2;
+      element *hydrogen;
+      element *oxygen;
+      periodentafel *tafel;
+      const element *hydrogen;
+      const element *oxygen;
       BondGraph *BG;

src/unittests/LinkedCellUnitTest.cpp

-              rc39cc4
+              rbdb143
   atom *Walker = NULL;
-  // init private all pointers to zero
-  TestMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  hydrogen->CovalentRadius = 0.23;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  CPPUNIT_ASSERT(hydrogen != NULL && "could not find element hydrogen");
   // construct molecule (water molecule)
   TestMolecule = World::getInstance().createMolecule();
+  CPPUNIT_ASSERT(TestMolecule != NULL && "could not create molecule");
   for (double x=0.5;x<3;x+=1.)
     for (double y=0.5;y<3;y+=1.)
       for (double z=0.5;z<3;z+=1.) {
         Walker = World::getInstance().createAtom();
+        CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
         Walker->type = hydrogen;
         *Walker->node = Vector(x, y, z );
 …
   // construct linked cell
   LC = new LinkedCell (TestMolecule, 1.);
+  CPPUNIT_ASSERT(LC != NULL && "could not create LinkedCell");
   // check that TestMolecule was correctly constructed
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 3*3*3 );
+  Walker = TestMolecule->start->next;
+  CPPUNIT_ASSERT( TestMolecule->end != Walker );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 3*3*3 );
 };
 …
   delete(LC);
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
 };
 …
+{
   // check all atoms
+  atom *Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    CPPUNIT_ASSERT_EQUAL( true, LC->SetIndexToNode(Walker) );
+  for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end();++iter){
+    CPPUNIT_ASSERT_EQUAL( true, LC->SetIndexToNode(*iter) );
+  }
   // check internal vectors, returns false, because this atom is not in LC-list!
   Walker = World::getInstance().createAtom();
   Walker->setName("test");
   Walker->x= Vector(1,1,1);
   CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
   World::getInstance().destroyAtom(Walker);
+  atom *newAtom = World::getInstance().createAtom();
+  newAtom->setName("test");
+  newAtom->x= Vector(1,1,1);
+  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(newAtom) );
+  World::getInstance().destroyAtom(newAtom);
   // check out of bounds vectors
   Walker = World::getInstance().createAtom();
   Walker->setName("test");
   Walker->x = Vector(0,-1,0);
   CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(Walker) );
   World::getInstance().destroyAtom(Walker);
+  newAtom = World::getInstance().createAtom();
+  newAtom->setName("test");
+  newAtom->x = Vector(0,-1,0);
+  CPPUNIT_ASSERT_EQUAL( false, LC->SetIndexToNode(newAtom) );
+  World::getInstance().destroyAtom(newAtom);
 };
 …
   Vector tester;
   LinkedCell::LinkedNodes *ListOfPoints = NULL;
-  atom *Walker = NULL;
   size_t size = 0;
 …
   size = ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)27, size );
+  Walker = TestMolecule->start;
+  Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    ListOfPoints->remove(Walker);
+  for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end(); ++iter){
+    ListOfPoints->remove((*iter));
     size--;
     CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
 …
   size=ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)8, size );
+  Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    if ((Walker->x[0] <2) && (Walker->x[1] <2) && (Walker->x[2] <2)) {
+      ListOfPoints->remove(Walker);
+  for(molecule::iterator iter = TestMolecule->begin(); iter != TestMolecule->end(); ++iter){
+    if (((*iter)->x[0] <2) && ((*iter)->x[1] <2) && ((*iter)->x[2] <2)) {
+      ListOfPoints->remove(*iter);
       size--;
       CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
 …
   size=ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)27, size );
+  Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    ListOfPoints->remove(Walker);
+  for(molecule::iterator iter = TestMolecule->begin(); iter!=TestMolecule->end();++iter){
+    ListOfPoints->remove(*iter);
     size--;
     CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );
 …
   Vector tester;
   LinkedCell::LinkedNodes *ListOfPoints = NULL;
-  atom *Walker = NULL;
   size_t size = 0;
 …
   size = ListOfPoints->size();
   CPPUNIT_ASSERT_EQUAL( (size_t)7, size );
+  Walker = TestMolecule->start;
+  while (Walker->next != TestMolecule->end) {
+    Walker = Walker->next;
+    if ((Walker->x.DistanceSquared(tester) - 1.) < MYEPSILON ) {
+      ListOfPoints->remove(Walker);
+  for(molecule::iterator iter = TestMolecule->begin(); iter!=TestMolecule->end();++iter){
+    if (((*iter)->x.DistanceSquared(tester) - 1.) < MYEPSILON ) {
+      ListOfPoints->remove(*iter);
       size--;
       CPPUNIT_ASSERT_EQUAL( size, ListOfPoints->size() );

src/unittests/LinkedCellUnitTest.hpp

-              rc39cc4
+              rbdb143
       molecule *TestMolecule;
+      element *hydrogen;
+      periodentafel *tafel;
+      const element *hydrogen;
       LinkedCell *LC;
 };

src/unittests/Makefile.am

-              rc39cc4
+              rbdb143
+# PLEASE adhere to the alphabetical ordering in this Makefile!
+# Also indentation by a single tab
 INCLUDES = -I$(top_srcdir)/src
 …
   MemoryAllocatorUnitTest \
   MoleculeDescriptorTest \
+  ObserverTest \
+  ParserUnitTest \
+  periodentafelTest \
   PlaneUnittest \
-  ObserverTest \
   SingletonTest \
   StackClassUnitTest \
 …
 GSLLIBS = ../libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_LIB}
 ALLLIBS = ../libmolecuilder.a ${GSLLIBS}
+PARSERLIBS = ../libparser.a ${ALLLIBS}
 TESTSOURCES = \
 …
   memoryusageobserverunittest.cpp \
   MoleculeDescriptorTest.cpp \
+  ObserverTest.cpp \
+  ParserUnitTest.cpp \
+  periodentafelTest.cpp \
   PlaneUnittest.cpp \
-  ObserverTest.cpp \
   SingletonTest.cpp \
   stackclassunittest.cpp \
 …
   memoryusageobserverunittest.hpp \
   MoleculeDescriptorTest.hpp \
+  periodentafelTest.hpp \
   PlaneUnittest.hpp \
   ObserverTest.hpp \
 …
+ActionSequenceTest_SOURCES = UnitTestMain.cpp ../../../TestRunnerClient.hpp ActionSequenceTest.cpp ActionSequenceTest.hpp
+ActionSequenceTest_LDADD = ${ALLLIBS}
 ActOnAllUnitTest_SOURCES = UnitTestMain.cpp ../test/ActOnAllTest.hpp ActOnAllUnitTest.cpp ActOnAllUnitTest.hpp
 ActOnAllUnitTest_LDADD = ${ALLLIBS}
 …
 atomsCalculationTest_LDADD = ${ALLLIBS}
+AtomDescriptorTest_SOURCES = UnitTestMain.cpp AtomDescriptorTest.cpp AtomDescriptorTest.hpp
+AtomDescriptorTest_LDADD = ${ALLLIBS}
 BondGraphUnitTest_SOURCES = UnitTestMain.cpp bondgraphunittest.cpp bondgraphunittest.hpp
 BondGraphUnitTest_LDADD = ${ALLLIBS}
+CacheableTest_SOURCES = UnitTestMain.cpp CacheableTest.cpp CacheableTest.hpp
+CacheableTest_LDADD = ${ALLLIBS}
 CountBondsUnitTest_SOURCES = UnitTestMain.cpp CountBondsUnitTest.cpp CountBondsUnitTest.hpp
 CountBondsUnitTest_LDADD = ${ALLLIBS}
 …
 LogUnitTest_LDADD = ${ALLLIBS}
+MemoryAllocatorUnitTest_SOURCES = UnitTestMain.cpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp
+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 memoryusageobserverunittest.cpp memoryusageobserverunittest.hpp
+MemoryUsageObserverUnitTest_SOURCES = UnitTestMain.cpp ../memoryallocator.hpp ../memoryusageobserver.cpp ../memoryusageobserver.hpp memoryusageobserverunittest.cpp memoryusageobserverunittest.hpp
 MemoryUsageObserverUnitTest_LDADD = ${ALLLIBS}
 …
 MoleculeDescriptorTest_LDADD = ${ALLLIBS}
+ObserverTest_SOURCES = UnitTestMain.cpp ObserverTest.cpp ObserverTest.hpp
+ObserverTest_LDADD = ${ALLLIBS}
+ParserUnitTest_SOURCES = UnitTestMain.cpp ParserUnitTest.cpp ParserUnitTest.hpp
+ParserUnitTest_LDADD = ${PARSERLIBS}
+periodentafelTest_SOURCES = UnitTestMain.cpp periodentafelTest.cpp periodentafelTest.hpp
+periodentafelTest_LDADD = ${ALLLIBS}
 PlaneUnittest_SOURCES = UnitTestMain.cpp PlaneUnittest.cpp PlaneUnittest.hpp
 PlaneUnittest_LDADD = ${ALLLIBS}
 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}
 VectorUnitTest_SOURCES = UnitTestMain.cpp vectorunittest.cpp vectorunittest.hpp
 VectorUnitTest_LDADD = ${ALLLIBS}
-ActionSequenceTest_SOURCES = UnitTestMain.cpp ../../../TestRunnerClient.hpp ActionSequenceTest.cpp ActionSequenceTest.hpp
-ActionSequenceTest_LDADD = ${ALLLIBS}
-ObserverTest_SOURCES = UnitTestMain.cpp ObserverTest.cpp ObserverTest.hpp
-ObserverTest_LDADD = ${ALLLIBS}
-CacheableTest_SOURCES = UnitTestMain.cpp CacheableTest.cpp CacheableTest.hpp
-CacheableTest_LDADD = ${ALLLIBS}
-AtomDescriptorTest_SOURCES = UnitTestMain.cpp AtomDescriptorTest.cpp AtomDescriptorTest.hpp
-AtomDescriptorTest_LDADD = ${ALLLIBS}
-manipulateAtomsTest_SOURCES = UnitTestMain.cpp manipulateAtomsTest.cpp manipulateAtomsTest.hpp
-manipulateAtomsTest_LDADD = ${ALLLIBS}
-TestRunner_SOURCES = UnitTestMain.cpp $(TESTSOURCES) $(TESTHEADERS)
-TestRunner_LDADD = ${ALLLIBS}
 #AUTOMAKE_OPTIONS = parallel-tests

src/unittests/ObserverTest.cpp

-              rc39cc4
+              rbdb143
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <cppunit/ui/text/TestRunner.h>
+#include <set>
 #include "Patterns/Observer.hpp"
+#include "Patterns/ObservedIterator.hpp"
 #include "Helpers/Assert.hpp"
 …
 public:
   UpdateCountObserver() :
+    Observer("UpdateCountObserver"),
     updates(0)
   {};
 …
 class SimpleObservable : public Observable {
 public:
+  SimpleObservable() :
+    Observable("SimpleObservable")
+  {}
   void changeMethod() {
     OBSERVE;
 …
 class CallObservable : public Observable {
 public:
+  CallObservable() :
+    Observable("CallObservable")
+  {}
   void changeMethod1() {
     OBSERVE;
 …
 class BlockObservable : public Observable {
 public:
+  BlockObservable() :
+    Observable("BlockObservable")
+  {}
   void changeMethod1(){
     OBSERVE;
 …
 class SuperObservable : public Observable {
 public:
+  SuperObservable(){
+  SuperObservable():
+    Observable("SuperObservable")
+  {
     subObservable = new SimpleObservable();
     subObservable->signOn(this);
 …
 public:
   NotificationObservable() :
+      notification1(new Notification(this)),
+      notification2(new Notification(this))
+    Observable("NotificationObservable"),
+    notification1(new Notification(this)),
+    notification2(new Notification(this))
   {}
 …
 public:
   NotificationObserver(Notification_ptr notification) :
+    Observer("NotificationObserver"),
     requestedNotification(notification),
     wasNotified(false)
 …
   bool wasNotified;
 };
+class ObservableCollection : public Observable {
+public:
+  typedef std::set<SimpleObservable*> set;
+  typedef ObservedIterator<set> iterator;
+  typedef set::const_iterator const_iterator;
+  ObservableCollection(int _num) :
+    Observable("ObservableCollection"),
+    num(_num)
+  {
+    for(int i=0; i<num; ++i){
+      SimpleObservable *content = new SimpleObservable();
+      content->signOn(this);
+      theSet.insert(content);
+    }
+  }
+  ~ObservableCollection(){
+    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;
+};
 /******************* actuall tests ***************/
 …
   blockObservable = new BlockObservable();
   notificationObservable = new NotificationObservable();
+  collection = new ObservableCollection(5);
   observer1 = new UpdateCountObserver();
 …
   notificationObserver1 = new NotificationObserver(notificationObservable->notification1);
   notificationObserver2 = new NotificationObserver(notificationObservable->notification2);
+}
 …
   delete blockObservable;
   delete notificationObservable;
+  delete collection;
   delete observer1;
 …
+}
+void ObserverTest::iteratorTest(){
+  int i = 0;
+  // test the general iterator methods
+  for(ObservableCollection::iterator iter=collection->begin(); iter!=collection->end();++iter){
+    CPPUNIT_ASSERT(i< collection->num);
+    i++;
+  }
+  i=0;
+  for(ObservableCollection::const_iterator iter=collection->begin(); iter!=collection->end();++iter){
+    CPPUNIT_ASSERT(i<collection->num);
+    i++;
+  }
+  collection->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){
+      (*iter)->changeMethod();
+    }
+    // At this point no change should have been propagated
+    CPPUNIT_ASSERT_EQUAL( 0, observer1->updates);
+  }
+  // After the Iterator has died the propagation should take place
+  CPPUNIT_ASSERT_EQUAL( 1, observer1->updates);
+  // when using a const_iterator no changes should be propagated
+  for(ObservableCollection::const_iterator iter = collection->begin(); iter!=collection->end();++iter);
+  CPPUNIT_ASSERT_EQUAL( 1, observer1->updates);
+  collection->signOff(observer1);
+}
 void ObserverTest::CircleDetectionTest() {
   cout << endl << "Warning: the next test involved methods that can produce infinite loops." << endl;
 …
   // 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

-              rc39cc4
+              rbdb143
 class CallObservable;
 class SuperObservable;
+class ObservableCollection;
 class BlockObservable;
 class NotificationObservable;
 class ObserverTest :  public CppUnit::TestFixture
 …
   CPPUNIT_TEST ( doesNotifyTest );
   CPPUNIT_TEST ( doesReportTest );
+  CPPUNIT_TEST ( iteratorTest );
   CPPUNIT_TEST ( CircleDetectionTest );
   CPPUNIT_TEST_SUITE_END();
 …
   void doesNotifyTest();
   void doesReportTest();
+  void iteratorTest();
   void CircleDetectionTest();
 …
   SuperObservable *superObservable;
   NotificationObservable *notificationObservable;
+  ObservableCollection *collection;
 };

src/unittests/SingletonTest.cpp

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

src/unittests/TestRunnerMain.cpp

rc39cc4	rbdb143
14	14	// give the main function its correct name
15	15	#define CPPUNIT_MAIN main
16
17	16	// include the TestRunnerClient file containing the main class
18	17	#include "../../../TestRunnerClient.h"

src/unittests/analysisbondsunittest.cpp

-              rc39cc4
+              rbdb143
 #include "molecule.hpp"
 #include "periodentafel.hpp"
+#include "World.hpp"
 #ifdef HAVE_TESTRUNNER
 …
   atom *Walker = NULL;
+  // init private all pointers to zero
+  TestMolecule = NULL;
+  hydrogen = NULL;
+  tafel = NULL;
+  // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  hydrogen->Valence = 1;
+  hydrogen->NoValenceOrbitals = 1;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  carbon = new element;
+  carbon->Z = 2;
+  carbon->Valence = 4;
+  carbon->NoValenceOrbitals = 4;
+  strcpy(carbon->name, "carbon");
+  strcpy(carbon->symbol, "C");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  tafel->AddElement(carbon);
+  // get elements
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  carbon = World::getInstance().getPeriode()->FindElement(6);
+  CPPUNIT_ASSERT(hydrogen != NULL && "could not find element hydrogen");
+  CPPUNIT_ASSERT(carbon != NULL && "could not find element carbon");
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::getInstance().createMolecule();
+  CPPUNIT_ASSERT(TestMolecule != NULL && "could not create molecule");
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(1.5, 0., 1.5 );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0., 1.5, 1.5 );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(1.5, 1.5, 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0., 0., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = carbon;
   *Walker->node = Vector(0.5, 0.5, 0.5 );
 …
   // check that TestMolecule was correctly constructed
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 5 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 5 );
   // create a small file with table
   filename = new string("test.dat");
+  CPPUNIT_ASSERT(filename != NULL && "could not create string");
   ofstream test(filename->c_str());
+  test << ".\tH\tC\n";
+  test << "H\t1.\t1.2\n";
+  test << "C\t1.2\t1.5\n";
+  test << ".\tH\tHe\tLi\tBe\tB\tC\n";
+  test << "H\t1.\t1.\t1.\t1.\t1.\t1.2\n";
+  test << "He\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "Li\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "Be\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "B\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "C\t1.2\t1.\t1.\t1.\t1.\t1.5\n";
   test.close();
   BG = new BondGraph(true);
+  CPPUNIT_ASSERT(BG != NULL && "could not create BondGraph");
   CPPUNIT_ASSERT_EQUAL( true , BG->LoadBondLengthTable(*filename) );
   CPPUNIT_ASSERT_EQUAL( 1., BG->GetBondLength(0,0) );
   CPPUNIT_ASSERT_EQUAL( 1.2, BG->GetBondLength(0,1) );
   CPPUNIT_ASSERT_EQUAL( 1.5, BG->GetBondLength(1,1) );
+  CPPUNIT_ASSERT_EQUAL( 1.2, BG->GetBondLength(0,5) );
+  CPPUNIT_ASSERT_EQUAL( 1.5, BG->GetBondLength(5,5) );
   BG->ConstructBondGraph(TestMolecule);

src/unittests/analysisbondsunittest.hpp

-              rc39cc4
+              rbdb143
       molecule *TestMolecule;
+      element *hydrogen;
+      element *carbon;
+      periodentafel *tafel;
+      const element *hydrogen;
+      const element *carbon;
       BondGraph *BG;

src/unittests/bondgraphunittest.cpp

-              rc39cc4
+              rbdb143
 #include <stdio.h>
 #include <cstring>
+#include "Helpers/Assert.hpp"
 #include "World.hpp"
 …
   atom *Walker = NULL;
-  // init private all pointers to zero
-  TestMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  hydrogen->CovalentRadius = 0.23;
+  hydrogen->VanDerWaalsRadius = 1.09;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  carbon = new element;
+  carbon->Z = 2;
+  carbon->CovalentRadius = 0.68;
+  carbon->VanDerWaalsRadius = 1.7;
+  strcpy(carbon->name, "carbon");
+  strcpy(carbon->symbol, "C");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  tafel->AddElement(carbon);
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  carbon = World::getInstance().getPeriode()->FindElement(6);
+  CPPUNIT_ASSERT(hydrogen != NULL && "could not find element hydrogen");
+  CPPUNIT_ASSERT(carbon != NULL && "could not find element carbon");
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::getInstance().createMolecule();
+  CPPUNIT_ASSERT(TestMolecule != NULL && "could not create molecule");
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = carbon;
   *Walker->node = Vector(1., 0., 1. );
 …
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = carbon;
   *Walker->node = Vector(0., 1., 1. );
 …
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = carbon;
   *Walker->node = Vector(1., 1., 0. );
 …
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = carbon;
   *Walker->node = Vector(0., 0., 0. );
 …
   // check that TestMolecule was correctly constructed
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
   // create a small file with table
   dummyname = new string("dummy.dat");
+  CPPUNIT_ASSERT(dummyname != NULL && "could not create string");
   filename = new string("test.dat");
+  CPPUNIT_ASSERT(filename != NULL && "could not create string");
   ofstream test(filename->c_str());
+  test << ".\tH\tC\n";
+  test << "H\t1.\t1.2\n";
+  test << "C\t1.2\t1.5\n";
+  test << ".\tH\tHe\tLi\tBe\tB\tC\n";
+  test << "H\t1.\t1.\t1.\t1.\t1.\t1.2\n";
+  test << "He\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "Li\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "Be\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "B\t1.\t1.\t1.\t1.\t1.\t1.\n";
+  test << "C\t1.2\t1.\t1.\t1.\t1.\t1.5\n";
   test.close();
   BG = new BondGraph(true);
+  CPPUNIT_ASSERT(BG != NULL && "could not create BondGraph");
 };
 …
   // are all cleaned when the world is destroyed
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
+};
+/** Tests whether setup worked.
+ */
+void BondGraphTest::SetupTest()
+{
+  CPPUNIT_ASSERT_EQUAL (false, TestMolecule->empty());
+  CPPUNIT_ASSERT_EQUAL ((size_t)4, TestMolecule->size());
 };
 …
   CPPUNIT_ASSERT_EQUAL( true , BG->LoadBondLengthTable(*filename) );
   CPPUNIT_ASSERT_EQUAL( 1., BG->GetBondLength(0,0) );
   CPPUNIT_ASSERT_EQUAL( 1.2, BG->GetBondLength(0,1) );
   CPPUNIT_ASSERT_EQUAL( 1.5, BG->GetBondLength(1,1) );
+  CPPUNIT_ASSERT_EQUAL( 1.2, BG->GetBondLength(0,5) );
+  CPPUNIT_ASSERT_EQUAL( 1.5, BG->GetBondLength(5,5) );
 };
 …
 void BondGraphTest::ConstructGraphFromTableTest()
+{
   atom *Walker = TestMolecule->start->next;
   atom *Runner = TestMolecule->end->previous;
   CPPUNIT_ASSERT( TestMolecule->end != Walker );
+  molecule::iterator Walker = TestMolecule->begin();
+  molecule::iterator Runner = TestMolecule->begin();
+  Runner++;
   CPPUNIT_ASSERT_EQUAL( true , BG->LoadBondLengthTable(*filename) );
   CPPUNIT_ASSERT_EQUAL( true , BG->ConstructBondGraph(TestMolecule) );
   CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
+  CPPUNIT_ASSERT_EQUAL( true , (*Walker)->IsBondedTo((*Runner)) );
 };
 …
 void BondGraphTest::ConstructGraphFromCovalentRadiiTest()
+{
+  atom *Walker = TestMolecule->start->next;
+  atom *Runner = TestMolecule->end->previous;
+  CPPUNIT_ASSERT( TestMolecule->end != Walker );
+  //atom *Walker = TestMolecule->start->next;
+  //atom *Runner = TestMolecule->end->previous;
+  //CPPUNIT_ASSERT( TestMolecule->end != Walker );
   CPPUNIT_ASSERT_EQUAL( false , BG->LoadBondLengthTable(*dummyname) );
   CPPUNIT_ASSERT_EQUAL( true , BG->ConstructBondGraph(TestMolecule) );
+  CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
+  // this cannot be assured using dynamic IDs
+  //CPPUNIT_ASSERT_EQUAL( true , Walker->IsBondedTo(Runner) );
 };

src/unittests/bondgraphunittest.hpp

-              rc39cc4
+              rbdb143
+{
     CPPUNIT_TEST_SUITE( BondGraphTest) ;
+    CPPUNIT_TEST ( SetupTest );
     CPPUNIT_TEST ( LoadTableTest );
     CPPUNIT_TEST ( ConstructGraphFromTableTest );
 …
       void setUp();
       void tearDown();
+      void SetupTest();
       void LoadTableTest();
       void ConstructGraphFromTableTest();
 …
       molecule *TestMolecule;
+      element *hydrogen;
+      element *carbon;
+      periodentafel *tafel;
+      const element *hydrogen;
+      const element *carbon;
       BondGraph *BG;

src/unittests/listofbondsunittest.cpp

-              rc39cc4
+              rbdb143
   atom *Walker = NULL;
-  // init private all pointers to zero
-  TestMolecule = NULL;
-  hydrogen = NULL;
-  tafel = NULL;
   // construct element
+  hydrogen = new element;
+  hydrogen->Z = 1;
+  strcpy(hydrogen->name, "hydrogen");
+  strcpy(hydrogen->symbol, "H");
+  // construct periodentafel
+  tafel = World::getInstance().getPeriode();
+  tafel->AddElement(hydrogen);
+  hydrogen = World::getInstance().getPeriode()->FindElement(1);
+  CPPUNIT_ASSERT(hydrogen != NULL && "could not find element hydrogen");
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(TestMolecule != NULL && "could not create molecule");
+  Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::getInstance().createAtom();
+  CPPUNIT_ASSERT(Walker != NULL && "could not create atom");
   Walker->type = hydrogen;
   *Walker->node = Vector(0., 0., 0. );
 …
   // check that TestMolecule was correctly constructed
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
+  CPPUNIT_ASSERT_EQUAL( TestMolecule->getAtomCount(), 4 );
 };
 …
   // are all cleaned when the world is destroyed
   World::purgeInstance();
-  MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
 };
+/** Tests whether setup worked correctly.
+ *
+ */
+void ListOfBondsTest::SetupTest()
+{
+  CPPUNIT_ASSERT_EQUAL( false, TestMolecule->empty() );
+  CPPUNIT_ASSERT_EQUAL( (size_t)4, TestMolecule->size() );
+};
 /** Unit Test of molecule::AddBond()
+ *
 …
+{
   bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  CPPUNIT_ASSERT( atom1 != NULL );
+  CPPUNIT_ASSERT( atom2 != NULL );
+  // add bond
+  Binder = TestMolecule->AddBond(atom1, atom2, 1);
+  CPPUNIT_ASSERT( Binder != NULL );
+  bond *TestBond = TestMolecule->first->next;
+  CPPUNIT_ASSERT_EQUAL ( TestBond, Binder );
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
+  CPPUNIT_ASSERT( atom1 != NULL );
+  CPPUNIT_ASSERT( atom2 != NULL );
+  // add bond
+  Binder = TestMolecule->AddBond(atom1, atom2, 1);
+  CPPUNIT_ASSERT( Binder != NULL );
+  CPPUNIT_ASSERT_EQUAL ( true, TestMolecule->hasBondStructure() );
   // check that bond contains the two atoms
 …
+{
   bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
 …
   // check if removed from molecule
   CPPUNIT_ASSERT_EQUAL( TestMolecule->first->next, TestMolecule->last );
+  CPPUNIT_ASSERT_EQUAL( false, TestMolecule->hasBondStructure() );
 };
 …
+{
   bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  atom *atom3 = atom2->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
+  iter++;
+  atom *atom3 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
 …
   // check if removed from molecule
   CPPUNIT_ASSERT_EQUAL( TestMolecule->first->next, Binder );
   CPPUNIT_ASSERT_EQUAL( Binder->next, TestMolecule->last );
+  CPPUNIT_ASSERT_EQUAL( true, TestMolecule->hasBondStructure() );
+  CPPUNIT_ASSERT_EQUAL( (unsigned int)1, TestMolecule->CountBonds() );
 };
 …
+{
   bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
 …
   // check if removed from molecule
   CPPUNIT_ASSERT_EQUAL( TestMolecule->first->next, TestMolecule->last );
+  CPPUNIT_ASSERT_EQUAL( false, TestMolecule->hasBondStructure() );
 };
 …
+{
   bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  molecule::iterator iter = TestMolecule->begin();
+  atom *atom1 = *iter;
+  iter++;
+  atom *atom2 = *iter;
   CPPUNIT_ASSERT( atom1 != NULL );
   CPPUNIT_ASSERT( atom2 != NULL );
 …
   // check if removed from molecule
   CPPUNIT_ASSERT_EQUAL( TestMolecule->first->next, TestMolecule->last );
+  CPPUNIT_ASSERT_EQUAL( false, TestMolecule->hasBondStructure() );
 };
 …
 void ListOfBondsTest::DeleteAtomTest()
+{
+  bond *Binder = NULL;
+  atom *atom1 = TestMolecule->start->next;
+  atom *atom2 = atom1->next;
+  CPPUNIT_ASSERT( atom1 != NULL );
+  CPPUNIT_ASSERT( atom2 != NULL );
+  // add bond
+  Binder = TestMolecule->AddBond(atom1, atom2, 1);
+  CPPUNIT_ASSERT( Binder != NULL );
+  atom *atom1 = NULL;
+  atom *atom2 = NULL;
+  bond *Binder = NULL;
+  {
+    molecule::iterator iter = TestMolecule->begin();
+    atom1 = *iter;
+    iter++;
+    atom2 = *iter;
+  }
+  CPPUNIT_ASSERT( atom1 != NULL );
+  CPPUNIT_ASSERT( atom2 != NULL );
+  // add bond
+  Binder = TestMolecule->AddBond(atom1, atom2, 1);
+  CPPUNIT_ASSERT( Binder != NULL );
+  CPPUNIT_ASSERT_EQUAL( (size_t) 1, atom1->ListOfBonds.size() );
+  CPPUNIT_ASSERT_EQUAL( (size_t) 1, atom2->ListOfBonds.size() );
+  CPPUNIT_ASSERT_EQUAL( true, TestMolecule->hasBondStructure() );
   // remove atom2
 …
   // check if removed from molecule
   CPPUNIT_ASSERT_EQUAL( TestMolecule->first->next, TestMolecule->last );
 };
+  CPPUNIT_ASSERT_EQUAL( false, TestMolecule->hasBondStructure() );
+};

src/unittests/listofbondsunittest.hpp

-              rc39cc4
+              rbdb143
+{
     CPPUNIT_TEST_SUITE( ListOfBondsTest) ;
+    CPPUNIT_TEST ( SetupTest );
     CPPUNIT_TEST ( AddingBondTest );
     CPPUNIT_TEST ( RemovingBondTest );
 …
       void setUp();
       void tearDown();
+      void SetupTest();
       void AddingBondTest();
       void RemovingBondTest();
 …
       molecule *TestMolecule;
+      element *hydrogen;
+      periodentafel *tafel;
+      const element *hydrogen;
 };

src/unittests/manipulateAtomsTest.cpp

-              rc39cc4
+              rbdb143
 public:
   countObserver() :
+    Observer("countObserver"),
     count(0)
     {}
 …
 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/memoryallocatorunittest.cpp

rc39cc4	rbdb143
12	12	#include "memoryallocator.hpp"
13	13	#include "memoryallocatorunittest.hpp"
	14	#include "memoryusageobserver.hpp"
14	15	#include "helpers.hpp"
15	16	#include "log.hpp"

src/unittests/stackclassunittest.cpp

rc39cc4	rbdb143
37	37	Stack->ClearStack();
38	38	delete(Stack);
39		~~MemoryUsageObserver::purgeInstance();~~
40	39	logger::purgeInstance();
41	40	};

src/unittests/tesselation_boundarytriangleunittest.cpp

rc39cc4	rbdb143
70	70	delete tesselpoints[i];
71	71	}
72		~~MemoryUsageObserver::purgeInstance();~~
73	72	logger::purgeInstance();
74	73	errorLogger::purgeInstance();

src/unittests/tesselation_insideoutsideunittest.cpp

rc39cc4	rbdb143
134	134	}
135	135	Corners.clear();
136		~~MemoryUsageObserver::purgeInstance();~~
137	136	logger::purgeInstance();
138	137	errorLogger::purgeInstance();

src/unittests/tesselationunittest.cpp

rc39cc4	rbdb143
106	106	}
107	107	Corners.clear();
108		~~MemoryUsageObserver::purgeInstance();~~
109	108	logger::purgeInstance();
110	109	errorLogger::purgeInstance();

src/unittests/vectorunittest.cpp

rc39cc4	rbdb143
49	49	void VectorTest::tearDown()
50	50	{
51		~~MemoryUsageObserver::purgeInstance();~~
52	51	logger::purgeInstance();
53	52	errorLogger::purgeInstance();

src/valence.db

rc39cc4	rbdb143
	1	#atomicnumber numberofvalenceorbitals
1	2	1 0.10000000000000E+01
2	3	2 0.20000000000000E+01

src/vector.cpp

-              rc39cc4
+              rbdb143
  */
+#include "Helpers/MemDebug.hpp"
 #include "vector.hpp"
 …
 Vector::Vector()
+{
   x[0] = x[1] = x[2] = 0.;
+  content = gsl_vector_calloc (NDIM);
 };
 …
 Vector::Vector(const Vector& src)
+{
+  x[0] = src[0];
+  x[1] = src[1];
+  x[2] = src[2];
+  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]);
+}
 …
 Vector::Vector(const double x1, const double x2, const double x3)
+{
+  x[0] = x1;
+  x[1] = x2;
+  x[2] = x3;
+  content = gsl_vector_alloc(NDIM);
+  gsl_vector_set(content,0,x1);
+  gsl_vector_set(content,1,x2);
+  gsl_vector_set(content,2,x3);
 };
 …
   // check for self assignment
   if(&src!=this){
     x[0] = src[0];
     x[1] = src[1];
     x[2] = src[2];
+    gsl_vector_set(content,0,src[0]);
+    gsl_vector_set(content,1,src[1]);
+    gsl_vector_set(content,2,src[2]);
+  }
   return *this;
 …
 /** Desctructor of class vector.
  */
+Vector::~Vector() {};
+Vector::~Vector() {
+  gsl_vector_free(content);
+};
 /** Calculates square of distance between this and another vector.
 …
   double res = 0.;
   for (int i=NDIM;i--;)
     res += (x[i]-y[i])*(x[i]-y[i]);
+    res += (at(i)-y[i])*(at(i)-y[i]);
   return (res);
 };
 …
   double res = 0.;
   for (int i=NDIM;i--;)
     res += x[i]*y[i];
+    res += at(i)*y[i];
   return (res);
 };
 …
+{
   Vector tmp;
+  tmp[0] = x[1]* y[2] - x[2]* y[1];
+  tmp[1] = x[2]* y[0] - x[0]* y[2];
+  tmp[2] = x[0]* y[1] - x[1]* y[0];
+  for(int i=NDIM;i--;)
+    tmp[i] = at((i+1)%NDIM)*y[(i+2)%NDIM] - at((i+2)%NDIM)*y[(i+1)%NDIM];
   (*this) = tmp;
 };
 …
 bool Vector::IsZero() const
+{
   return (fabs(x[0])+fabs(x[1])+fabs(x[2]) < MYEPSILON);
+  return (fabs(at(0))+fabs(at(1))+fabs(at(2)) < MYEPSILON);
 };
 …
   bool status = true;
   for (int i=0;i<NDIM;i++) {
     if (fabs(x[i] - a[i]) > MYEPSILON)
+    if (fabs(at(i) - a[i]) > MYEPSILON)
       status = false;
+  }
 …
 double& Vector::operator[](size_t i){
   ASSERT(i<=NDIM && i>=0,"Vector Index out of Range");
   return x[i];
+  return *gsl_vector_ptr (content, i);
+}
 const double& Vector::operator[](size_t i) const{
   ASSERT(i<=NDIM && i>=0,"Vector Index out of Range");
   return x[i];
+  return *gsl_vector_ptr (content, i);
+}
 …
+}
 double* Vector::get(){
   return x;
+gsl_vector* Vector::get(){
+  return content;
+}
 …
+{
   for (int i=NDIM;i--;)
     x[i] *= factor[i];
+    at(i) *= factor[i];
 };
 …
+{
   for (int i=NDIM;i--;)
     x[i] *= factor;
+    at(i) *= factor;
 };
 …
   // truncate to [0,1] for each axis
   for (int i=0;i<NDIM;i++) {
     x[i] += 0.5;  // set to center of box
     while (x[i] >= 1.)
       x[i] -= 1.;
     while (x[i] < 0.)
       x[i] += 1.;
+    //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);
 …
 void Vector::MatrixMultiplication(const double * const M)
+{
+  Vector tmp;
   // do the matrix multiplication
+  at(0) = M[0]*x[0]+M[3]*x[1]+M[6]*x[2];
+  at(1) = M[1]*x[0]+M[4]*x[1]+M[7]*x[2];
+  at(2) = M[2]*x[0]+M[5]*x[1]+M[8]*x[2];
+  for(int i=NDIM;i--;)
+    tmp[i] = M[i]*at(0)+M[i+3]*at(1)+M[i+6]*at(2);
+  (*this) = tmp;
 };
 …
     B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);    // A_33
+    // do the matrix multiplication
+    at(0) = B[0]*x[0]+B[3]*x[1]+B[6]*x[2];
+    at(1) = B[1]*x[0]+B[4]*x[1]+B[7]*x[2];
+    at(2) = B[2]*x[0]+B[5]*x[1]+B[8]*x[2];
+    MatrixMultiplication(B);
     return true;
 …
   SubtractVector(x1);
   for (int i=NDIM;i--;)
     result = result || (fabs(x[i]) > MYEPSILON);
+    result = result || (fabs(at(i)) > MYEPSILON);
   return result;
 …
+{
   for(int i=NDIM;i--;)
     x[i] += y[i];
+    at(i) += y[i];
+}
 …
+{
   for(int i=NDIM;i--;)
     x[i] -= y[i];
+    at(i) -= y[i];
+}

src/vector.hpp

-              rc39cc4
+              rbdb143
  */
 class Vector : public Space{
-protected:
-  // this struct is used to indicate calls to the Baseconstructor from inside vectors.
-  struct Baseconstructor{};
 public:
 …
   // Access to internal structure
   double* get();
+  gsl_vector* get();
   // Methods that are derived directly from other methods
 …
 private:
   double x[NDIM];
+  gsl_vector *content;
 };

src/vector_ops.cpp

rc39cc4	rbdb143
5	5	* Author: crueger
6	6	*/
	7
	8	#include "Helpers/MemDebug.hpp"
7	9
8	10	#include "vector.hpp"

src/verbose.cpp

rc39cc4	rbdb143
1	1	using namespace std;
	2
	3	#include "Helpers/MemDebug.hpp"
2	4
3	5	#include "info.hpp"

tests/Makefile.am

-              rc39cc4
+              rbdb143
+AUTOM4TE = autom4te
+EXTRA_DIST = testsuite.at $(TESTSUITE) atlocal.in regression
+TESTSUITE = $(srcdir)/testsuite
+SUBDIRS = regression Tesselations
-SUBDIRS = Tesselations
-check-local: atconfig atlocal package.m4 $(TESTSUITE)
-                $(SHELL) '$(TESTSUITE)' $(TESTSUITEFLAGS)
-installcheck-local: atconfig atlocal $(TESTSUITE)
-                $(SHELL) '$(TESTSUITE)' AUTOTEST_PATH='$(bindir)' \
-                $(TESTSUITEFLAGS)
-clean-local:
-                test ! -f '$(TESTSUITE)' || \
-                $(SHELL) '$(TESTSUITE)' --clean
-AUTOTEST = $(AUTOM4TE) --language=autotest
-$(TESTSUITE): $(srcdir)/testsuite.at
-                $(AUTOTEST) -I '$(srcdir)' -o $@.tmp $@.at
-                mv $@.tmp $@
-# The `:;' works around a Bash 3.2 bug when the output is not writeable.
-$(srcdir)/package.m4: $(top_srcdir)/configure.ac
-                        :;{ \
-                                        echo '# Signature of the current package.' && \
-                                        echo 'm4_define([AT_PACKAGE_NAME],      [@PACKAGE_NAME@])' && \
-                                        echo 'm4_define([AT_PACKAGE_TARNAME],   [@PACKAGE_TARNAME@])' && \
-                                        echo 'm4_define([AT_PACKAGE_VERSION],   [@PACKAGE_VERSION@])' && \
-                                        echo 'm4_define([AT_PACKAGE_STRING],    [@PACKAGE_STRING@])' && \
-                                        echo 'm4_define([AT_PACKAGE_BUGREPORT], [@PACKAGE_BUGREPORT@])'; \
-                                } >'$(srcdir)/package.m4'

tests/Tesselations/defs.in

-              rc39cc4
+              rbdb143
         CLEANUP="$CLEANUP; rm -rf $testdir"
         cp -r @srcdir@/$testdir/* $testdir/
-        cd $testdir
         CLEANUP="rm -f stderr stdout diffstderr diffstdout; cd ..; $CLEANUP"
         CLEANUP="rm -f *.conf*; rm -f NonConvexEnvelope*; rm -f ${testdir}.xyz; rm -f ${testdir}.dbond; $CLEANUP"
 …
         FILENAME="NonConvexEnvelope"
         exitcode=0
         cd $RADIUS
+        cd $testdir/$RADIUS
         #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 $RADIUS $FILENAME 2>stderr >stdout || exitcode=$?
+                $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -A $mol.dbond -N 0 --sphere-radius $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
         else
                 $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -N $RADIUS $FILENAME 2>stderr >stdout || exitcode=$?
+                $MOLECUILDER $mol.conf -e $exec_prefix -p ../$mol.xyz -N 0 --sphere-radius $RADIUS --nonconvex-file $FILENAME 2>stderr >stdout || exitcode=$?
         fi
         #echo "Molecuilder done with exitcode $exitcode."
         #cat stderr
         #cat stdout
+        diff ${FILENAME}.dat ../@srcdir@/$mol/$2/${FILENAME}-$mol.dat 2>diffstderr >diffstdout || exitcode=$?
+        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=$?
         #echo "Diff done with exitcode $exitcode."
         #cat diffstderr
         #cat diffstdout
         cd ..
+        cd ../..
         test $exitcode = $expected_exitcode || exit 1
+}

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

-              rc39cc4
+              rbdb143
 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
+-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 27.0641
+-2.4985 -1.22006 -0.849545 19.9769
+-2.4985 -1.22006 0.930455 27.4727
+.4985 -1.22006 0.930455 19.9769
+.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 12.1988
+-7.27e-07 -0.590759 0.0404545 23.0174
+-1.2492 0.292641 0.0404545 23.0167
+.2492 0.292641 0.0404545 20.1632
+-2.4985 -0.590759 0.0404545 18.9798
+.4985 -0.590759 0.0404545 18.9798
+-3.7477 0.292641 0.0404545 39.5267
+.7477 0.292641 0.0404545 23.2512
 15 23
 …
 18 19
 5 18
+18 19
+6 18
 4 18
 4 18
-18 19
-6 19
 18 22
 13 22
 …
 13 22
 13 22
+19 23
+16 19
+16 23
+16 23
+14 23
+16 23
+19 23
+16 23
 13 22
 13 22
 …
 11 22
 12 22
+16 23
+16 23
+14 23
+16 23
+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
 …
 17 20
 7 20
-17 20
-8 20
 8 20
 8 20
 11 20
 11 20
+17 20
+8 17

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

-              rc39cc4
+              rbdb143
 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

-              rc39cc4
+              rbdb143
 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

-              rc39cc4
+              rbdb143
 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

-              rc39cc4
+              rbdb143
 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

-              rc39cc4
+              rbdb143
 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

-              rc39cc4
+              rbdb143
 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/Simple_configuration/2/post/test.conf

-              rc39cc4
+              rbdb143
 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/2/post/test.conf.xyz

rc39cc4	rbdb143
1	1	1
2	2	Created by molecuilder on Tue Oct 6 18:34:23 2009
3		H 10 10 10
	3	H 10 10 10

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

-              rc39cc4
+              rbdb143
 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.xyz

rc39cc4	rbdb143
1	1	1
2	2	Created by molecuilder on Tue Oct 6 18:34:23 2009
3		H 10 10 10
	3	H 10 10 10

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

-              rc39cc4
+              rbdb143
 RelEpsTotalE    1e-07   # relative change in total energy
 RelEpsKineticE  1e-05   # relative change in kinetic energy
 MaxMinStopStep  0       # check every ..th steps
+MaxMinStopStep  2       # 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      2       # 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    2       # here: specifying both maximum number of SpinUp- and -Down-states
+PsiMaxNoUp      2       # here: specifying maximum number of SpinUp-states
+PsiMaxNoDown    2       # here: specifying maximum number of SpinDown-states
 AddPsis         0       # Additional unoccupied Psis for bandgap determination

tests/regression/Simple_configuration/4/post/test.conf.xyz

rc39cc4	rbdb143
1	1	1
2	2	Created by molecuilder on Tue Oct 6 18:31:23 2009
3		C 10 10 10
	3	C 10 10 10

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

-              rc39cc4
+              rbdb143
 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/1/post/NonConvexEnvelope.r3d

rc39cc4	rbdb143
3	3	# All atoms as spheres
4	4	2
5		1.~~37419 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	5	1.24926 -0.870237 -0.89 0.1 1. 1. 1.
6	6	2
7		~~0.12489 0.61837 -4.44089e-16~~ 0.1 1. 1. 1.
	7	1.24926 -0.870237 0.89 0.1 1. 1. 1.
8	8	2
9		~~-1.12431 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	9	2.13922 0.388414 0 0.1 1. 1. 1.
10	10	2
11		~~1.37419 -0.89433~~ -0.89 0.1 1. 1. 1.
	11	-3.63639e-05 1.27176 -0.89 0.1 1. 1. 1.
12	12	2
13		~~1.37419 -0.89433~~ 0.89 0.1 1. 1. 1.
	13	-3.63639e-05 1.27176 0.89 0.1 1. 1. 1.
14	14	2
15		~~2.26414 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	15	-2.13919 0.388414 0 0.1 1. 1. 1.
16	16	2
17		~~0.12489 1.2476~~7 -0.89 0.1 1. 1. 1.
	17	-1.24924 -0.870237 -0.89 0.1 1. 1. 1.
18	18	2
19		~~0.12489 1.2476~~7 0.89 0.1 1. 1. 1.
	19	-1.24924 -0.870237 0.89 0.1 1. 1. 1.
20	20	2
21		~~-2.01426 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	21	1.24926 -0.240937 0 0.1 1. 1. 1.
22	22	2
23		-~~1.12431 -0.89433 -0.89~~ 0.1 1. 1. 1.
	23	-3.63639e-05 0.642463 0 0.1 1. 1. 1.
24	24	2
25		-1.~~12431 -0.89433 0.89~~ 0.1 1. 1. 1.
	25	-1.24924 -0.240937 0 0.1 1. 1. 1.
26	26	# All tesselation triangles
27	27	8
…	…
30	30	BACKFACE 0.3 0.3 1.0 0 0
31	31	1
32		1.~~37419 -0.89433 -0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ -0.89 1. 0. 0.
	32	1.24926 -0.870237 -0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 1. 0. 0.
33	33	1
34		1.~~37419 -0.89433 -0.89 0.12489 1.24767 -0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	34	1.24926 -0.870237 -0.89 -3.63639e-05 1.27176 -0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
35	35	1
36		~~0.12489 1.24767 -0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	36	-3.63639e-05 1.27176 -0.89 -2.13919 0.388414 0 -1.24924 -0.870237 -0.89 1. 0. 0.
37	37	1
38		2.~~26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767~~ 0.89 1. 0. 0.
	38	2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 1. 0. 0.
39	39	1
40		~~0.12489 1.24767 -0.89 0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16~~ 1. 0. 0.
	40	-3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 1. 0. 0.
41	41	1
42		1.~~37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ 0.89 1. 0. 0.
	42	1.24926 -0.870237 0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 0.89 1. 0. 0.
43	43	1
44		1.~~37419 -0.89433 0.89 0.12489 1.24767 0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	44	1.24926 -0.870237 0.89 -3.63639e-05 1.27176 0.89 -1.24924 -0.870237 0.89 1. 0. 0.
45	45	1
46		~~0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	46	-3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 -1.24924 -0.870237 0.89 1. 0. 0.
47	47	1
48		-2.~~01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	48	-2.13919 0.388414 0 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
49	49	1
50		1.~~37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	50	1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
51	51	1
52		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	52	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
53	53	1
54		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16~~ 1. 0. 0.
	54	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 2.13922 0.388414 0 1. 0. 0.
55	55	9
56	56	# terminating special property
…	…
59	59	25.0 0.6 -1.0 -1.0 -1.0 0.2 0 0 0 0
60	60	2
61		1.~~67084 -0.47478 -8.88178~~e-16 5 1 0 0
	61	1.54591 -0.450686 -4.44089e-16 5 1 0 0
62	62	9
63	63	terminating special property

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

-              rc39cc4
+              rbdb143
 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.r3d

rc39cc4	rbdb143
3	3	# All atoms as spheres
4	4	2
5		1.~~37419 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	5	1.24926 -0.870237 -0.89 0.1 1. 1. 1.
6	6	2
7		~~0.12489 0.61837 -4.44089e-16~~ 0.1 1. 1. 1.
	7	1.24926 -0.870237 0.89 0.1 1. 1. 1.
8	8	2
9		~~-1.12431 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	9	2.13922 0.388414 0 0.1 1. 1. 1.
10	10	2
11		~~1.37419 -0.89433~~ -0.89 0.1 1. 1. 1.
	11	-3.63639e-05 1.27176 -0.89 0.1 1. 1. 1.
12	12	2
13		~~1.37419 -0.89433~~ 0.89 0.1 1. 1. 1.
	13	-3.63639e-05 1.27176 0.89 0.1 1. 1. 1.
14	14	2
15		~~2.26414 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	15	-2.13919 0.388414 0 0.1 1. 1. 1.
16	16	2
17		~~0.12489 1.2476~~7 -0.89 0.1 1. 1. 1.
	17	-1.24924 -0.870237 -0.89 0.1 1. 1. 1.
18	18	2
19		~~0.12489 1.2476~~7 0.89 0.1 1. 1. 1.
	19	-1.24924 -0.870237 0.89 0.1 1. 1. 1.
20	20	2
21		~~-2.01426 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	21	1.24926 -0.240937 0 0.1 1. 1. 1.
22	22	2
23		-~~1.12431 -0.89433 -0.89~~ 0.1 1. 1. 1.
	23	-3.63639e-05 0.642463 0 0.1 1. 1. 1.
24	24	2
25		-1.~~12431 -0.89433 0.89~~ 0.1 1. 1. 1.
	25	-1.24924 -0.240937 0 0.1 1. 1. 1.
26	26	# All tesselation triangles
27	27	8
…	…
30	30	BACKFACE 0.3 0.3 1.0 0 0
31	31	1
32		1.~~37419 -0.89433 -0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ -0.89 1. 0. 0.
	32	1.24926 -0.870237 -0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 1. 0. 0.
33	33	1
34		1.~~37419 -0.89433 -0.89 0.12489 1.24767 -0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	34	1.24926 -0.870237 -0.89 -3.63639e-05 1.27176 -0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
35	35	1
36		~~0.12489 1.24767 -0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	36	-3.63639e-05 1.27176 -0.89 -2.13919 0.388414 0 -1.24924 -0.870237 -0.89 1. 0. 0.
37	37	1
38		2.~~26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767~~ 0.89 1. 0. 0.
	38	2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 1. 0. 0.
39	39	1
40		~~0.12489 1.24767 -0.89 0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16~~ 1. 0. 0.
	40	-3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 1. 0. 0.
41	41	1
42		1.~~37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ 0.89 1. 0. 0.
	42	1.24926 -0.870237 0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 0.89 1. 0. 0.
43	43	1
44		1.~~37419 -0.89433 0.89 0.12489 1.24767 0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	44	1.24926 -0.870237 0.89 -3.63639e-05 1.27176 0.89 -1.24924 -0.870237 0.89 1. 0. 0.
45	45	1
46		~~0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	46	-3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 -1.24924 -0.870237 0.89 1. 0. 0.
47	47	1
48		-2.~~01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	48	-2.13919 0.388414 0 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
49	49	1
50		1.~~37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	50	1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
51	51	1
52		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	52	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
53	53	1
54		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16~~ 1. 0. 0.
	54	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 2.13922 0.388414 0 1. 0. 0.
55	55	9
56	56	# terminating special property
…	…
59	59	25.0 0.6 -1.0 -1.0 -1.0 0.2 0 0 0 0
60	60	2
61		1.~~67084 -0.47478 -8.88178~~e-16 5 1 0 0
	61	1.54591 -0.450686 -4.44089e-16 5 1 0 0
62	62	9
63	63	terminating special property

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

-              rc39cc4
+              rbdb143
 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.r3d

rc39cc4	rbdb143
3	3	# All atoms as spheres
4	4	2
5		1.~~37419 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	5	1.24926 -0.870237 -0.89 0.1 1. 1. 1.
6	6	2
7		~~0.12489 0.61837 -4.44089e-16~~ 0.1 1. 1. 1.
	7	1.24926 -0.870237 0.89 0.1 1. 1. 1.
8	8	2
9		~~-1.12431 -0.26503 -4.44089e-16~~ 0.1 1. 1. 1.
	9	2.13922 0.388414 0 0.1 1. 1. 1.
10	10	2
11		~~1.37419 -0.89433~~ -0.89 0.1 1. 1. 1.
	11	-3.63639e-05 1.27176 -0.89 0.1 1. 1. 1.
12	12	2
13		~~1.37419 -0.89433~~ 0.89 0.1 1. 1. 1.
	13	-3.63639e-05 1.27176 0.89 0.1 1. 1. 1.
14	14	2
15		~~2.26414 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	15	-2.13919 0.388414 0 0.1 1. 1. 1.
16	16	2
17		~~0.12489 1.2476~~7 -0.89 0.1 1. 1. 1.
	17	-1.24924 -0.870237 -0.89 0.1 1. 1. 1.
18	18	2
19		~~0.12489 1.2476~~7 0.89 0.1 1. 1. 1.
	19	-1.24924 -0.870237 0.89 0.1 1. 1. 1.
20	20	2
21		~~-2.01426 0.364321 -4.44089e-16~~ 0.1 1. 1. 1.
	21	1.24926 -0.240937 0 0.1 1. 1. 1.
22	22	2
23		-~~1.12431 -0.89433 -0.89~~ 0.1 1. 1. 1.
	23	-3.63639e-05 0.642463 0 0.1 1. 1. 1.
24	24	2
25		-1.~~12431 -0.89433 0.89~~ 0.1 1. 1. 1.
	25	-1.24924 -0.240937 0 0.1 1. 1. 1.
26	26	# All tesselation triangles
27	27	8
…	…
30	30	BACKFACE 0.3 0.3 1.0 0 0
31	31	1
32		1.~~37419 -0.89433 -0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ -0.89 1. 0. 0.
	32	1.24926 -0.870237 -0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 1. 0. 0.
33	33	1
34		1.~~37419 -0.89433 -0.89 0.12489 1.24767 -0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	34	1.24926 -0.870237 -0.89 -3.63639e-05 1.27176 -0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
35	35	1
36		~~0.12489 1.24767 -0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	36	-3.63639e-05 1.27176 -0.89 -2.13919 0.388414 0 -1.24924 -0.870237 -0.89 1. 0. 0.
37	37	1
38		2.~~26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767~~ 0.89 1. 0. 0.
	38	2.13922 0.388414 0 -3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 1. 0. 0.
39	39	1
40		~~0.12489 1.24767 -0.89 0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16~~ 1. 0. 0.
	40	-3.63639e-05 1.27176 -0.89 -3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 1. 0. 0.
41	41	1
42		1.~~37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767~~ 0.89 1. 0. 0.
	42	1.24926 -0.870237 0.89 2.13922 0.388414 0 -3.63639e-05 1.27176 0.89 1. 0. 0.
43	43	1
44		1.~~37419 -0.89433 0.89 0.12489 1.24767 0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	44	1.24926 -0.870237 0.89 -3.63639e-05 1.27176 0.89 -1.24924 -0.870237 0.89 1. 0. 0.
45	45	1
46		~~0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	46	-3.63639e-05 1.27176 0.89 -2.13919 0.388414 0 -1.24924 -0.870237 0.89 1. 0. 0.
47	47	1
48		-2.~~01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	48	-2.13919 0.388414 0 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
49	49	1
50		1.~~37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433~~ 0.89 1. 0. 0.
	50	1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 -1.24924 -0.870237 0.89 1. 0. 0.
51	51	1
52		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433~~ -0.89 1. 0. 0.
	52	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 -1.24924 -0.870237 -0.89 1. 0. 0.
53	53	1
54		1.~~37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16~~ 1. 0. 0.
	54	1.24926 -0.870237 -0.89 1.24926 -0.870237 0.89 2.13922 0.388414 0 1. 0. 0.
55	55	9
56	56	# terminating special property
…	…
59	59	25.0 0.6 -1.0 -1.0 -1.0 0.2 0 0 0 0
60	60	2
61		1.~~67084 -0.47478 -8.88178~~e-16 5 1 0 0
	61	1.54591 -0.450686 -4.44089e-16 5 1 0 0
62	62	9
63	63	terminating special property

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

-              rc39cc4
+              rbdb143
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="test", N=44, E=86, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 .9077 1.1106 0.1214 1
 .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 -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
 32 44

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

-              rc39cc4
+              rbdb143
 # All atoms as spheres
 .952534 -3.05798 0.420171    0.1     1. 1. 1.
   -0.139866 -1.98848 0.359771   0.1     1. 1. 1.
 .0788342 -1.07508 -0.875229  0.1     1. 1. 1.
   -1.49147 -2.63828 0.0780712   0.1     1. 1. 1.
   -0.0588658 -1.09478 1.58347   0.1     1. 1. 1.
 .53473 -0.644479 -0.868129   0.1     1. 1. 1.
   -0.333166 -2.00128 -2.02443   0.1     1. 1. 1.
   -2.62147 -1.78218 0.653571    0.1     1. 1. 1.
   -1.60077 -2.70398 -1.46563    0.1     1. 1. 1.
 .37913 -0.560579 1.65607     0.1     1. 1. 1.
 .75933 0.205421 0.395371     0.1     1. 1. 1.
 .79893 0.246421 -2.08883     0.1     1. 1. 1.
   -2.64037 -0.423279 -0.0491288         0.1     1. 1. 1.
   -3.96017 -2.48928 0.432671    0.1     1. 1. 1.
 .23013 0.593821 0.484471     0.1     1. 1. 1.
 .14803 0.889821 -1.96833     0.1     1. 1. 1.
   -3.79507 0.418021 0.498371    0.1     1. 1. 1.
 .36023 1.76962 1.45487       0.1     1. 1. 1.
 .78273 1.01752 -0.849429     0.1     1. 1. 1.
 .07093 -0.563879 1.01767     0.1     1. 1. 1.
   -3.81397 1.77692 -0.204329    0.1     1. 1. 1.
 .17783 1.62112 -0.842829     0.1     1. 1. 1.
 .49863 -0.464179 0.482071    0.1     1. 1. 1.
   -4.96867 2.61822 0.343171     0.1     1. 1. 1.
 .93083 0.990421 0.337371     0.1     1. 1. 1.
   -4.98757 3.97722 -0.359529    0.1     1. 1. 1.
   -6.29237 1.89422 0.0890712    0.1     1. 1. 1.
 .33693 1.04442 0.0886712     0.1     1. 1. 1.
 .790434 -3.69418 1.29027     0.1     1. 1. 1.
 .917634 -3.66448 -0.484829   0.1     1. 1. 1.
 .92773 -2.57738 0.498071     0.1     1. 1. 1.
   -0.574266 -0.203779 -0.824729         0.1     1. 1. 1.
   -1.52417 -3.64138 0.503471    0.1     1. 1. 1.
   -0.759066 -0.265179 1.48487   0.1     1. 1. 1.
   -0.287266 -1.67078 2.48017    0.1     1. 1. 1.
 .19193 -1.51408 -0.867629    0.1     1. 1. 1.
   -0.573766 -1.42458 -2.91753   0.1     1. 1. 1.
 .450934 -2.72908 -2.23353    0.1     1. 1. 1.
   -2.45927 -1.63678 1.72157     0.1     1. 1. 1.
   -1.62867 -3.74268 -1.79493    0.1     1. 1. 1.
   -2.49667 -2.18078 -1.79993    0.1     1. 1. 1.
 .46453 0.112321 2.50927      0.1     1. 1. 1.
 .06173 -1.39848 1.79787      0.1     1. 1. 1.
 .15633 1.11082 0.326671      0.1     1. 1. 1.
 .76663 -0.360379 -2.99373    0.1     1. 1. 1.
 .03283 1.01972 -2.14533      0.1     1. 1. 1.
   -1.69727 0.0925205 0.131971   0.1     1. 1. 1.
   -2.77417 -0.570279 -1.12083   0.1     1. 1. 1.
   -4.75167 -1.93408 0.935971    0.1     1. 1. 1.
   -4.17327 -2.53828 -0.635229   0.1     1. 1. 1.
   -3.90927 -3.49908 0.839771    0.1     1. 1. 1.
 .62023 1.25552 -2.86813      0.1     1. 1. 1.
   -4.73807 -0.0977795 0.317371  0.1     1. 1. 1.
   -3.66127 0.565021 1.57007     0.1     1. 1. 1.
 .24233 1.41142 2.47757       0.1     1. 1. 1.
 .34293 2.22742 1.34117       0.1     1. 1. 1.
 .58823 2.50762 1.23707       0.1     1. 1. 1.
 .08983 -0.525479 2.10687     0.1     1. 1. 1.
 .62993 -1.50808 0.698371     0.1     1. 1. 1.
   -2.87097 2.29272 -0.0233288   0.1     1. 1. 1.
   -3.94777 1.63002 -1.27603     0.1     1. 1. 1.
 .68853 1.38852 -1.77723      0.1     1. 1. 1.
 .11553 2.70122 -0.710229     0.1     1. 1. 1.
 .17523 -0.969279 1.17127     0.1     1. 1. 1.
 .55043 -0.952879 -0.490929   0.1     1. 1. 1.
   -4.83487 2.76522 1.41487      0.1     1. 1. 1.
 .70193 1.54062 1.25007       0.1     1. 1. 1.
   -5.81017 4.57652 0.0304712    0.1     1. 1. 1.
   -4.04457 4.49292 -0.178529    0.1     1. 1. 1.
   -5.12137 3.83022 -1.43123     0.1     1. 1. 1.
   -6.27887 0.926121 0.589671    0.1     1. 1. 1.
   -7.11497 2.49352 0.479071     0.1     1. 1. 1.
   -6.42617 1.74722 -0.982629    0.1     1. 1. 1.
 .56833 1.97852 -0.00632877   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.
+.777562 -3.65286 1.28459     0.1     1. 1. 1.
+.904762 -3.62316 -0.490507   0.1     1. 1. 1.
+.91486 -2.53606 0.492393     0.1     1. 1. 1.
+  -0.587138 -0.162455 -0.830407         0.1     1. 1. 1.
+  -1.53704 -3.60006 0.497793    0.1     1. 1. 1.
+  -0.771938 -0.223855 1.47919   0.1     1. 1. 1.
+  -0.300138 -1.62946 2.47449    0.1     1. 1. 1.
+.17906 -1.47276 -0.873307    0.1     1. 1. 1.
+  -0.586638 -1.38326 -2.92321   0.1     1. 1. 1.
+.438062 -2.68776 -2.23921    0.1     1. 1. 1.
+  -2.47214 -1.59546 1.71589     0.1     1. 1. 1.
+  -1.64154 -3.70136 -1.80061    0.1     1. 1. 1.
+  -2.50954 -2.13946 -1.80561    0.1     1. 1. 1.
+.45166 0.153645 2.50359      0.1     1. 1. 1.
+.04886 -1.35716 1.79219      0.1     1. 1. 1.
+.14346 1.15214 0.320993      0.1     1. 1. 1.
+.75376 -0.319055 -2.99941    0.1     1. 1. 1.
+.01996 1.06104 -2.15101      0.1     1. 1. 1.
+  -1.71014 0.133845 0.126293    0.1     1. 1. 1.
+  -2.78704 -0.528955 -1.12651   0.1     1. 1. 1.
+  -4.76454 -1.89276 0.930293    0.1     1. 1. 1.
+  -4.18614 -2.49696 -0.640907   0.1     1. 1. 1.
+  -3.92214 -3.45776 0.834093    0.1     1. 1. 1.
+.60736 1.29684 -2.87381      0.1     1. 1. 1.
+  -4.75094 -0.0564554 0.311693  0.1     1. 1. 1.
+  -3.67414 0.606345 1.56439     0.1     1. 1. 1.
+.22946 1.45274 2.47189       0.1     1. 1. 1.
+.33006 2.26874 1.33549       0.1     1. 1. 1.
+.57536 2.54894 1.23139       0.1     1. 1. 1.
+.07696 -0.484155 2.10119     0.1     1. 1. 1.
+.61706 -1.46676 0.692693     0.1     1. 1. 1.
+  -2.88384 2.33404 -0.0290068   0.1     1. 1. 1.
+  -3.96064 1.67134 -1.28171     0.1     1. 1. 1.
+.67566 1.42984 -1.78291      0.1     1. 1. 1.
+.10266 2.74254 -0.715907     0.1     1. 1. 1.
+.16236 -0.927955 1.16559     0.1     1. 1. 1.
+.53756 -0.911555 -0.496607   0.1     1. 1. 1.
+  -4.84774 2.80654 1.40919      0.1     1. 1. 1.
+.68906 1.58194 1.24439       0.1     1. 1. 1.
+  -5.82304 4.61784 0.0247932    0.1     1. 1. 1.
+  -4.05744 4.53424 -0.184207    0.1     1. 1. 1.
+  -5.13424 3.87154 -1.43691     0.1     1. 1. 1.
+  -6.29174 0.967445 0.583993    0.1     1. 1. 1.
+  -7.12784 2.53484 0.473393     0.1     1. 1. 1.
+  -6.43904 1.78854 -0.988307    0.1     1. 1. 1.
+.55546 2.01984 -0.0120068    0.1     1. 1. 1.
 # All tesselation triangles
 …
   BACKFACE  0.3 0.3 1.0   0 0
 .33693 1.04442 0.0886712     5.68853 1.38852 -1.77723        7.56833 1.97852 -0.00632877     1. 0. 0.
 .33693 1.04442 0.0886712     5.68853 1.38852 -1.77723        5.55043 -0.952879 -0.490929     1. 0. 0.
 .33693 1.04442 0.0886712     6.17523 -0.969279 1.17127       5.55043 -0.952879 -0.490929     1. 0. 0.
 .62023 1.25552 -2.86813      5.68853 1.38852 -1.77723        5.55043 -0.952879 -0.490929     1. 0. 0.
 .76663 -0.360379 -2.99373    3.62023 1.25552 -2.86813        5.55043 -0.952879 -0.490929     1. 0. 0.
 .19193 -1.51408 -0.867629    1.76663 -0.360379 -2.99373      5.55043 -0.952879 -0.490929     1. 0. 0.
 .19193 -1.51408 -0.867629    0.450934 -2.72908 -2.23353      1.76663 -0.360379 -2.99373      1. 0. 0.
 .917634 -3.66448 -0.484829   2.19193 -1.51408 -0.867629      0.450934 -2.72908 -2.23353      1. 0. 0.
 .917634 -3.66448 -0.484829   2.19193 -1.51408 -0.867629      5.55043 -0.952879 -0.490929     1. 0. 0.
 .917634 -3.66448 -0.484829   1.92773 -2.57738 0.498071       5.55043 -0.952879 -0.490929     1. 0. 0.
 .92773 -2.57738 0.498071     3.62993 -1.50808 0.698371       5.55043 -0.952879 -0.490929     1. 0. 0.
 .62993 -1.50808 0.698371     6.17523 -0.969279 1.17127       5.55043 -0.952879 -0.490929     1. 0. 0.
 .790434 -3.69418 1.29027     0.917634 -3.66448 -0.484829     1.92773 -2.57738 0.498071       1. 0. 0.
 .790434 -3.69418 1.29027     1.92773 -2.57738 0.498071       3.62993 -1.50808 0.698371       1. 0. 0.
 .790434 -3.69418 1.29027     2.06173 -1.39848 1.79787        3.62993 -1.50808 0.698371       1. 0. 0.
 .06173 -1.39848 1.79787      4.08983 -0.525479 2.10687       3.62993 -1.50808 0.698371       1. 0. 0.
 .08983 -0.525479 2.10687     3.62993 -1.50808 0.698371       6.17523 -0.969279 1.17127       1. 0. 0.
 .790434 -3.69418 1.29027     -0.287266 -1.67078 2.48017      2.06173 -1.39848 1.79787        1. 0. 0.
   -0.287266 -1.67078 2.48017    1.46453 0.112321 2.50927        2.06173 -1.39848 1.79787        1. 0. 0.
 .46453 0.112321 2.50927      2.06173 -1.39848 1.79787        4.08983 -0.525479 2.10687       1. 0. 0.
 .46453 0.112321 2.50927      3.24233 1.41142 2.47757         4.08983 -0.525479 2.10687       1. 0. 0.
 .24233 1.41142 2.47757       4.08983 -0.525479 2.10687       5.70193 1.54062 1.25007         1. 0. 0.
 .08983 -0.525479 2.10687     6.17523 -0.969279 1.17127       5.70193 1.54062 1.25007         1. 0. 0.
 .33693 1.04442 0.0886712     6.17523 -0.969279 1.17127       5.70193 1.54062 1.25007         1. 0. 0.
 .33693 1.04442 0.0886712     5.70193 1.54062 1.25007         7.56833 1.97852 -0.00632877     1. 0. 0.
 .24233 1.41142 2.47757       4.34293 2.22742 1.34117         5.70193 1.54062 1.25007         1. 0. 0.
 .24233 1.41142 2.47757       4.34293 2.22742 1.34117         2.58823 2.50762 1.23707         1. 0. 0.
 .34293 2.22742 1.34117       2.58823 2.50762 1.23707         5.11553 2.70122 -0.710229       1. 0. 0.
 .34293 2.22742 1.34117       5.11553 2.70122 -0.710229       7.56833 1.97852 -0.00632877     1. 0. 0.
 .34293 2.22742 1.34117       5.70193 1.54062 1.25007         7.56833 1.97852 -0.00632877     1. 0. 0.
 .46453 0.112321 2.50927      3.24233 1.41142 2.47757         2.58823 2.50762 1.23707         1. 0. 0.
 .46453 0.112321 2.50927      2.58823 2.50762 1.23707         -2.87097 2.29272 -0.0233288     1. 0. 0.
   -0.759066 -0.265179 1.48487   1.46453 0.112321 2.50927        -2.87097 2.29272 -0.0233288     1. 0. 0.
   -0.759066 -0.265179 1.48487   -3.66127 0.565021 1.57007       -2.87097 2.29272 -0.0233288     1. 0. 0.
   -3.66127 0.565021 1.57007     -2.87097 2.29272 -0.0233288     -4.83487 2.76522 1.41487        1. 0. 0.
   -2.87097 2.29272 -0.0233288   -4.83487 2.76522 1.41487        -4.04457 4.49292 -0.178529      1. 0. 0.
 .58823 2.50762 1.23707       -2.87097 2.29272 -0.0233288     -4.04457 4.49292 -0.178529      1. 0. 0.
 .58823 2.50762 1.23707       -2.87097 2.29272 -0.0233288     -4.04457 4.49292 -0.178529      1. 0. 0.
 .15633 1.11082 0.326671      2.58823 2.50762 1.23707         -2.87097 2.29272 -0.0233288     1. 0. 0.
 .15633 1.11082 0.326671      1.03283 1.01972 -2.14533        -2.87097 2.29272 -0.0233288     1. 0. 0.
 .15633 1.11082 0.326671      1.03283 1.01972 -2.14533        2.58823 2.50762 1.23707         1. 0. 0.
 .03283 1.01972 -2.14533      2.58823 2.50762 1.23707         5.11553 2.70122 -0.710229       1. 0. 0.
 .03283 1.01972 -2.14533      3.62023 1.25552 -2.86813        5.11553 2.70122 -0.710229       1. 0. 0.
   -0.759066 -0.265179 1.48487   -0.287266 -1.67078 2.48017      -3.66127 0.565021 1.57007       1. 0. 0.
   -0.759066 -0.265179 1.48487   -0.287266 -1.67078 2.48017      1.46453 0.112321 2.50927        1. 0. 0.
   -0.287266 -1.67078 2.48017    -2.45927 -1.63678 1.72157       -3.66127 0.565021 1.57007       1. 0. 0.
   -2.45927 -1.63678 1.72157     -4.75167 -1.93408 0.935971      -3.66127 0.565021 1.57007       1. 0. 0.
   -4.75167 -1.93408 0.935971    -3.66127 0.565021 1.57007       -6.27887 0.926121 0.589671      1. 0. 0.
   -3.66127 0.565021 1.57007     -4.83487 2.76522 1.41487        -6.27887 0.926121 0.589671      1. 0. 0.
   -4.83487 2.76522 1.41487      -6.27887 0.926121 0.589671      -7.11497 2.49352 0.479071       1. 0. 0.
   -2.45927 -1.63678 1.72157     -4.75167 -1.93408 0.935971      -3.90927 -3.49908 0.839771      1. 0. 0.
   -1.52417 -3.64138 0.503471    -2.45927 -1.63678 1.72157       -3.90927 -3.49908 0.839771      1. 0. 0.
   -1.52417 -3.64138 0.503471    -0.287266 -1.67078 2.48017      -2.45927 -1.63678 1.72157       1. 0. 0.
 .790434 -3.69418 1.29027     -1.52417 -3.64138 0.503471      -0.287266 -1.67078 2.48017      1. 0. 0.
   -4.83487 2.76522 1.41487      -5.81017 4.57652 0.0304712      -4.04457 4.49292 -0.178529      1. 0. 0.
   -4.83487 2.76522 1.41487      -5.81017 4.57652 0.0304712      -7.11497 2.49352 0.479071       1. 0. 0.
 .03283 1.01972 -2.14533      -2.87097 2.29272 -0.0233288     -3.94777 1.63002 -1.27603       1. 0. 0.
   -2.87097 2.29272 -0.0233288   -3.94777 1.63002 -1.27603       -4.04457 4.49292 -0.178529      1. 0. 0.
   -3.94777 1.63002 -1.27603     -4.04457 4.49292 -0.178529      -5.12137 3.83022 -1.43123       1. 0. 0.
   -0.573766 -1.42458 -2.91753   1.03283 1.01972 -2.14533        -3.94777 1.63002 -1.27603       1. 0. 0.
   -0.573766 -1.42458 -2.91753   1.76663 -0.360379 -2.99373      1.03283 1.01972 -2.14533        1. 0. 0.
 .76663 -0.360379 -2.99373    1.03283 1.01972 -2.14533        3.62023 1.25552 -2.86813        1. 0. 0.
   -0.573766 -1.42458 -2.91753   -2.77417 -0.570279 -1.12083     -3.94777 1.63002 -1.27603       1. 0. 0.
   -0.573766 -1.42458 -2.91753   -2.49667 -2.18078 -1.79993      -2.77417 -0.570279 -1.12083     1. 0. 0.
   -2.49667 -2.18078 -1.79993    -2.77417 -0.570279 -1.12083     -3.94777 1.63002 -1.27603       1. 0. 0.
   -2.49667 -2.18078 -1.79993    -4.17327 -2.53828 -0.635229     -3.94777 1.63002 -1.27603       1. 0. 0.
   -4.17327 -2.53828 -0.635229   -3.94777 1.63002 -1.27603       -6.42617 1.74722 -0.982629      1. 0. 0.
   -3.94777 1.63002 -1.27603     -5.12137 3.83022 -1.43123       -6.42617 1.74722 -0.982629      1. 0. 0.
   -0.573766 -1.42458 -2.91753   -1.62867 -3.74268 -1.79493      -2.49667 -2.18078 -1.79993      1. 0. 0.
   -0.573766 -1.42458 -2.91753   0.450934 -2.72908 -2.23353      -1.62867 -3.74268 -1.79493      1. 0. 0.
   -0.573766 -1.42458 -2.91753   0.450934 -2.72908 -2.23353      1.76663 -0.360379 -2.99373      1. 0. 0.
   -1.62867 -3.74268 -1.79493    -2.49667 -2.18078 -1.79993      -4.17327 -2.53828 -0.635229     1. 0. 0.
   -1.62867 -3.74268 -1.79493    -4.17327 -2.53828 -0.635229     -3.90927 -3.49908 0.839771      1. 0. 0.
   -1.52417 -3.64138 0.503471    -1.62867 -3.74268 -1.79493      -3.90927 -3.49908 0.839771      1. 0. 0.
 .917634 -3.66448 -0.484829   -1.52417 -3.64138 0.503471      -1.62867 -3.74268 -1.79493      1. 0. 0.
 .790434 -3.69418 1.29027     0.917634 -3.66448 -0.484829     -1.52417 -3.64138 0.503471      1. 0. 0.
 .917634 -3.66448 -0.484829   0.450934 -2.72908 -2.23353      -1.62867 -3.74268 -1.79493      1. 0. 0.
   -4.75167 -1.93408 0.935971    -4.17327 -2.53828 -0.635229     -3.90927 -3.49908 0.839771      1. 0. 0.
   -4.75167 -1.93408 0.935971    -4.17327 -2.53828 -0.635229     -6.27887 0.926121 0.589671      1. 0. 0.
   -4.17327 -2.53828 -0.635229   -6.27887 0.926121 0.589671      -6.42617 1.74722 -0.982629      1. 0. 0.
   -6.27887 0.926121 0.589671    -7.11497 2.49352 0.479071       -6.42617 1.74722 -0.982629      1. 0. 0.
 .62023 1.25552 -2.86813      5.68853 1.38852 -1.77723        5.11553 2.70122 -0.710229       1. 0. 0.
 .68853 1.38852 -1.77723      5.11553 2.70122 -0.710229       7.56833 1.97852 -0.00632877     1. 0. 0.
   -5.12137 3.83022 -1.43123     -7.11497 2.49352 0.479071       -6.42617 1.74722 -0.982629      1. 0. 0.
   -5.81017 4.57652 0.0304712    -5.12137 3.83022 -1.43123       -7.11497 2.49352 0.479071       1. 0. 0.
   -5.81017 4.57652 0.0304712    -4.04457 4.49292 -0.178529      -5.12137 3.83022 -1.43123       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.
+.75376 -0.319055 -2.99941    3.60736 1.29684 -2.87381        5.53756 -0.911555 -0.496607     1. 0. 0.
+.17906 -1.47276 -0.873307    1.75376 -0.319055 -2.99941      5.53756 -0.911555 -0.496607     1. 0. 0.
+.17906 -1.47276 -0.873307    0.438062 -2.68776 -2.23921      1.75376 -0.319055 -2.99941      1. 0. 0.
+.904762 -3.62316 -0.490507   2.17906 -1.47276 -0.873307      0.438062 -2.68776 -2.23921      1. 0. 0.
+.904762 -3.62316 -0.490507   2.17906 -1.47276 -0.873307      5.53756 -0.911555 -0.496607     1. 0. 0.
+.904762 -3.62316 -0.490507   1.91486 -2.53606 0.492393       5.53756 -0.911555 -0.496607     1. 0. 0.
+.91486 -2.53606 0.492393     3.61706 -1.46676 0.692693       5.53756 -0.911555 -0.496607     1. 0. 0.
+.61706 -1.46676 0.692693     6.16236 -0.927955 1.16559       5.53756 -0.911555 -0.496607     1. 0. 0.
+.777562 -3.65286 1.28459     0.904762 -3.62316 -0.490507     1.91486 -2.53606 0.492393       1. 0. 0.
+.777562 -3.65286 1.28459     1.91486 -2.53606 0.492393       3.61706 -1.46676 0.692693       1. 0. 0.
+.777562 -3.65286 1.28459     2.04886 -1.35716 1.79219        3.61706 -1.46676 0.692693       1. 0. 0.
+.04886 -1.35716 1.79219      4.07696 -0.484155 2.10119       3.61706 -1.46676 0.692693       1. 0. 0.
+.07696 -0.484155 2.10119     3.61706 -1.46676 0.692693       6.16236 -0.927955 1.16559       1. 0. 0.
+.777562 -3.65286 1.28459     -0.300138 -1.62946 2.47449      2.04886 -1.35716 1.79219        1. 0. 0.
+  -0.300138 -1.62946 2.47449    1.45166 0.153645 2.50359        2.04886 -1.35716 1.79219        1. 0. 0.
+.45166 0.153645 2.50359      2.04886 -1.35716 1.79219        4.07696 -0.484155 2.10119       1. 0. 0.
+.45166 0.153645 2.50359      3.22946 1.45274 2.47189         4.07696 -0.484155 2.10119       1. 0. 0.
+.22946 1.45274 2.47189       4.07696 -0.484155 2.10119       5.68906 1.58194 1.24439         1. 0. 0.
+.07696 -0.484155 2.10119     6.16236 -0.927955 1.16559       5.68906 1.58194 1.24439         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.
+.22946 1.45274 2.47189       4.33006 2.26874 1.33549         2.57536 2.54894 1.23139         1. 0. 0.
+.33006 2.26874 1.33549       2.57536 2.54894 1.23139         5.10266 2.74254 -0.715907       1. 0. 0.
+.33006 2.26874 1.33549       5.10266 2.74254 -0.715907       7.55546 2.01984 -0.0120068      1. 0. 0.
+.33006 2.26874 1.33549       5.68906 1.58194 1.24439         7.55546 2.01984 -0.0120068      1. 0. 0.
+.45166 0.153645 2.50359      3.22946 1.45274 2.47189         2.57536 2.54894 1.23139         1. 0. 0.
+.45166 0.153645 2.50359      2.57536 2.54894 1.23139         -2.88384 2.33404 -0.0290068     1. 0. 0.
+  -0.771938 -0.223855 1.47919   1.45166 0.153645 2.50359        -2.88384 2.33404 -0.0290068     1. 0. 0.
+  -0.771938 -0.223855 1.47919   -3.67414 0.606345 1.56439       -2.88384 2.33404 -0.0290068     1. 0. 0.
+  -3.67414 0.606345 1.56439     -2.88384 2.33404 -0.0290068     -4.84774 2.80654 1.40919        1. 0. 0.
+  -2.88384 2.33404 -0.0290068   -4.84774 2.80654 1.40919        -4.05744 4.53424 -0.184207      1. 0. 0.
+.57536 2.54894 1.23139       -2.88384 2.33404 -0.0290068     -4.05744 4.53424 -0.184207      1. 0. 0.
+.57536 2.54894 1.23139       -2.88384 2.33404 -0.0290068     -4.05744 4.53424 -0.184207      1. 0. 0.
+.14346 1.15214 0.320993      2.57536 2.54894 1.23139         -2.88384 2.33404 -0.0290068     1. 0. 0.
+.14346 1.15214 0.320993      1.01996 1.06104 -2.15101        -2.88384 2.33404 -0.0290068     1. 0. 0.
+.14346 1.15214 0.320993      1.01996 1.06104 -2.15101        2.57536 2.54894 1.23139         1. 0. 0.
+.01996 1.06104 -2.15101      2.57536 2.54894 1.23139         5.10266 2.74254 -0.715907       1. 0. 0.
+.01996 1.06104 -2.15101      3.60736 1.29684 -2.87381        5.10266 2.74254 -0.715907       1. 0. 0.
+  -0.771938 -0.223855 1.47919   -0.300138 -1.62946 2.47449      -3.67414 0.606345 1.56439       1. 0. 0.
+  -0.771938 -0.223855 1.47919   -0.300138 -1.62946 2.47449      1.45166 0.153645 2.50359        1. 0. 0.
+  -0.300138 -1.62946 2.47449    -2.47214 -1.59546 1.71589       -3.67414 0.606345 1.56439       1. 0. 0.
+  -2.47214 -1.59546 1.71589     -4.76454 -1.89276 0.930293      -3.67414 0.606345 1.56439       1. 0. 0.
+  -4.76454 -1.89276 0.930293    -3.67414 0.606345 1.56439       -6.29174 0.967445 0.583993      1. 0. 0.
+  -3.67414 0.606345 1.56439     -4.84774 2.80654 1.40919        -6.29174 0.967445 0.583993      1. 0. 0.
+  -4.84774 2.80654 1.40919      -6.29174 0.967445 0.583993      -7.12784 2.53484 0.473393       1. 0. 0.
+  -2.47214 -1.59546 1.71589     -4.76454 -1.89276 0.930293      -3.92214 -3.45776 0.834093      1. 0. 0.
+  -1.53704 -3.60006 0.497793    -2.47214 -1.59546 1.71589       -3.92214 -3.45776 0.834093      1. 0. 0.
+  -1.53704 -3.60006 0.497793    -0.300138 -1.62946 2.47449      -2.47214 -1.59546 1.71589       1. 0. 0.
+.777562 -3.65286 1.28459     -1.53704 -3.60006 0.497793      -0.300138 -1.62946 2.47449      1. 0. 0.
+  -4.84774 2.80654 1.40919      -5.82304 4.61784 0.0247932      -4.05744 4.53424 -0.184207      1. 0. 0.
+  -4.84774 2.80654 1.40919      -5.82304 4.61784 0.0247932      -7.12784 2.53484 0.473393       1. 0. 0.
+.01996 1.06104 -2.15101      -2.88384 2.33404 -0.0290068     -3.96064 1.67134 -1.28171       1. 0. 0.
+  -2.88384 2.33404 -0.0290068   -3.96064 1.67134 -1.28171       -4.05744 4.53424 -0.184207      1. 0. 0.
+  -3.96064 1.67134 -1.28171     -4.05744 4.53424 -0.184207      -5.13424 3.87154 -1.43691       1. 0. 0.
+  -0.586638 -1.38326 -2.92321   1.01996 1.06104 -2.15101        -3.96064 1.67134 -1.28171       1. 0. 0.
+  -0.586638 -1.38326 -2.92321   1.75376 -0.319055 -2.99941      1.01996 1.06104 -2.15101        1. 0. 0.
+.75376 -0.319055 -2.99941    1.01996 1.06104 -2.15101        3.60736 1.29684 -2.87381        1. 0. 0.
+  -0.586638 -1.38326 -2.92321   -2.78704 -0.528955 -1.12651     -3.96064 1.67134 -1.28171       1. 0. 0.
+  -0.586638 -1.38326 -2.92321   -2.50954 -2.13946 -1.80561      -2.78704 -0.528955 -1.12651     1. 0. 0.
+  -2.50954 -2.13946 -1.80561    -2.78704 -0.528955 -1.12651     -3.96064 1.67134 -1.28171       1. 0. 0.
+  -2.50954 -2.13946 -1.80561    -4.18614 -2.49696 -0.640907     -3.96064 1.67134 -1.28171       1. 0. 0.
+  -4.18614 -2.49696 -0.640907   -3.96064 1.67134 -1.28171       -6.43904 1.78854 -0.988307      1. 0. 0.
+  -3.96064 1.67134 -1.28171     -5.13424 3.87154 -1.43691       -6.43904 1.78854 -0.988307      1. 0. 0.
+  -0.586638 -1.38326 -2.92321   -1.64154 -3.70136 -1.80061      -2.50954 -2.13946 -1.80561      1. 0. 0.
+  -0.586638 -1.38326 -2.92321   0.438062 -2.68776 -2.23921      -1.64154 -3.70136 -1.80061      1. 0. 0.
+  -0.586638 -1.38326 -2.92321   0.438062 -2.68776 -2.23921      1.75376 -0.319055 -2.99941      1. 0. 0.
+  -1.64154 -3.70136 -1.80061    -2.50954 -2.13946 -1.80561      -4.18614 -2.49696 -0.640907     1. 0. 0.
+  -1.64154 -3.70136 -1.80061    -4.18614 -2.49696 -0.640907     -3.92214 -3.45776 0.834093      1. 0. 0.
+  -1.53704 -3.60006 0.497793    -1.64154 -3.70136 -1.80061      -3.92214 -3.45776 0.834093      1. 0. 0.
+.904762 -3.62316 -0.490507   -1.53704 -3.60006 0.497793      -1.64154 -3.70136 -1.80061      1. 0. 0.
+.777562 -3.65286 1.28459     0.904762 -3.62316 -0.490507     -1.53704 -3.60006 0.497793      1. 0. 0.
+.904762 -3.62316 -0.490507   0.438062 -2.68776 -2.23921      -1.64154 -3.70136 -1.80061      1. 0. 0.
+  -4.76454 -1.89276 0.930293    -4.18614 -2.49696 -0.640907     -3.92214 -3.45776 0.834093      1. 0. 0.
+  -4.76454 -1.89276 0.930293    -4.18614 -2.49696 -0.640907     -6.29174 0.967445 0.583993      1. 0. 0.
+  -4.18614 -2.49696 -0.640907   -6.29174 0.967445 0.583993      -6.43904 1.78854 -0.988307      1. 0. 0.
+  -6.29174 0.967445 0.583993    -7.12784 2.53484 0.473393       -6.43904 1.78854 -0.988307      1. 0. 0.
+.60736 1.29684 -2.87381      5.67566 1.42984 -1.78291        5.10266 2.74254 -0.715907       1. 0. 0.
+.67566 1.42984 -1.78291      5.10266 2.74254 -0.715907       7.55546 2.01984 -0.0120068      1. 0. 0.
+  -5.13424 3.87154 -1.43691     -7.12784 2.53484 0.473393       -6.43904 1.78854 -0.988307      1. 0. 0.
+  -5.82304 4.61784 0.0247932    -5.13424 3.87154 -1.43691       -7.12784 2.53484 0.473393       1. 0. 0.
+  -5.82304 4.61784 0.0247932    -4.05744 4.53424 -0.184207      -5.13424 3.87154 -1.43691       1. 0. 0.
 #  terminating special property
 …
 .0    0.6     -1.0 -1.0 -1.0     0.2        0 0 0 0
   -4.99203 4.29989 -0.526429    5       1 0 0
+  -5.0049 4.34121 -0.532107     5       1 0 0
   terminating special property

Context Navigation

Changes in / [c39cc4:bdb143]

Legend: