Changes in / [986c80:edcda5]

Files:

• ChangeLog (modified) (1 prop)
• Makefile.am (modified) (1 prop)
• configure.ac (modified) (1 diff, 1 prop)
• doc/Doxyfile (modified) (1 prop)
• doc/Makefile.am (modified) (1 prop)
• m4/ac_doxygen.m4 (modified) (1 diff, 1 prop)
• m4/acx_compilerflags.m4 (modified) (1 diff, 1 prop)
• src/#border.cpp# (deleted)
• src/#makefile# (deleted)
• src/#molecules.hpp# (deleted)
• src/Hbondangle.db (modified) (1 diff, 1 prop)
• src/Hbonddistance.db (modified) (1 diff, 1 prop)
• src/Makefile.am (modified) (1 diff, 1 prop)
• src/ReMapDBondFileFromXYZ.py (deleted)
• src/TAGS (deleted)
• src/analyzer.cpp (modified) (13 diffs, 1 prop)
• src/atom.cpp (modified) (1 diff, 1 prop)
• src/bond.cpp (modified) (2 diffs, 1 prop)
• src/boundary.cpp (modified) (21 diffs, 1 prop)
• src/boundary.hpp (modified) (5 diffs, 1 prop)
• src/builder.cpp (modified) (73 diffs, 1 prop)
• src/config.cpp (modified) (12 diffs, 1 prop)
• src/datacreator.cpp (modified) (36 diffs, 1 prop)
• src/datacreator.hpp (modified) (2 diffs, 1 prop)
• src/defs.hpp (modified) (1 diff, 1 prop)
• src/element.cpp (modified) (1 prop)
• src/elements.db (modified) (1 prop)
• src/graph.cpp (modified) (1 diff, 1 prop)
• src/graph.hpp (deleted)
• src/helpers.cpp (modified) (1 diff, 1 prop)
• src/helpers.hpp (modified) (1 diff, 1 prop)
• src/joiner.cpp (modified) (10 diffs, 1 prop)
• src/moleculelist.cpp (modified) (3 diffs, 1 prop)
• src/molecules.cpp (modified) (207 diffs, 1 prop)
• src/molecules.hpp (modified) (24 diffs, 1 prop)
• src/orbitals.db (modified) (1 diff, 1 prop)
• src/parser.cpp (modified) (24 diffs, 1 prop)
• src/parser.hpp (modified) (4 diffs, 1 prop)
• src/periodentafel.cpp (modified) (19 diffs, 1 prop)
• src/periodentafel.hpp (modified) (1 prop)
• src/stackclass.hpp (modified) (1 prop)
• src/valence.db (modified) (1 diff, 1 prop)
• src/vector.cpp (modified) (32 diffs, 1 prop)
• src/vector.hpp (modified) (5 diffs, 1 prop)
• src/verbose.cpp (modified) (1 prop)
• tests/Makefile.am (modified) (1 prop)
• tests/atlocal.in (modified) (1 prop)
• tests/molecuilder.in (modified) (1 prop)
• tests/testsuite.at (modified) (2 diffs, 1 prop)

configure.ac

@@ -14 +14 @@
 AC_PROG_CC
 AM_MISSING_PROG([DOXYGEN], [doxygen])
+
+AC_ARG_ENABLE([debug],AS_HELP_STRING([--enable-debug],[debugging level of compiler. Argument is yes or debugging level. (default is no)]),
+              [enable_debugging=$enableval], [enable_debugging=no])
+AC_ARG_ENABLE([optimization],AS_HELP_STRING([--enable-optimization],[Optimization level of compiler. Argument is yes or optimization. (default is 2)]),
+              [enable_optimization=$enableval], [enable_optimization=2])
+AC_ARG_ENABLE([warnings], AS_HELP_STRING([--enable-warnings],[Output compiler warnings, argument is none, some or full (default is some).]),
+              [enable_warnings=$enableval], [enable_warnings=some])
+AC_SET_COMPILER_FLAGS([$enable_optimization], [$enable_debugging], [$enable_warnings])
 
 # Checks for libraries.

m4/ac_doxygen.m4

@@ -1 @@
-# This file is part of Autoconf.                       -*- Autoconf -*-
-
-# Copyright (C) 2004 Oren Ben-Kiki
-# This file is distributed under the same terms as the Autoconf macro files.
-
-# Generate automatic documentation using Doxygen. Works in concert with the
-# aminclude.m4 file and a compatible doxygen configuration file. Defines the
-# following public macros:
-#
-# DX_???_FEATURE(ON|OFF) - control the default setting fo a Doxygen feature.
-# Supported features are 'DOXYGEN' itself, 'DOT' for generating graphics,
-# 'HTML' for plain HTML, 'CHM' for compressed HTML help (for MS users), 'CHI'
-# for generating a seperate .chi file by the .chm file, and 'MAN', 'RTF',
-# 'XML', 'PDF' and 'PS' for the appropriate output formats. The environment
-# variable DOXYGEN_PAPER_SIZE may be specified to override the default 'a4wide'
-# paper size.
-#
-# By default, HTML, PDF and PS documentation is generated as this seems to be
-# the most popular and portable combination. MAN pages created by Doxygen are
-# usually problematic, though by picking an appropriate subset and doing some
-# massaging they might be better than nothing. CHM and RTF are specific for MS
-# (note that you can't generate both HTML and CHM at the same time). The XML is
-# rather useless unless you apply specialized post-processing to it.
-#
-# The macro mainly controls the default state of the feature. The use can
-# override the default by specifying --enable or --disable. The macros ensure
-# that contradictory flags are not given (e.g., --enable-doxygen-html and
-# --enable-doxygen-chm, --enable-doxygen-anything with --disable-doxygen, etc.)
-# Finally, each feature will be automatically disabled (with a warning) if the
-# required programs are missing.
-#
-# Once all the feature defaults have been specified, call DX_INIT_DOXYGEN with
-# the following parameters: a one-word name for the project for use as a
-# filename base etc., an optional configuration file name (the default is
-# 'Doxyfile', the same as Doxygen's default), and an optional output directory
-# name (the default is 'doxygen-doc').
-
-## ----------##
-## Defaults. ##
-## ----------##
-
-DX_ENV=""
-AC_DEFUN([DX_FEATURE_doc],  ON)
-AC_DEFUN([DX_FEATURE_dot],  ON)
-AC_DEFUN([DX_FEATURE_man],  OFF)
-AC_DEFUN([DX_FEATURE_html], ON)
-AC_DEFUN([DX_FEATURE_chm],  OFF)
-AC_DEFUN([DX_FEATURE_chi],  OFF)
-AC_DEFUN([DX_FEATURE_rtf],  OFF)
-AC_DEFUN([DX_FEATURE_xml],  OFF)
-AC_DEFUN([DX_FEATURE_pdf],  ON)
-AC_DEFUN([DX_FEATURE_ps],   ON)
-
-## --------------- ##
-## Private macros. ##
-## --------------- ##
-
-# DX_ENV_APPEND(VARIABLE, VALUE)
-# ------------------------------
-# Append VARIABLE="VALUE" to DX_ENV for invoking doxygen.
-AC_DEFUN([DX_ENV_APPEND], [AC_SUBST([DX_ENV], ["$DX_ENV $1='$2'"])])
-
-# DX_DIRNAME_EXPR
-# ---------------
-# Expand into a shell expression prints the directory part of a path.
-AC_DEFUN([DX_DIRNAME_EXPR],
-         [[expr ".$1" : '\(\.\)[^/]*$' \| "x$1" : 'x\(.*\)/[^/]*$']])
-
-# DX_IF_FEATURE(FEATURE, IF-ON, IF-OFF)
-# -------------------------------------
-# Expands according to the M4 (static) status of the feature.
-AC_DEFUN([DX_IF_FEATURE], [ifelse(DX_FEATURE_$1, ON, [$2], [$3])])
-
-# DX_REQUIRE_PROG(VARIABLE, PROGRAM)
-# ----------------------------------
-# Require the specified program to be found for the DX_CURRENT_FEATURE to work.
-AC_DEFUN([DX_REQUIRE_PROG], [
-AC_PATH_TOOL([$1], [$2])
-if test "$DX_FLAG_[]DX_CURRENT_FEATURE$$1" = 1; then
-    AC_MSG_WARN([$2 not found - will not DX_CURRENT_DESCRIPTION])
-    AC_SUBST([DX_FLAG_[]DX_CURRENT_FEATURE], 0)
-fi
-])
-
-# DX_TEST_FEATURE(FEATURE)
-# ------------------------
-# Expand to a shell expression testing whether the feature is active.
-AC_DEFUN([DX_TEST_FEATURE], [test "$DX_FLAG_$1" = 1])
-
-# DX_CHECK_DEPEND(REQUIRED_FEATURE, REQUIRED_STATE)
-# -------------------------------------------------
-# Verify that a required features has the right state before trying to turn on
-# the DX_CURRENT_FEATURE.
-AC_DEFUN([DX_CHECK_DEPEND], [
-test "$DX_FLAG_$1" = "$2" \
-|| AC_MSG_ERROR([doxygen-DX_CURRENT_FEATURE ifelse([$2], 1,
-                            requires, contradicts) doxygen-DX_CURRENT_FEATURE])
-])
-
-# DX_CLEAR_DEPEND(FEATURE, REQUIRED_FEATURE, REQUIRED_STATE)
-# ----------------------------------------------------------
-# Turn off the DX_CURRENT_FEATURE if the required feature is off.
-AC_DEFUN([DX_CLEAR_DEPEND], [
-test "$DX_FLAG_$1" = "$2" || AC_SUBST([DX_FLAG_[]DX_CURRENT_FEATURE], 0)
-])
-
-# DX_FEATURE_ARG(FEATURE, DESCRIPTION,
-#                CHECK_DEPEND, CLEAR_DEPEND,
-#                REQUIRE, DO-IF-ON, DO-IF-OFF)
-# --------------------------------------------
-# Parse the command-line option controlling a feature. CHECK_DEPEND is called
-# if the user explicitly turns the feature on (and invokes DX_CHECK_DEPEND),
-# otherwise CLEAR_DEPEND is called to turn off the default state if a required
-# feature is disabled (using DX_CLEAR_DEPEND). REQUIRE performs additional
-# requirement tests (DX_REQUIRE_PROG). Finally, an automake flag is set and
-# DO-IF-ON or DO-IF-OFF are called according to the final state of the feature.
-AC_DEFUN([DX_ARG_ABLE], [
-    AC_DEFUN([DX_CURRENT_FEATURE], [$1])
-    AC_DEFUN([DX_CURRENT_DESCRIPTION], [$2])
-    AC_ARG_ENABLE(doxygen-$1,
-                  [AS_HELP_STRING(DX_IF_FEATURE([$1], [--disable-doxygen-$1],
-                                                      [--enable-doxygen-$1]),
-                                  DX_IF_FEATURE([$1], [don't $2], [$2]))],
-                  [
-case "$enableval" in
-#(
-y|Y|yes|Yes|YES)
-    AC_SUBST([DX_FLAG_$1], 1)
-    $3
-;; #(
-n|N|no|No|NO)
-    AC_SUBST([DX_FLAG_$1], 0)
-;; #(
-*)
-    AC_MSG_ERROR([invalid value '$enableval' given to doxygen-$1])
-;;
-esac
-], [
-AC_SUBST([DX_FLAG_$1], [DX_IF_FEATURE([$1], 1, 0)])
-$4
-])
-if DX_TEST_FEATURE([$1]); then
-    $5
-    :
-fi
-if DX_TEST_FEATURE([$1]); then
-    AM_CONDITIONAL(DX_COND_$1, :)
-    $6
-    :
-else
-    AM_CONDITIONAL(DX_COND_$1, false)
-    $7
-    :
-fi
-])
-
-## -------------- ##
-## Public macros. ##
-## -------------- ##
-
-# DX_XXX_FEATURE(DEFAULT_STATE)
-# -----------------------------
-AC_DEFUN([DX_DOXYGEN_FEATURE], [AC_DEFUN([DX_FEATURE_doc],  [$1])])
-AC_DEFUN([DX_MAN_FEATURE],     [AC_DEFUN([DX_FEATURE_man],  [$1])])
-AC_DEFUN([DX_HTML_FEATURE],    [AC_DEFUN([DX_FEATURE_html], [$1])])
-AC_DEFUN([DX_CHM_FEATURE],     [AC_DEFUN([DX_FEATURE_chm],  [$1])])
-AC_DEFUN([DX_CHI_FEATURE],     [AC_DEFUN([DX_FEATURE_chi],  [$1])])
-AC_DEFUN([DX_RTF_FEATURE],     [AC_DEFUN([DX_FEATURE_rtf],  [$1])])
-AC_DEFUN([DX_XML_FEATURE],     [AC_DEFUN([DX_FEATURE_xml],  [$1])])
-AC_DEFUN([DX_XML_FEATURE],     [AC_DEFUN([DX_FEATURE_xml],  [$1])])
-AC_DEFUN([DX_PDF_FEATURE],     [AC_DEFUN([DX_FEATURE_pdf],  [$1])])
-AC_DEFUN([DX_PS_FEATURE],      [AC_DEFUN([DX_FEATURE_ps],   [$1])])
-
-# DX_INIT_DOXYGEN(PROJECT, [CONFIG-FILE], [OUTPUT-DOC-DIR])
-# ---------------------------------------------------------
-# PROJECT also serves as the base name for the documentation files.
-# The default CONFIG-FILE is "Doxyfile" and OUTPUT-DOC-DIR is "doxygen-doc".
-AC_DEFUN([DX_INIT_DOXYGEN], [
-
-# Files:
-AC_SUBST([DX_PROJECT], [$1])
-AC_SUBST([DX_CONFIG], [ifelse([$2], [], Doxyfile, [$2])])
-AC_SUBST([DX_DOCDIR], [ifelse([$3], [], doxygen-doc, [$3])])
-
-# Environment variables used inside doxygen.cfg:
-DX_ENV_APPEND(SRCDIR, $srcdir)
-DX_ENV_APPEND(PROJECT, $DX_PROJECT)
-DX_ENV_APPEND(DOCDIR, $DX_DOCDIR)
-DX_ENV_APPEND(VERSION, $PACKAGE_VERSION)
-
-# Doxygen itself:
-DX_ARG_ABLE(doc, [generate any doxygen documentation],
-            [],
-            [],
-            [DX_REQUIRE_PROG([DX_DOXYGEN], doxygen)
-             DX_REQUIRE_PROG([DX_PERL], perl)],
-            [DX_ENV_APPEND(PERL_PATH, $DX_PERL)])
-
-# Dot for graphics:
-DX_ARG_ABLE(dot, [generate graphics for doxygen documentation],
-            [DX_CHECK_DEPEND(doc, 1)],
-            [DX_CLEAR_DEPEND(doc, 1)],
-            [DX_REQUIRE_PROG([DX_DOT], dot)],
-            [DX_ENV_APPEND(HAVE_DOT, YES)
-             DX_ENV_APPEND(DOT_PATH, [`DX_DIRNAME_EXPR($DX_DOT)`])],
-            [DX_ENV_APPEND(HAVE_DOT, NO)])
-
-# Man pages generation:
-DX_ARG_ABLE(man, [generate doxygen manual pages],
-            [DX_CHECK_DEPEND(doc, 1)],
-            [DX_CLEAR_DEPEND(doc, 1)],
-            [],
-            [DX_ENV_APPEND(GENERATE_MAN, YES)],
-            [DX_ENV_APPEND(GENERATE_MAN, NO)])
-
-# RTF file generation:
-DX_ARG_ABLE(rtf, [generate doxygen RTF documentation],
-            [DX_CHECK_DEPEND(doc, 1)],
-            [DX_CLEAR_DEPEND(doc, 1)],
-            [],
-            [DX_ENV_APPEND(GENERATE_RTF, YES)],
-            [DX_ENV_APPEND(GENERATE_RTF, NO)])
-
-# XML file generation:
-DX_ARG_ABLE(xml, [generate doxygen XML documentation],
-            [DX_CHECK_DEPEND(doc, 1)],
-            [DX_CLEAR_DEPEND(doc, 1)],
-            [],
-            [DX_ENV_APPEND(GENERATE_XML, YES)],
-            [DX_ENV_APPEND(GENERATE_XML, NO)])
-
-# (Compressed) HTML help generation:
-DX_ARG_ABLE(chm, [generate doxygen compressed HTML help documentation],
-            [DX_CHECK_DEPEND(doc, 1)],
-            [DX_CLEAR_DEPEND(doc, 1)],
-            [DX_REQUIRE_PROG([DX_HHC], hhc)],
-            [DX_ENV_APPEND(HHC_PATH, $DX_HHC)
-             DX_ENV_APPEND(GENERATE_HTML, YES)
-             DX_ENV_APPEND(GENERATE_HTMLHELP, YES)],
-            [DX_ENV_APPEND(GENERATE_HTMLHELP, NO)])
-
-# Seperate CHI file generation.
-DX_ARG_ABLE(chi, [generate doxygen seperate compressed HTML help index file],
-            [DX_CHECK_DEPEND(chm, 1)],
-            [DX_CLEAR_DEPEND(chm, 1)],
-            [],
-            [DX_ENV_APPEND(GENERATE_CHI, YES)],
-            [DX_ENV_APPEND(GENERATE_CHI, NO)])
-
-# Plain HTML pages generation:
-DX_ARG_ABLE(html, [generate doxygen plain HTML documentation],
-            [DX_CHECK_DEPEND(doc, 1) DX_CHECK_DEPEND(chm, 0)],
-            [DX_CLEAR_DEPEND(doc, 1) DX_CLEAR_DEPEND(chm, 0)],
-            [],
-            [DX_ENV_APPEND(GENERATE_HTML, YES)],
-            [DX_TEST_FEATURE(chm) || DX_ENV_APPEND(GENERATE_HTML, NO)])
-
-# PostScript file generation:
-DX_ARG_ABLE(ps, [generate doxygen PostScript documentation],
-            [DX_CHECK_DEPEND(doc, 1)],
-            [DX_CLEAR_DEPEND(doc, 1)],
-            [DX_REQUIRE_PROG([DX_LATEX], latex)
-             DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
-             DX_REQUIRE_PROG([DX_DVIPS], dvips)
-             DX_REQUIRE_PROG([DX_EGREP], egrep)])
-
-# PDF file generation:
-DX_ARG_ABLE(pdf, [generate doxygen PDF documentation],
-            [DX_CHECK_DEPEND(doc, 1)],
-            [DX_CLEAR_DEPEND(doc, 1)],
-            [DX_REQUIRE_PROG([DX_PDFLATEX], pdflatex)
-             DX_REQUIRE_PROG([DX_MAKEINDEX], makeindex)
-             DX_REQUIRE_PROG([DX_EGREP], egrep)])
-
-# LaTeX generation for PS and/or PDF:
-if DX_TEST_FEATURE(ps) || DX_TEST_FEATURE(pdf); then
-    AM_CONDITIONAL(DX_COND_latex, :)
-    DX_ENV_APPEND(GENERATE_LATEX, YES)
-else
-    AM_CONDITIONAL(DX_COND_latex, false)
-    DX_ENV_APPEND(GENERATE_LATEX, NO)
-fi
-
-# Paper size for PS and/or PDF:
-AC_ARG_VAR(DOXYGEN_PAPER_SIZE,
-           [a4wide (default), a4, letter, legal or executive])
-case "$DOXYGEN_PAPER_SIZE" in
-#(
-"")
-    AC_SUBST(DOXYGEN_PAPER_SIZE, "")
-;; #(
-a4wide|a4|letter|legal|executive)
-    DX_ENV_APPEND(PAPER_SIZE, $DOXYGEN_PAPER_SIZE)
-;; #(
-*)
-    AC_MSG_ERROR([unknown DOXYGEN_PAPER_SIZE='$DOXYGEN_PAPER_SIZE'])
-;;
-esac
-
-#For debugging:
-#echo DX_FLAG_doc=$DX_FLAG_doc
-#echo DX_FLAG_dot=$DX_FLAG_dot
-#echo DX_FLAG_man=$DX_FLAG_man
-#echo DX_FLAG_html=$DX_FLAG_html
-#echo DX_FLAG_chm=$DX_FLAG_chm
-#echo DX_FLAG_chi=$DX_FLAG_chi
-#echo DX_FLAG_rtf=$DX_FLAG_rtf
-#echo DX_FLAG_xml=$DX_FLAG_xml
-#echo DX_FLAG_pdf=$DX_FLAG_pdf
-#echo DX_FLAG_ps=$DX_FLAG_ps
-#echo DX_ENV=$DX_ENV
-])
+../../m4/ac_doxygen.m4

m4/acx_compilerflags.m4

@@ -1 @@
-# AC_SET_COMPILER_FLAGS(optimization, debugging, warnings)
-#----------------------------------------------------------------
-AC_DEFUN([AC_SET_COMPILER_FLAGS],[
-AC_MSG_NOTICE([Using AC@&t@_SET_COMPILER_FLAGS macro])
-
-dnl optimization
-if test ! x"$1" = xno; then
-        if test x"$2" = xno; then
-                if test x"$1" = xyes; then
-                        optimization="-O2"
-                else
-                        optimization="-O$1"
-                fi
-        fi
-fi
-dnl debugging info
-if ! test x"$2" = xno; then
-        if test x"$2" = xyes; then
-                debugging="-g3"
-        else
-                debugging="-g$2"
-        fi
-  AC_DEFINE(HAVE_DEBUG,1, ["Output debugging info"])
-  AC_SUBST(HAVE_DEBUG)
-fi
-
-dnl enable all warnings
-if test x"$3" = xsome; then
-        dnl even without debugging we want some minimal info of something's utterly wrong
-        Cwarnings="-Wall"
-        CXXwarnings="-Wall"
-fi
-if test x"$3" = xfull; then
-        Cwarnings="-Wall -W -Wstrict-prototypes -Wmissing-prototypes -Wold-style-definition -Wshadow -Wpointer-arith -Wcast-align -Wcast-qual -Wwrite-strings -Wredundant-decls -Wnested-externs -Wmissing-noreturn -Wformat-security -Wmissing-format-attribute -Winit-self"
-        CXXwarnings="-Wall -W -Wshadow -Wpointer-arith -Wcast-align -Wcast-qual -Wwrite-strings -Wredundant-decls -Wmissing-noreturn -Wformat-security -Wmissing-format-attribute -Winit-self"
-fi
-if test x"$3" = xnone; then
-        unset Cwarnings
-        unset CXXwarnings
-else
-        AC_DEFINE(HAVE_WARNINGS,$enable_warnings, ["Output compiler warnings"])
-fi
-
-# finally, apply whatever was set
-CFLAGS="$CFLAGS $debugging $optimization $Cwarnings"
-CXXFLAGS="$CXXFLAGS $debugging $optimization $CXXwarnings"
-
-])
+../../m4/acx_compilerflags.m4

src/Hbondangle.db

@@ -4 +4 @@
 7       180     110     106.67
 8       180     104.5   -1
-14      180     120     109.47
+14      180     120     109.5
 15      180     -1      -1
 16      180     -1      -1
 17      180 -1 -1
-20      180     120     109.47
 34      180 -1 -1
 35      180 -1 -1

src/Hbonddistance.db

@@ -9 +9 @@
 16      1.35    -1      -1
 17      1.29    -1      -1
-20      1.09    1.09    -1
 34      1.47    -1      -1
 35      1.44    -1      -1

src/Makefile.am

@@ -10 +10 @@
 
 
-EXTRA_DIST = ${molecuilder_DATA}
+#EXTRA_DIST = ${molecuilder_DATA}

src/analyzer.cpp

@@ -25 +25 @@
   periodentafel *periode = NULL; // and a period table of all elements
   EnergyMatrix Energy;
-  EnergyMatrix EnergyFragments;
+  EnergyMatrix Hcorrection;
   ForceMatrix Force;
-  ForceMatrix ForceFragments;
-  HessianMatrix Hessian;
-  HessianMatrix HessianFragments;
-  EnergyMatrix Hcorrection;
-  EnergyMatrix HcorrectionFragments;
   ForceMatrix Shielding;
   ForceMatrix ShieldingPAS;
-  ForceMatrix Chi;
-  ForceMatrix ChiPAS;
   EnergyMatrix Time;
+  EnergyMatrix EnergyFragments;
+  EnergyMatrix HcorrectionFragments;
+  ForceMatrix ForceFragments;
   ForceMatrix ShieldingFragments;
   ForceMatrix ShieldingPASFragments;
-  ForceMatrix ChiFragments;
-  ForceMatrix ChiPASFragments;
   KeySetsContainer KeySet;
   ofstream output;
@@ -55 +49 @@
   stringstream yrange;
   char *dir = NULL;
-  bool NoHCorrection = false;
-  bool NoHessian = false;
-  bool NoTime = false;
+  bool Hcorrected = true;
+  double norm;
   int counter;
   
@@ -91 +84 @@
   // ------------- Parse through all Fragment subdirs --------
   if (!Energy.ParseFragmentMatrix(argv[1], dir, EnergySuffix,0,0)) return 1;
-  if (!Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX,0,0)) {
-    NoHCorrection = true;
-    cout << "No HCorrection file found, skipping these." << endl;
-  }
-  
+  Hcorrected = Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX,0,0);
   if (!Force.ParseFragmentMatrix(argv[1], dir, ForcesSuffix,0,0)) return 1;
-  if (!Hessian.ParseFragmentMatrix(argv[1], dir, HessianSuffix,0,0)) {
-    NoHessian = true;
-    cout << "No Hessian file found, skipping these." << endl;
-  }
-  if (!Time.ParseFragmentMatrix(argv[1], dir, TimeSuffix, 10,1)) {
-    NoTime = true;
-    cout << "No speed file found, skipping these." << endl;
-  }
+  if (!Time.ParseFragmentMatrix(argv[1], dir, TimeSuffix, 10,1)) return 1;
   if (periode != NULL) { // also look for PAS values
     if (!Shielding.ParseFragmentMatrix(argv[1], dir, ShieldingSuffix, 1, 0)) return 1;
     if (!ShieldingPAS.ParseFragmentMatrix(argv[1], dir, ShieldingPASSuffix, 1, 0)) return 1;
-    if (!Chi.ParseFragmentMatrix(argv[1], dir, ChiSuffix, 1, 0)) return 1;
-    if (!ChiPAS.ParseFragmentMatrix(argv[1], dir, ChiPASSuffix, 1, 0)) return 1;
   }
 
   // ---------- Parse the TE Factors into an array -----------------
-  if (!Energy.InitialiseIndices()) return 1;
-  if (!NoHCorrection) 
-    Hcorrection.InitialiseIndices();
+  if (!Energy.ParseIndices()) return 1;
+  if (Hcorrected) Hcorrection.ParseIndices();
   
   // ---------- Parse the Force indices into an array ---------------
   if (!Force.ParseIndices(argv[1])) return 1;
   if (!ForceFragments.AllocateMatrix(Force.Header, Force.MatrixCounter, Force.RowCounter, Force.ColumnCounter)) return 1;
-  if (!ForceFragments.InitialiseIndices((class MatrixContainer *)&Force)) return 1;
-
-  // ---------- Parse hessian indices into an array -----------------
-  if (!NoHessian) {
-    if (!Hessian.InitialiseIndices((class MatrixContainer *)&Force)) return 1;
-    if (!HessianFragments.AllocateMatrix(Hessian.Header, Hessian.MatrixCounter, Hessian.RowCounter, Hessian.ColumnCounter)) return 1;
-    if (!HessianFragments.InitialiseIndices((class MatrixContainer *)&Force)) return 1;
-  }
+  if (!ForceFragments.ParseIndices(argv[1])) return 1;
 
   // ---------- Parse the shielding indices into an array ---------------
@@ -133 +105 @@
     if(!Shielding.ParseIndices(argv[1])) return 1;
     if(!ShieldingPAS.ParseIndices(argv[1])) return 1;
-    if (!ShieldingFragments.AllocateMatrix(Shielding.Header, Shielding.MatrixCounter, Shielding.RowCounter, Shielding.ColumnCounter)) return 1;
-    if (!ShieldingPASFragments.AllocateMatrix(ShieldingPAS.Header, ShieldingPAS.MatrixCounter, ShieldingPAS.RowCounter, ShieldingPAS.ColumnCounter)) return 1;
-    if(!ShieldingFragments.ParseIndices(argv[1])) return 1;
-    if(!ShieldingPASFragments.ParseIndices(argv[1])) return 1;
-    if(!Chi.ParseIndices(argv[1])) return 1;
-    if(!ChiPAS.ParseIndices(argv[1])) return 1;
-    if (!ChiFragments.AllocateMatrix(Chi.Header, Chi.MatrixCounter, Chi.RowCounter, Chi.ColumnCounter)) return 1;
-    if (!ChiPASFragments.AllocateMatrix(ChiPAS.Header, ChiPAS.MatrixCounter, ChiPAS.RowCounter, ChiPAS.ColumnCounter)) return 1;
-    if(!ChiFragments.ParseIndices(argv[1])) return 1;
-    if(!ChiPASFragments.ParseIndices(argv[1])) return 1;
   }
 
@@ -151 +113 @@
   // ---------- Parse fragment files created by 'joiner' into an array -------------
   if (!EnergyFragments.ParseFragmentMatrix(argv[1], dir, EnergyFragmentSuffix,0,0)) return 1;
-  if (!NoHCorrection) 
-    HcorrectionFragments.ParseFragmentMatrix(argv[1], dir, HcorrectionFragmentSuffix,0,0);
+  if (Hcorrected) HcorrectionFragments.ParseFragmentMatrix(argv[1], dir, HcorrectionFragmentSuffix,0,0);
   if (!ForceFragments.ParseFragmentMatrix(argv[1], dir, ForceFragmentSuffix,0,0)) return 1;
-  if (!NoHessian)
-    if (!HessianFragments.ParseFragmentMatrix(argv[1], dir, HessianFragmentSuffix,0,0)) return 1;
   if (periode != NULL) { // also look for PAS values
-    if (!ShieldingFragments.ParseFragmentMatrix(argv[1], dir, ShieldingFragmentSuffix, 1, 0)) return 1;
-    if (!ShieldingPASFragments.ParseFragmentMatrix(argv[1], dir, ShieldingPASFragmentSuffix, 1, 0)) return 1;
-    if (!ChiFragments.ParseFragmentMatrix(argv[1], dir, ChiFragmentSuffix, 1, 0)) return 1;
-    if (!ChiPASFragments.ParseFragmentMatrix(argv[1], dir, ChiPASFragmentSuffix, 1, 0)) return 1;
+    if (!ShieldingFragments.ParseFragmentMatrix(argv[1], dir, ShieldingSuffix, 1, 0)) return 1;
+    if (!ShieldingPASFragments.ParseFragmentMatrix(argv[1], dir, ShieldingPASSuffix, 1, 0)) return 1;
   }
 
@@ -169 +126 @@
   filename << argv[3] << "/" << "energy-forces.all";
   output.open(filename.str().c_str(), ios::out);
-  output << endl << "Total Energy" << endl << "==============" << endl << Energy.Header[Energy.MatrixCounter] << endl;
+  output << endl << "Total Energy" << endl << "==============" << endl << Energy.Header << endl;
   for(int j=0;j<Energy.RowCounter[Energy.MatrixCounter];j++) {
-    for(int k=0;k<Energy.ColumnCounter[Energy.MatrixCounter];k++)
+    for(int k=0;k<Energy.ColumnCounter;k++)
       output << scientific << Energy.Matrix[ Energy.MatrixCounter ][j][k] << "\t";
     output << endl;
@@ -177 +134 @@
   output << endl;
   
-  output << endl << "Total Forces" << endl << "===============" << endl << Force.Header[Force.MatrixCounter] << endl;
+  output << endl << "Total Forces" << endl << "===============" << endl << Force.Header << endl;
   for(int j=0;j<Force.RowCounter[Force.MatrixCounter];j++) {
-    for(int k=0;k<Force.ColumnCounter[Force.MatrixCounter];k++)
+    for(int k=0;k<Force.ColumnCounter;k++)
       output << scientific << Force.Matrix[ Force.MatrixCounter ][j][k] << "\t";
     output << endl;
@@ -185 +142 @@
   output << endl;
 
-  if (!NoHessian) {
-    output << endl << "Total Hessian" << endl << "===============" << endl << Hessian.Header[Hessian.MatrixCounter] << endl;
-    for(int j=0;j<Hessian.RowCounter[Hessian.MatrixCounter];j++) {
-      for(int k=0;k<Hessian.ColumnCounter[Hessian.MatrixCounter];k++)
-        output << scientific << Hessian.Matrix[ Hessian.MatrixCounter ][j][k] << "\t";
-      output << endl;
-    }
-    output << endl;
-  }
-
   if (periode != NULL) { // also look for PAS values
-    output << endl << "Total Shieldings" << endl << "===============" << endl << Shielding.Header[Hessian.MatrixCounter] << endl;
+    output << endl << "Total Shieldings" << endl << "===============" << endl << Shielding.Header << endl;
     for(int j=0;j<Shielding.RowCounter[Shielding.MatrixCounter];j++) {
-      for(int k=0;k<Shielding.ColumnCounter[Shielding.MatrixCounter];k++)
+      for(int k=0;k<Shielding.ColumnCounter;k++)
         output << scientific << Shielding.Matrix[ Shielding.MatrixCounter ][j][k] << "\t";
       output << endl;
@@ -204 +151 @@
     output << endl;
   
-    output << endl << "Total Shieldings PAS" << endl << "===============" << endl << ShieldingPAS.Header[ShieldingPAS.MatrixCounter] << endl;
+    output << endl << "Total Shieldings PAS" << endl << "===============" << endl << ShieldingPAS.Header << endl;
     for(int j=0;j<ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter];j++) {
-      for(int k=0;k<ShieldingPAS.ColumnCounter[ShieldingPAS.MatrixCounter];k++)
+      for(int k=0;k<ShieldingPAS.ColumnCounter;k++)
         output << scientific << ShieldingPAS.Matrix[ ShieldingPAS.MatrixCounter ][j][k] << "\t";
       output << endl;
     }
     output << endl;
-
-    output << endl << "Total Chis" << endl << "===============" << endl << Chi.Header[Chi.MatrixCounter] << endl;
-    for(int j=0;j<Chi.RowCounter[Chi.MatrixCounter];j++) {
-      for(int k=0;k<Chi.ColumnCounter[Chi.MatrixCounter];k++)
-        output << scientific << Chi.Matrix[ Chi.MatrixCounter ][j][k] << "\t";
-      output << endl;
-    }
-    output << endl;
-  
-    output << endl << "Total Chis PAS" << endl << "===============" << endl << ChiPAS.Header[ChiPAS.MatrixCounter] << endl;
-    for(int j=0;j<ChiPAS.RowCounter[ChiPAS.MatrixCounter];j++) {
-      for(int k=0;k<ChiPAS.ColumnCounter[ChiPAS.MatrixCounter];k++)
-        output << scientific << ChiPAS.Matrix[ ChiPAS.MatrixCounter ][j][k] << "\t";
-      output << endl;
-    }
-    output << endl;
-  }
-  
-  if (!NoTime) {
-    output << endl << "Total Times" << endl << "===============" << endl << Time.Header[Time.MatrixCounter] << endl;
-    for(int j=0;j<Time.RowCounter[Time.MatrixCounter];j++) {
-      for(int k=0;k<Time.ColumnCounter[Time.MatrixCounter];k++) {
-        output << scientific << Time.Matrix[ Time.MatrixCounter ][j][k] << "\t";
-      }
-      output << endl;
-    }
-    output << endl;
-  }
+  }
+  
+  output << endl << "Total Times" << endl << "===============" << endl << Time.Header << endl;
+  for(int j=0;j<Time.RowCounter[Time.MatrixCounter];j++) {
+    for(int k=0;k<Time.ColumnCounter;k++) {
+      output << scientific << Time.Matrix[ Time.MatrixCounter ][j][k] << "\t";
+    }
+    output << endl;
+  }
+  output << endl;
   output.close();
-  if (!NoTime)
-    for(int k=0;k<Time.ColumnCounter[Time.MatrixCounter];k++)
-      Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k] = Time.Matrix[ Time.MatrixCounter ][Time.RowCounter[Time.MatrixCounter]-1][k];
+  for(int k=0;k<Time.ColumnCounter;k++)
+    Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k] = Time.Matrix[ Time.MatrixCounter ][Time.RowCounter[Time.MatrixCounter]-1][k];
 
   // +++++++++++++++ ANALYZING ++++++++++++++++++++++++++++++
@@ -252 +180 @@
   // +++++++++++++++++++++++++++++++++++++++ Plotting Simtime vs Bond Order
   // +++++++++++++++++++++++++++++++++++++++ Plotting Delta Simtime vs Bond Order
-  if (!NoTime) {
-    if (!OpenOutputFile(output, argv[3], "SimTime-Order.dat" )) return false;
-    if (!OpenOutputFile(output2, argv[3], "DeltaSimTime-Order.dat" )) return false;
-    for(int j=Time.RowCounter[Time.MatrixCounter];j--;)
-      for(int k=Time.ColumnCounter[Time.MatrixCounter];k--;) {
-        Time.Matrix[ Time.MatrixCounter ][j][k] = 0.;
-      }
-    counter = 0;
-    output << "#Order\tFrag.No.\t" << Time.Header[Time.MatrixCounter] << endl;
-    output2 << "#Order\tFrag.No.\t" << Time.Header[Time.MatrixCounter] << endl;
-    for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
-      for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;)
-        for(int j=Time.RowCounter[Time.MatrixCounter];j--;)
-          for(int k=Time.ColumnCounter[Time.MatrixCounter];k--;) {
-            Time.Matrix[ Time.MatrixCounter ][j][k] += Time.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
-          }
-      counter += KeySet.FragmentsPerOrder[BondOrder];
-      output << BondOrder+1 << "\t" << counter;
-      output2 << BondOrder+1 << "\t" << counter;
-      for(int k=0;k<Time.ColumnCounter[Time.MatrixCounter];k++) {
-        output << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k];
-        if (fabs(Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k]) > MYEPSILON)
-          output2 << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k] / Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k];
-        else
-          output2 << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k];
-      }
-      output << endl;
-      output2 << endl;
-    }
-    output.close();
-    output2.close();
-  }
-
-  if (!NoHessian) {
-    // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in hessian to full QM
-    if (!CreateDataDeltaHessianOrderPerAtom(Hessian, HessianFragments, KeySet, argv[3], "DeltaHessian_xx-Order", "Plot of error between approximated hessian and full hessian versus the Bond Order", datum)) return 1;
-
-    if (!CreateDataDeltaFrobeniusOrderPerAtom(Hessian, HessianFragments, KeySet, argv[3], "DeltaFrobeniusHessian_xx-Order", "Plot of error between approximated hessian and full hessian in the frobenius norm versus the Bond Order", datum)) return 1;
-
-    // ++++++++++++++++++++++++++++++++++++++Plotting Hessian vs. Order
-    if (!CreateDataHessianOrderPerAtom(HessianFragments, KeySet, argv[3], "Hessian_xx-Order", "Plot of approximated hessian versus the Bond Order", datum)) return 1;
-    if (!AppendOutputFile(output, argv[3], "Hessian_xx-Order.dat" )) return false;
-    output << endl << "# Full" << endl;
-    for(int j=0;j<Hessian.RowCounter[Hessian.MatrixCounter];j++) {
-      output << j << "\t";
-      for(int k=0;k<Hessian.ColumnCounter[Force.MatrixCounter];k++)
-        output << scientific <<  Hessian.Matrix[ Hessian.MatrixCounter ][j][k] << "\t";
-      output << endl;
-    }
-    output.close();
-  }
-
-  // +++++++++++++++++++++++++++++++++++++++ Plotting shieldings
-  if (periode != NULL) { // also look for PAS values
-    if (!CreateDataDeltaForcesOrderPerAtom(ShieldingPAS, ShieldingPASFragments, KeySet, argv[3], "DeltaShieldingsPAS-Order", "Plot of error between approximated shieldings and full shieldings versus the Bond Order", datum)) return 1;
-    if (!CreateDataForcesOrderPerAtom(ShieldingPASFragments, KeySet, argv[3], "ShieldingsPAS-Order", "Plot of approximated shieldings versus the Bond Order", datum)) return 1;
-    if (!AppendOutputFile(output, argv[3], "ShieldingsPAS-Order.dat" )) return false;
-    output << endl << "# Full" << endl;
-    for(int j=0;j<ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter];j++) {
-      output << j << "\t";
-      for(int k=0;k<ShieldingPAS.ColumnCounter[ShieldingPAS.MatrixCounter];k++)
-        output << scientific <<  ShieldingPAS.Matrix[ ShieldingPAS.MatrixCounter ][j][k] << "\t"; //*(((k>1) && (k<6))? 1.e6 : 1.) << "\t";
-      output << endl;
-    }
-    output.close();
-    if (!CreateDataDeltaForcesOrderPerAtom(ChiPAS, ChiPASFragments, KeySet, argv[3], "DeltaChisPAS-Order", "Plot of error between approximated Chis and full Chis versus the Bond Order", datum)) return 1;
-    if (!CreateDataForcesOrderPerAtom(ChiPASFragments, KeySet, argv[3], "ChisPAS-Order", "Plot of approximated Chis versus the Bond Order", datum)) return 1;
-    if (!AppendOutputFile(output, argv[3], "ChisPAS-Order.dat" )) return false;
-    output << endl << "# Full" << endl;
-    for(int j=0;j<ChiPAS.RowCounter[ChiPAS.MatrixCounter];j++) {
-      output << j << "\t";
-      for(int k=0;k<ChiPAS.ColumnCounter[ChiPAS.MatrixCounter];k++)
-        output << scientific <<  ChiPAS.Matrix[ ChiPAS.MatrixCounter ][j][k] << "\t"; //*(((k>1) && (k<6))? 1.e6 : 1.) << "\t";
-      output << endl;
-    }
-    output.close();
-  }
-
-  
+  if (!OpenOutputFile(output, argv[3], "SimTime-Order.dat" )) return false;
+  if (!OpenOutputFile(output2, argv[3], "DeltaSimTime-Order.dat" )) return false;
+  for(int j=Time.RowCounter[Time.MatrixCounter];j--;)
+    for(int k=Time.ColumnCounter;k--;) {
+      Time.Matrix[ Time.MatrixCounter ][j][k] = 0.;
+    }
+  counter = 0;
+  output << "#Order\tFrag.No.\t" << Time.Header << endl;
+  output2 << "#Order\tFrag.No.\t" << Time.Header << endl;
+  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
+    for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;)
+      for(int j=Time.RowCounter[Time.MatrixCounter];j--;)
+        for(int k=Time.ColumnCounter;k--;) {
+          Time.Matrix[ Time.MatrixCounter ][j][k] += Time.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
+        }
+    counter += KeySet.FragmentsPerOrder[BondOrder];
+    output << BondOrder+1 << "\t" << counter;
+    output2 << BondOrder+1 << "\t" << counter;
+    for(int k=0;k<Time.ColumnCounter;k++) {
+      output << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k];
+      if (fabs(Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k]) > MYEPSILON)
+        output2 << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k] / Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter] ][k];
+      else
+        output2 << "\t" << scientific << Time.Matrix[ Time.MatrixCounter ][ Time.RowCounter[Time.MatrixCounter]-1 ][k];
+    }
+    output << endl;
+    output2 << endl;
+  }
+  output.close();
+  output2.close();
+
+
   // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in energy to full QM
   if (!CreateDataDeltaEnergyOrder(Energy, EnergyFragments, KeySet, argv[3], "DeltaEnergies-Order", "Plot of error between approximated and full energies energies versus the Bond Order", datum)) return 1;
@@ -351 +232 @@
   // ++++++++++++++++++++++++++++++++++++++Plotting Forces vs. Order
   if (!CreateDataForcesOrderPerAtom(ForceFragments, KeySet, argv[3], "Forces-Order", "Plot of approximated forces versus the Bond Order", datum)) return 1;
-  if (!AppendOutputFile(output, argv[3], "Forces-Order.dat" )) return false;
-  output << endl << "# Full" << endl;
-  for(int j=0;j<Force.RowCounter[Force.MatrixCounter];j++) {
-    output << j << "\t";
-    for(int k=0;k<Force.ColumnCounter[Force.MatrixCounter];k++)
-      output << scientific <<  Force.Matrix[ Force.MatrixCounter ][j][k] << "\t";
-    output << endl;
-  }
-  output.close();
+
   // min force
   if (!CreateDataForcesOrder(ForceFragments, KeySet, argv[3], "MinForces-Order", "Plot of min approximated forces versus the Bond Order", datum, CreateMinimumForce)) return 1;
@@ -404 +277 @@
   yrange.str("[1e-8:1e+1]");
   
-  if (!NoTime) {
-    // +++++++++++++++++++++++++++++++++++++++ Plotting Simtime vs Bond Order
-    if (!CreatePlotOrder(Time, KeySet, argv[3], "SimTime-Order", 1, "below", "y", "",  1, 1, "bond order k", "Evaluation time [s]", Orderxrange.str().c_str(), "", "1" , "with linespoints", EnergyPlotLine)) return 1;
-  }
+  // +++++++++++++++++++++++++++++++++++++++ Plotting Simtime vs Bond Order
+  if (!CreatePlotOrder(Time, KeySet, argv[3], "SimTime-Order", 1, "below", "y", "",  1, 1, "bond order k", "Evaluation time [s]", Orderxrange.str().c_str(), "", "1" , "with linespoints", EnergyPlotLine)) return 1;
   
   // +++++++++++++++++++++++++++++++++++++++ Plotting deviation in energy to full QM
@@ -488 +359 @@
   if (!CreatePlotOrder(ForceFragments, KeySet, argv[3], "MaxForces-FragmentOrder", 5, "below", "y", "set boxwidth 0.2", 1, 1, "bond order", "maximum of approximated forces [Ht/a.u.]", Orderxrange.str().c_str(), yrange.str().c_str(), "1" , "with boxes fillcolor", BoxesForcePlotLine)) return 1;
  
-  // +++++++++++++++++++++++++++++++=Ploting approximated and true shielding for each atom
-  if (periode != NULL) { // also look for PAS values
-    if(!OpenOutputFile(output, argv[3], "ShieldingsPAS-Order.pyx")) return 1;
-    if(!OpenOutputFile(output2, argv[3], "DeltaShieldingsPAS-Order.pyx")) return 1;
-    CreatePlotHeader(output, "ShieldingsPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical shielding value [ppm]");
-    CreatePlotHeader(output2, "DeltaShieldingsPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical shielding value [ppm]");
-    double step=0.8/KeySet.Order;
-    output << "set boxwidth " << step << endl;
-    output << "plot [0:" << ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter]+10 << "]\\" << endl;
-    output2 << "plot [0:" << ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter]+10 << "]\\" << endl;
-    for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
-      output << "'ShieldingsPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1+" << step*(double)BondOrder << "):7 with boxes, \\" << endl;
-      output2 << "'DeltaShieldingsPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1):7 with linespoints";
-      if (BondOrder-1 != KeySet.Order)
-        output2 << ", \\" << endl;
-    }
-    output << "'ShieldingsPAS-Order.dat' index " << KeySet.Order << " title 'Full' using ($1+" << step*(double)KeySet.Order << "):7 with boxes" << endl;
-    output2.close();  
-
-    if(!OpenOutputFile(output, argv[3], "ChisPAS-Order.pyx")) return 1;
-    if(!OpenOutputFile(output2, argv[3], "DeltaChisPAS-Order.pyx")) return 1;
-    CreatePlotHeader(output, "ChisPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical Chi value [ppm]");
-    CreatePlotHeader(output2, "DeltaChisPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical Chi value [ppm]");
-    output << "set boxwidth " << step << endl;
-    output << "plot [0:" << ChiPAS.RowCounter[ChiPAS.MatrixCounter]+10 << "]\\" << endl;
-    output2 << "plot [0:" << ChiPAS.RowCounter[ChiPAS.MatrixCounter]+10 << "]\\" << endl;
-    for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
-      output << "'ChisPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1+" << step*(double)BondOrder << "):7 with boxes, \\" << endl;
-      output2 << "'DeltaChisPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1):7 with linespoints";
-      if (BondOrder-1 != KeySet.Order)
-        output2 << ", \\" << endl;
-    }
-    output << "'ChisPAS-Order.dat' index " << KeySet.Order << " title 'Full' using ($1+" << step*(double)KeySet.Order << "):7 with boxes" << endl;
-    output.close();  
-    output2.close();  
-
-    if(!OpenOutputFile(output, argv[3], "ChisPAS-Order.pyx")) return 1;
-    if(!OpenOutputFile(output2, argv[3], "DeltaChisPAS-Order.pyx")) return 1;
-    CreatePlotHeader(output, "ChisPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical Chi value [ppm]");
-    CreatePlotHeader(output2, "DeltaChisPAS-Order", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "iso chemical Chi value [ppm]");
-    output << "set boxwidth " << step << endl;
-    output << "plot [0:" << ChiPAS.RowCounter[ChiPAS.MatrixCounter]+10 << "]\\" << endl;
-    output2 << "plot [0:" << ChiPAS.RowCounter[ChiPAS.MatrixCounter]+10 << "]\\" << endl;
-    for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
-      output << "'ChisPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1+" << step*(double)BondOrder << "):7 with boxes, \\" << endl;
-      output2 << "'DeltaChisPAS-Order.dat' index " << BondOrder << " title 'Order " << BondOrder+1 << "' using ($1):7 with linespoints";
-      if (BondOrder-1 != KeySet.Order)
-        output2 << ", \\" << endl;
-    }
-    output << "'ChisPAS-Order.dat' index " << KeySet.Order << " title 'Full' using ($1+" << step*(double)KeySet.Order << "):7 with boxes" << endl;
-    output.close();  
-    output2.close();  
-  }
-
   // create Makefile
   if(!OpenOutputFile(output, argv[3], "Makefile")) return 1;

src/atom.cpp

@@ -85 +85 @@
 };
 
-ostream & operator << (ostream &ost, const atom &a) 
+ostream & operator << (ostream &ost, atom &a) 
 {
   ost << "[" << a.Name << "|" << &a << "]";

src/bond.cpp

@@ -82 +82 @@
 };
 
-ostream & operator << (ostream &ost, const bond &b) 
+ostream & operator << (ostream &ost, bond &b) 
 {
   ost << "[" << b.leftatom->Name << " <" << b.BondDegree << "(H" << b.HydrogenBond << ")>" << b.rightatom->Name << "]";
@@ -98 +98 @@
   if(rightatom == Atom) 
     return leftatom;
-  cerr << "Bond " << *this << " does not contain atom " << *Atom << "!" << endl;
   return NULL;
 };

src/boundary.cpp

@@ -2 +2 @@
 #include "boundary.hpp"
 
-#define DEBUG 1
-#define DoTecplotOutput 0
-#define DoRaster3DOutput 1
-#define TecplotSuffix ".dat"
-#define Raster3DSuffix ".r3d"
-
 // ======================================== Points on Boundary =================================
 
@@ -14 +8 @@
   LinesCount = 0;
   Nr = -1;
-}
-;
+};
 
 BoundaryPointSet::BoundaryPointSet(atom *Walker)
@@ -22 +15 @@
   LinesCount = 0;
   Nr = Walker->nr;
-}
-;
+};
 
 BoundaryPointSet::~BoundaryPointSet()
@@ -29 +21 @@
   cout << Verbose(5) << "Erasing point nr. " << Nr << "." << endl;
   node = NULL;
-  lines.clear();
-}
-;
-
-void
-BoundaryPointSet::AddLine(class BoundaryLineSet *line)
-{
-  cout << Verbose(6) << "Adding " << *this << " to line " << *line << "."
-      << endl;
-  if (line->endpoints[0] == this)
-    {
-      lines.insert(LinePair(line->endpoints[1]->Nr, line));
-    }
-  else
-    {
-      lines.insert(LinePair(line->endpoints[0]->Nr, line));
-    }
+};
+
+void BoundaryPointSet::AddLine(class BoundaryLineSet *line) 
+{
+  cout << Verbose(6) << "Adding line " << *line << " to " << *this << "." << endl;
+  if (line->endpoints[0] == this) {
+    lines.insert ( LinePair( line->endpoints[1]->Nr, line) );
+  } else {
+    lines.insert ( LinePair( line->endpoints[0]->Nr, line) );
+  }
   LinesCount++;
-}
-;
-
-ostream &
-operator <<(ostream &ost, BoundaryPointSet &a)
+};
+
+ostream & operator << (ostream &ost, BoundaryPointSet &a) 
 {
   ost << "[" << a.Nr << "|" << a.node->Name << "]";
   return ost;
-}
-;
+};
 
 // ======================================== Lines on Boundary =================================
@@ -62 +44 @@
 BoundaryLineSet::BoundaryLineSet()
 {
-  for (int i = 0; i < 2; i++)
+  for (int i=0;i<2;i++)
     endpoints[i] = NULL;
   TrianglesCount = 0;
   Nr = -1;
-}
-;
+};
 
 BoundaryLineSet::BoundaryLineSet(class BoundaryPointSet *Point[2], int number)
@@ -76 +57 @@
   SetEndpointsOrdered(endpoints, Point[0], Point[1]);
   // add this line to the hash maps of both endpoints
-  Point[0]->AddLine(this); //Taken out, to check whether we can avoid unwanted double adding.
-  Point[1]->AddLine(this); //
+  Point[0]->AddLine(this);
+  Point[1]->AddLine(this);
   // clear triangles list
   TrianglesCount = 0;
   cout << Verbose(5) << "New Line with endpoints " << *this << "." << endl;
-}
-;
+};
 
 BoundaryLineSet::~BoundaryLineSet()
 {
-        for (int i = 0; i < 2; i++) {
-                cout << Verbose(5) << "Erasing Line Nr. " << Nr << " in boundary point " << *endpoints[i] << "." << endl;
-                endpoints[i]->lines.erase(Nr);
-                LineMap::iterator tester = endpoints[i]->lines.begin();
-                tester++;
-                if (tester == endpoints[i]->lines.end()) {
-                        cout << Verbose(5) << *endpoints[i] << " has no more lines it's attached to, erasing." << endl;
-                        if (endpoints[i] != NULL) {
-                                delete(endpoints[i]);
-                                endpoints[i] = NULL;
-                        } else
-                                cerr << "ERROR: Endpoint " << i << " has already been free'd." << endl;
-                } else
-                        cout << Verbose(5) << *endpoints[i] << " has still lines it's attached to." << endl;
-        }
-}
-;
-
-void
-BoundaryLineSet::AddTriangle(class BoundaryTriangleSet *triangle)
-{
-  cout << Verbose(6) << "Add " << triangle->Nr << " to line " << *this << "."
-      << endl;
-  triangles.insert(TrianglePair(TrianglesCount, triangle));
+  for (int i=0;i<2;i++) {
+    cout << Verbose(5) << "Erasing Line Nr. " << Nr << " in boundary point " << *endpoints[i] << "." << endl; 
+    endpoints[i]->lines.erase(Nr);
+    LineMap::iterator tester = endpoints[i]->lines.begin();
+    tester++;
+    if (tester == endpoints[i]->lines.end()) {
+      cout << Verbose(5) << *endpoints[i] << " has no more lines it's attached to, erasing." << endl;
+      delete(endpoints[i]);
+    } else
+      cout << Verbose(5) << *endpoints[i] << " has still lines it's attached to." << endl;
+  }
+};
+
+void BoundaryLineSet::AddTriangle(class BoundaryTriangleSet *triangle) 
+{
+  cout << Verbose(6) << "Add " << triangle->Nr << " to line " << *this << "." << endl;
+  triangles.insert ( TrianglePair( TrianglesCount, triangle) );
   TrianglesCount++;
-}
-;
-
-ostream &
-operator <<(ostream &ost, BoundaryLineSet &a)
-{
-  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << ","
-      << a.endpoints[1]->node->Name << "]";
+};
+
+ostream & operator << (ostream &ost, BoundaryLineSet &a) 
+{
+  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << "," << a.endpoints[1]->node->Name << "]";
   return ost;
-}
-;
+};
 
 // ======================================== Triangles on Boundary =================================
@@ -128 +97 @@
 BoundaryTriangleSet::BoundaryTriangleSet()
 {
-  for (int i = 0; i < 3; i++)
-    {
-      endpoints[i] = NULL;
-      lines[i] = NULL;
-    }
+  for (int i=0;i<3;i++) {
+    endpoints[i] = NULL;
+    lines[i] = NULL;
+  }
   Nr = -1;
-}
-;
-
-BoundaryTriangleSet::BoundaryTriangleSet(class BoundaryLineSet *line[3],
-    int number)
+};
+
+BoundaryTriangleSet::BoundaryTriangleSet(class BoundaryLineSet *line[3], int number)
 {
   // set number
@@ -144 +110 @@
   // set lines
   cout << Verbose(5) << "New triangle " << Nr << ":" << endl;
-  for (int i = 0; i < 3; i++)
-    {
-      lines[i] = line[i];
-      lines[i]->AddTriangle(this);
+  for (int i=0;i<3;i++) {
+    lines[i] = line[i];
+    lines[i]->AddTriangle(this);
+  }
+  // get ascending order of endpoints
+  map <int, class BoundaryPointSet * > OrderMap;
+  for(int i=0;i<3;i++)  // for all three lines
+    for (int j=0;j<2;j++) { // for both endpoints
+      OrderMap.insert ( pair <int, class BoundaryPointSet * >( line[i]->endpoints[j]->Nr, line[i]->endpoints[j]) );
+      // and we don't care whether insertion fails 
     }
-  // get ascending order of endpoints
-  map<int, class BoundaryPointSet *> OrderMap;
-  for (int i = 0; i < 3; i++)
-    // for all three lines
-    for (int j = 0; j < 2; j++)
-      { // for both endpoints
-        OrderMap.insert(pair<int, class BoundaryPointSet *> (
-            line[i]->endpoints[j]->Nr, line[i]->endpoints[j]));
-        // and we don't care whether insertion fails
-      }
   // set endpoints
   int Counter = 0;
   cout << Verbose(6) << " with end points ";
-  for (map<int, class BoundaryPointSet *>::iterator runner = OrderMap.begin(); runner
-      != OrderMap.end(); runner++)
-    {
-      endpoints[Counter] = runner->second;
-      cout << " " << *endpoints[Counter];
-      Counter++;
-    }
-  if (Counter < 3)
-    {
-      cerr << "ERROR! We have a triangle with only two distinct endpoints!"
-          << endl;
-      //exit(1);
-    }
+  for (map <int, class BoundaryPointSet * >::iterator runner = OrderMap.begin(); runner != OrderMap.end(); runner++) {
+    endpoints[Counter] = runner->second;
+    cout << " " << *endpoints[Counter];
+    Counter++;
+  }
+  if (Counter < 3) {
+    cerr << "ERROR! We have a triangle with only two distinct endpoints!" << endl;
+    //exit(1);
+  }
   cout << "." << endl;
-}
-;
+};
 
 BoundaryTriangleSet::~BoundaryTriangleSet()
 {
-        for (int i = 0; i < 3; i++) {
-                cout << Verbose(5) << "Erasing triangle Nr." << Nr << endl;
-                lines[i]->triangles.erase(Nr);
-                if (lines[i]->triangles.empty()) {
-                        cout << Verbose(5) << *lines[i] << " is no more attached to any triangle, erasing." << endl;
-                        if (lines[i] != NULL) {
-                                delete (lines[i]);
-                                lines[i] = NULL;
-                        } else
-                                cerr << "ERROR: This line " << i << " has already been free'd." << endl;
-                } else
-                        cout << Verbose(5) << *lines[i] << " is still attached to a triangle." << endl;
-        }
-}
-;
-
-void
-BoundaryTriangleSet::GetNormalVector(Vector &OtherVector)
+  for (int i=0;i<3;i++) {
+    cout << Verbose(5) << "Erasing triangle Nr." << Nr << endl;
+    lines[i]->triangles.erase(Nr);
+    TriangleMap::iterator tester = lines[i]->triangles.begin();
+    tester++;
+    if (tester == lines[i]->triangles.end()) {
+      cout << Verbose(5) << *lines[i] << " is no more attached to any triangle, erasing." << endl;
+      delete(lines[i]);
+    } else
+      cout << Verbose(5) << *lines[i] << " is still attached to a triangle." << endl;
+  }
+};
+
+void BoundaryTriangleSet::GetNormalVector(Vector &NormalVector)
 {
   // get normal vector
-  NormalVector.MakeNormalVector(&endpoints[0]->node->x, &endpoints[1]->node->x,
-      &endpoints[2]->node->x);
-
+  NormalVector.MakeNormalVector(&endpoints[0]->node->x, &endpoints[1]->node->x, &endpoints[2]->node->x);
+  
   // make it always point inward (any offset vector onto plane projected onto normal vector suffices)
-  if (endpoints[0]->node->x.Projection(&OtherVector) > 0)
+  if (endpoints[0]->node->x.Projection(&NormalVector) > 0)
     NormalVector.Scale(-1.);
-}
-;
-
-ostream &
-operator <<(ostream &ost, BoundaryTriangleSet &a)
-{
-  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << ","
-      << a.endpoints[1]->node->Name << "," << a.endpoints[2]->node->Name << "]";
+};
+
+ostream & operator << (ostream &ost, BoundaryTriangleSet &a) 
+{
+  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << "," << a.endpoints[1]->node->Name << "," << a.endpoints[2]->node->Name << "]";
   return ost;
-}
-;
+};
 
 // ========================================== F U N C T I O N S =================================
@@ -226 +174 @@
  * \return point which is shared or NULL if none
  */
-class BoundaryPointSet *
-GetCommonEndpoint(class BoundaryLineSet * line1, class BoundaryLineSet * line2)
-{
-  class BoundaryLineSet * lines[2] =
-    { line1, line2 };
+class BoundaryPointSet * GetCommonEndpoint(class BoundaryLineSet * line1, class BoundaryLineSet * line2)
+{
+  class BoundaryLineSet * lines[2] = {line1, line2};
   class BoundaryPointSet *node = NULL;
-  map<int, class BoundaryPointSet *> OrderMap;
-  pair<map<int, class BoundaryPointSet *>::iterator, bool> OrderTest;
-  for (int i = 0; i < 2; i++)
-    // for both lines
-    for (int j = 0; j < 2; j++)
-      { // for both endpoints
-        OrderTest = OrderMap.insert(pair<int, class BoundaryPointSet *> (
-            lines[i]->endpoints[j]->Nr, lines[i]->endpoints[j]));
-        if (!OrderTest.second)
-          { // if insertion fails, we have common endpoint
-            node = OrderTest.first->second;
-            cout << Verbose(5) << "Common endpoint of lines " << *line1
-                << " and " << *line2 << " is: " << *node << "." << endl;
-            j = 2;
-            i = 2;
-            break;
-          }
+  map <int, class BoundaryPointSet * > OrderMap;
+  pair < map <int, class BoundaryPointSet * >::iterator, bool > OrderTest;
+  for(int i=0;i<2;i++)  // for both lines
+    for (int j=0;j<2;j++) { // for both endpoints
+      OrderTest = OrderMap.insert ( pair <int, class BoundaryPointSet * >( lines[i]->endpoints[j]->Nr, lines[i]->endpoints[j]) );
+      if (!OrderTest.second) { // if insertion fails, we have common endpoint
+        node = OrderTest.first->second;
+        cout << Verbose(5) << "Common endpoint of lines " << *line1 << " and " << *line2 << " is: " << *node << "." << endl;
+        j=2;
+        i=2;
+        break;
       }
+    }
   return node;
-}
-;
+};
 
 /** Determines the boundary points of a cluster.
@@ -261 +201 @@
  * \param *mol molecule structure representing the cluster
  */
-Boundaries *
-GetBoundaryPoints(ofstream *out, molecule *mol)
+Boundaries * GetBoundaryPoints(ofstream *out, molecule *mol)
 {
   atom *Walker = NULL;
@@ -268 +207 @@
   LineMap LinesOnBoundary;
   TriangleMap TrianglesOnBoundary;
-
+  
   *out << Verbose(1) << "Finding all boundary points." << endl;
-  Boundaries *BoundaryPoints = new Boundaries[NDIM]; // first is alpha, second is (r, nr)
+  Boundaries *BoundaryPoints = new Boundaries [NDIM];  // first is alpha, second is (r, nr)
   BoundariesTestPair BoundaryTestPair;
   Vector AxisVector, AngleReferenceVector, AngleReferenceNormalVector;
   double radius, angle;
   // 3a. Go through every axis
-  for (int axis = 0; axis < NDIM; axis++)
-    {
-      AxisVector.Zero();
-      AngleReferenceVector.Zero();
-      AngleReferenceNormalVector.Zero();
-      AxisVector.x[axis] = 1.;
-      AngleReferenceVector.x[(axis + 1) % NDIM] = 1.;
-      AngleReferenceNormalVector.x[(axis + 2) % NDIM] = 1.;
-      //    *out << Verbose(1) << "Axisvector is ";
-      //    AxisVector.Output(out);
-      //    *out << " and AngleReferenceVector is ";
-      //    AngleReferenceVector.Output(out);
-      //    *out << "." << endl;
-      //    *out << " and AngleReferenceNormalVector is ";
-      //    AngleReferenceNormalVector.Output(out);
-      //    *out << "." << endl;
-      // 3b. construct set of all points, transformed into cylindrical system and with left and right neighbours
-      Walker = mol->start;
-      while (Walker->next != mol->end)
+  for (int axis=0; axis<NDIM; axis++)  {
+    AxisVector.Zero();
+    AngleReferenceVector.Zero();
+    AngleReferenceNormalVector.Zero();
+    AxisVector.x[axis] = 1.;
+    AngleReferenceVector.x[(axis+1)%NDIM] = 1.;
+    AngleReferenceNormalVector.x[(axis+2)%NDIM] = 1.;
+  //    *out << Verbose(1) << "Axisvector is ";
+  //    AxisVector.Output(out);
+  //    *out << " and AngleReferenceVector is ";
+  //    AngleReferenceVector.Output(out);
+  //    *out << "." << endl;
+  //    *out << " and AngleReferenceNormalVector is ";
+  //    AngleReferenceNormalVector.Output(out);
+  //    *out << "." << endl;
+    // 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;
+      Vector ProjectedVector;
+      ProjectedVector.CopyVector(&Walker->x);
+      ProjectedVector.ProjectOntoPlane(&AxisVector);
+      // correct for negative side
+      //if (Projection(y) < 0)
+        //angle = 2.*M_PI - angle;
+      radius = ProjectedVector.Norm();
+      if (fabs(radius) > MYEPSILON)
+        angle = ProjectedVector.Angle(&AngleReferenceVector);
+      else
+        angle = 0.;  // otherwise it's a vector in Axis Direction and unimportant for boundary issues
+        
+      //*out << "Checking sign in quadrant : " << ProjectedVector.Projection(&AngleReferenceNormalVector) << "." << endl;
+      if (ProjectedVector.Projection(&AngleReferenceNormalVector) > 0) {
+        angle = 2.*M_PI - angle;
+      }
+      //*out << Verbose(2) << "Inserting " << *Walker << ": (r, alpha) = (" << radius << "," << angle << "): ";
+      //ProjectedVector.Output(out);
+      //*out << endl;
+      BoundaryTestPair = BoundaryPoints[axis].insert( BoundariesPair (angle, DistancePair (radius, Walker) ) );
+      if (BoundaryTestPair.second) { // successfully inserted
+      } else { // same point exists, check first r, then distance of original vectors to center of gravity
+        *out << Verbose(2) << "Encountered two vectors whose projection onto axis " << axis << " is equal: " << endl;
+        *out << Verbose(2) << "Present vector: ";
+        BoundaryTestPair.first->second.second->x.Output(out);
+        *out << endl;
+        *out << Verbose(2) << "New vector: ";
+        Walker->x.Output(out);
+        *out << endl;
+        double tmp = ProjectedVector.Norm(); 
+        if (tmp > BoundaryTestPair.first->second.first) {
+          BoundaryTestPair.first->second.first = tmp;
+          BoundaryTestPair.first->second.second = Walker; 
+          *out << Verbose(2) << "Keeping new vector." << endl;
+        } else if (tmp == BoundaryTestPair.first->second.first) {
+          if (BoundaryTestPair.first->second.second->x.ScalarProduct(&BoundaryTestPair.first->second.second->x) < Walker->x.ScalarProduct(&Walker->x)) { // Norm() does a sqrt, which makes it a lot slower
+            BoundaryTestPair.first->second.second = Walker;
+            *out << Verbose(2) << "Keeping new vector." << endl;
+          } else {
+            *out << Verbose(2) << "Keeping present vector." << endl;
+          }
+        } else {
+            *out << Verbose(2) << "Keeping present vector." << endl;
+        }
+      }
+    }
+    // printing all inserted for debugging
+  //    {
+  //      *out << Verbose(2) << "Printing list of candidates for axis " << axis << " which we have inserted so far." << endl;
+  //      int i=0;
+  //      for(Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
+  //        if (runner != BoundaryPoints[axis].begin())
+  //          *out << ", " << i << ": " << *runner->second.second;
+  //        else
+  //          *out << i << ": " << *runner->second.second;
+  //        i++;
+  //      }
+  //      *out << endl;
+  //    }
+    // 3c. throw out points whose distance is less than the mean of left and right neighbours
+    bool flag = false;
+    do { // do as long as we still throw one out per round
+      *out << Verbose(1) << "Looking for candidates to kick out by convex condition ... " << endl;
+      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++) {
+        // set neighbours correctly
+        if (runner == BoundaryPoints[axis].begin()) {
+          left = BoundaryPoints[axis].end();
+        } else {
+          left = runner;
+        }
+        left--;
+        right = runner;
+        right++;
+        if (right == BoundaryPoints[axis].end()) {
+          right = BoundaryPoints[axis].begin();
+        }
+        // check distance
+        
+        // construct the vector of each side of the triangle on the projected plane (defined by normal vector AxisVector)
         {
-          Walker = Walker->next;
-          Vector ProjectedVector;
-          ProjectedVector.CopyVector(&Walker->x);
-          ProjectedVector.ProjectOntoPlane(&AxisVector);
-          // correct for negative side
-          //if (Projection(y) < 0)
-          //angle = 2.*M_PI - angle;
-          radius = ProjectedVector.Norm();
-          if (fabs(radius) > MYEPSILON)
-            angle = ProjectedVector.Angle(&AngleReferenceVector);
-          else
-            angle = 0.; // otherwise it's a vector in Axis Direction and unimportant for boundary issues
-
-          //*out << "Checking sign in quadrant : " << ProjectedVector.Projection(&AngleReferenceNormalVector) << "." << endl;
-          if (ProjectedVector.Projection(&AngleReferenceNormalVector) > 0)
-            {
-              angle = 2. * M_PI - angle;
-            }
-          //*out << Verbose(2) << "Inserting " << *Walker << ": (r, alpha) = (" << radius << "," << angle << "): ";
-          //ProjectedVector.Output(out);
-          //*out << endl;
-          BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle,
-              DistancePair (radius, Walker)));
-          if (BoundaryTestPair.second)
-            { // successfully inserted
-            }
-          else
-            { // same point exists, check first r, then distance of original vectors to center of gravity
-              *out << Verbose(2)
-                  << "Encountered two vectors whose projection onto axis "
-                  << axis << " is equal: " << endl;
-              *out << Verbose(2) << "Present vector: ";
-              BoundaryTestPair.first->second.second->x.Output(out);
-              *out << endl;
-              *out << Verbose(2) << "New vector: ";
-              Walker->x.Output(out);
-              *out << endl;
-              double tmp = ProjectedVector.Norm();
-              if (tmp > BoundaryTestPair.first->second.first)
-                {
-                  BoundaryTestPair.first->second.first = tmp;
-                  BoundaryTestPair.first->second.second = Walker;
-                  *out << Verbose(2) << "Keeping new vector." << endl;
-                }
-              else if (tmp == BoundaryTestPair.first->second.first)
-                {
-                  if (BoundaryTestPair.first->second.second->x.ScalarProduct(
-                      &BoundaryTestPair.first->second.second->x)
-                      < Walker->x.ScalarProduct(&Walker->x))
-                    { // Norm() does a sqrt, which makes it a lot slower
-                      BoundaryTestPair.first->second.second = Walker;
-                      *out << Verbose(2) << "Keeping new vector." << endl;
-                    }
-                  else
-                    {
-                      *out << Verbose(2) << "Keeping present vector." << endl;
-                    }
-                }
-              else
-                {
-                  *out << Verbose(2) << "Keeping present vector." << endl;
-                }
-            }
+          Vector SideA, SideB, SideC, SideH;
+          SideA.CopyVector(&left->second.second->x);
+          SideA.ProjectOntoPlane(&AxisVector);
+  //          *out << "SideA: ";
+  //          SideA.Output(out);
+  //          *out << endl;
+          
+          SideB.CopyVector(&right->second.second->x);
+          SideB.ProjectOntoPlane(&AxisVector);
+  //          *out << "SideB: ";
+  //          SideB.Output(out);
+  //          *out << endl;
+          
+          SideC.CopyVector(&left->second.second->x);
+          SideC.SubtractVector(&right->second.second->x);
+          SideC.ProjectOntoPlane(&AxisVector);
+  //          *out << "SideC: ";
+  //          SideC.Output(out);
+  //          *out << endl;
+  
+          SideH.CopyVector(&runner->second.second->x);
+          SideH.ProjectOntoPlane(&AxisVector);
+  //          *out << "SideH: ";
+  //          SideH.Output(out);
+  //          *out << endl;
+          
+          // calculate each length
+          double a = SideA.Norm();
+          //double b = SideB.Norm();
+          //double c = SideC.Norm();
+          double h = SideH.Norm();
+          // calculate the angles
+          double alpha = SideA.Angle(&SideH);
+          double beta = SideA.Angle(&SideC); 
+          double gamma = SideB.Angle(&SideH);
+          double delta = SideC.Angle(&SideH);
+          double MinDistance = a * sin(beta)/(sin(delta)) * (((alpha < M_PI/2.) || (gamma < M_PI/2.)) ? 1. : -1.);
+  //          *out << Verbose(2) << " I calculated: a = " << a << ", h = " << h << ", beta(" << left->second.second->Name << "," << left->second.second->Name << "-" << right->second.second->Name << ") = " << beta << ", delta(" << left->second.second->Name << "," << runner->second.second->Name << ") = " << delta << ", Min = " << MinDistance << "." << endl; 
+          //*out << Verbose(1) << "Checking CoG distance of runner " << *runner->second.second << " " << h << " against triangle's side length spanned by (" << *left->second.second << "," << *right->second.second << ") of " << MinDistance << "." << endl;
+          if ((fabs(h/fabs(h) - MinDistance/fabs(MinDistance)) < MYEPSILON) && (h <  MinDistance)) {
+            // throw out point
+            //*out << Verbose(1) << "Throwing out " << *runner->second.second << "." << endl;
+            BoundaryPoints[axis].erase(runner);
+            flag = true;
+          }
         }
-      // printing all inserted for debugging
-      //    {
-      //      *out << Verbose(2) << "Printing list of candidates for axis " << axis << " which we have inserted so far." << endl;
-      //      int i=0;
-      //      for(Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
-      //        if (runner != BoundaryPoints[axis].begin())
-      //          *out << ", " << i << ": " << *runner->second.second;
-      //        else
-      //          *out << i << ": " << *runner->second.second;
-      //        i++;
-      //      }
-      //      *out << endl;
-      //    }
-      // 3c. throw out points whose distance is less than the mean of left and right neighbours
-      bool flag = false;
-      do
-        { // do as long as we still throw one out per round
-          *out << Verbose(1)
-              << "Looking for candidates to kick out by convex condition ... "
-              << endl;
-          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++)
-            {
-              // set neighbours correctly
-              if (runner == BoundaryPoints[axis].begin())
-                {
-                  left = BoundaryPoints[axis].end();
-                }
-              else
-                {
-                  left = runner;
-                }
-              left--;
-              right = runner;
-              right++;
-              if (right == BoundaryPoints[axis].end())
-                {
-                  right = BoundaryPoints[axis].begin();
-                }
-              // check distance
-
-              // construct the vector of each side of the triangle on the projected plane (defined by normal vector AxisVector)
-                {
-                  Vector SideA, SideB, SideC, SideH;
-                  SideA.CopyVector(&left->second.second->x);
-                  SideA.ProjectOntoPlane(&AxisVector);
-                  //          *out << "SideA: ";
-                  //          SideA.Output(out);
-                  //          *out << endl;
-
-                  SideB.CopyVector(&right->second.second->x);
-                  SideB.ProjectOntoPlane(&AxisVector);
-                  //          *out << "SideB: ";
-                  //          SideB.Output(out);
-                  //          *out << endl;
-
-                  SideC.CopyVector(&left->second.second->x);
-                  SideC.SubtractVector(&right->second.second->x);
-                  SideC.ProjectOntoPlane(&AxisVector);
-                  //          *out << "SideC: ";
-                  //          SideC.Output(out);
-                  //          *out << endl;
-
-                  SideH.CopyVector(&runner->second.second->x);
-                  SideH.ProjectOntoPlane(&AxisVector);
-                  //          *out << "SideH: ";
-                  //          SideH.Output(out);
-                  //          *out << endl;
-
-                  // calculate each length
-                  double a = SideA.Norm();
-                  //double b = SideB.Norm();
-                  //double c = SideC.Norm();
-                  double h = SideH.Norm();
-                  // calculate the angles
-                  double alpha = SideA.Angle(&SideH);
-                  double beta = SideA.Angle(&SideC);
-                  double gamma = SideB.Angle(&SideH);
-                  double delta = SideC.Angle(&SideH);
-                  double MinDistance = a * sin(beta) / (sin(delta)) * (((alpha
-                      < M_PI / 2.) || (gamma < M_PI / 2.)) ? 1. : -1.);
-                  //          *out << Verbose(2) << " I calculated: a = " << a << ", h = " << h << ", beta(" << left->second.second->Name << "," << left->second.second->Name << "-" << right->second.second->Name << ") = " << beta << ", delta(" << left->second.second->Name << "," << runner->second.second->Name << ") = " << delta << ", Min = " << MinDistance << "." << endl;
-                  //*out << Verbose(1) << "Checking CoG distance of runner " << *runner->second.second << " " << h << " against triangle's side length spanned by (" << *left->second.second << "," << *right->second.second << ") of " << MinDistance << "." << endl;
-                  if ((fabs(h / fabs(h) - MinDistance / fabs(MinDistance))
-                      < MYEPSILON) && (h < MinDistance))
-                    {
-                      // throw out point
-                      //*out << Verbose(1) << "Throwing out " << *runner->second.second << "." << endl;
-                      BoundaryPoints[axis].erase(runner);
-                      flag = true;
-                    }
-                }
-            }
-        }
-      while (flag);
-    }
+      }
+    } while (flag);
+  } 
   return BoundaryPoints;
-}
-;
+};
 
 /** Determines greatest diameters of a cluster defined by its convex envelope.
@@ -469 +375 @@
  * \param IsAngstroem whether we have angstroem or atomic units
  * \return NDIM array of the diameters
- */
-double *
-GetDiametersOfCluster(ofstream *out, Boundaries *BoundaryPtr, molecule *mol,
-    bool IsAngstroem)
+ */ 
+double * GetDiametersOfCluster(ofstream *out, Boundaries *BoundaryPtr, molecule *mol, bool IsAngstroem)
 {
   // get points on boundary of NULL was given as parameter
   bool BoundaryFreeFlag = false;
   Boundaries *BoundaryPoints = BoundaryPtr;
-  if (BoundaryPoints == NULL)
-    {
-      BoundaryFreeFlag = true;
-      BoundaryPoints = GetBoundaryPoints(out, mol);
-    }
-  else
-    {
-      *out << Verbose(1) << "Using given boundary points set." << endl;
-    }
+  if (BoundaryPoints == NULL) {
+    BoundaryFreeFlag = true;
+    BoundaryPoints = GetBoundaryPoints(out, mol);
+  } else {
+    *out << Verbose(1) << "Using given boundary points set." << endl;
+  }
+  
   // determine biggest "diameter" of cluster for each axis
   Boundaries::iterator Neighbour, OtherNeighbour;
   double *GreatestDiameter = new double[NDIM];
-  for (int i = 0; i < NDIM; i++)
+  for(int i=0;i<NDIM;i++)
     GreatestDiameter[i] = 0.;
   double OldComponent, tmp, w1, w2;
   Vector DistanceVector, OtherVector;
   int component, Othercomponent;
-  for (int axis = 0; axis < NDIM; axis++)
-    { // regard each projected plane
-      //*out << Verbose(1) << "Current axis is " << axis << "." << endl;
-      for (int j = 0; j < 2; j++)
-        { // and for both axis on the current plane
-          component = (axis + j + 1) % NDIM;
-          Othercomponent = (axis + 1 + ((j + 1) & 1)) % NDIM;
-          //*out << Verbose(1) << "Current component is " << component << ", Othercomponent is " << Othercomponent << "." << endl;
-          for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner
-              != BoundaryPoints[axis].end(); runner++)
-            {
-              //*out << Verbose(2) << "Current runner is " << *(runner->second.second) << "." << endl;
-              // seek for the neighbours pair where the Othercomponent sign flips
-              Neighbour = runner;
-              Neighbour++;
-              if (Neighbour == BoundaryPoints[axis].end()) // make it wrap around
-                Neighbour = BoundaryPoints[axis].begin();
-              DistanceVector.CopyVector(&runner->second.second->x);
-              DistanceVector.SubtractVector(&Neighbour->second.second->x);
-              do
-                { // seek for neighbour pair where it flips
-                  OldComponent = DistanceVector.x[Othercomponent];
-                  Neighbour++;
-                  if (Neighbour == BoundaryPoints[axis].end()) // make it wrap around
-                    Neighbour = BoundaryPoints[axis].begin();
-                  DistanceVector.CopyVector(&runner->second.second->x);
-                  DistanceVector.SubtractVector(&Neighbour->second.second->x);
-                  //*out << Verbose(3) << "OldComponent is " << OldComponent << ", new one is " << DistanceVector.x[Othercomponent] << "." << endl;
-                }
-              while ((runner != Neighbour) && (fabs(OldComponent / fabs(
-                  OldComponent) - DistanceVector.x[Othercomponent] / fabs(
-                  DistanceVector.x[Othercomponent])) < MYEPSILON)); // as long as sign does not flip
-              if (runner != Neighbour)
-                {
-                  OtherNeighbour = Neighbour;
-                  if (OtherNeighbour == BoundaryPoints[axis].begin()) // make it wrap around
-                    OtherNeighbour = BoundaryPoints[axis].end();
-                  OtherNeighbour--;
-                  //*out << Verbose(2) << "The pair, where the sign of OtherComponent flips, is: " << *(Neighbour->second.second) << " and " << *(OtherNeighbour->second.second) << "." << endl;
-                  // now we have found the pair: Neighbour and OtherNeighbour
-                  OtherVector.CopyVector(&runner->second.second->x);
-                  OtherVector.SubtractVector(&OtherNeighbour->second.second->x);
-                  //*out << Verbose(2) << "Distances to Neighbour and OtherNeighbour are " << DistanceVector.x[component] << " and " << OtherVector.x[component] << "." << endl;
-                  //*out << Verbose(2) << "OtherComponents to Neighbour and OtherNeighbour are " << DistanceVector.x[Othercomponent] << " and " << OtherVector.x[Othercomponent] << "." << endl;
-                  // do linear interpolation between points (is exact) to extract exact intersection between Neighbour and OtherNeighbour
-                  w1 = fabs(OtherVector.x[Othercomponent]);
-                  w2 = fabs(DistanceVector.x[Othercomponent]);
-                  tmp = fabs((w1 * DistanceVector.x[component] + w2
-                      * OtherVector.x[component]) / (w1 + w2));
-                  // mark if it has greater diameter
-                  //*out << Verbose(2) << "Comparing current greatest " << GreatestDiameter[component] << " to new " << tmp << "." << endl;
-                  GreatestDiameter[component] = (GreatestDiameter[component]
-                      > tmp) ? GreatestDiameter[component] : tmp;
-                } //else
-              //*out << Verbose(2) << "Saw no sign flip, probably top or bottom node." << endl;
-            }
-        }
+  for(int axis=0;axis<NDIM;axis++) { // regard each projected plane
+    //*out << Verbose(1) << "Current axis is " << axis << "." << endl;
+    for (int j=0;j<2;j++) { // and for both axis on the current plane
+      component = (axis+j+1)%NDIM;
+      Othercomponent = (axis+1+((j+1) & 1))%NDIM;
+      //*out << Verbose(1) << "Current component is " << component << ", Othercomponent is " << Othercomponent << "." << endl;
+      for(Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
+        //*out << Verbose(2) << "Current runner is " << *(runner->second.second) << "." << endl;
+        // seek for the neighbours pair where the Othercomponent sign flips
+        Neighbour = runner;
+        Neighbour++;
+        if (Neighbour == BoundaryPoints[axis].end())  // make it wrap around
+          Neighbour = BoundaryPoints[axis].begin();
+        DistanceVector.CopyVector(&runner->second.second->x);
+        DistanceVector.SubtractVector(&Neighbour->second.second->x);
+        do {  // seek for neighbour pair where it flips
+          OldComponent = DistanceVector.x[Othercomponent]; 
+          Neighbour++;
+          if (Neighbour == BoundaryPoints[axis].end())  // make it wrap around
+            Neighbour = BoundaryPoints[axis].begin();
+          DistanceVector.CopyVector(&runner->second.second->x);
+          DistanceVector.SubtractVector(&Neighbour->second.second->x);
+          //*out << Verbose(3) << "OldComponent is " << OldComponent << ", new one is " << DistanceVector.x[Othercomponent] << "." << endl;
+        } while ((runner != Neighbour) && ( fabs( OldComponent/fabs(OldComponent) - DistanceVector.x[Othercomponent]/fabs(DistanceVector.x[Othercomponent]) ) < MYEPSILON)); // as long as sign does not flip
+        if (runner != Neighbour) {
+          OtherNeighbour = Neighbour;
+          if (OtherNeighbour == BoundaryPoints[axis].begin())  // make it wrap around
+            OtherNeighbour = BoundaryPoints[axis].end();
+          OtherNeighbour--;
+          //*out << Verbose(2) << "The pair, where the sign of OtherComponent flips, is: " << *(Neighbour->second.second) << " and " << *(OtherNeighbour->second.second) << "." << endl; 
+          // now we have found the pair: Neighbour and OtherNeighbour
+          OtherVector.CopyVector(&runner->second.second->x);
+          OtherVector.SubtractVector(&OtherNeighbour->second.second->x);
+          //*out << Verbose(2) << "Distances to Neighbour and OtherNeighbour are " << DistanceVector.x[component] << " and " << OtherVector.x[component] << "." << endl;
+          //*out << Verbose(2) << "OtherComponents to Neighbour and OtherNeighbour are " << DistanceVector.x[Othercomponent] << " and " << OtherVector.x[Othercomponent] << "." << endl;
+          // do linear interpolation between points (is exact) to extract exact intersection between Neighbour and OtherNeighbour
+          w1 = fabs(OtherVector.x[Othercomponent]);
+          w2 = fabs(DistanceVector.x[Othercomponent]);
+          tmp = fabs((w1*DistanceVector.x[component] + w2*OtherVector.x[component])/(w1+w2));
+          // mark if it has greater diameter
+          //*out << Verbose(2) << "Comparing current greatest " << GreatestDiameter[component] << " to new " << tmp << "." << endl;
+          GreatestDiameter[component] = (GreatestDiameter[component] > tmp) ? GreatestDiameter[component] : tmp;
+        } //else
+          //*out << Verbose(2) << "Saw no sign flip, probably top or bottom node." << endl;
+      }
     }
-  *out << Verbose(0) << "RESULT: The biggest diameters are "
-      << GreatestDiameter[0] << " and " << GreatestDiameter[1] << " and "
-      << GreatestDiameter[2] << " " << (IsAngstroem ? "angstrom"
-      : "atomiclength") << "." << endl;
+  }
+  *out << Verbose(0) << "RESULT: The biggest diameters are " << GreatestDiameter[0] << " and " << GreatestDiameter[1] << " and " << GreatestDiameter[2] << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "." << endl;
 
   // free reference lists
   if (BoundaryFreeFlag)
-    delete[] (BoundaryPoints);
+    delete[](BoundaryPoints);
 
   return GreatestDiameter;
-}
-;
-
-/** Creates the objects in a raster3d file (renderable with a header.r3d)
- * \param *out output stream for debugging
- * \param *tecplot output stream for tecplot data
- * \param *Tess Tesselation structure with constructed triangles
- * \param *mol molecule structure with atom positions
- */
-void write_raster3d_file(ofstream *out, ofstream *rasterfile, class Tesselation *Tess, class molecule *mol)
-{
-        atom *Walker = mol->start;
-        bond *Binder = mol->first;
-        int i;
-        Vector *center = mol->DetermineCenterOfAll(out);
-        if (rasterfile != NULL) {
-                //cout << Verbose(1) << "Writing Raster3D file ... ";
-                *rasterfile << "# Raster3D object description, created by MoleCuilder" << endl;
-                *rasterfile << "@header.r3d" << endl;
-                *rasterfile << "# All atoms as spheres" << endl;
-                while (Walker->next != mol->end) {
-                        Walker = Walker->next;
-                        *rasterfile << "2" << endl << "  ";     // 2 is sphere type
-                        for (i=0;i<NDIM;i++)
-                                *rasterfile << Walker->x.x[i]+center->x[i] << " ";
-                        *rasterfile << "\t0.1\t1. 1. 1." << endl; // radius 0.05 and white as colour
-                }
-
-                *rasterfile << "# All bonds as vertices" << endl;
-                while (Binder->next != mol->last) {
-                        Binder = Binder->next;
-                        *rasterfile << "3" << endl << "  ";     // 2 is round-ended cylinder type
-                        for (i=0;i<NDIM;i++)
-                                *rasterfile << Binder->leftatom->x.x[i]+center->x[i] << " ";
-                        *rasterfile << "\t0.03\t";
-                        for (i=0;i<NDIM;i++)
-                                *rasterfile << Binder->rightatom->x.x[i]+center->x[i] << " ";
-                        *rasterfile << "\t0.03\t0. 0. 1." << endl; // radius 0.05 and blue as colour
-                }
-
-                *rasterfile << "# All tesselation triangles" << endl;
-                for (TriangleMap::iterator TriangleRunner = Tess->TrianglesOnBoundary.begin(); TriangleRunner != Tess->TrianglesOnBoundary.end(); TriangleRunner++) {
-                        *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->x.x[j]+center->x[j] << " ";
-                                *rasterfile << "\t";
-                        }
-                        *rasterfile << "1. 0. 0." << endl;      // red as colour
-                        *rasterfile << "18" << endl << "  0.5 0.5 0.5" << endl; // 18 is transparency type for previous object
-                }
-        } else {
-                cerr << "ERROR: Given rasterfile is " << rasterfile << "." << endl;
-        }
-        delete(center);
-};
-
-/** This function creates the tecplot file, displaying the tesselation of the hull.
- * \param *out output stream for debugging
- * \param *tecplot output stream for tecplot data
- * \param N arbitrary number to differentiate various zones in the tecplot format
- */
-void
-write_tecplot_file(ofstream *out, ofstream *tecplot,
-    class Tesselation *TesselStruct, class molecule *mol, int N)
-{
-  if (tecplot != NULL)
-    {
-      *tecplot << "TITLE = \"3D CONVEX SHELL\"" << endl;
-      *tecplot << "VARIABLES = \"X\" \"Y\" \"Z\"" << endl;
-      *tecplot << "ZONE T=\"TRIANGLES" << N << "\", N="
-          << TesselStruct->PointsOnBoundaryCount << ", E="
-          << TesselStruct->TrianglesOnBoundaryCount
-          << ", DATAPACKING=POINT, ZONETYPE=FETRIANGLE" << endl;
-      int *LookupList = new int[mol->AtomCount];
-      for (int i = 0; i < mol->AtomCount; i++)
-        LookupList[i] = -1;
-
-      // print atom coordinates
-      *out << Verbose(2) << "The following triangles were created:";
-      int Counter = 1;
-      atom *Walker = NULL;
-      for (PointMap::iterator target = TesselStruct->PointsOnBoundary.begin(); target
-          != TesselStruct->PointsOnBoundary.end(); target++)
-        {
-          Walker = target->second->node;
-          LookupList[Walker->nr] = Counter++;
-          *tecplot << Walker->x.x[0] << " " << Walker->x.x[1] << " "
-              << Walker->x.x[2] << " " << endl;
-        }
-      *tecplot << endl;
-      // print connectivity
-      for (TriangleMap::iterator runner =
-          TesselStruct->TrianglesOnBoundary.begin(); runner
-          != TesselStruct->TrianglesOnBoundary.end(); runner++)
-        {
-          *out << " " << runner->second->endpoints[0]->node->Name << "<->"
-              << runner->second->endpoints[1]->node->Name << "<->"
-              << runner->second->endpoints[2]->node->Name;
-          *tecplot << LookupList[runner->second->endpoints[0]->node->nr] << " "
-              << LookupList[runner->second->endpoints[1]->node->nr] << " "
-              << LookupList[runner->second->endpoints[2]->node->nr] << endl;
-        }
-      delete[] (LookupList);
-      *out << endl;
-    }
-}
+};
+
 
 /** Determines the volume of a cluster.
  * Determines first the convex envelope, then tesselates it and calculates its volume.
  * \param *out output stream for debugging
- * \param *tecplot output stream for tecplot data
  * \param *configuration needed for path to store convex envelope file
  * \param *BoundaryPoints NDIM set of boundary points on the projected plane per axis, on return if desired
  * \param *mol molecule structure representing the cluster
- * \return determined volume of the cluster in cubed config:GetIsAngstroem()
  */
-double
-VolumeOfConvexEnvelope(ofstream *out, ofstream *tecplot, config *configuration,
-    Boundaries *BoundaryPtr, molecule *mol)
+double VolumeOfConvexEnvelope(ofstream *out, config *configuration, Boundaries *BoundaryPtr, molecule *mol) 
 {
   bool IsAngstroem = configuration->GetIsAngstroem();
@@ -690 +469 @@
   double volume = 0.;
   double PyramidVolume = 0.;
-  double G, h;
-  Vector x, y;
-  double a, b, c;
-
-  //Find_non_convex_border(out, tecplot, *TesselStruct, mol); // Is now called from command line.
+  double G,h;
+  Vector x,y;
+  double a,b,c;
 
   // 1. calculate center of gravity
   *out << endl;
   Vector *CenterOfGravity = mol->DetermineCenterOfGravity(out);
-
+  
   // 2. translate all points into CoG
   *out << Verbose(1) << "Translating system to Center of Gravity." << endl;
   Walker = mol->start;
-  while (Walker->next != mol->end)
-    {
-      Walker = Walker->next;
-      Walker->x.Translate(CenterOfGravity);
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    Walker->x.Translate(CenterOfGravity);
+  }
+  
+  // 3. Find all points on the boundary
+  if (BoundaryPoints == NULL) {
+    BoundaryFreeFlag = true;
+    BoundaryPoints = GetBoundaryPoints(out, mol);
+  } else {
+    *out << Verbose(1) << "Using given boundary points set." << endl;
+  }
+  
+  // 4. fill the boundary point list
+  for (int axis=0;axis<NDIM;axis++)
+    for(Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
+      TesselStruct->AddPoint(runner->second.second);
     }
 
-  // 3. Find all points on the boundary
-  if (BoundaryPoints == NULL)
-    {
-      BoundaryFreeFlag = true;
-      BoundaryPoints = GetBoundaryPoints(out, mol);
-    }
-  else
-    {
-      *out << Verbose(1) << "Using given boundary points set." << endl;
-    }
-
-  // 4. fill the boundary point list
-  for (int axis = 0; axis < NDIM; axis++)
-    for (Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner
-        != BoundaryPoints[axis].end(); runner++)
-      {
-        TesselStruct->AddPoint(runner->second.second);
-      }
-
-  *out << Verbose(2) << "I found " << TesselStruct->PointsOnBoundaryCount
-      << " points on the convex boundary." << endl;
+  *out << Verbose(2) << "I found " << TesselStruct->PointsOnBoundaryCount << " points on the convex boundary." << endl;
   // now we have the whole set of edge points in the BoundaryList
 
+
   // listing for debugging
-  //  *out << Verbose(1) << "Listing PointsOnBoundary:";
-  //  for(PointMap::iterator runner = PointsOnBoundary.begin(); runner != PointsOnBoundary.end(); runner++) {
-  //    *out << " " << *runner->second;
-  //  }
-  //  *out << endl;
-
+//  *out << Verbose(1) << "Listing PointsOnBoundary:";
+//  for(PointMap::iterator runner = PointsOnBoundary.begin(); runner != PointsOnBoundary.end(); runner++) {
+//    *out << " " << *runner->second;
+//  }
+//  *out << endl;
+  
   // 5a. guess starting triangle
   TesselStruct->GuessStartingTriangle(out);
-
+  
   // 5b. go through all lines, that are not yet part of two triangles (only of one so far)
   TesselStruct->TesselateOnBoundary(out, configuration, mol);
 
-  *out << Verbose(2) << "I created " << TesselStruct->TrianglesOnBoundaryCount
-      << " triangles with " << TesselStruct->LinesOnBoundaryCount
-      << " lines and " << TesselStruct->PointsOnBoundaryCount << " points."
-      << endl;
+  *out << Verbose(2) << "I created " << TesselStruct->TrianglesOnBoundaryCount << " triangles with " << TesselStruct->LinesOnBoundaryCount << " lines and " << TesselStruct->PointsOnBoundaryCount << " points." << endl;
 
   // 6a. Every triangle forms a pyramid with the center of gravity as its peak, sum up the volumes
-  *out << Verbose(1)
-      << "Calculating the volume of the pyramids formed out of triangles and center of gravity."
-      << endl;
-  for (TriangleMap::iterator runner = TesselStruct->TrianglesOnBoundary.begin(); runner
-      != TesselStruct->TrianglesOnBoundary.end(); runner++)
-    { // go through every triangle, calculate volume of its pyramid with CoG as peak
-      x.CopyVector(&runner->second->endpoints[0]->node->x);
-      x.SubtractVector(&runner->second->endpoints[1]->node->x);
-      y.CopyVector(&runner->second->endpoints[0]->node->x);
-      y.SubtractVector(&runner->second->endpoints[2]->node->x);
-      a = sqrt(runner->second->endpoints[0]->node->x.Distance(
-          &runner->second->endpoints[1]->node->x));
-      b = sqrt(runner->second->endpoints[0]->node->x.Distance(
-          &runner->second->endpoints[2]->node->x));
-      c = sqrt(runner->second->endpoints[2]->node->x.Distance(
-          &runner->second->endpoints[1]->node->x));
-      G = sqrt(((a * a + b * b + c * c) * (a * a + b * b + c * c) - 2 * (a * a
-          * a * a + b * b * b * b + c * c * c * c)) / 16.); // area of tesselated triangle
-      x.MakeNormalVector(&runner->second->endpoints[0]->node->x,
-          &runner->second->endpoints[1]->node->x,
-          &runner->second->endpoints[2]->node->x);
-      x.Scale(runner->second->endpoints[1]->node->x.Projection(&x));
-      h = x.Norm(); // distance of CoG to triangle
-      PyramidVolume = (1. / 3.) * G * h; // this formula holds for _all_ pyramids (independent of n-edge base or (not) centered peak)
-      *out << Verbose(2) << "Area of triangle is " << G << " "
-          << (IsAngstroem ? "angstrom" : "atomiclength") << "^2, height is "
-          << h << " and the volume is " << PyramidVolume << " "
-          << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
-      volume += PyramidVolume;
-    }
-  *out << Verbose(0) << "RESULT: The summed volume is " << setprecision(10)
-      << volume << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "^3."
-      << endl;
+  *out << Verbose(1) << "Calculating the volume of the pyramids formed out of triangles and center of gravity." << endl;
+  for (TriangleMap::iterator runner = TesselStruct->TrianglesOnBoundary.begin(); runner != TesselStruct->TrianglesOnBoundary.end(); runner++) { // go through every triangle, calculate volume of its pyramid with CoG as peak
+    x.CopyVector(&runner->second->endpoints[0]->node->x);
+    x.SubtractVector(&runner->second->endpoints[1]->node->x);
+    y.CopyVector(&runner->second->endpoints[0]->node->x);
+    y.SubtractVector(&runner->second->endpoints[2]->node->x);
+    a = sqrt(runner->second->endpoints[0]->node->x.Distance(&runner->second->endpoints[1]->node->x));
+    b = sqrt(runner->second->endpoints[0]->node->x.Distance(&runner->second->endpoints[2]->node->x));
+    c = sqrt(runner->second->endpoints[2]->node->x.Distance(&runner->second->endpoints[1]->node->x));
+    G =  sqrt( ( (a*a+b*b+c*c)*(a*a+b*b+c*c) - 2*(a*a*a*a + b*b*b*b + c*c*c*c) )/16.); // area of tesselated triangle
+    x.MakeNormalVector(&runner->second->endpoints[0]->node->x, &runner->second->endpoints[1]->node->x, &runner->second->endpoints[2]->node->x);
+    x.Scale(runner->second->endpoints[1]->node->x.Projection(&x));
+    h = x.Norm(); // distance of CoG to triangle
+    PyramidVolume = (1./3.) * G * h;    // this formula holds for _all_ pyramids (independent of n-edge base or (not) centered peak)
+    *out << Verbose(2) << "Area of triangle is " << G << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "^2, height is " << h << " and the volume is " << PyramidVolume << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+    volume += PyramidVolume; 
+  }
+  *out << Verbose(0) << "RESULT: The summed volume is " << setprecision(10) << volume << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+
 
   // 7. translate all points back from CoG
-  *out << Verbose(1) << "Translating system back from Center of Gravity."
-      << endl;
+  *out << Verbose(1) << "Translating system back from Center of Gravity." << endl;
   CenterOfGravity->Scale(-1);
   Walker = mol->start;
-  while (Walker->next != mol->end)
-    {
-      Walker = Walker->next;
-      Walker->x.Translate(CenterOfGravity);
-    }
-
-  // 8. Store triangles in tecplot file
-  write_tecplot_file(out, tecplot, TesselStruct, mol, 0);
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    Walker->x.Translate(CenterOfGravity);
+  }
 
   // free reference lists
   if (BoundaryFreeFlag)
-    delete[] (BoundaryPoints);
-
+    delete[](BoundaryPoints);
+  
   return volume;
-}
-;
+};
+
 
 /** Creates multiples of the by \a *mol given cluster and suspends them in water with a given final density.
@@ -815 +564 @@
  * \param celldensity desired average density in final cell
  */
-void
-PrepareClustersinWater(ofstream *out, config *configuration, molecule *mol,
-    double ClusterVolume, double celldensity)
+void PrepareClustersinWater(ofstream *out, config *configuration, molecule *mol, double ClusterVolume, double celldensity)
 {
   // transform to PAS
   mol->PrincipalAxisSystem(out, true);
-
+  
   // some preparations beforehand
   bool IsAngstroem = configuration->GetIsAngstroem();
@@ -827 +574 @@
   double clustervolume;
   if (ClusterVolume == 0)
-    clustervolume = VolumeOfConvexEnvelope(out, NULL, configuration,
-        BoundaryPoints, mol);
-  else
+    clustervolume = VolumeOfConvexEnvelope(out, configuration, BoundaryPoints, mol);
+  else 
     clustervolume = ClusterVolume;
-  double *GreatestDiameter = GetDiametersOfCluster(out, BoundaryPoints, mol,
-      IsAngstroem);
+  double *GreatestDiameter = GetDiametersOfCluster(out, BoundaryPoints, mol, IsAngstroem);
   Vector BoxLengths;
-  int repetition[NDIM] =
-    { 1, 1, 1 };
+  int repetition[NDIM] = {1, 1, 1};
   int TotalNoClusters = 1;
-  for (int i = 0; i < NDIM; i++)
+  for (int i=0;i<NDIM;i++)
     TotalNoClusters *= repetition[i];
 
@@ -843 +587 @@
   double totalmass = 0.;
   atom *Walker = mol->start;
-  while (Walker->next != mol->end)
-    {
-      Walker = Walker->next;
-      totalmass += Walker->type->mass;
-    }
-  *out << Verbose(0) << "RESULT: The summed mass is " << setprecision(10)
-      << totalmass << " atomicmassunit." << endl;
-
-  *out << Verbose(0) << "RESULT: The average density is " << setprecision(10)
-      << totalmass / clustervolume << " atomicmassunit/"
-      << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
-
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    totalmass += Walker->type->mass;
+  }
+  *out << Verbose(0) << "RESULT: The summed mass is " << setprecision(10) << totalmass << " atomicmassunit." << endl;
+  
+  *out << Verbose(0) << "RESULT: The average density is " << setprecision(10) << totalmass/clustervolume << " atomicmassunit/" << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+  
   // solve cubic polynomial
-  *out << Verbose(1) << "Solving equidistant suspension in water problem ..."
-      << endl;
+  *out << Verbose(1) << "Solving equidistant suspension in water problem ..." << endl;
   double cellvolume;
   if (IsAngstroem)
-    cellvolume = (TotalNoClusters * totalmass / SOLVENTDENSITY_A - (totalmass
-        / clustervolume)) / (celldensity - 1);
+    cellvolume = (TotalNoClusters*totalmass/SOLVENTDENSITY_A - (totalmass/clustervolume))/(celldensity-1);
   else
-    cellvolume = (TotalNoClusters * totalmass / SOLVENTDENSITY_a0 - (totalmass
-        / clustervolume)) / (celldensity - 1);
-  *out << Verbose(1) << "Cellvolume needed for a density of " << celldensity
-      << " g/cm^3 is " << cellvolume << " " << (IsAngstroem ? "angstrom"
-      : "atomiclength") << "^3." << endl;
-
-  double minimumvolume = TotalNoClusters * (GreatestDiameter[0]
-      * GreatestDiameter[1] * GreatestDiameter[2]);
-  *out << Verbose(1)
-      << "Minimum volume of the convex envelope contained in a rectangular box is "
-      << minimumvolume << " atomicmassunit/" << (IsAngstroem ? "angstrom"
-      : "atomiclength") << "^3." << endl;
-  if (minimumvolume > cellvolume)
-    {
-      cerr << Verbose(0)
-          << "ERROR: the containing box already has a greater volume than the envisaged cell volume!"
-          << endl;
-      cout << Verbose(0)
-          << "Setting Box dimensions to minimum possible, the greatest diameters."
-          << endl;
-      for (int i = 0; i < NDIM; i++)
-        BoxLengths.x[i] = GreatestDiameter[i];
-      mol->CenterEdge(out, &BoxLengths);
+    cellvolume = (TotalNoClusters*totalmass/SOLVENTDENSITY_a0 - (totalmass/clustervolume))/(celldensity-1);
+  *out << Verbose(1) << "Cellvolume needed for a density of " << celldensity << " g/cm^3 is " << cellvolume << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+  
+  double minimumvolume = TotalNoClusters*(GreatestDiameter[0]*GreatestDiameter[1]*GreatestDiameter[2]);
+  *out << Verbose(1) << "Minimum volume of the convex envelope contained in a rectangular box is " << minimumvolume << " atomicmassunit/" << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+  if (minimumvolume > cellvolume) {
+    cerr << Verbose(0) << "ERROR: the containing box already has a greater volume than the envisaged cell volume!" << endl;
+    cout << Verbose(0) << "Setting Box dimensions to minimum possible, the greatest diameters." << endl;
+    for(int i=0;i<NDIM;i++)
+      BoxLengths.x[i] = GreatestDiameter[i];
+    mol->CenterEdge(out, &BoxLengths);
+  } else {
+    BoxLengths.x[0] = (repetition[0]*GreatestDiameter[0] + repetition[1]*GreatestDiameter[1] + repetition[2]*GreatestDiameter[2]);
+    BoxLengths.x[1] = (repetition[0]*repetition[1]*GreatestDiameter[0]*GreatestDiameter[1] 
+              + repetition[0]*repetition[2]*GreatestDiameter[0]*GreatestDiameter[2] 
+              + repetition[1]*repetition[2]*GreatestDiameter[1]*GreatestDiameter[2]);
+    BoxLengths.x[2] = minimumvolume - cellvolume;
+    double x0 = 0.,x1 = 0.,x2 = 0.;
+    if (gsl_poly_solve_cubic(BoxLengths.x[0],BoxLengths.x[1],BoxLengths.x[2],&x0,&x1,&x2) == 1) // either 1 or 3 on return
+      *out << Verbose(0) << "RESULT: The resulting spacing is: " << x0 << " ." << endl;
+    else {
+      *out << Verbose(0) << "RESULT: The resulting spacings are: " << x0 << " and " << x1 << " and " << x2 << " ." << endl;
+      x0 = x2;  // sorted in ascending order
     }
-  else
-    {
-      BoxLengths.x[0] = (repetition[0] * GreatestDiameter[0] + repetition[1]
-          * GreatestDiameter[1] + repetition[2] * GreatestDiameter[2]);
-      BoxLengths.x[1] = (repetition[0] * repetition[1] * GreatestDiameter[0]
-          * GreatestDiameter[1] + repetition[0] * repetition[2]
-          * GreatestDiameter[0] * GreatestDiameter[2] + repetition[1]
-          * repetition[2] * GreatestDiameter[1] * GreatestDiameter[2]);
-      BoxLengths.x[2] = minimumvolume - cellvolume;
-      double x0 = 0., x1 = 0., x2 = 0.;
-      if (gsl_poly_solve_cubic(BoxLengths.x[0], BoxLengths.x[1],
-          BoxLengths.x[2], &x0, &x1, &x2) == 1) // either 1 or 3 on return
-        *out << Verbose(0) << "RESULT: The resulting spacing is: " << x0
-            << " ." << endl;
-      else
-        {
-          *out << Verbose(0) << "RESULT: The resulting spacings are: " << x0
-              << " and " << x1 << " and " << x2 << " ." << endl;
-          x0 = x2; // sorted in ascending order
-        }
-
-      cellvolume = 1;
-      for (int i = 0; i < NDIM; i++)
-        {
-          BoxLengths.x[i] = repetition[i] * (x0 + GreatestDiameter[i]);
-          cellvolume *= BoxLengths.x[i];
-        }
-
-      // set new box dimensions
-      *out << Verbose(0) << "Translating to box with these boundaries." << endl;
-      mol->CenterInBox((ofstream *) &cout, &BoxLengths);
+  
+    cellvolume = 1;
+    for(int i=0;i<NDIM;i++) {
+      BoxLengths.x[i] = repetition[i] * (x0 + GreatestDiameter[i]);
+      cellvolume *= BoxLengths.x[i];
     }
+  
+    // set new box dimensions
+    *out << Verbose(0) << "Translating to box with these boundaries." << endl;
+    mol->CenterInBox((ofstream *)&cout, &BoxLengths);
+  }
   // update Box of atoms by boundary
   mol->SetBoxDimension(&BoxLengths);
-  *out << Verbose(0) << "RESULT: The resulting cell dimensions are: "
-      << BoxLengths.x[0] << " and " << BoxLengths.x[1] << " and "
-      << BoxLengths.x[2] << " with total volume of " << cellvolume << " "
-      << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
-}
-;
+  *out << Verbose(0) << "RESULT: The resulting cell dimensions are: " << BoxLengths.x[0] << " and " << BoxLengths.x[1] << " and " << BoxLengths.x[2] << " with total volume of " << cellvolume << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "^3." << endl;
+};
+
 
 // =========================================================== class TESSELATION ===========================================
@@ -934 +648 @@
 Tesselation::Tesselation()
 {
-  PointsOnBoundaryCount = 0;
-  LinesOnBoundaryCount = 0;
+  PointsOnBoundaryCount = 0; 
+  LinesOnBoundaryCount = 0; 
   TrianglesOnBoundaryCount = 0;
-  TriangleFilesWritten = 0;
-}
-;
+};
 
 /** Constructor of class Tesselation.
@@ -946 +658 @@
 Tesselation::~Tesselation()
 {
-        cout << Verbose(1) << "Free'ing TesselStruct ... " << endl;
-        for (TriangleMap::iterator runner = TrianglesOnBoundary.begin(); runner != TrianglesOnBoundary.end(); runner++) {
-                if (runner->second != NULL) {
-                        delete (runner->second);
-                        runner->second = NULL;
-                } else
-                        cerr << "ERROR: The triangle " << runner->first << " has already been free'd." << endl;
-        }
-        for (LineMap::iterator runner = LinesOnBoundary.begin(); runner != LinesOnBoundary.end(); runner++) {
-                if (runner->second != NULL) {
-                        delete (runner->second);
-                        runner->second = NULL;
-                } else
-                        cerr << "ERROR: The line " << runner->first << " has already been free'd." << endl;
-        }
-        for (PointMap::iterator runner = PointsOnBoundary.begin(); runner != PointsOnBoundary.end(); runner++) {
-                if (runner->second != NULL) {
-                        delete (runner->second);
-                        runner->second = NULL;
-                } else
-                        cerr << "ERROR: The point " << runner->first << " has already been free'd." << endl;
-        }
-}
-;
+  for (TriangleMap::iterator runner = TrianglesOnBoundary.begin(); runner != TrianglesOnBoundary.end(); runner++) {
+    delete(runner->second);
+  }
+};
 
 /** Gueses first starting triangle of the convex envelope.
@@ -975 +667 @@
  * \param *out output stream for debugging
  * \param PointsOnBoundary set of boundary points defining the convex envelope of the cluster
- */
-void
-Tesselation::GuessStartingTriangle(ofstream *out)
+ */ 
+void Tesselation::GuessStartingTriangle(ofstream *out)
 {
   // 4b. create a starting triangle
   // 4b1. create all distances
   DistanceMultiMap DistanceMMap;
-  double distance, tmp;
-  Vector PlaneVector, TrialVector;
-  PointMap::iterator A, B, C; // three nodes of the first triangle
-  A = PointsOnBoundary.begin(); // the first may be chosen arbitrarily
-
-  // with A chosen, take each pair B,C and sort
-  if (A != PointsOnBoundary.end())
-    {
-      B = A;
-      B++;
-      for (; B != PointsOnBoundary.end(); B++)
-        {
-          C = B;
-          C++;
-          for (; C != PointsOnBoundary.end(); C++)
-            {
-              tmp = A->second->node->x.Distance(&B->second->node->x);
-              distance = tmp * tmp;
-              tmp = A->second->node->x.Distance(&C->second->node->x);
-              distance += tmp * tmp;
-              tmp = B->second->node->x.Distance(&C->second->node->x);
-              distance += tmp * tmp;
-              DistanceMMap.insert(DistanceMultiMapPair(distance, pair<
-                  PointMap::iterator, PointMap::iterator> (B, C)));
-            }
-        }
+  double distance;
+  for (PointMap::iterator runner = PointsOnBoundary.begin(); runner != PointsOnBoundary.end(); runner++) {
+    for(PointMap::iterator sprinter = PointsOnBoundary.begin(); sprinter != PointsOnBoundary.end(); sprinter++) {
+      if (runner->first < sprinter->first) {
+        distance = runner->second->node->x.Distance(&sprinter->second->node->x);
+        DistanceMMap.insert( DistanceMultiMapPair(distance, pair<PointMap::iterator, PointMap::iterator>(runner,sprinter) ) );
+      }
     }
-  //    // listing distances
-  //    *out << Verbose(1) << "Listing DistanceMMap:";
-  //    for(DistanceMultiMap::iterator runner = DistanceMMap.begin(); runner != DistanceMMap.end(); runner++) {
-  //      *out << " " << runner->first << "(" << *runner->second.first->second << ", " << *runner->second.second->second << ")";
-  //    }
-  //    *out << endl;
-  // 4b2. pick three baselines forming a triangle
-  // 1. we take from the smallest sum of squared distance as the base line BC (with peak A) onward as the triangle candidate
+  }
+
+//    // listing distances
+//    *out << Verbose(1) << "Listing DistanceMMap:";
+//    for(DistanceMultiMap::iterator runner = DistanceMMap.begin(); runner != DistanceMMap.end(); runner++) {
+//      *out << " " << runner->first << "(" << *runner->second.first->second << ", " << *runner->second.second->second << ")";
+//    }
+//    *out << endl;
+  
+  // 4b2. take three smallest distance that form a triangle
+  // we take the smallest distance as the base line
   DistanceMultiMap::iterator baseline = DistanceMMap.begin();
-  for (; baseline != DistanceMMap.end(); baseline++)
-    {
-      // we take from the smallest sum of squared distance as the base line BC (with peak A) onward as the triangle candidate
-      // 2. next, we have to check whether all points reside on only one side of the triangle
-      // 3. construct plane vector
-      PlaneVector.MakeNormalVector(&A->second->node->x,
-          &baseline->second.first->second->node->x,
-          &baseline->second.second->second->node->x);
-      *out << Verbose(2) << "Plane vector of candidate triangle is ";
-      PlaneVector.Output(out);
-      *out << endl;
-      // 4. loop over all points
-      double sign = 0.;
-      PointMap::iterator checker = PointsOnBoundary.begin();
-      for (; checker != PointsOnBoundary.end(); checker++)
-        {
-          // (neglecting A,B,C)
-          if ((checker == A) || (checker == baseline->second.first) || (checker
-              == baseline->second.second))
-            continue;
-          // 4a. project onto plane vector
-          TrialVector.CopyVector(&checker->second->node->x);
-          TrialVector.SubtractVector(&A->second->node->x);
-          distance = TrialVector.Projection(&PlaneVector);
-          if (fabs(distance) < 1e-4) // we need to have a small epsilon around 0 which is still ok
-            continue;
-          *out << Verbose(3) << "Projection of " << checker->second->node->Name
-              << " yields distance of " << distance << "." << endl;
-          tmp = distance / fabs(distance);
-          // 4b. Any have different sign to than before? (i.e. would lie outside convex hull with this starting triangle)
-          if ((sign != 0) && (tmp != sign))
-            {
-              // 4c. If so, break 4. loop and continue with next candidate in 1. loop
-              *out << Verbose(2) << "Current candidates: "
-                  << A->second->node->Name << ","
-                  << baseline->second.first->second->node->Name << ","
-                  << baseline->second.second->second->node->Name << " leave "
-                  << checker->second->node->Name << " outside the convex hull."
-                  << endl;
-              break;
-            }
-          else
-            { // note the sign for later
-              *out << Verbose(2) << "Current candidates: "
-                  << A->second->node->Name << ","
-                  << baseline->second.first->second->node->Name << ","
-                  << baseline->second.second->second->node->Name << " leave "
-                  << checker->second->node->Name << " inside the convex hull."
-                  << endl;
-              sign = tmp;
-            }
-          // 4d. Check whether the point is inside the triangle (check distance to each node
-          tmp = checker->second->node->x.Distance(&A->second->node->x);
-          int innerpoint = 0;
-          if ((tmp < A->second->node->x.Distance(
-              &baseline->second.first->second->node->x)) && (tmp
-              < A->second->node->x.Distance(
-                  &baseline->second.second->second->node->x)))
-            innerpoint++;
-          tmp = checker->second->node->x.Distance(
-              &baseline->second.first->second->node->x);
-          if ((tmp < baseline->second.first->second->node->x.Distance(
-              &A->second->node->x)) && (tmp
-              < baseline->second.first->second->node->x.Distance(
-                  &baseline->second.second->second->node->x)))
-            innerpoint++;
-          tmp = checker->second->node->x.Distance(
-              &baseline->second.second->second->node->x);
-          if ((tmp < baseline->second.second->second->node->x.Distance(
-              &baseline->second.first->second->node->x)) && (tmp
-              < baseline->second.second->second->node->x.Distance(
-                  &A->second->node->x)))
-            innerpoint++;
-          // 4e. If so, break 4. loop and continue with next candidate in 1. loop
-          if (innerpoint == 3)
-            break;
-        }
-      // 5. come this far, all on same side? Then break 1. loop and construct triangle
-      if (checker == PointsOnBoundary.end())
-        {
-          *out << "Looks like we have a candidate!" << endl;
-          break;
-        }
-    }
-  if (baseline != DistanceMMap.end())
-    {
-      BPS[0] = baseline->second.first->second;
-      BPS[1] = baseline->second.second->second;
-      BLS[0] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
-      BPS[0] = A->second;
-      BPS[1] = baseline->second.second->second;
-      BLS[1] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
-      BPS[0] = baseline->second.first->second;
-      BPS[1] = A->second;
-      BLS[2] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
-
-      // 4b3. insert created triangle
-      BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
-      TrianglesOnBoundary.insert(TrianglePair(TrianglesOnBoundaryCount, BTS));
-      TrianglesOnBoundaryCount++;
-      for (int i = 0; i < NDIM; i++)
-        {
-          LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount, BTS->lines[i]));
-          LinesOnBoundaryCount++;
-        }
-
-      *out << Verbose(1) << "Starting triangle is " << *BTS << "." << endl;
-    }
-  else
-    {
-      *out << Verbose(1) << "No starting triangle found." << endl;
-      exit(255);
-    }
-}
-;
+  BPS[0] = baseline->second.first->second;
+  BPS[1] = baseline->second.second->second;
+  BLS[0] = new class BoundaryLineSet(BPS , LinesOnBoundaryCount);
+
+  // take the second smallest as the second base line
+  DistanceMultiMap::iterator secondline = DistanceMMap.begin();
+  do {
+    secondline++;
+  } while (!(
+      ((BPS[0] == secondline->second.first->second) && (BPS[1] != secondline->second.second->second)) ||
+      ((BPS[0] == secondline->second.second->second) && (BPS[1] != secondline->second.first->second)) ||
+      ((BPS[1] == secondline->second.first->second) && (BPS[0] != secondline->second.second->second)) ||
+      ((BPS[1] == secondline->second.second->second) && (BPS[0] != secondline->second.first->second))
+    ));
+  BPS[0] = secondline->second.first->second;
+  BPS[1] = secondline->second.second->second;
+  BLS[1] = new class BoundaryLineSet(BPS , LinesOnBoundaryCount);
+
+  // connection yields the third line (note: first and second endpoint are sorted!)
+  if (baseline->second.first->second == secondline->second.first->second) {
+    SetEndpointsOrdered(BPS, baseline->second.second->second, secondline->second.second->second);
+  } else if (baseline->second.first->second == secondline->second.second->second) {
+    SetEndpointsOrdered(BPS, baseline->second.second->second, secondline->second.first->second);
+  } else if (baseline->second.second->second == secondline->second.first->second) {
+    SetEndpointsOrdered(BPS, baseline->second.first->second, baseline->second.second->second);
+  } else if (baseline->second.second->second == secondline->second.second->second) {
+    SetEndpointsOrdered(BPS, baseline->second.first->second, baseline->second.first->second);
+  }
+  BLS[2] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
+  
+  // 4b3. insert created triangle
+  BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+  TrianglesOnBoundary.insert( TrianglePair(TrianglesOnBoundaryCount, BTS) );
+  TrianglesOnBoundaryCount++;
+  for(int i=0;i<NDIM;i++) {
+    LinesOnBoundary.insert( LinePair(LinesOnBoundaryCount, BTS->lines[i]) );
+    LinesOnBoundaryCount++;
+  }
+
+  *out << Verbose(1) << "Starting triangle is " << *BTS << "." << endl;
+};
+
 
 /** Tesselates the convex envelope of a cluster from a single starting triangle.
@@ -1147 +749 @@
  * \param *mol the cluster as a molecule structure
  */
-void
-Tesselation::TesselateOnBoundary(ofstream *out, config *configuration,
-    molecule *mol)
+void Tesselation::TesselateOnBoundary(ofstream *out, config *configuration, molecule *mol)
 {
   bool flag;
@@ -1155 +755 @@
   class BoundaryPointSet *peak = NULL;
   double SmallestAngle, TempAngle;
-  Vector NormalVector, VirtualNormalVector, CenterVector, TempVector,
-      PropagationVector;
+  Vector NormalVector, VirtualNormalVector, CenterVector, TempVector, PropagationVector;
   LineMap::iterator LineChecker[2];
-  do
-    {
-      flag = false;
-      for (LineMap::iterator baseline = LinesOnBoundary.begin(); baseline
-          != LinesOnBoundary.end(); baseline++)
-        if (baseline->second->TrianglesCount == 1)
-          {
-            *out << Verbose(2) << "Current baseline is between "
-                << *(baseline->second) << "." << endl;
-            // 5a. go through each boundary point if not _both_ edges between either endpoint of the current line and this point exist (and belong to 2 triangles)
-            SmallestAngle = M_PI;
-            BTS = baseline->second->triangles.begin()->second; // there is only one triangle so far
-            // get peak point with respect to this base line's only triangle
-            for (int i = 0; i < 3; i++)
-              if ((BTS->endpoints[i] != baseline->second->endpoints[0])
-                  && (BTS->endpoints[i] != baseline->second->endpoints[1]))
-                peak = BTS->endpoints[i];
-            *out << Verbose(3) << " and has peak " << *peak << "." << endl;
-            // normal vector of triangle
-            BTS->GetNormalVector(NormalVector);
-            *out << Verbose(4) << "NormalVector of base triangle is ";
-            NormalVector.Output(out);
-            *out << endl;
-            // offset to center of triangle
-            CenterVector.Zero();
-            for (int i = 0; i < 3; i++)
-              CenterVector.AddVector(&BTS->endpoints[i]->node->x);
-            CenterVector.Scale(1. / 3.);
-            *out << Verbose(4) << "CenterVector of base triangle is ";
-            CenterVector.Output(out);
-            *out << endl;
-            // vector in propagation direction (out of triangle)
-            // project center vector onto triangle plane (points from intersection plane-NormalVector to plane-CenterVector intersection)
-            TempVector.CopyVector(&baseline->second->endpoints[0]->node->x);
-            TempVector.SubtractVector(&baseline->second->endpoints[1]->node->x);
-            PropagationVector.MakeNormalVector(&TempVector, &NormalVector);
-            TempVector.CopyVector(&CenterVector);
-            TempVector.SubtractVector(&baseline->second->endpoints[0]->node->x); // TempVector is vector on triangle plane pointing from one baseline egde towards center!
-            //*out << Verbose(2) << "Projection of propagation onto temp: " << PropagationVector.Projection(&TempVector) << "." << endl;
-            if (PropagationVector.Projection(&TempVector) > 0) // make sure normal propagation vector points outward from baseline
-              PropagationVector.Scale(-1.);
-            *out << Verbose(4) << "PropagationVector of base triangle is ";
-            PropagationVector.Output(out);
-            *out << endl;
-            winner = PointsOnBoundary.end();
-            for (PointMap::iterator target = PointsOnBoundary.begin(); target
-                != PointsOnBoundary.end(); target++)
-              if ((target->second != baseline->second->endpoints[0])
-                  && (target->second != baseline->second->endpoints[1]))
-                { // don't take the same endpoints
-                  *out << Verbose(3) << "Target point is " << *(target->second)
-                      << ":";
-                  bool continueflag = true;
-
-                  VirtualNormalVector.CopyVector(
-                      &baseline->second->endpoints[0]->node->x);
-                  VirtualNormalVector.AddVector(
-                      &baseline->second->endpoints[0]->node->x);
-                  VirtualNormalVector.Scale(-1. / 2.); // points now to center of base line
-                  VirtualNormalVector.AddVector(&target->second->node->x); // points from center of base line to target
-                  TempAngle = VirtualNormalVector.Angle(&PropagationVector);
-                  continueflag = continueflag && (TempAngle < (M_PI/2.)); // no bends bigger than Pi/2 (90 degrees)
-                  if (!continueflag)
-                    {
-                      *out << Verbose(4)
-                          << "Angle between propagation direction and base line to "
-                          << *(target->second) << " is " << TempAngle
-                          << ", bad direction!" << endl;
-                      continue;
-                    }
-                  else
-                    *out << Verbose(4)
-                        << "Angle between propagation direction and base line to "
-                        << *(target->second) << " is " << TempAngle
-                        << ", good direction!" << endl;
-                  LineChecker[0] = baseline->second->endpoints[0]->lines.find(
-                      target->first);
-                  LineChecker[1] = baseline->second->endpoints[1]->lines.find(
-                      target->first);
-                  //            if (LineChecker[0] != baseline->second->endpoints[0]->lines.end())
-                  //              *out << Verbose(4) << *(baseline->second->endpoints[0]) << " has line " << *(LineChecker[0]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[0]->second->TrianglesCount << " triangles." << endl;
-                  //            else
-                  //              *out << Verbose(4) << *(baseline->second->endpoints[0]) << " has no line to " << *(target->second) << " as endpoint." << endl;
-                  //            if (LineChecker[1] != baseline->second->endpoints[1]->lines.end())
-                  //              *out << Verbose(4) << *(baseline->second->endpoints[1]) << " has line " << *(LineChecker[1]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[1]->second->TrianglesCount << " triangles." << endl;
-                  //            else
-                  //              *out << Verbose(4) << *(baseline->second->endpoints[1]) << " has no line to " << *(target->second) << " as endpoint." << endl;
-                  // check first endpoint (if any connecting line goes to target or at least not more than 1)
-                  continueflag = continueflag && (((LineChecker[0]
-                      == baseline->second->endpoints[0]->lines.end())
-                      || (LineChecker[0]->second->TrianglesCount == 1)));
-                  if (!continueflag)
-                    {
-                      *out << Verbose(4) << *(baseline->second->endpoints[0])
-                          << " has line " << *(LineChecker[0]->second)
-                          << " to " << *(target->second)
-                          << " as endpoint with "
-                          << LineChecker[0]->second->TrianglesCount
-                          << " triangles." << endl;
-                      continue;
-                    }
-                  // check second endpoint (if any connecting line goes to target or at least not more than 1)
-                  continueflag = continueflag && (((LineChecker[1]
-                      == baseline->second->endpoints[1]->lines.end())
-                      || (LineChecker[1]->second->TrianglesCount == 1)));
-                  if (!continueflag)
-                    {
-                      *out << Verbose(4) << *(baseline->second->endpoints[1])
-                          << " has line " << *(LineChecker[1]->second)
-                          << " to " << *(target->second)
-                          << " as endpoint with "
-                          << LineChecker[1]->second->TrianglesCount
-                          << " triangles." << endl;
-                      continue;
-                    }
-                  // check whether the envisaged triangle does not already exist (if both lines exist and have same endpoint)
-                  continueflag = continueflag && (!(((LineChecker[0]
-                      != baseline->second->endpoints[0]->lines.end())
-                      && (LineChecker[1]
-                          != baseline->second->endpoints[1]->lines.end())
-                      && (GetCommonEndpoint(LineChecker[0]->second,
-                          LineChecker[1]->second) == peak))));
-                  if (!continueflag)
-                    {
-                      *out << Verbose(4) << "Current target is peak!" << endl;
-                      continue;
-                    }
-                  // in case NOT both were found
-                  if (continueflag)
-                    { // create virtually this triangle, get its normal vector, calculate angle
-                      flag = true;
-                      VirtualNormalVector.MakeNormalVector(
-                          &baseline->second->endpoints[0]->node->x,
-                          &baseline->second->endpoints[1]->node->x,
-                          &target->second->node->x);
-                      // make it always point inward
-                      if (baseline->second->endpoints[0]->node->x.Projection(
-                          &VirtualNormalVector) > 0)
-                        VirtualNormalVector.Scale(-1.);
-                      // calculate angle
-                      TempAngle = NormalVector.Angle(&VirtualNormalVector);
-                      *out << Verbose(4) << "NormalVector is ";
-                      VirtualNormalVector.Output(out);
-                      *out << " and the angle is " << TempAngle << "." << endl;
-                      if (SmallestAngle > TempAngle)
-                        { // set to new possible winner
-                          SmallestAngle = TempAngle;
-                          winner = target;
-                        }
-                    }
-                }
-            // 5b. The point of the above whose triangle has the greatest angle with the triangle the current line belongs to (it only belongs to one, remember!): New triangle
-            if (winner != PointsOnBoundary.end())
-              {
-                *out << Verbose(2) << "Winning target point is "
-                    << *(winner->second) << " with angle " << SmallestAngle
-                    << "." << endl;
-                // create the lins of not yet present
-                BLS[0] = baseline->second;
-                // 5c. add lines to the line set if those were new (not yet part of a triangle), delete lines that belong to two triangles)
-                LineChecker[0] = baseline->second->endpoints[0]->lines.find(
-                    winner->first);
-                LineChecker[1] = baseline->second->endpoints[1]->lines.find(
-                    winner->first);
-                if (LineChecker[0]
-                    == baseline->second->endpoints[0]->lines.end())
-                  { // create
-                    BPS[0] = baseline->second->endpoints[0];
-                    BPS[1] = winner->second;
-                    BLS[1] = new class BoundaryLineSet(BPS,
-                        LinesOnBoundaryCount);
-                    LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount,
-                        BLS[1]));
-                    LinesOnBoundaryCount++;
-                  }
-                else
-                  BLS[1] = LineChecker[0]->second;
-                if (LineChecker[1]
-                    == baseline->second->endpoints[1]->lines.end())
-                  { // create
-                    BPS[0] = baseline->second->endpoints[1];
-                    BPS[1] = winner->second;
-                    BLS[2] = new class BoundaryLineSet(BPS,
-                        LinesOnBoundaryCount);
-                    LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount,
-                        BLS[2]));
-                    LinesOnBoundaryCount++;
-                  }
-                else
-                  BLS[2] = LineChecker[1]->second;
-                BTS = new class BoundaryTriangleSet(BLS,
-                    TrianglesOnBoundaryCount);
-                TrianglesOnBoundary.insert(TrianglePair(
-                    TrianglesOnBoundaryCount, BTS));
-                TrianglesOnBoundaryCount++;
+  do {
+    flag = false;
+    for (LineMap::iterator baseline = LinesOnBoundary.begin(); baseline != LinesOnBoundary.end(); baseline++) 
+      if (baseline->second->TrianglesCount == 1) {
+        *out << Verbose(2) << "Current baseline is between " << *(baseline->second) << "." << endl; 
+        // 5a. go through each boundary point if not _both_ edges between either endpoint of the current line and this point exist (and belong to 2 triangles)
+        SmallestAngle = M_PI;
+        BTS = baseline->second->triangles.begin()->second; // there is only one triangle so far
+        // get peak point with respect to this base line's only triangle
+        for(int i=0;i<3;i++)
+          if ((BTS->endpoints[i] != baseline->second->endpoints[0]) && (BTS->endpoints[i] != baseline->second->endpoints[1]))
+            peak = BTS->endpoints[i];
+        *out << Verbose(3) << " and has peak " << *peak << "." << endl;
+        // normal vector of triangle
+        BTS->GetNormalVector(NormalVector);
+        *out << Verbose(4) << "NormalVector of base triangle is ";
+        NormalVector.Output(out);
+        *out << endl;
+        // offset to center of triangle
+        CenterVector.Zero();
+        for(int i=0;i<3;i++)
+          CenterVector.AddVector(&BTS->endpoints[i]->node->x);
+        CenterVector.Scale(1./3.);
+        *out << Verbose(4) << "CenterVector of base triangle is ";
+        CenterVector.Output(out);
+        *out << endl;
+        // vector in propagation direction (out of triangle)
+        // project center vector onto triangle plane (points from intersection plane-NormalVector to plane-CenterVector intersection)
+        TempVector.CopyVector(&baseline->second->endpoints[0]->node->x);
+        TempVector.SubtractVector(&baseline->second->endpoints[1]->node->x);
+        PropagationVector.MakeNormalVector(&TempVector, &NormalVector);
+        TempVector.CopyVector(&CenterVector);
+        TempVector.SubtractVector(&baseline->second->endpoints[0]->node->x);  // TempVector is vector on triangle plane pointing from one baseline egde towards center!
+        //*out << Verbose(2) << "Projection of propagation onto temp: " << PropagationVector.Projection(&TempVector) << "." << endl; 
+        if (PropagationVector.Projection(&TempVector) > 0)  // make sure normal propagation vector points outward from baseline
+          PropagationVector.Scale(-1.);
+        *out << Verbose(4) << "PropagationVector of base triangle is ";
+        PropagationVector.Output(out);
+        *out << endl;
+        winner = PointsOnBoundary.end();
+        for (PointMap::iterator target = PointsOnBoundary.begin(); target != PointsOnBoundary.end(); target++) 
+          if ((target->second != baseline->second->endpoints[0]) && (target->second != baseline->second->endpoints[1])) { // don't take the same endpoints
+            *out << Verbose(3) << "Target point is " << *(target->second) << ":";
+            bool continueflag = true;
+            
+            VirtualNormalVector.CopyVector(&baseline->second->endpoints[0]->node->x);
+            VirtualNormalVector.AddVector(&baseline->second->endpoints[0]->node->x);
+            VirtualNormalVector.Scale(-1./2.);   // points now to center of base line
+            VirtualNormalVector.AddVector(&target->second->node->x); // points from center of base line to target
+            TempAngle = VirtualNormalVector.Angle(&PropagationVector);
+            continueflag = continueflag && (TempAngle < (M_PI/2.)); // no bends bigger than Pi/2 (90 degrees)
+            if (!continueflag) {
+              *out << Verbose(4) << "Angle between propagation direction and base line to " << *(target->second) << " is " << TempAngle << ", bad direction!" << endl;
+              continue;
+            } else
+              *out << Verbose(4) << "Angle between propagation direction and base line to " << *(target->second) << " is " << TempAngle << ", good direction!" << endl;
+            LineChecker[0] = baseline->second->endpoints[0]->lines.find(target->first);
+            LineChecker[1] = baseline->second->endpoints[1]->lines.find(target->first);
+  //            if (LineChecker[0] != baseline->second->endpoints[0]->lines.end())
+  //              *out << Verbose(4) << *(baseline->second->endpoints[0]) << " has line " << *(LineChecker[0]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[0]->second->TrianglesCount << " triangles." << endl;
+  //            else
+  //              *out << Verbose(4) << *(baseline->second->endpoints[0]) << " has no line to " << *(target->second) << " as endpoint." << endl;
+  //            if (LineChecker[1] != baseline->second->endpoints[1]->lines.end())
+  //              *out << Verbose(4) << *(baseline->second->endpoints[1]) << " has line " << *(LineChecker[1]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[1]->second->TrianglesCount << " triangles." << endl;
+  //            else
+  //              *out << Verbose(4) << *(baseline->second->endpoints[1]) << " has no line to " << *(target->second) << " as endpoint." << endl;
+            // check first endpoint (if any connecting line goes to target or at least not more than 1)
+            continueflag = continueflag && (( (LineChecker[0] == baseline->second->endpoints[0]->lines.end()) || (LineChecker[0]->second->TrianglesCount == 1)));
+            if (!continueflag) {
+              *out << Verbose(4) << *(baseline->second->endpoints[0]) << " has line " << *(LineChecker[0]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[0]->second->TrianglesCount << " triangles." << endl;
+              continue;
+            }
+            // check second endpoint (if any connecting line goes to target or at least not more than 1)
+            continueflag = continueflag && (( (LineChecker[1] == baseline->second->endpoints[1]->lines.end()) || (LineChecker[1]->second->TrianglesCount == 1)));
+            if (!continueflag) {
+              *out << Verbose(4) << *(baseline->second->endpoints[1]) << " has line " << *(LineChecker[1]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[1]->second->TrianglesCount << " triangles." << endl;
+              continue;
+            }
+            // check whether the envisaged triangle does not already exist (if both lines exist and have same endpoint)
+            continueflag = continueflag && (!(
+                ((LineChecker[0] != baseline->second->endpoints[0]->lines.end()) && (LineChecker[1] != baseline->second->endpoints[1]->lines.end()) 
+                && (GetCommonEndpoint(LineChecker[0]->second, LineChecker[1]->second) == peak))
+               ));
+            if (!continueflag) {
+              *out << Verbose(4) << "Current target is peak!" << endl;
+              continue;
+            }
+            // in case NOT both were found
+            if (continueflag) {  // create virtually this triangle, get its normal vector, calculate angle
+              flag = true;
+              VirtualNormalVector.MakeNormalVector(&baseline->second->endpoints[0]->node->x, &baseline->second->endpoints[1]->node->x, &target->second->node->x);
+              // make it always point inward
+              if (baseline->second->endpoints[0]->node->x.Projection(&VirtualNormalVector) > 0)
+                VirtualNormalVector.Scale(-1.);
+              // calculate angle
+              TempAngle = NormalVector.Angle(&VirtualNormalVector);
+              *out << Verbose(4) << "NormalVector is ";
+              VirtualNormalVector.Output(out);
+              *out << " and the angle is " << TempAngle << "." << endl;
+              if (SmallestAngle > TempAngle) {  // set to new possible winner
+                SmallestAngle = TempAngle;
+                winner = target;
               }
-            else
-              {
-                *out << Verbose(1)
-                    << "I could not determine a winner for this baseline "
-                    << *(baseline->second) << "." << endl;
-              }
-
-            // 5d. If the set of lines is not yet empty, go to 5. and continue
+            }
           }
-        else
-          *out << Verbose(2) << "Baseline candidate " << *(baseline->second)
-              << " has a triangle count of "
-              << baseline->second->TrianglesCount << "." << endl;
-    }
-  while (flag);
-
-}
-;
+        // 5b. The point of the above whose triangle has the greatest angle with the triangle the current line belongs to (it only belongs to one, remember!): New triangle
+        if (winner != PointsOnBoundary.end()) {
+          *out << Verbose(2) << "Winning target point is " << *(winner->second) << " with angle " << SmallestAngle << "." << endl;
+          // create the lins of not yet present
+          BLS[0] = baseline->second;
+          // 5c. add lines to the line set if those were new (not yet part of a triangle), delete lines that belong to two triangles)
+          LineChecker[0] = baseline->second->endpoints[0]->lines.find(winner->first);
+          LineChecker[1] = baseline->second->endpoints[1]->lines.find(winner->first);
+          if (LineChecker[0] == baseline->second->endpoints[0]->lines.end()) { // create
+            BPS[0] = baseline->second->endpoints[0];
+            BPS[1] = winner->second;
+            BLS[1] = new class BoundaryLineSet(BPS , LinesOnBoundaryCount);
+            LinesOnBoundary.insert( LinePair(LinesOnBoundaryCount, BLS[1]) );
+            LinesOnBoundaryCount++;
+          } else
+            BLS[1] = LineChecker[0]->second;
+          if (LineChecker[1] == baseline->second->endpoints[1]->lines.end()) { // create
+            BPS[0] = baseline->second->endpoints[1];
+            BPS[1] = winner->second;
+            BLS[2] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
+            LinesOnBoundary.insert( LinePair(LinesOnBoundaryCount, BLS[2]) );
+            LinesOnBoundaryCount++;
+          } else
+            BLS[2] = LineChecker[1]->second;
+          BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+          TrianglesOnBoundary.insert( TrianglePair(TrianglesOnBoundaryCount, BTS) );
+          TrianglesOnBoundaryCount++;
+        } else {
+          *out << Verbose(1) << "I could not determine a winner for this baseline " << *(baseline->second) << "." << endl;
+        }
+  
+        // 5d. If the set of lines is not yet empty, go to 5. and continue
+      } else
+        *out << Verbose(2) << "Baseline candidate " << *(baseline->second) << " has a triangle count of " << baseline->second->TrianglesCount << "." << endl;
+  } while (flag);
+  
+  stringstream line;
+  line << configuration->configpath << "/" << CONVEXENVELOPE;
+  *out << Verbose(1) << "Storing convex envelope in tecplot data file " << line.str() << "." << endl;
+  ofstream output(line.str().c_str());
+  output << "TITLE = \"3D CONVEX SHELL\"" << endl;
+  output << "VARIABLES = \"X\" \"Y\" \"Z\"" << endl;
+  output << "ZONE T=\"TRIANGLES\", N=" << PointsOnBoundaryCount << ", E=" << TrianglesOnBoundaryCount << ", DATAPACKING=POINT, ZONETYPE=FETRIANGLE" << endl;
+  int *LookupList = new int[mol->AtomCount];
+  for (int i=0;i<mol->AtomCount;i++)
+    LookupList[i] = -1;
+  
+  // print atom coordinates
+  *out << Verbose(2) << "The following triangles were created:";
+  int Counter = 1;
+  atom *Walker = NULL;
+  for (PointMap::iterator target = PointsOnBoundary.begin(); target != PointsOnBoundary.end(); target++) {
+    Walker = target->second->node;
+    LookupList[Walker->nr] = Counter++;
+    output << Walker->x.x[0] << " " << Walker->x.x[1] << " " << Walker->x.x[2] << " " << endl;
+  }
+  output << endl;
+    // print connectivity
+  for (TriangleMap::iterator runner = TrianglesOnBoundary.begin(); runner != TrianglesOnBoundary.end(); runner++) {
+    *out << " " << runner->second->endpoints[0]->node->Name << "<->" << runner->second->endpoints[1]->node->Name << "<->" << runner->second->endpoints[2]->node->Name;
+    output << LookupList[runner->second->endpoints[0]->node->nr] << " " << LookupList[runner->second->endpoints[1]->node->nr] << " " << LookupList[runner->second->endpoints[2]->node->nr] << endl; 
+  }
+  output.close();
+  delete[](LookupList);
+  *out << endl;
+};
 
 /** Adds an atom to the tesselation::PointsOnBoundary list.
  * \param *Walker atom to add
  */
-void
-Tesselation::AddPoint(atom *Walker)
-{
-  PointTestPair InsertUnique;
+void Tesselation::AddPoint(atom *Walker)
+{
   BPS[0] = new class BoundaryPointSet(Walker);
-  InsertUnique = PointsOnBoundary.insert(PointPair(Walker->nr, BPS[0]));
-  if (InsertUnique.second) // if new point was not present before, increase counter
-    PointsOnBoundaryCount++;
-}
-;
-
-/** Adds point to Tesselation::PointsOnBoundary if not yet present.
- * Tesselation::TPS is set to either this new BoundaryPointSet or to the existing one of not unique.
- * @param Candidate point to add
- * @param n index for this point in Tesselation::TPS array
- */
-void
-Tesselation::AddTrianglePoint(atom* Candidate, int n)
-{
-  PointTestPair InsertUnique;
-  TPS[n] = new class BoundaryPointSet(Candidate);
-  InsertUnique = PointsOnBoundary.insert(PointPair(Candidate->nr, TPS[n]));
-  if (InsertUnique.second) // if new point was not present before, increase counter
-    {
-      PointsOnBoundaryCount++;
-    }
-  else
-    {
-      delete TPS[n];
-      cout << Verbose(2) << "Atom " << *((InsertUnique.first)->second->node)
-          << " gibt's schon in der PointMap." << endl;
-      TPS[n] = (InsertUnique.first)->second;
-    }
-}
-;
-
-/** Function tries to add line from current Points in BPS to BoundaryLineSet.
- * If succesful it raises the line count and inserts the new line into the BLS,
- * if unsuccesful, it writes the line which had been present into the BLS, deleting the new constructed one.
- * @param *a first endpoint
- * @param *b second endpoint
- * @param n index of Tesselation::BLS giving the line with both endpoints
- */
-void
-Tesselation::AddTriangleLine(class BoundaryPointSet *a,
-    class BoundaryPointSet *b, int n)
-{
-  LineMap::iterator LineWalker;
-  //cout << "Manually checking endpoints for line." << endl;
-  if ((a->lines.find(b->node->nr)) != a->lines.end()) // ->first == b->node->nr)
-  //If a line is there, how do I recognize that beyond a shadow of a doubt?
-    {
-      //cout << Verbose(2) << "Line exists already, retrieving it from LinesOnBoundarySet" << endl;
-
-      LineWalker = LinesOnBoundary.end();
-      LineWalker--;
-
-      while (LineWalker->second->endpoints[0]->node->nr != min(a->node->nr,
-          b->node->nr) or LineWalker->second->endpoints[1]->node->nr != max(
-          a->node->nr, b->node->nr))
-        {
-          //cout << Verbose(1) << "Looking for line which already exists"<< endl;
-          LineWalker--;
-        }
-      BPS[0] = LineWalker->second->endpoints[0];
-      BPS[1] = LineWalker->second->endpoints[1];
-      BLS[n] = LineWalker->second;
-
-    }
-  else
-    {
-      cout << Verbose(2)
-          << "Adding line which has not been used before between "
-          << *(a->node) << " and " << *(b->node) << "." << endl;
-      BPS[0] = a;
-      BPS[1] = b;
-      BLS[n] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
-
-      LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount, BLS[n]));
-      LinesOnBoundaryCount++;
-
-    }
-}
-;
-
-/** Function tries to add Triangle just created to Triangle and remarks if already existent (Failure of algorithm).
- * Furthermore it adds the triangle to all of its lines, in order to recognize those which are saturated later.
- */
-void
-Tesselation::AddTriangleToLines()
-{
-
-  cout << Verbose(1) << "Adding triangle to its lines" << endl;
-  TrianglesOnBoundary.insert(TrianglePair(TrianglesOnBoundaryCount, BTS));
-  TrianglesOnBoundaryCount++;
-
-  /*
-   * this is apparently done when constructing triangle
-
-   for (int i=0; i<3; i++)
-   {
-   BLS[i]->AddTriangle(BTS);
-   }
-   */
-}
-;
-
-/**
- * Function returns center of sphere with RADIUS, which rests on points a, b, c
- * @param Center this vector will be used for return
- * @param a vector first point of triangle
- * @param b vector second point of triangle
- * @param c vector third point of triangle
- * @param *Umkreismittelpunkt new cneter point of circumference
- * @param Direction vector indicates up/down
- * @param AlternativeDirection vecotr, needed in case the triangles have 90 deg angle
- * @param Halfplaneindicator double indicates whether Direction is up or down
- * @param AlternativeIndicator doube indicates in case of orthogonal triangles which direction of AlternativeDirection is suitable
- * @param alpha double angle at a
- * @param beta double, angle at b
- * @param gamma, double, angle at c
- * @param Radius, double
- * @param Umkreisradius double radius of circumscribing circle
- */
-
-  void Get_center_of_sphere(Vector* Center, Vector a, Vector b, Vector c, Vector *NewUmkreismittelpunkt, Vector* Direction, Vector* AlternativeDirection,
-      double HalfplaneIndicator, double AlternativeIndicator, double alpha, double beta, double gamma, double RADIUS, double Umkreisradius)
-  {
-    Vector TempNormal, helper;
-    double Restradius;
-    cout << Verbose(3) << "Begin of Get_center_of_sphere.\n";
-    Center->Zero();
-    helper.CopyVector(&a);
-    helper.Scale(sin(2.*alpha));
-    Center->AddVector(&helper);
-    helper.CopyVector(&b);
-    helper.Scale(sin(2.*beta));
-    Center->AddVector(&helper);
-    helper.CopyVector(&c);
-    helper.Scale(sin(2.*gamma));
-    Center->AddVector(&helper);
-    //*Center = a * sin(2.*alpha) + b * sin(2.*beta) + c * sin(2.*gamma) ;
-    Center->Scale(1./(sin(2.*alpha) + sin(2.*beta) + sin(2.*gamma)));
-    NewUmkreismittelpunkt->CopyVector(Center);
-    cout << Verbose(4) << "Center of new circumference is " << *NewUmkreismittelpunkt << ".\n";
-    // Here we calculated center of circumscribing circle, using barycentric coordinates
-    cout << Verbose(4) << "Center of circumference is " << *Center << " in direction " << *Direction << ".\n";
-
-    TempNormal.CopyVector(&a);
-    TempNormal.SubtractVector(&b);
-    helper.CopyVector(&a);
-    helper.SubtractVector(&c);
-    TempNormal.VectorProduct(&helper);
-    if (fabs(HalfplaneIndicator) < MYEPSILON)
-      {
-        if ((TempNormal.ScalarProduct(AlternativeDirection) <0 and AlternativeIndicator >0) or (TempNormal.ScalarProduct(AlternativeDirection) >0 and AlternativeIndicator <0))
-          {
-            TempNormal.Scale(-1);
-          }
-      }
-    else
-      {
-        if (TempNormal.ScalarProduct(Direction)<0 && HalfplaneIndicator >0 || TempNormal.ScalarProduct(Direction)>0 && HalfplaneIndicator<0)
-          {
-            TempNormal.Scale(-1);
-          }
-      }
-
-    TempNormal.Normalize();
-    Restradius = sqrt(RADIUS*RADIUS - Umkreisradius*Umkreisradius);
-    cout << Verbose(4) << "Height of center of circumference to center of sphere is " << Restradius << ".\n";
-    TempNormal.Scale(Restradius);
-    cout << Verbose(4) << "Shift vector to sphere of circumference is " << TempNormal << ".\n";
-
-    Center->AddVector(&TempNormal);
-    cout << Verbose(4) << "Center of sphere of circumference is " << *Center << ".\n";
-    cout << Verbose(3) << "End of Get_center_of_sphere.\n";
-  }
-  ;
-
-
-/** This recursive function finds a third point, to form a triangle with two given ones.
- * Two atoms are fixed, a candidate is supplied, additionally two vectors for direction distinction, a Storage area to \
- *  supply results to the calling function, the radius of the sphere which the triangle shall support and the molecule \
- *  upon which we operate.
- *  If the candidate is more fitting to support the sphere than the already stored atom is, then we write its general \
- *  direction and angle into Storage.
- *  We the determine the recursive level we have reached and if this is not on the threshold yet, call this function again, \
- *  with all neighbours of the candidate.
- * @param a first point
- * @param b second point
- * *param c atom old third point of old triangle
- * @param Candidate base point along whose bonds to start looking from
- * @param Parent point to avoid during search as its wrong direction
- * @param RecursionLevel contains current recursion depth
- * @param Chord baseline vector of first and second point
- * @param direction1 second in plane vector (along with \a Chord) of the triangle the baseline belongs to
- * @param OldNormal normal of the triangle which the baseline belongs to
- * @param ReferencePoint Vector of center of circumscribing circle from which we look towards center of sphere
- * @param Opt_Candidate candidate reference to return
- * @param Storage array containing two angles of current Opt_Candidate
- * @param RADIUS radius of ball
- * @param mol molecule structure with atoms and bonds
- */
-
-void Tesselation::Find_next_suitable_point_via_Angle_of_Sphere(atom* a, atom* b, atom* c, atom* Candidate, atom* Parent,
-    int RecursionLevel, Vector *Chord, Vector *direction1, Vector *OldNormal, Vector ReferencePoint,
-    atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule* mol)
-{
-        cout << Verbose(2) << "Begin of Find_next_suitable_point_via_Angle_of_Sphere, recursion level " << RecursionLevel << ".\n";
-        cout << Verbose(3) << "Candidate is "<< *Candidate << endl;
-        cout << Verbose(4) << "Baseline vector is " << *Chord << "." << endl;
-        cout << Verbose(4) << "ReferencePoint is " << ReferencePoint << "." << endl;
-        cout << Verbose(4) << "Normal of base triangle is " << *OldNormal << "." << endl;
-        cout << Verbose(4) << "Search direction is " << *direction1 << "." << endl;
-        /* OldNormal is normal vector on the old triangle
-         * direction1 is normal on the triangle line, from which we come, as well as on OldNormal.
-         * Chord points from b to a!!!
-         */
-        Vector dif_a; //Vector from a to candidate
-        Vector dif_b; //Vector from b to candidate
-        Vector AngleCheck;
-        Vector TempNormal, Umkreismittelpunkt;
-        Vector Mittelpunkt;
-
-        double alpha, beta, gamma, SideA, SideB, SideC, sign, Umkreisradius;
-        double BallAngle, AlternativeSign;
-        atom *Walker; // variable atom point
-
-        Vector NewUmkreismittelpunkt;
-
-        if (a != Candidate and b != Candidate and c != Candidate) {
-                cout << Verbose(3) << "We have a unique candidate!" << endl;
-                dif_a.CopyVector(&(a->x));
-                dif_a.SubtractVector(&(Candidate->x));
-                dif_b.CopyVector(&(b->x));
-                dif_b.SubtractVector(&(Candidate->x));
-                AngleCheck.CopyVector(&(Candidate->x));
-                AngleCheck.SubtractVector(&(a->x));
-                AngleCheck.ProjectOntoPlane(Chord);
-
-                SideA = dif_b.Norm();
-                SideB = dif_a.Norm();
-                SideC = Chord->Norm();
-                //Chord->Scale(-1);
-
-                alpha = Chord->Angle(&dif_a);
-                beta = M_PI - Chord->Angle(&dif_b);
-                gamma = dif_a.Angle(&dif_b);
-
-                cout << Verbose(2) << "Base triangle has sides " << dif_a << ", " << dif_b << ", " << *Chord << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
-
-                if (fabs(M_PI - alpha - beta - gamma) > MYEPSILON) {
-                        cerr << Verbose(0) << "WARNING: sum of angles for base triangle " << (alpha + beta + gamma)/M_PI*180. << " != 180.\n";
-                        cout << Verbose(1) << "Base triangle has sides " << dif_a << ", " << dif_b << ", " << *Chord << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
-                }
-
-                if ((M_PI*4. > alpha*5.) && (M_PI*4. > beta*5.) && (M_PI*4 > gamma*5.)) {
-                        Umkreisradius = SideA / 2.0 / sin(alpha);
-                        //cout << Umkreisradius << endl;
-                        //cout << SideB / 2.0 / sin(beta) << endl;
-                        //cout << SideC / 2.0 / sin(gamma) << endl;
-
-                        if (Umkreisradius < RADIUS) { //Checking whether ball will at least rest on points.
-                                cout << Verbose(3) << "Circle of circumference would fit: " << Umkreisradius << " < " << RADIUS << "." << endl;
-                                cout << Verbose(2) << "Candidate is "<< *Candidate << endl;
-                                sign = AngleCheck.ScalarProduct(direction1);
-                                if (fabs(sign)<MYEPSILON) {
-                                        if (AngleCheck.ScalarProduct(OldNormal)<0) {
-                                                sign =0;
-                                                AlternativeSign=1;
-                                        } else {
-                                                sign =0;
-                                                AlternativeSign=-1;
-                                        }
-                                } else {
-                                        sign /= fabs(sign);
-                                        cout << Verbose(3) << "Candidate is in search direction: " << sign << "." << endl;
-                                }
-
-                                Get_center_of_sphere(&Mittelpunkt, (a->x), (b->x), (Candidate->x), &NewUmkreismittelpunkt, OldNormal, direction1, sign, AlternativeSign, alpha, beta, gamma, RADIUS, Umkreisradius);
-
-                                AngleCheck.CopyVector(&ReferencePoint);
-                                AngleCheck.Scale(-1);
-                                //cout << "AngleCheck is " << AngleCheck.x[0] << " "<< AngleCheck.x[1] << " "<< AngleCheck.x[2] << " "<< endl;
-                                AngleCheck.AddVector(&Mittelpunkt);
-                                //cout << "AngleCheck is " << AngleCheck.x[0] << " "<< AngleCheck.x[1] << " "<< AngleCheck.x[2] << " "<< endl;
-                                cout << Verbose(4) << "Reference vector to sphere's center is " << AngleCheck << "." << endl;
-
-                                BallAngle = AngleCheck.Angle(OldNormal);
-                                cout << Verbose(3) << "Angle between normal of base triangle and center of ball sphere is :" << BallAngle << "." << endl;
-
-                                //cout << "direction1 is " << direction1->x[0] <<" "<< direction1->x[1] <<" "<< direction1->x[2] <<" " << endl;
-                                //cout << "AngleCheck is " << AngleCheck.x[0] << " "<< AngleCheck.x[1] << " "<< AngleCheck.x[2] << " "<< endl;
-
-                                cout << Verbose(3) << "BallAngle is " << BallAngle << " Sign is " << sign << endl;
-
-                                NewUmkreismittelpunkt.SubtractVector(&ReferencePoint);
-
-                                if ((AngleCheck.ScalarProduct(direction1) >=0) || (fabs(NewUmkreismittelpunkt.Norm()) < MYEPSILON)) {
-                                        if (Storage[0]< -1.5) { // first Candidate at all
-                                                if (1) {//if (CheckPresenceOfTriangle((ofstream *)&cout,a,b,Candidate)) {
-                                                        cout << Verbose(2) << "First good candidate is " << *Candidate << " with ";
-                                                        Opt_Candidate = Candidate;
-                                                        Storage[0] = sign;
-                                                        Storage[1] = AlternativeSign;
-                                                        Storage[2] = BallAngle;
-                                                        cout << " angle " << Storage[2] << " and Up/Down "
-                                                        << Storage[0] << endl;
-                                                } else
-                                                        cout << "Candidate " << *Candidate << " does not belong to a valid triangle." << endl;
-                                        } else {
-                                                if ( Storage[2] > BallAngle) {
-                                                        if (1) { //if (CheckPresenceOfTriangle((ofstream *)&cout,a,b,Candidate)) {
-                                                                cout << Verbose(2) << "Next better candidate is " << *Candidate << " with ";
-                                                                Opt_Candidate = Candidate;
-                                                                Storage[0] = sign;
-                                                                Storage[1] = AlternativeSign;
-                                                                Storage[2] = BallAngle;
-                                                                cout << " angle " << Storage[2] << " and Up/Down "
-                                                                << Storage[0] << endl;
-                                                        } else
-                                                                cout << "Candidate " << *Candidate << " does not belong to a valid triangle." << endl;
-                                                } else {
-                                                        if (DEBUG) {
-                                                                cout << Verbose(3) << *Candidate << " looses against better candidate " << *Opt_Candidate << "." << endl;
-                                                        }
-                                                }
-                                        }
-                                } else {
-                                        if (DEBUG) {
-                                                cout << Verbose(3) << *Candidate << " refused due to Up/Down sign which is " << sign << endl;
-                                        }
-                                }
-                        } else {
-                                if (DEBUG) {
-                                        cout << Verbose(3) << *Candidate << " would have circumference of " << Umkreisradius << " bigger than ball's radius " << RADIUS << "." << endl;
-                                }
-                        }
-                } else {
-                        if (DEBUG) {
-                                cout << Verbose(0) << "Triangle consisting of " << *Candidate << ", " << *a << " and " << *b << " has an angle >150!" << endl;
-                        }
-                }
-        } else {
-                if (DEBUG) {
-                        cout << Verbose(3) << *Candidate << " is either " << *a << " or " << *b << "." << endl;
-                }
-        }
-
-        if (RecursionLevel < 5) { // Seven is the recursion level threshold.
-                for (int i = 0; i < mol->NumberOfBondsPerAtom[Candidate->nr]; i++) { // go through all bond
-                        Walker = mol->ListOfBondsPerAtom[Candidate->nr][i]->GetOtherAtom(Candidate);
-                        if (Walker == Parent) { // don't go back the same bond
-                                continue;
-                        } else {
-                                Find_next_suitable_point_via_Angle_of_Sphere(a, b, c, Walker, Candidate, RecursionLevel+1, Chord, direction1, OldNormal, ReferencePoint, Opt_Candidate, Storage, RADIUS, mol); //call function again
-                        }
-                }
-        }
-        cout << Verbose(2) << "End of Find_next_suitable_point_via_Angle_of_Sphere, recursion level " << RecursionLevel << ".\n";
-}
-;
-
-
-  /** This recursive function finds a third point, to form a triangle with two given ones.
-   * Two atoms are fixed, a candidate is supplied, additionally two vectors for direction distinction, a Storage area to \
-   *  supply results to the calling function, the radius of the sphere which the triangle shall support and the molecule \
-   *  upon which we operate.
-   *  If the candidate is more fitting to support the sphere than the already stored atom is, then we write its general \
-   *  direction and angle into Storage.
-   *  We the determine the recursive level we have reached and if this is not on the threshold yet, call this function again, \
-   *  with all neighbours of the candidate.
-   * @param a first point
-   * @param b second point
-   * @param Candidate base point along whose bonds to start looking from
-   * @param Parent point to avoid during search as its wrong direction
-   * @param RecursionLevel contains current recursion depth
-   * @param Chord baseline vector of first and second point
-   * @param d1 second in plane vector (along with \a Chord) of the triangle the baseline belongs to
-   * @param OldNormal normal of the triangle which the baseline belongs to
-   * @param Opt_Candidate candidate reference to return
-   * @param Opt_Mittelpunkt Centerpoint of ball, when resting on Opt_Candidate
-   * @param Storage array containing two angles of current Opt_Candidate
-   * @param RADIUS radius of ball
-   * @param mol molecule structure with atoms and bonds
-   */
-void Find_next_suitable_point(atom* a, atom* b, atom* Candidate, atom* Parent,
-    int RecursionLevel, Vector *Chord, Vector *d1, Vector *OldNormal,
-    atom*& Opt_Candidate, Vector *Opt_Mittelpunkt, double *Storage, const double RADIUS, molecule* mol)
-{
-        /* OldNormal is normal vector on the old triangle
-         * d1 is normal on the triangle line, from which we come, as well as on OldNormal.
-         * Chord points from b to a!!!
-         */
-        Vector dif_a; //Vector from a to candidate
-        Vector dif_b; //Vector from b to candidate
-        Vector AngleCheck, AngleCheckReference, DirectionCheckPoint;
-        Vector TempNormal, Umkreismittelpunkt, Mittelpunkt, helper;
-
-        double CurrentEpsilon = 0.1;
-        double alpha, beta, gamma, SideA, SideB, SideC, sign, Umkreisradius, Restradius;
-        double BallAngle;
-        atom *Walker; // variable atom point
-
-
-        dif_a.CopyVector(&(a->x));
-        dif_a.SubtractVector(&(Candidate->x));
-        dif_b.CopyVector(&(b->x));
-        dif_b.SubtractVector(&(Candidate->x));
-        DirectionCheckPoint.CopyVector(&dif_a);
-        DirectionCheckPoint.Scale(-1);
-        DirectionCheckPoint.ProjectOntoPlane(Chord);
-
-        SideA = dif_b.Norm();
-        SideB = dif_a.Norm();
-        SideC = Chord->Norm();
-        //Chord->Scale(-1);
-
-        alpha = Chord->Angle(&dif_a);
-        beta = M_PI - Chord->Angle(&dif_b);
-        gamma = dif_a.Angle(&dif_b);
-
-
-        if (DEBUG) {
-                cout << "Atom number" << Candidate->nr << endl;
-                Candidate->x.Output((ofstream *) &cout);
-                cout << "number of bonds " << mol->NumberOfBondsPerAtom[Candidate->nr] << endl;
-        }
-
-        if (a != Candidate and b != Candidate) {
-                //      alpha = dif_a.Angle(&dif_b) / 2.;
-                //      SideA = Chord->Norm() / 2.;// (Chord->Norm()/2.) / sin(0.5*alpha);
-                //      SideB = dif_a.Norm();
-                //      centerline = SideA * SideA + SideB * SideB - 2. * SideA * SideB * cos(
-                //          alpha); // note this is squared of center line length
-                //      centerline = (Chord->Norm()/2.) / sin(0.5*alpha);
-                // Those are remains from Freddie. Needed?
-
-                Umkreisradius = SideA / 2.0 / sin(alpha);
-                //cout << Umkreisradius << endl;
-                //cout << SideB / 2.0 / sin(beta) << endl;
-                //cout << SideC / 2.0 / sin(gamma) << endl;
-
-                if (Umkreisradius < RADIUS && DirectionCheckPoint.ScalarProduct(&(Candidate->x))>0) { //Checking whether ball will at least rest o points.
-                        // intermediate calculations to aquire centre of sphere, called Mittelpunkt:
-                        Umkreismittelpunkt.Zero();
-                        helper.CopyVector(&a->x);
-                        helper.Scale(sin(2.*alpha));
-                        Umkreismittelpunkt.AddVector(&helper);
-                        helper.CopyVector(&b->x);
-                        helper.Scale(sin(2.*beta));
-                        Umkreismittelpunkt.AddVector(&helper);
-                        helper.CopyVector(&Candidate->x);
-                        helper.Scale(sin(2.*gamma));
-                        Umkreismittelpunkt.AddVector(&helper);
-                        //Umkreismittelpunkt = (a->x) * sin(2.*alpha) + b->x * sin(2.*beta) + (Candidate->x) * sin(2.*gamma) ;
-                        Umkreismittelpunkt.Scale(1/(sin(2*alpha) + sin(2*beta) + sin(2*gamma)));
-
-                        TempNormal.CopyVector(&dif_a);
-                        TempNormal.VectorProduct(&dif_b);
-                        if (TempNormal.ScalarProduct(OldNormal)<0 && sign>0 || TempNormal.ScalarProduct(OldNormal)>0 && sign<0) {
-                                TempNormal.Scale(-1);
-                        }
-                        TempNormal.Normalize();
-                        Restradius = sqrt(RADIUS*RADIUS - Umkreisradius*Umkreisradius);
-                        TempNormal.Scale(Restradius);
-
-                        Mittelpunkt.CopyVector(&Umkreismittelpunkt);
-                        Mittelpunkt.AddVector(&TempNormal);  //this is center of sphere supported by a, b and Candidate
-
-                        AngleCheck.CopyVector(Chord);
-                        AngleCheck.Scale(-0.5);
-                        AngleCheck.SubtractVector(&(b->x));
-                        AngleCheckReference.CopyVector(&AngleCheck);
-                        AngleCheckReference.AddVector(Opt_Mittelpunkt);
-                        AngleCheck.AddVector(&Mittelpunkt);
-
-                        BallAngle = AngleCheck.Angle(&AngleCheckReference);
-
-                        d1->ProjectOntoPlane(&AngleCheckReference);
-                        sign = AngleCheck.ScalarProduct(d1);
-                        if (fabs(sign) < MYEPSILON)
-                                sign = 0;
-                        else
-                                sign /= fabs(sign); // +1 if in direction of triangle plane, -1 if in other direction...
-
-
-                        if (Storage[0]< -1.5) { // first Candidate at all
-                                cout << "Next better candidate is " << *Candidate << " with ";
-                                Opt_Candidate = Candidate;
-                                Storage[0] = sign;
-                                Storage[1] = BallAngle;
-                                Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-                                cout << "Angle is " << Storage[1] << ", Halbraum ist " << Storage[0] << endl;
-                        } else {
-                                /*
-                                 * removed due to change in criterium, now checking angle of ball to old normal.
-                                //We will now check for non interference, that is if the new candidate would have the Opt_Candidate
-                                //within the ball.
-
-                                Distance = Opt_Candidate->x.Distance(&Mittelpunkt);
-                                //cout << "Opt_Candidate " << Opt_Candidate << " has distance " << Distance << " to Center of Candidate " << endl;
-
-
-                                if (Distance >RADIUS) { // We have no interference and may now check whether the new point is better.
-                                 */
-                                        //cout << "Atom " << Candidate << " has distance " << Candidate->x.Distance(Opt_Mittelpunkt) << " to Center of Candidate " << endl;
-
-                                if (((Storage[0] < 0 && fabs(sign - Storage[0]) > CurrentEpsilon))) { //This will give absolute preference to those in "right-hand" quadrants
-                                        //(Candidate->x.Distance(Opt_Mittelpunkt) < RADIUS))    //and those where Candidate would be within old Sphere.
-                                        cout << "Next better candidate is " << *Candidate << " with ";
-                                        Opt_Candidate = Candidate;
-                                        Storage[0] = sign;
-                                        Storage[1] = BallAngle;
-                                        Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-                                        cout << "Angle is " << Storage[1] << ", Halbraum ist " << Storage[0] << endl;
-                                } else {
-                                        if ((fabs(sign - Storage[0]) < CurrentEpsilon && sign > 0 && Storage[1] > BallAngle) || (fabs(sign - Storage[0]) < CurrentEpsilon && sign < 0 && Storage[1] < BallAngle)) {
-                                                //Depending on quadrant we prefer higher or lower atom with respect to Triangle normal first.
-                                                cout << "Next better candidate is " << *Candidate << " with ";
-                                                Opt_Candidate = Candidate;
-                                                Storage[0] = sign;
-                                                Storage[1] = BallAngle;
-                                                Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-                                                cout << "Angle is " << Storage[1] << ", Halbraum ist " << Storage[0] << endl;
-                                        }
-                                }
-                        }
-/*
-               * This is for checking point-angle and presence of Candidates in Ball, currently we are checking the ball Angle.
-               *
-                else
-                {
-                  if (sign>0 && BallAngle>0 && Storage[0]<0)
-                    {
-                      cout << "Next better candidate is " << *Candidate << " with ";
-                      Opt_Candidate = Candidate;
-                      Storage[0] = sign;
-                      Storage[1] = BallAngle;
-                      Opt_Mittelpunkt->CopyVector(&Mittelpunkt);
-                      cout << "Angle is " << Storage[1] << ", Halbraum ist "
-                      << Storage[0] << endl;
-
-//Debugging purposes only
-                      cout << "Umkreismittelpunkt has coordinates" << Umkreismittelpunkt.x[0] << " "<< Umkreismittelpunkt.x[1] <<" "<<Umkreismittelpunkt.x[2] << endl;
-                      cout << "Candidate has coordinates" << Candidate->x.x[0]<< " " << Candidate->x.x[1] << " " << Candidate->x.x[2] << endl;
-                      cout << "a has coordinates" << a->x.x[0]<< " " << a->x.x[1] << " " << a->x.x[2] << endl;
-                      cout << "b has coordinates" << b->x.x[0]<< " " << b->x.x[1] << " " << b->x.x[2] << endl;
-                      cout << "Mittelpunkt has coordinates" << Mittelpunkt.x[0] << " " << Mittelpunkt.x[1]<< " "  <<Mittelpunkt.x[2] << endl;
-                      cout << "Umkreisradius ist " << Umkreisradius << endl;
-                      cout << "Restradius ist " << Restradius << endl;
-                      cout << "TempNormal has coordinates " << TempNormal.x[0] << " " << TempNormal.x[1] << " " << TempNormal.x[2] << " " << endl;
-                      cout << "OldNormal has coordinates " << OldNormal->x[0] << " " << OldNormal->x[1] << " " << OldNormal->x[2] << " " << endl;
-                      cout << "Dist a to UmkreisMittelpunkt " << a->x.Distance(&Umkreismittelpunkt) << endl;
-                      cout << "Dist b to UmkreisMittelpunkt " << b->x.Distance(&Umkreismittelpunkt) << endl;
-                      cout << "Dist Candidate to UmkreisMittelpunkt " << Candidate->x.Distance(&Umkreismittelpunkt) << endl;
-                      cout << "Dist a to Mittelpunkt " << a->x.Distance(&Mittelpunkt) << endl;
-                      cout << "Dist b to Mittelpunkt " << b->x.Distance(&Mittelpunkt) << endl;
-                      cout << "Dist Candidate to Mittelpunkt " << Candidate->x.Distance(&Mittelpunkt) << endl;
-
-
-
-                    }
-                  else
-                    {
-                      if (DEBUG)
-                        cout << "Looses to better candidate" << endl;
-                    }
-                }
-                */
-                } else {
-                        if (DEBUG) {
-                                cout << "Doesn't satisfy requirements for circumscribing circle" << endl;
-                        }
-                }
-        } else {
-                if (DEBUG) {
-                        cout << "identisch mit Ursprungslinie" << endl;
-                }
-        }
-
-        if (RecursionLevel < 9) { // Five is the recursion level threshold.
-                for (int i = 0; i < mol->NumberOfBondsPerAtom[Candidate->nr]; i++) { // go through all bond
-                        Walker = mol->ListOfBondsPerAtom[Candidate->nr][i]->GetOtherAtom(Candidate);
-                        if (Walker == Parent) { // don't go back the same bond
-                                continue;
-                        } else {
-                                Find_next_suitable_point(a, b, Walker, Candidate, RecursionLevel+1, Chord, d1, OldNormal, Opt_Candidate, Opt_Mittelpunkt, Storage, RADIUS, mol); //call function again
-                        }
-                }
-        }
-};
-
-/** This function finds a triangle to a line, adjacent to an existing one.
- * @param out   output stream for debugging
- * @param tecplot output stream for writing found triangles in TecPlot format
- * @param mol molecule structure with all atoms and bonds
- * @param Line current baseline to search from
- * @param T current triangle which \a Line is edge of
- * @param RADIUS radius of the rolling ball
- * @param N number of found triangles
- * @param *filename filename base for intermediate envelopes
- */
-bool Tesselation::Find_next_suitable_triangle(ofstream *out, ofstream *tecplot,
-    molecule* mol, BoundaryLineSet &Line, BoundaryTriangleSet &T,
-    const double& RADIUS, int N, const char *tempbasename)
-{
-        cout << Verbose(1) << "Begin of Find_next_suitable_triangle\n";
-        Vector direction1;
-        Vector helper;
-        Vector Chord;
-        ofstream *tempstream = NULL;
-        char NumberName[255];
-        double tmp;
-        //atom* Walker;
-        atom* OldThirdPoint;
-
-        double Storage[3];
-        Storage[0] = -2.; // This direction is either +1 or -1 one, so any result will take precedence over initial values
-        Storage[1] = -2.; // This is also lower then any value produced by an eligible atom, which are all positive
-        Storage[2] = 9999999.;
-        atom* Opt_Candidate = NULL;
-        Vector Opt_Mittelpunkt;
-
-        cout << Verbose(1) << "Current baseline is " << Line << " of triangle " << T << "." << endl;
-
-        helper.CopyVector(&(Line.endpoints[0]->node->x));
-        for (int i = 0; i < 3; i++) {
-                if (T.endpoints[i]->node->nr != Line.endpoints[0]->node->nr && T.endpoints[i]->node->nr != Line.endpoints[1]->node->nr) {
-                        OldThirdPoint = T.endpoints[i]->node;
-                        helper.SubtractVector(&T.endpoints[i]->node->x);
-                        break;
-                }
-        }
-
-        direction1.CopyVector(&Line.endpoints[0]->node->x);
-        direction1.SubtractVector(&Line.endpoints[1]->node->x);
-        direction1.VectorProduct(&(T.NormalVector));
-
-        if (direction1.ScalarProduct(&helper) < 0) {
-                direction1.Scale(-1);
-        }
-        cout << Verbose(2) << "Looking in direction " << direction1 << " for candidates.\n";
-
-        Chord.CopyVector(&(Line.endpoints[0]->node->x)); // bring into calling function
-        Chord.SubtractVector(&(Line.endpoints[1]->node->x));
-        cout << Verbose(2) << "Baseline vector is " << Chord << ".\n";
-
-
-        Vector Umkreismittelpunkt, a, b, c;
-        double alpha, beta, gamma;
-        a.CopyVector(&(T.endpoints[0]->node->x));
-        b.CopyVector(&(T.endpoints[1]->node->x));
-        c.CopyVector(&(T.endpoints[2]->node->x));
-        a.SubtractVector(&(T.endpoints[1]->node->x));
-        b.SubtractVector(&(T.endpoints[2]->node->x));
-        c.SubtractVector(&(T.endpoints[0]->node->x));
-
-        alpha = M_PI - a.Angle(&c);
-        beta = M_PI - b.Angle(&a);
-        gamma = M_PI - c.Angle(&b);
-        if (fabs(M_PI - alpha - beta - gamma) > MYEPSILON)
-                cerr << Verbose(0) << "WARNING: sum of angles for candidate triangle " << (alpha + beta + gamma)/M_PI*180. << " != 180.\n";
-
-        Umkreismittelpunkt.Zero();
-        helper.CopyVector(&T.endpoints[0]->node->x);
-        helper.Scale(sin(2.*alpha));
-        Umkreismittelpunkt.AddVector(&helper);
-        helper.CopyVector(&T.endpoints[1]->node->x);
-        helper.Scale(sin(2.*beta));
-        Umkreismittelpunkt.AddVector(&helper);
-        helper.CopyVector(&T.endpoints[2]->node->x);
-        helper.Scale(sin(2.*gamma));
-        Umkreismittelpunkt.AddVector(&helper);
-        //Umkreismittelpunkt = (T.endpoints[0]->node->x) * sin(2.*alpha) + T.endpoints[1]->node->x * sin(2.*beta) + (T.endpoints[2]->node->x) * sin(2.*gamma) ;
-        //cout << "UmkreisMittelpunkt is " << Umkreismittelpunkt.x[0] << " "<< Umkreismittelpunkt.x[1] << " "<< Umkreismittelpunkt.x[2] << " "<< endl;
-        Umkreismittelpunkt.Scale(1/(sin(2*alpha) + sin(2*beta) + sin(2*gamma)));
-        //cout << "UmkreisMittelpunkt is " << Umkreismittelpunkt.x[0] << " "<< Umkreismittelpunkt.x[1] << " "<< Umkreismittelpunkt.x[2] << " "<< endl;
-        cout << " We look over line " << Line << " in direction " << direction1.x[0] << " " << direction1.x[1] << " " << direction1.x[2] << " " << endl;
-        cout << " Old Normal is " <<  (T.NormalVector.x)[0] << " " << T.NormalVector.x[1] << " " << (T.NormalVector.x)[2] << " " << endl;
-
-        cout << Verbose(2) << "Base triangle has sides " << a << ", " << b << ", " << c << " with angles " << alpha/M_PI*180. << ", " << beta/M_PI*180. << ", " << gamma/M_PI*180. << "." << endl;
-        cout << Verbose(2) << "Center of circumference is " << Umkreismittelpunkt << "." << endl;
-        if (DEBUG)
-                cout << Verbose(3) << "Check of relative endpoints (same distance, equally spreaded): "<< endl;
-        tmp = 0;
-        for (int i=0;i<NDIM;i++) {
-                helper.CopyVector(&T.endpoints[i]->node->x);
-                helper.SubtractVector(&Umkreismittelpunkt);
-                if (DEBUG)
-                        cout << Verbose(3) << "Endpoint[" << i << "]: " << helper << " with length " << helper.Norm() << "." << endl;
-                if (tmp == 0) // set on first time for comparison against next ones
-                        tmp = helper.Norm();
-                if (fabs(helper.Norm() - tmp) > MYEPSILON)
-                        cerr << Verbose(1) << "WARNING: center of circumference is wrong!" << endl;
-        }
-
-        cout << Verbose(1) << "Looking for third point candidates for triangle ... " << endl;
-
-        Find_next_suitable_point_via_Angle_of_Sphere(Line.endpoints[0]->node, Line.endpoints[1]->node, OldThirdPoint, Line.endpoints[0]->node, Line.endpoints[1]->node, 0, &Chord, &direction1, &(T.NormalVector), Umkreismittelpunkt, Opt_Candidate, Storage, RADIUS, mol);
-        Find_next_suitable_point_via_Angle_of_Sphere(Line.endpoints[0]->node, Line.endpoints[1]->node, OldThirdPoint, Line.endpoints[1]->node, Line.endpoints[0]->node, 0, &Chord, &direction1, &(T.NormalVector), Umkreismittelpunkt, Opt_Candidate, Storage, RADIUS, mol);
-        if (Opt_Candidate == NULL) {
-                cerr << "WARNING: Could not find a suitable candidate." << endl;
-                return false;
-        }
-        cout << Verbose(1) << " Optimal candidate is " << *Opt_Candidate << endl;
-
-        // check whether all edges of the new triangle still have space for one more triangle (i.e. TriangleCount <2)
-        bool flag = CheckPresenceOfTriangle(out, Opt_Candidate, Line.endpoints[0]->node, Line.endpoints[1]->node);
-
-        if (flag) { // if so, add
-                AddTrianglePoint(Opt_Candidate, 0);
-                AddTrianglePoint(Line.endpoints[0]->node, 1);
-                AddTrianglePoint(Line.endpoints[1]->node, 2);
-
-                AddTriangleLine(TPS[0], TPS[1], 0);
-                AddTriangleLine(TPS[0], TPS[2], 1);
-                AddTriangleLine(TPS[1], TPS[2], 2);
-
-                BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
-                AddTriangleToLines();
-
-                BTS->GetNormalVector(BTS->NormalVector);
-
-                if ((BTS->NormalVector.ScalarProduct(&(T.NormalVector)) < 0 && Storage[0] > 0)  || (BTS->NormalVector.ScalarProduct(&(T.NormalVector)) > 0 && Storage[0] < 0) || (fabs(Storage[0]) < MYEPSILON && Storage[1]*BTS->NormalVector.ScalarProduct(&direction1) < 0) ) {
-                        BTS->NormalVector.Scale(-1);
-                };
-                cout << Verbose(1) << "New triangle with " << *BTS << " and normal vector " << BTS->NormalVector << " for this triangle ... " << endl;
-                cout << Verbose(1) << "We have "<< TrianglesOnBoundaryCount << " for line " << Line << "." << endl;
-        } else { // else, yell and do nothing
-                cout << Verbose(1) << "This triangle consisting of ";
-                cout << *Opt_Candidate << ", ";
-                cout << *Line.endpoints[0]->node << " and ";
-                cout << *Line.endpoints[1]->node << " ";
-                cout << "is invalid!" << endl;
-                return false;
-        }
-
-        if ((TrianglesOnBoundaryCount % 10) == 0) {
-                sprintf(NumberName, "-%d", TriangleFilesWritten);
-                if (DoTecplotOutput) {
-                        string NameofTempFile(tempbasename);
-                        NameofTempFile.append(NumberName);
-                        NameofTempFile.append(TecplotSuffix);
-                        cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
-                        tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
-                        write_tecplot_file(out, tempstream, this, mol, TriangleFilesWritten);
-                        tempstream->close();
-                        tempstream->flush();
-                        delete(tempstream);
-                }
-
-                if (DoRaster3DOutput) {
-                        string NameofTempFile(tempbasename);
-                        NameofTempFile.append(NumberName);
-                        NameofTempFile.append(Raster3DSuffix);
-                        cout << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
-                        tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
-                        write_raster3d_file(out, tempstream, this, mol);
-                        tempstream->close();
-                        tempstream->flush();
-                        delete(tempstream);
-                }
-                if (DoTecplotOutput || DoRaster3DOutput)
-                        TriangleFilesWritten++;
-        }
-
-        cout << Verbose(1) << "End of Find_next_suitable_triangle\n";
-        return true;
-};
-
-/** Checks whether the triangle consisting of the three atoms is already present.
- * Searches for the points in Tesselation::PointsOnBoundary and checks their
- * lines. If any of the three edges already has two triangles attached, false is
- * returned.
- * \param *out output stream for debugging
- * \param *a first endpoint
- * \param *b second endpoint
- * \param *c third endpoint
- * \return false - triangle invalid due to edge criteria, true - triangle may be added.
- */
-bool Tesselation::CheckPresenceOfTriangle(ofstream *out, atom *a, atom *b, atom *c) {
-        LineMap::iterator TryAndError;
-        PointTestPair InsertPoint;
-        bool Present[3];
-
-        *out << Verbose(2) << "Begin of CheckPresenceOfTriangle" << endl;
-        TPS[0] = new class BoundaryPointSet(a);
-        TPS[1] = new class BoundaryPointSet(b);
-        TPS[2] = new class BoundaryPointSet(c);
-        for (int i=0;i<3;i++) { // check through all endpoints
-                InsertPoint = PointsOnBoundary.insert(PointPair(TPS[i]->node->nr, TPS[i]));
-                Present[i] = !InsertPoint.second;
-                if (Present[i]) { // if new point was not present before, increase counter
-                        delete TPS[i];
-                        *out << Verbose(2) << "Atom " << *((InsertPoint.first)->second->node) << " gibt's schon in der PointMap." << endl;
-                        TPS[i] = (InsertPoint.first)->second;
-                }
-        }
-
-        // check lines
-        for (int i=0;i<3;i++)
-                if (Present[i])
-                        for (int j=i;j<3;j++)
-                                if (Present[j]) {
-                                        TryAndError = TPS[i]->lines.find(TPS[j]->node->nr);
-                                        if ((TryAndError != TPS[i]->lines.end()) && (TryAndError->second->TrianglesCount > 1)) {
-                                                *out << "WARNING: Line " << *TryAndError->second << " already present with " << TryAndError->second->TrianglesCount << " triangles attached." << endl;
-                                                *out << Verbose(2) << "End of CheckPresenceOfTriangle" << endl;
-                                                return false;
-                                        }
-                                }
-        *out << Verbose(2) << "End of CheckPresenceOfTriangle" << endl;
-        return true;
-};
-
-
-void Find_second_point_for_Tesselation(atom* a, atom* Candidate, atom* Parent,
-    int RecursionLevel, Vector Oben, atom*& Opt_Candidate, double Storage[3],
-    molecule* mol, double RADIUS)
-{
-        cout << Verbose(2) << "Begin of Find_second_point_for_Tesselation, recursive level " << RecursionLevel << endl;
-        int i;
-        Vector AngleCheck;
-        atom* Walker;
-        double norm = -1., angle;
-
-        // check if we only have one unique point yet ...
-        if (a != Candidate) {
-                cout << Verbose(3) << "Current candidate is " << *Candidate << ": ";
-                AngleCheck.CopyVector(&(Candidate->x));
-                AngleCheck.SubtractVector(&(a->x));
-                norm = AngleCheck.Norm();
-                // second point shall have smallest angle with respect to Oben vector
-                if (norm < RADIUS) {
-                        angle = AngleCheck.Angle(&Oben);
-                        if (angle < Storage[0]) {
-                                //cout << Verbose(1) << "Old values of Storage: %lf %lf \n", Storage[0], Storage[1]);
-                                cout << "Is a better candidate with distance " << norm << " and " << angle << ".\n";
-                                Opt_Candidate = Candidate;
-                                Storage[0] = AngleCheck.Angle(&Oben);
-                                //cout << Verbose(1) << "Changing something in Storage: %lf %lf. \n", Storage[0], Storage[2]);
-                        } else {
-                                cout << "Looses with angle " << angle << " to a better candidate " << *Opt_Candidate << endl;
-                        }
-                } else {
-                        cout << "Refused due to Radius " << norm << endl;
-                }
-        }
-
-        // if not recursed to deeply, look at all its bonds
-        if (RecursionLevel < 7) {
-                for (i = 0; i < mol->NumberOfBondsPerAtom[Candidate->nr]; i++) {
-                        Walker = mol->ListOfBondsPerAtom[Candidate->nr][i]->GetOtherAtom(Candidate);
-                        if (Walker == Parent) // don't go back along the bond we came from
-                                continue;
-                        else
-                                Find_second_point_for_Tesselation(a, Walker, Candidate, RecursionLevel + 1, Oben, Opt_Candidate, Storage, mol, RADIUS);
-                }
-        }
-        cout << Verbose(2) << "End of Find_second_point_for_Tesselation, recursive level " << RecursionLevel << endl;
-};
-
-void Tesselation::Find_starting_triangle(molecule* mol, const double RADIUS)
-{
-        cout << Verbose(1) << "Begin of Find_starting_triangle\n";
-        int i = 0;
-        atom* Walker;
-        atom* FirstPoint;
-        atom* SecondPoint;
-        atom* max_index[NDIM];
-        double max_coordinate[NDIM];
-        Vector Oben;
-        Vector helper;
-        Vector Chord;
-        Vector CenterOfFirstLine;
-
-        Oben.Zero();
-
-        for (i = 0; i < 3; i++) {
-                max_index[i] = NULL;
-                max_coordinate[i] = -1;
-        }
-        cout << Verbose(2) << "Molecule mol is there and has " << mol->AtomCount << " Atoms \n";
-
-        // 1. searching topmost atom with respect to each axis
-        Walker = mol->start;
-        while (Walker->next != mol->end) {
-                Walker = Walker->next;
-                for (i = 0; i < 3; i++) {
-                        if (Walker->x.x[i] > max_coordinate[i]) {
-                                max_coordinate[i] = Walker->x.x[i];
-                                max_index[i] = Walker;
-                        }
-                }
-        }
-
-        cout << Verbose(2) << "Found maximum coordinates: ";
-        for (int i=0;i<NDIM;i++)
-                cout << i << ": " << *max_index[i] << "\t";
-        cout << endl;
-  //Koennen dies fuer alle Richtungen, legen hier erstmal Richtung auf k=0
-        const int k = 1;
-        Oben.x[k] = 1.;
-        FirstPoint = max_index[k];
-
-        cout << Verbose(1) << "Coordinates of start atom " << *FirstPoint << " at " << FirstPoint->x << " with " << mol->NumberOfBondsPerAtom[FirstPoint->nr] << " bonds." << endl;
-        double Storage[3];
-        atom* Opt_Candidate = NULL;
-        Storage[0] = 999999.; // This will contain the angle, which will be always positive (when looking for second point), when looking for third point this will be the quadrant.
-        Storage[1] = 999999.; // This will be an angle looking for the third point.
-        Storage[2] = 999999.;
-
-        Find_second_point_for_Tesselation(FirstPoint, FirstPoint, FirstPoint, 0, Oben, Opt_Candidate, Storage, mol, RADIUS); // we give same point as next candidate as its bonds are looked into in find_second_...
-        SecondPoint = Opt_Candidate;
-        cout << Verbose(1) << "Found second point is " << *SecondPoint << " at " << SecondPoint->x << ".\n";
-
-        helper.CopyVector(&(FirstPoint->x));
-        helper.SubtractVector(&(SecondPoint->x));
-        helper.Normalize();
-        Oben.ProjectOntoPlane(&helper);
-        Oben.Normalize();
-        helper.VectorProduct(&Oben);
-        Storage[0] = -2.; // This will indicate the quadrant.
-        Storage[1] = 9999999.; // This will be an angle looking for the third point.
-        Storage[2] = 9999999.;
-
-        Chord.CopyVector(&(FirstPoint->x)); // bring into calling function
-        Chord.SubtractVector(&(SecondPoint->x));
-        // Now, oben and helper are two orthonormalized vectors in the plane defined by Chord (not normalized)
-
-        cout << Verbose(2) << "Looking for third point candidates \n";
-        // look in one direction of baseline for initial candidate
-        Opt_Candidate = NULL;
-        CenterOfFirstLine.CopyVector(&Chord);
-        CenterOfFirstLine.Scale(0.5);
-        CenterOfFirstLine.AddVector(&(SecondPoint->x));
-
-        cout << Verbose(1) << "Looking for third point candidates from " << *FirstPoint << " onward ...\n";
-        Find_next_suitable_point_via_Angle_of_Sphere(FirstPoint, SecondPoint, SecondPoint, SecondPoint, FirstPoint, 0, &Chord, &helper, &Oben, CenterOfFirstLine,  Opt_Candidate, Storage, RADIUS, mol);
-        // look in other direction of baseline for possible better candidate
-        cout << Verbose(1) << "Looking for third point candidates from " << *SecondPoint << " onward ...\n";
-        Find_next_suitable_point_via_Angle_of_Sphere(FirstPoint, SecondPoint, SecondPoint, FirstPoint, SecondPoint, 0, &Chord, &helper, &Oben, CenterOfFirstLine, Opt_Candidate, Storage, RADIUS, mol);
-        cout << Verbose(1) << "Third Point is " << *Opt_Candidate << endl;
-
-        // FOUND Starting Triangle: FirstPoint, SecondPoint, Opt_Candidate
-
-        // Finally, we only have to add the found points
-        AddTrianglePoint(FirstPoint, 0);
-        AddTrianglePoint(SecondPoint, 1);
-        AddTrianglePoint(Opt_Candidate, 2);
-        // ... and respective lines
-        AddTriangleLine(TPS[0], TPS[1], 0);
-        AddTriangleLine(TPS[1], TPS[2], 1);
-        AddTriangleLine(TPS[0], TPS[2], 2);
-        // ... and triangles to the Maps of the Tesselation class
-        BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
-        AddTriangleToLines();
-        // ... and calculate its normal vector (with correct orientation)
-        Oben.Scale(-1.);
-        BTS->GetNormalVector(Oben);
-        cout << Verbose(0) << "==> The found starting triangle consists of " << *FirstPoint << ", " << *SecondPoint << " and " << *Opt_Candidate << " with normal vector " << BTS->NormalVector << ".\n";
-        cout << Verbose(1) << "End of Find_starting_triangle\n";
-};
-
-void Find_non_convex_border(ofstream *out, ofstream *tecplot, molecule* mol, const char *filename, const double RADIUS)
-{
-        int N = 0;
-        struct Tesselation *Tess = new Tesselation;
-        cout << Verbose(1) << "Entering search for non convex hull. " << endl;
-        cout << flush;
-        LineMap::iterator baseline;
-        cout << Verbose(0) << "Begin of Find_non_convex_border\n";
-        bool flag = false;  // marks whether we went once through all baselines without finding any without two triangles
-        bool failflag = false;
-        if ((mol->first->next == mol->last) || (mol->last->previous == mol->first))
-                mol->CreateAdjacencyList((ofstream *)&cout, 1.6, true);
-
-        Tess->Find_starting_triangle(mol, RADIUS);
-
-        baseline = Tess->LinesOnBoundary.begin();
-        while ((baseline != Tess->LinesOnBoundary.end()) || (flag)) {
-                if (baseline->second->TrianglesCount == 1) {
-                        failflag = Tess->Find_next_suitable_triangle(out, tecplot, mol, *(baseline->second), *(((baseline->second->triangles.begin()))->second), RADIUS, N, filename); //the line is there, so there is a triangle, but only one.
-                        flag = flag || failflag;
-                        if (!failflag)
-                                cerr << "WARNING: Find_next_suitable_triangle failed." << endl;
-                } else {
-                        cout << Verbose(1) << "Line " << *baseline->second << " has " << baseline->second->TrianglesCount << " triangles adjacent" << endl;
-                }
-                N++;
-                baseline++;
-                if ((baseline == Tess->LinesOnBoundary.end()) && (flag)) {
-                        baseline = Tess->LinesOnBoundary.begin();   // restart if we reach end due to newly inserted lines
-                        flag = false;
-                }
-        }
-        if (failflag) {
-                cout << Verbose(1) << "Writing final tecplot file\n";
-                if (DoTecplotOutput)
-                        write_tecplot_file(out, tecplot, Tess, mol, -1);
-                if (DoRaster3DOutput)
-                        write_raster3d_file(out, tecplot, Tess, mol);
-        } else {
-                cerr << "ERROR: Could definately not find all necessary triangles!" << endl;
-        }
-
-        cout << Verbose(0) << "End of Find_non_convex_border\n";
-        delete(Tess);
-};
-
+  PointsOnBoundary.insert( PointPair(Walker->nr, BPS[0]) );
+  PointsOnBoundaryCount++;
+};

src/boundary.hpp

@@ -36 +36 @@
     BoundaryPointSet(atom *Walker);
     ~BoundaryPointSet();
-
+    
     void AddLine(class BoundaryLineSet *line);
-
+    
     LineMap lines;
     int LinesCount;
@@ -64 +64 @@
     BoundaryTriangleSet(class BoundaryLineSet *line[3], int number);
     ~BoundaryTriangleSet();
-
+    
     void GetNormalVector(Vector &NormalVector);
-
+    
     class BoundaryPointSet *endpoints[3];
     class BoundaryLineSet *lines[3];
-    Vector NormalVector;
     int Nr;
 };
@@ -75 +74 @@
 class Tesselation {
   public:
-
+    
     Tesselation();
     ~Tesselation();
-
+    
     void TesselateOnBoundary(ofstream *out, config *configuration, molecule *mol);
     void GuessStartingTriangle(ofstream *out);
     void AddPoint(atom * Walker);
-    void AddTrianglePoint(atom* Candidate, int n);
-    void AddTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, int n);
-    void AddTriangleToLines();
-    void Find_starting_triangle(molecule* mol, const double RADIUS);
-    bool Find_next_suitable_triangle(ofstream *out, ofstream *tecplot, molecule* mol, BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, int N, const char *filename);
-    bool CheckPresenceOfTriangle(ofstream *out, atom *a, atom *b, atom *c);
-    void Find_next_suitable_point_via_Angle_of_Sphere(atom* a, atom* b, atom* c, atom* Candidate, atom* Parent, int RecursionLevel, Vector *Chord, Vector *direction1, Vector *OldNormal, Vector ReferencePoint, atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule* mol);
-
+    
     PointMap PointsOnBoundary;
     LineMap LinesOnBoundary;
     TriangleMap TrianglesOnBoundary;
-    class BoundaryPointSet *TPS[3]; //this is a Storage for pointers to triangle points, this and BPS[2] needed due to AddLine restrictions
     class BoundaryPointSet *BPS[2];
     class BoundaryLineSet *BLS[3];
@@ -100 +91 @@
     int LinesOnBoundaryCount;
     int TrianglesOnBoundaryCount;
-    int TriangleFilesWritten;
 };
 
@@ -109 +99 @@
 
 
-double VolumeOfConvexEnvelope(ofstream *out, ofstream *tecplot, config *configuration, Boundaries *BoundaryPoints, molecule *mol);
+double VolumeOfConvexEnvelope(ofstream *out, config *configuration, Boundaries *BoundaryPoints, molecule *mol);
 double * GetDiametersOfCluster(ofstream *out, Boundaries *BoundaryPtr, molecule *mol, bool IsAngstroem);
 void PrepareClustersinWater(ofstream *out, config *configuration, molecule *mol, double ClusterVolume, double celldensity);
-void Find_non_convex_border(ofstream *out, ofstream *tecplot, molecule* mol, const char *tempbasename, const double RADIUS);
-void Find_next_suitable_point(atom a, atom b, atom Candidate, int n, Vector *d1, Vector *d2, atom*& Opt_Candidate, double *Storage, const double RADIUS, molecule *mol, bool problem);
 
 

src/builder.cpp

@@ -1 +1 @@
 /** \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.
@@ -6 +6 @@
  * -# 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
- *
+ *    
  */
 
 /*! \mainpage Molecuilder - a molecular set builder
- *
+ * 
  * This introductory shall briefly make aquainted 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.
- *
+ * 
  *  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
- *
+ * 
  *  Installation should without problems succeed as follows:
  *  -# ./configure (or: mkdir build;mkdir run;cd build; ../configure --bindir=../run)
  *  -# make
  *  -# make install
- *
+ * 
  *  Further useful commands are
  *  -# 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 doxygen-doc: Creates these html pages out of the documented source 
+ * 
  * \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.
- *
+ *  later re-execution. 
+ * 
  * \section ref References
- *
+ *  
  *  For the special configuration file format, see the documentation of pcp.
- *
+ * 
  */
 
@@ -80 +80 @@
   cout << Verbose(0) << "INPUT: ";
   cin >> choice;
-
+  
   switch (choice) {
       case 'a': // absolute coordinates of atom
@@ -89 +89 @@
         mol->AddAtom(first);  // add to molecule
         break;
-
+        
       case 'b': // relative coordinates of atom wrt to reference point
         first = new atom;
@@ -105 +105 @@
         mol->AddAtom(first);  // add to molecule
         break;
-
+        
       case 'c': // relative coordinates of atom wrt to already placed atom
         first = new atom;
@@ -111 +111 @@
         do {
           if (!valid) cout << Verbose(0) << "Resulting position out of cell." << endl;
-          second = mol->AskAtom("Enter atom number: ");
+          second = mol->AskAtom("Enter atom number: ");                
           cout << Verbose(0) << "Enter relative coordinates." << endl;
           first->x.AskPosition(mol->cell_size, false);
@@ -121 +121 @@
         mol->AddAtom(first);  // add to molecule
         break;
-
+      
       case 'd': // two atoms, two angles and a distance
         first = new atom;
@@ -152 +152 @@
           x.Copyvector(&fourth->x);
           x.SubtractVector(&third->x);
-
+          
           if (!z.SolveSystem(&x,&y,&n, b, c, a)) {
             cout << Verbose(0) << "Failure solving self-dependent linear system!" << endl;
@@ -167 +167 @@
           cout << "x: ",
           x.Output((ofstream *)&cout);
-          cout << endl;
+          cout << endl;          
           z.MakeNormalVector(&second->x,&third->x,&fourth->x);
           cout << "z: ",
           z.Output((ofstream *)&cout);
-          cout << endl;
+          cout << endl;          
           y.MakeNormalVector(&x,&z);
           cout << "y: ",
           y.Output((ofstream *)&cout);
-          cout << endl;
-
+          cout << endl;          
+         
           // rotate vector around first angle
           first->x.CopyVector(&x);
@@ -182 +182 @@
           cout << "Rotated vector: ",
           first->x.Output((ofstream *)&cout);
-          cout << endl;
+          cout << endl;          
           // remove the projection onto the rotation plane of the second angle
           n.CopyVector(&y);
@@ -188 +188 @@
           cout << "N1: ",
           n.Output((ofstream *)&cout);
-          cout << endl;
+          cout << endl;          
           first->x.SubtractVector(&n);
           cout << "Subtracted vector: ",
           first->x.Output((ofstream *)&cout);
-          cout << endl;
+          cout << endl;          
           n.CopyVector(&z);
           n.Scale(first->x.Projection(&z));
           cout << "N2: ",
           n.Output((ofstream *)&cout);
-          cout << endl;
+          cout << endl;          
           first->x.SubtractVector(&n);
           cout << "2nd subtracted vector: ",
           first->x.Output((ofstream *)&cout);
-          cout << endl;
-
+          cout << endl;          
+          
           // rotate another vector around second angle
           n.CopyVector(&y);
@@ -208 +208 @@
           cout << "2nd Rotated vector: ",
           n.Output((ofstream *)&cout);
-          cout << endl;
-
+          cout << endl;          
+          
           // add the two linear independent vectors
           first->x.AddVector(&n);
-          first->x.Normalize();
+          first->x.Normalize();         
           first->x.Scale(a);
           first->x.AddVector(&second->x);
-
+          
           cout << Verbose(0) << "resulting coordinates: ";
           first->x.Output((ofstream *)&cout);
@@ -241 +241 @@
         } while ((j != -1) && (i<128));
         if (i >= 2) {
-          first->x.LSQdistance(atoms, i);
+          first->x.LSQdistance(atoms, i);             
 
           first->x.Output((ofstream *)&cout);
@@ -259 +259 @@
 static void CenterAtoms(molecule *mol)
 {
-  Vector x, y, helper;
+  Vector x, y;
   char choice;  // menu choice char
-
+  
   cout << Verbose(0) << "===========CENTER ATOMS=========================" << endl;
   cout << Verbose(0) << " a - on origin" << endl;
@@ -271 +271 @@
   cout << Verbose(0) << "INPUT: ";
   cin >> choice;
-
+  
   switch (choice) {
     default:
@@ -292 +292 @@
       mol->CenterEdge((ofstream *)&cout, &x);  // make every coordinate positive
       mol->Translate(&y); // translate by boundary
-      helper.CopyVector(&y);
-      helper.Scale(2.);
-      helper.AddVector(&x);
-      mol->SetBoxDimension(&helper);  // update Box of atoms by boundary
+      mol->SetBoxDimension(&(x+y*2));  // update Box of atoms by boundary
       break;
     case 'd':
@@ -330 +327 @@
   cout << Verbose(0) << "INPUT: ";
   cin >> choice;
-
+  
   switch (choice) {
     default:
@@ -349 +346 @@
       second = mol->AskAtom("Enter second atom: ");
 
-      n.CopyVector((const Vector *)&first->x);
-      n.SubtractVector((const Vector *)&second->x);
+      n.CopyVector((const Vector *)&first->x);  
+      n.SubtractVector((const Vector *)&second->x);  
       n.Normalize();
-      break;
+      break;        
     case 'd':
       char shorthand[4];
@@ -366 +363 @@
         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: ";
@@ -372 +369 @@
       cout << Verbose(0) << endl;
       n.Normalize();
-      break;
+      break;       
   };
   cout << Verbose(0) << "Alignment vector: ";
@@ -388 +385 @@
   Vector n;
   char choice;  // menu choice char
-
+  
   cout << Verbose(0) << "===========MIRROR ATOMS=========================" << endl;
   cout << Verbose(0) << " a - state three atoms defining mirror plane" << endl;
@@ -397 +394 @@
   cout << Verbose(0) << "INPUT: ";
   cin >> choice;
-
+  
   switch (choice) {
     default:
@@ -416 +413 @@
       second = mol->AskAtom("Enter second atom: ");
 
-      n.CopyVector((const Vector *)&first->x);
-      n.SubtractVector((const Vector *)&second->x);
+      n.CopyVector((const Vector *)&first->x);  
+      n.SubtractVector((const Vector *)&second->x);  
       n.Normalize();
-      break;
+      break;          
   };
   cout << Verbose(0) << "Normal vector: ";
@@ -436 +433 @@
   double tmp1, tmp2;
   char choice;  // menu choice char
-
+  
   cout << Verbose(0) << "===========REMOVE ATOMS=========================" << endl;
   cout << Verbose(0) << " a - state atom for removal by number" << endl;
@@ -445 +442 @@
   cout << Verbose(0) << "INPUT: ";
   cin >> choice;
-
+  
   switch (choice) {
     default:
@@ -478 +475 @@
           mol->RemoveAtom(first);
       }
-      break;
+      break;          
   };
   //mol->Output((ofstream *)&cout);
@@ -495 +492 @@
   int Z;
   char choice;  // menu choice char
-
+  
   cout << Verbose(0) << "===========MEASURE ATOMS=========================" << endl;
   cout << Verbose(0) << " a - calculate bond length between one atom and all others" << endl;
@@ -517 +514 @@
       for (int i=MAX_ELEMENTS;i--;)
         min[i] = 0.;
-
-      second = mol->start;
+        
+      second = mol->start;   
       while ((second->next != mol->end)) {
         second = second->next; // advance
@@ -529 +526 @@
         }
         if ((tmp1 != 0.) && ((min[Z] == 0.) || (tmp1 < min[Z]))) min[Z] = tmp1;
-        //cout << Verbose(0) << "Bond length between Atom " << first->nr << " and " << second->nr << ": " << tmp1 << " a.u." << endl;
+        //cout << 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.) cout << 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: ");
@@ -559 +556 @@
       y.SubtractVector((const Vector *)&second->x);
       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) << (acos(x.ScalarProduct((const Vector *)&y)/(y.Norm()*x.Norm()))/M_PI*180.) << " degrees" << endl;
+      cout << Verbose(0) << (acos(x.ScalarProduct((const Vector *)&y)/(y.Norm()*x.Norm()))/M_PI*180.) << " degrees" << endl;         
       break;
     case 'd':
@@ -572 +569 @@
     case 'e':
         cout << Verbose(0) << "Evaluating volume of the convex envelope.";
-        VolumeOfConvexEnvelope((ofstream *)&cout, NULL, configuration, NULL, mol);
+        VolumeOfConvexEnvelope((ofstream *)&cout, configuration, NULL, mol);
         break;
     case 'f':
@@ -603 +600 @@
   int Order1;
   clock_t start, end;
-
+  
   cout << Verbose(0) << "Fragmenting molecule with current connection matrix ..." << endl;
   cout << Verbose(0) << "What's the desired bond order: ";
@@ -612 +609 @@
     end = clock();
     cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
-  } else
+  } else 
     cout << Verbose(0) << "Connection matrix has not yet been generated!" << endl;
 };
@@ -626 +623 @@
   atom *Walker = mol->start;
   int i, comp, counter=0;
-
+  
   // generate some KeySets
   cout << "Generating KeySets." << endl;
@@ -640 +637 @@
   cout << "Testing insertion of already present item in KeySets." << endl;
   KeySetTestPair test;
-  test = TestSets[mol->AtomCount-1].insert(Walker->nr);
+  test = TestSets[mol->AtomCount-1].insert(Walker->nr); 
   if (test.second) {
     cout << Verbose(1) << "Insertion worked?!" << endl;
@@ -649 +646 @@
   TestSets[mol->AtomCount].insert(mol->end->previous->previous->previous->nr);
 
-  // constructing Graph structure
+  // constructing Graph structure  
   cout << "Generating Subgraph class." << endl;
   Graph Subgraphs;
@@ -660 +657 @@
   cout << "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->AtomCount],pair<int, double>(counter++, 1.))); 
   if (test2.second) {
     cout << Verbose(1) << "Insertion worked?!" << endl;
@@ -666 +663 @@
     cout << Verbose(1) << "Insertion rejected: Present object is " << (*(test2.first)).second.first << "." << endl;
   }
-
+  
   // show graphs
   cout << "Showing Subgraph's contents, checking that it's sorted." << endl;
@@ -677 +674 @@
       if ((*key) > comp)
         cout << (*key) << " ";
-      else
+      else 
         cout << (*key) << "! ";
       comp = (*key);
@@ -697 +694 @@
   char filename[MAXSTRINGSIZE];
   ofstream output;
-  string basis("3-21G");
 
   cout << Verbose(0) << "Storing configuration ... " << endl;
@@ -703 +699 @@
   mol->CalculateOrbitals(*configuration);
   configuration->InitMaxMinStopStep = configuration->MaxMinStopStep = configuration->MaxPsiDouble;
-  strcpy(filename, ConfigFileName);
-  if (ConfigFileName != NULL) { // test the file name
+  if (ConfigFileName != NULL) {
     output.open(ConfigFileName, 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();
   cout << Verbose(0) << "Saving of config file ";
-  if (configuration->Save(filename, periode, mol))
+  if (configuration->Save(&output, periode, mol))
     cout << "successful." << endl;
   else
     cout << "failed." << endl;
-
+  output.close();
+  output.clear();
+  
   // and save to xyz file
   if (ConfigFileName != NULL) {
@@ -731 +724 @@
     strcat(filename, ".xyz");
     output.open(filename, ios::trunc);
-  }
+  } 
   cout << Verbose(0) << "Saving of XYZ file ";
   if (mol->MDSteps <= 1) {
@@ -746 +739 @@
   output.close();
   output.clear();
-
+  
   // and save as MPQC configuration
-  if (ConfigFileName != NULL)
+  if (ConfigFileName != NULL) {
     strcpy(filename, ConfigFileName);
-  if (output == NULL)
+    strcat(filename, ".in");
+    output.open(filename, ios::trunc);
+  }
+  if (output == NULL) {
     strcpy(filename,"main_pcp_linux");
+    strcat(filename, ".in");
+    output.open(filename, ios::trunc);
+  } 
   cout << Verbose(0) << "Saving as mpqc input ";
-  if (configuration->SaveMPQC(filename, mol))
+  if (configuration->SaveMPQC(&output, mol))
     cout << "done." << endl;
   else
     cout << "failed." << endl;
-
+  output.close();
+  output.clear();
+  
   if (!strcmp(configuration->configpath, configuration->GetDefaultPath())) {
     cerr << "WARNING: config is found under different path then stated in config file::defaultpath!" << endl;
@@ -789 +790 @@
   int argptr;
   PathToDatabases = LocalPath;
-
+  
   if (argc > 1) { // config file specified as option
     // 1. : Parse options that just set variables or print help
@@ -802 +803 @@
           case '?':
             cout << "MoleCuilder suite" << endl << "==================" << endl << endl;
-            cout << "Usage: " << argv[0] << "[config file] [-{acefpsthH?vfrp}] [further arguments]" << endl;
+            cout << "Usage: " << argv[0] << "[config file] [-{acefpsthH?vfrp}] [further arguments]" << endl; 
             cout << "or simply " << argv[0] << " without arguments for interactive session." << endl;
             cout << "\t-a Z x1 x2 x3\tAdd new atom of element Z at coordinates (x1,x2,x3)." << endl;
-            cout << "\t-A <source>\tCreate adjacency list from bonds parsed from 'dbond'-style file." <<endl;
             cout << "\t-b x1 x2 x3\tCenter atoms in domain with given edge lengths of (x1,x2,x3)." << endl;
-            cout << "\t-B <basis>\tgive gaussian basis for MPQC output." << endl;
             cout << "\t-c x1 x2 x3\tCenter atoms in domain with a minimum distance to boundary of (x1,x2,x3)." << endl;
             cout << "\t-D <bond distance>\tDepth-First-Search Analysis of the molecule, giving cycles and tree/back edges." << endl;
@@ -818 +817 @@
             cout << "\t-m <0/1>\tCalculate (0)/ Align in(1) PAS with greatest EV along z axis." << endl;
             cout << "\t-n\tFast parsing (i.e. no trajectories are looked for)." << endl;
-            cout << "\t-N\tGet non-convex-envelope." << endl;
-            cout << "\t-o <out>\tGet volume of the convex envelope (and store to tecplot file)." << endl;
+            cout << "\t-o\tGet volume of the convex envelope (and store to tecplot file)." << endl;
             cout << "\t-p <file>\tParse given xyz file and create raw config file from it." << endl;
             cout << "\t-P <file>\tParse given forces file and append as an MD step to config file via Verlet." << endl;
@@ -825 +823 @@
             cout << "\t-r\t\tConvert file from an old pcp syntax." << endl;
             cout << "\t-t x1 x2 x3\tTranslate all atoms by this vector (x1,x2,x3)." << endl;
-            cout << "\t-T <file> Store temperatures from the config file in <file>." << endl;
+            cout << "\t-T <file> Store temperatures from the config file in <file>." << endl; 
             cout << "\t-s x1 x2 x3\tScale all atom coordinates by this vector (x1,x2,x3)." << endl;
-            cout << "\t-u rho\tsuspend in water solution and output necessary cell lengths, average density rho and repetition." << endl;
+            cout << "\t-u rho\tsuspend in water solution and output necessary cell lengths, average density rho and repetition." << endl; 
             cout << "\t-v/-V\t\tGives version information." << endl;
             cout << "Note: config files must not begin with '-' !" << endl;
@@ -843 +841 @@
             break;
           case 'e':
-            if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-              cerr << "Not enough or invalid arguments for specifying element db: -e <db file>" << endl;
-            } else {
-              cout << "Using " << argv[argptr] << " as elements database." << endl;
-              PathToDatabases = argv[argptr];
-              argptr+=1;
-            }
+            cout << "Using " << argv[argptr] << " as elements database." << endl;
+            PathToDatabases = argv[argptr];
+            argptr+=1;
             break;
           case 'n':
@@ -862 +856 @@
         argptr++;
     } while (argptr < argc);
-
+    
     // 2. Parse the element database
     if (periode->LoadPeriodentafel(PathToDatabases)) {
@@ -871 +865 @@
       return 1;
     }
-
+    
     // 3. Find config file name and parse if possible
     if (argv[1][0] != '-') {
@@ -910 +904 @@
     } else
       config_present = absent;
-
+    
     // 4. parse again through options, now for those depending on elements db and config presence
     argptr = 1;
@@ -921 +915 @@
             case 'p':
               ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                cerr << "Not enough arguments for parsing: -p <xyz file>" << endl;
-              } else {
-                SaveFlag = true;
-                cout << Verbose(1) << "Parsing xyz file for new atoms." << endl;
-                if (!mol->AddXYZFile(argv[argptr]))
-                  cout << Verbose(2) << "File not found." << endl;
-                else {
-                  cout << Verbose(2) << "File found and parsed." << endl;
+              SaveFlag = true;
+              cout << Verbose(1) << "Parsing xyz file for new atoms." << endl;
+              if (!mol->AddXYZFile(argv[argptr]))
+                cout << Verbose(2) << "File not found." << endl;
+              else {
+                cout << Verbose(2) << "File found and parsed." << endl;
+                config_present = present;
+              }
+              break;
+            case 'a':
+              ExitFlag = 1;
+              SaveFlag = true;
+              cout << Verbose(1) << "Adding new atom with element " << argv[argptr] << " at (" << argv[argptr+1] << "," << argv[argptr+2] << "," << argv[argptr+3] << "), ";
+              first = new atom;
+              first->type = periode->FindElement(atoi(argv[argptr]));
+              if (first->type != NULL)
+                cout << Verbose(2) << "found element " << first->type->name << endl;
+              for (int i=NDIM;i--;)
+                first->x.x[i] = atof(argv[argptr+1+i]);
+              if (first->type != NULL) {
+                mol->AddAtom(first);  // add to molecule
+                if ((config_present == empty) && (mol->AtomCount != 0))
                   config_present = present;
-                }
-              }
-              break;
-            case 'a':
-              ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-') || (!IsValidNumber(argv[argptr+1]))) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments for adding atom: -a <element> <x> <y> <z>" << endl;
-              } else {
-                SaveFlag = true;
-                cout << Verbose(1) << "Adding new atom with element " << argv[argptr] << " at (" << argv[argptr+1] << "," << argv[argptr+2] << "," << argv[argptr+3] << "), ";
-                first = new atom;
-                first->type = periode->FindElement(atoi(argv[argptr]));
-                if (first->type != NULL)
-                  cout << Verbose(2) << "found element " << first->type->name << endl;
-                for (int i=NDIM;i--;)
-                  first->x.x[i] = atof(argv[argptr+1+i]);
-                if (first->type != NULL) {
-                  mol->AddAtom(first);  // add to molecule
-                  if ((config_present == empty) && (mol->AtomCount != 0))
-                    config_present = present;
-                } else
-                  cerr << Verbose(1) << "Could not find the specified element." << endl;
-                argptr+=4;
-              }
+              } else
+                cerr << 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)
@@ -964 +948 @@
         if (config_present == present) {
           switch(argv[argptr-1][1]) {
-            case 'B':
-              if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for giving gaussian basis: -B <basis>" << endl;
-              } else {
-                cout << Verbose(1) << "Setting gaussian basis to " << argv[argptr] << "." << endl;
-                configuration.basis.copy(argv[argptr],strlen(argv[argptr]));
-                argptr+=1;
-              }
-              break;
-            case 'D':
+            case 'D': 
               ExitFlag = 1;
               {
@@ -1005 +979 @@
                 delete[](MinimumRingSize);
               }
-              //argptr+=1;
+              argptr+=1;
               break;
             case 'E':
               ExitFlag = 1;
-              if ((argptr+1 >= argc) || (!IsValidNumber(argv[argptr])) || (argv[argptr+1][0] == '-')) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for changing element: -E <atom nr.> <element>" << endl;
-              } else {
-                SaveFlag = true;
-                cout << 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 'A':
-                                                        ExitFlag = 1;
-                                                        if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) || (argv[argptr][0] == '-')) {
-                                                                ExitFlag =255;
-                                                                cerr << "Missing source file for bonds in molecule: -A <bond sourcefile>" << endl;
-                                                        } else {
-                                                                cout << "Parsing bonds from " << argv[argptr] << "." << endl;
-                                                                ifstream *input = new ifstream(argv[argptr]);
-                                                                mol->CreateAdjacencyList2((ofstream *)&cout, input);
-                                                                input->close();
-                                                        }
-                                                        break;
-                                                case 'N':
-                                                        ExitFlag = 1;
-                                                        if ((argptr+1 >= argc) || (argv[argptr+1][0] == '-')){
-                                                                ExitFlag = 255;
-                                                                cerr << "Not enough or invalid arguments given for non-convex envelope: -o <radius> <tecplot output file>" << endl;
-                                                        } else {
-                                                                cout << Verbose(0) << "Evaluating npn-convex envelope.";
-                                                                string TempName(argv[argptr+1]);
-                                                                TempName.append(".r3d");
-                                                                ofstream *output = new ofstream(TempName.c_str(), ios::trunc);
-                                                                cout << Verbose(1) << "Using rolling ball of radius " << atof(argv[argptr]) << " and storing tecplot data in " << argv[argptr+1] << "." << endl;
-                                                                Find_non_convex_border((ofstream *)&cout, output, mol, argv[argptr+1], atof(argv[argptr]));
-                                                                output->close();
-                                                                delete(output);
-                                                                argptr+=2;
-                                                        }
-                                                        break;
+              SaveFlag = true;
+              cout << 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 'T':
               ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for storing tempature: -T <temperature file>" << endl;
-              } else {
+              {
                 cout << Verbose(1) << "Storing temperatures in " << argv[argptr] << "." << endl;
                 ofstream *output = new ofstream(argv[argptr], ios::trunc);
@@ -1063 +1000 @@
                 output->close();
                 delete(output);
-                argptr+=1;
               }
+              argptr+=1;
               break;
             case 'L':
@@ -1078 +1015 @@
             case 'P':
               ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-')) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for parsing and integrating forces: -P <forces file>" << endl;
-              } else {
-                SaveFlag = true;
-                cout << Verbose(1) << "Parsing forces file and Verlet integrating." << endl;
-                if (!mol->VerletForceIntegration((ofstream *)&cout, argv[argptr], configuration))
-                  cout << Verbose(2) << "File not found." << endl;
-                else
-                  cout << Verbose(2) << "File found and parsed." << endl;
-                argptr+=1;
+              SaveFlag = true;
+              cout << Verbose(1) << "Parsing forces file and Verlet integrating." << endl;
+              if (!mol->VerletForceIntegration((ofstream *)&cout, argv[argptr], configuration.Deltat, configuration.GetIsAngstroem(), configuration.DoConstrainedMD))
+                cout << Verbose(2) << "File not found." << endl;
+              else {
+                cout << Verbose(2) << "File found and parsed." << endl;
+                if (configuration.DoConstrainedMD)
+                  // increase source step in expectancy of a new step in the config
+                  configuration.DoConstrainedMD++;
               }
+              argptr+=1;
               break;
             case 't':
               ExitFlag = 1;
-              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for translation: -t <x> <y> <z>" << endl;
-              } else {
-                ExitFlag = 1;
-                SaveFlag = true;
-                cout << Verbose(1) << "Translating all ions to new origin." << endl;
-                for (int i=NDIM;i--;)
-                  x.x[i] = atof(argv[argptr+i]);
-                mol->Translate((const Vector *)&x);
-                argptr+=3;
+              SaveFlag = true;
+              cout << Verbose(1) << "Translating all ions to new origin." << endl;
+              for (int i=NDIM;i--;)
+                x.x[i] = atof(argv[argptr+i]);
+              mol->Translate((const Vector *)&x);
+              argptr+=3;
+              break;
+            case 's':
+              ExitFlag = 1;
+              SaveFlag = true;
+              j = -1;
+              cout << Verbose(1) << "Scaling all ion positions by factor." << endl;
+              factor = new double[NDIM];
+              factor[0] = atof(argv[argptr]);
+              if (argc > argptr+1)
+                argptr++;
+              factor[1] = atof(argv[argptr]);
+              if (argc > argptr+1)
+                argptr++;
+              factor[2] = atof(argv[argptr]);
+              mol->Scale(&factor);
+              for (int i=0;i<NDIM;i++) {
+                j += i+1;
+                x.x[i] = atof(argv[NDIM+i]);
+                mol->cell_size[j]*=factor[i];
               }
-              break;
-            case 's':
-              ExitFlag = 1;
-              if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) ) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for scaling: -s <factor/[factor_x]> [factor_y] [factor_z]" << endl;
-              } else {
-                SaveFlag = true;
-                j = -1;
-                cout << Verbose(1) << "Scaling all ion positions by factor." << endl;
-                factor = new double[NDIM];
-                factor[0] = atof(argv[argptr]);
-                if ((argptr < argc) && (IsValidNumber(argv[argptr])))
-                  argptr++;
-                factor[1] = atof(argv[argptr]);
-                if ((argptr < argc) && (IsValidNumber(argv[argptr])))
-                  argptr++;
-                factor[2] = atof(argv[argptr]);
-                mol->Scale(&factor);
-                for (int i=0;i<NDIM;i++) {
-                  j += i+1;
-                  x.x[i] = atof(argv[NDIM+i]);
-                  mol->cell_size[j]*=factor[i];
-                }
-                delete[](factor);
-                argptr+=1;
+              delete[](factor);
+              argptr+=1;
+              break;
+            case 'b':
+              ExitFlag = 1;
+              SaveFlag = true;
+              j = -1;
+              cout << Verbose(1) << "Centering atoms in config file within given simulation box." << endl;
+              j=-1;
+              for (int i=0;i<NDIM;i++) {
+                j += i+1;
+                x.x[i] = atof(argv[argptr++]);
+                mol->cell_size[j] += x.x[i]*2.;
               }
-              break;
-            case 'b':
-              ExitFlag = 1;
-              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for centering in box: -b <length_x> <length_y> <length_z>" << endl;
-              } else {
-                SaveFlag = true;
-                j = -1;
-                cout << Verbose(1) << "Centering atoms in config file within given simulation box." << endl;
-                j=-1;
-                for (int i=0;i<NDIM;i++) {
-                  j += i+1;
-                  x.x[i] = atof(argv[argptr++]);
-                  mol->cell_size[j] += x.x[i]*2.;
-                }
-                // center
-                mol->CenterInBox((ofstream *)&cout, &x);
-                // update Box of atoms by boundary
-                mol->SetBoxDimension(&x);
+              // center
+              mol->CenterInBox((ofstream *)&cout, &x);
+              // update Box of atoms by boundary
+              mol->SetBoxDimension(&x);
+              break;
+            case 'c':
+              ExitFlag = 1;
+              SaveFlag = true;
+              j = -1;
+              cout << Verbose(1) << "Centering atoms in config file within given additional boundary." << endl;
+              // make every coordinate positive
+              mol->CenterEdge((ofstream *)&cout, &x);
+              // update Box of atoms by boundary
+              mol->SetBoxDimension(&x);
+              // translate each coordinate by boundary
+              j=-1;
+              for (int i=0;i<NDIM;i++) {
+                j += i+1;
+                x.x[i] = atof(argv[argptr++]);
+                mol->cell_size[j] += x.x[i]*2.;
               }
-              break;
-            case 'c':
-              ExitFlag = 1;
-              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for centering with boundary: -c <boundary_x> <boundary_y> <boundary_z>" << endl;
-              } else {
-                SaveFlag = true;
-                j = -1;
-                cout << Verbose(1) << "Centering atoms in config file within given additional boundary." << endl;
-                // make every coordinate positive
-                mol->CenterEdge((ofstream *)&cout, &x);
-                // update Box of atoms by boundary
-                mol->SetBoxDimension(&x);
-                // translate each coordinate by boundary
-                j=-1;
-                for (int i=0;i<NDIM;i++) {
-                  j += i+1;
-                  x.x[i] = atof(argv[argptr++]);
-                  mol->cell_size[j] += x.x[i]*2.;
-                }
-                mol->Translate((const Vector *)&x);
-              }
+              mol->Translate((const Vector *)&x);
               break;
             case 'O':
@@ -1192 +1107 @@
             case 'f':
               ExitFlag = 1;
-              if ((argptr+1 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1]))) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments for fragmentation: -f <max. bond distance> <bond order>" << endl;
-              } else {
-                cout << "Fragmenting molecule with bond distance " << argv[argptr] << " angstroem, order of " << argv[argptr+1] << "." << endl;
+              cout << "Fragmenting molecule with bond distance " << argv[argptr] << " angstroem, order of " << argv[argptr+1] << "." << endl;
+              if (argc >= argptr+2) {
                 cout << Verbose(0) << "Creating connection matrix..." << endl;
                 start = clock();
@@ -1206 +1118 @@
                 end = clock();
                 cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
-                argptr+=2;
+                argptr+=1;
+              } else {
+                cerr << "Not enough arguments for fragmentation: -f <max. bond distance> <bond order>" << endl;
               }
               break;
@@ -1225 +1139 @@
             case 'o':
               ExitFlag = 1;
-              if ((argptr >= argc) || (argv[argptr][0] == '-')){
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for convex envelope: -o <tecplot output file>" << endl;
-              } else {
-                cout << Verbose(0) << "Evaluating volume of the convex envelope.";
-                ofstream *output = new ofstream(argv[argptr], ios::trunc);
-                //$$$
-                cout << Verbose(1) << "Storing tecplot data in " << argv[argptr] << "." << endl;
-                VolumeOfConvexEnvelope((ofstream *)&cout, output, &configuration, NULL, mol);
-                output->close();
-                delete(output);
-                argptr+=1;
-              }
+              SaveFlag = true;
+              cout << Verbose(0) << "Evaluating volume of the convex envelope.";
+              VolumeOfConvexEnvelope((ofstream *)&cout, &configuration, NULL, mol);
               break;
             case 'U':
               ExitFlag = 1;
-              if ((argptr+1 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) ) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for suspension with specified volume: -U <volume> <density>" << endl;
-                volume = -1; // for case 'u': don't print error again
-              } else {
-                volume = atof(argv[argptr++]);
-                cout << Verbose(0) << "Using " << volume << " angstrom^3 as the volume instead of convex envelope one's." << endl;
-              }
+              volume = atof(argv[argptr++]);
+              cout << Verbose(0) << "Using " << volume << " angstrom^3 as the volume instead of convex envelope one's." << endl;  
             case 'u':
               ExitFlag = 1;
-              if ((argptr >= argc) || (!IsValidNumber(argv[argptr])) ) {
-                if (volume != -1)
-                  ExitFlag = 255;
-                  cerr << "Not enough arguments given for suspension: -u <density>" << endl;
-              } else {
+              {
                 double density;
                 SaveFlag = true;
@@ -1270 +1164 @@
 //                  repetition[i] = 1;
 //                }
-                PrepareClustersinWater((ofstream *)&cout, &configuration, mol, volume, density);  // if volume == 0, will calculate from ConvexEnvelope
+                PrepareClustersinWater((ofstream *)&cout, &configuration, mol, volume, density);
               }
               break;
             case 'd':
               ExitFlag = 1;
-              if ((argptr+2 >= argc) || (!IsValidNumber(argv[argptr])) || (!IsValidNumber(argv[argptr+1])) || (!IsValidNumber(argv[argptr+2])) ) {
-                ExitFlag = 255;
-                cerr << "Not enough or invalid arguments given for repeating cells: -d <repeat_x> <repeat_y> <repeat_z>" << endl;
-              } else {
-                SaveFlag = true;
-                for (int axis = 1; axis <= NDIM; axis++) {
-                  int faktor = atoi(argv[argptr++]);
-                  int count;
-                  element ** Elements;
-                  Vector ** vectors;
-                  if (faktor < 1) {
-                    cerr << Verbose(0) << "ERROR: Repetition faktor mus be greater than 1!" << endl;
-                    faktor = 1;
+              SaveFlag = true;
+              for (int axis = 1; axis <= NDIM; axis++) {
+                int faktor = atoi(argv[argptr++]);
+                int count;
+                element ** Elements;
+                Vector ** vectors;
+                if (faktor < 1) {
+                  cerr << Verbose(0) << "ERROR: Repetition faktor mus be greater than 1!" << endl;
+                  faktor = 1;
+                }
+                mol->CountAtoms((ofstream *)&cout);  // 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++;
                   }
-                  mol->CountAtoms((ofstream *)&cout);  // 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)
+                    cout << Verbose(0) << "ERROR: AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl;
+                  x.Zero();
+                  y.Zero();
+                  y.x[abs(axis)-1] = mol->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.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 (count != j)
-                      cout << Verbose(0) << "ERROR: AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl;
+                  }
+                  // free memory
+                  delete[](Elements);
+                  delete[](vectors);
+                  // correct cell size
+                  if (axis < 0) { // if sign was negative, we have to translate everything
                     x.Zero();
-                    y.Zero();
-                    y.x[abs(axis)-1] = mol->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.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, ...)
-                      }
-                    }
-                    // 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);
-                    }
-                    mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+                    x.AddVector(&y);
+                    x.Scale(-(faktor-1));
+                    mol->Translate(&x);
                   }
+                  mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor; 
                 }
               }
@@ -1390 +1279 @@
   if (j == 1) return 0; // just for -v and -h options
   if (j) return j;  // something went wrong
-
+  
   // General stuff
   if (mol->cell_size[0] == 0.) {
@@ -1404 +1293 @@
   // now the main construction loop
   cout << Verbose(0) << endl << "Now comes the real construction..." << endl;
-  do {
+  do {    
     cout << Verbose(0) << endl << endl;
     cout << Verbose(0) << "============Element list=======================" << endl;
@@ -1423 +1312 @@
     cout << Verbose(0) << "-----------------------------------------------" << endl;
     cout << Verbose(0) << "d - duplicate molecule/periodic cell" << endl;
-    cout << Verbose(0) << "i - realign molecule" << endl;
-    cout << Verbose(0) << "m - mirror all molecules" << endl;
+    cout << Verbose(0) << "i - realign molecule" << endl; 
+    cout << Verbose(0) << "m - mirror all molecules" << endl; 
     cout << Verbose(0) << "t - translate molecule by vector" << endl;
     cout << Verbose(0) << "c - scale by unit transformation" << endl;
@@ -1435 +1324 @@
     cout << Verbose(0) << "Input: ";
     cin >> choice;
-
+    
     switch (choice) {
       default:
       case 'a': // add atom
         AddAtoms(periode, mol);
-        choice = 'a';
-        break;
-
+        choice = 'a'; 
+        break;
+      
       case 'b': // scale a bond
         cout << Verbose(0) << "Scaling bond length between two atoms." << endl;
@@ -1458 +1347 @@
         }
         //cout << Verbose(0) << "New coordinates of Atom " << second->nr << " are: ";
-        //second->Output(second->type->No, 1, (ofstream *)&cout);
-        break;
-
-      case 'c': // unit scaling of the metric
+        //second->Output(second->type->No, 1, (ofstream *)&cout);       
+        break;
+
+      case 'c': // unit scaling of the metric 
        cout << Verbose(0) << "Angstroem -> Bohrradius: 1.8897261\t\tBohrradius -> Angstroem: 0.52917721" << endl;
        cout << Verbose(0) << "Enter three factors: ";
@@ -1472 +1361 @@
        delete[](factor);
        break;
-
+       
       case 'd': // duplicate the periodic cell along a given axis, given times
         cout << Verbose(0) << "State the axis [(+-)123]: ";
@@ -1478 +1367 @@
         cout << Verbose(0) << "State the factor: ";
         cin >> faktor;
-
+        
         mol->CountAtoms((ofstream *)&cout);  // recount atoms
         if (mol->AtomCount != 0) {  // if there is more than none
@@ -1519 +1408 @@
             mol->Translate(&x);
           }
-          mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+          mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor; 
         }
         break;
-
+      
       case 'e': // edit each field of the configuration
        configuration.Edit(mol);
        break;
-
+  
       case 'f':
         FragmentAtoms(mol, &configuration);
         break;
-
+        
       case 'g': // center the atoms
         CenterAtoms(mol);
         break;
-
-      case 'i': // align all atoms
+        
+      case 'i': // align all atoms 
         AlignAtoms(periode, mol);
         break;
@@ -1546 +1435 @@
         MirrorAtoms(mol);
         break;
-
+       
       case 'o': // create the connection matrix
         {
@@ -1567 +1456 @@
         }
         break;
-
+        
       case 'p': // parse and XYZ file
         cout << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
@@ -1576 +1465 @@
         break;
 
-      case 'q': // quit
-        break;
-
+      case 'q': // quit 
+        break;
+        
       case 'r': // remove atom
-        RemoveAtoms(mol);
-        break;
-
+        RemoveAtoms(mol);        
+        break;
+        
       case 's': // save to config file
         SaveConfig(ConfigFileName, &configuration, periode, mol);
@@ -1588 +1477 @@
 
       case 't': // translate all atoms
-       cout << Verbose(0) << "Enter translation vector." << endl;
+       cout << Verbose(0) << "Enter translation vector." << endl;       
        x.AskPosition(mol->cell_size,0);
        mol->Translate((const Vector *)&x);
        break;
-
+  
       case 'T':
         testroutine(mol);
         break;
-
+      
       case 'u': // change an atom's element
         first = NULL;
@@ -1603 +1492 @@
           cin >> Z;
         } while ((first = mol->FindAtom(Z)) == NULL);
-        cout << Verbose(0) << "New element by atomic number Z: ";
+        cout << Verbose(0) << "New element by atomic number Z: ";        
         cin >> Z;
         first->type = periode->FindElement(Z);
-        cout << Verbose(0) << "Atom " << first->nr << "'s element is " << first->type->name << "." << endl;
+        cout << Verbose(0) << "Atom " << first->nr << "'s element is " << first->type->name << "." << endl;    
         break;
     };
   } while (choice != 'q');
-
+  
   // save element data base
   if (periode->StorePeriodentafel(ElementsFileName)) //ElementsFileName

src/config.cpp

@@ -18 +18 @@
   configpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
   configname = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
-  ThermostatImplemented = (int *) Malloc((MaxThermostats)*(sizeof(int)), "IonsInitRead: *ThermostatImplemented");
-  ThermostatNames = (char **) Malloc((MaxThermostats)*(sizeof(char *)), "IonsInitRead: *ThermostatNames");
-  for (int j=0;j<MaxThermostats;j++)
-    ThermostatNames[j] = (char *) MallocString(12*(sizeof(char)), "IonsInitRead: ThermostatNames[]");
-  Thermostat = 4;
-  alpha = 0.;
-  ScaleTempStep = 25;
-  TempFrequency = 2.5;
   strcpy(mainname,"pcp");
   strcpy(defaultpath,"not specified");
@@ -31 +23 @@
   configpath[0]='\0';
   configname[0]='\0';
-  basis="3-21G";
-  
-
-  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;
-
+  
   FastParsing = false;
   ProcPEGamma=8;
@@ -65 +42 @@
   UseAddGramSch=1;
   Seed=1;
+  
   MaxOuterStep=0;
-  Deltat=0.01;
+  Deltat=1;
   OutVisStep=10;
   OutSrcStep=5;
@@ -118 +96 @@
   Free((void **)&configname, "config::~config: *configname");
 };
-
-/** Readin of Thermostat related values from parameter file.
- * \param *source parameter file
- */
-void config::InitThermostats(ifstream *source)
-{
-  char *thermo = MallocString(12, "IonsInitRead: thermo");
-  int verbose = 0;
-
-  // read desired Thermostat from file along with needed additional parameters
-  if (ParseForParameter(verbose,source,"Thermostat", 0, 1, 1, string_type, thermo, 1, optional)) {
-    if (strcmp(thermo, ThermostatNames[0]) == 0) { // None
-      if (ThermostatImplemented[0] == 1) {
-        Thermostat = None;
-      } else {
-        cout << 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,source,"Thermostat", 0, 2, 1, int_type, &ScaleTempStep, 1, critical); // read scaling frequency
-      } else {
-        cout << 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,source,"Thermostat", 0, 2, 1, int_type, &ScaleTempStep, 1, critical); // read collision rate
-      } else {
-        cout << 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,source,"Thermostat", 0, 2, 1, double_type, &TempFrequency, 1, critical); // read gamma
-        if (ParseForParameter(verbose,source,"Thermostat", 0, 3, 1, double_type, &alpha, 1, optional)) {
-          cout << Verbose(2) << "Extended Stochastic Thermostat detected with interpolation coefficient " << alpha << "." << endl;
-        } else {
-          alpha = 1.;
-        }
-      } else {
-        cout << 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,source,"Thermostat", 0, 2, 1, double_type, &TempFrequency, 1, critical); // read \tau_T
-      } else {
-        cout << 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,source,"Thermostat", 0, 2, 1, double_type, &HooverMass, 1, critical); // read Hoovermass
-        alpha = 0.;
-      } else {
-        cout << Verbose(1) << "Warning: " << ThermostatNames[0] << " thermostat not implemented, falling back to None." << endl;
-        Thermostat = None;
-      }
-    } else {
-      cout << Verbose(1) << " Warning: thermostat name was not understood!" << endl;
-      Thermostat = None;
-    }
-  } else {
-    if ((MaxOuterStep > 0) && (TargetTemp != 0)) 
-      cout << Verbose(2) <<  "No thermostat chosen despite finite temperature MD, falling back to None." << endl;
-    Thermostat = None;
-  }
-  Free((void **)&thermo, "InitThermostats: thermo");
-};
-
 
 /** Displays menu for editing each entry of the config file.
@@ -563 +465 @@
   double value[3];
   
-  InitThermostats(file);
-  
   /* Namen einlesen */
 
@@ -1075 +975 @@
 
 /** Stores all elements of config structure from which they can be re-read.
- * \param *filename name of file
+ * \param output open output *file stream to write to
  * \param *periode pointer to a periodentafel class with all elements
  * \param *mol pointer to molecule containing all atoms of the molecule 
  */
-bool config::Save(const char *filename, periodentafel *periode, molecule *mol) const
+bool config::Save(ofstream *output, periodentafel *periode, molecule *mol) const
 {
   bool result = true;
         // bring MaxTypes up to date
         mol->CountElements();
-  ofstream *output = NULL;
-  output = new ofstream(filename, ios::out);
   if (output != NULL) {
     *output << "# ParallelCarParinello - main configuration file - created with molecuilder" << endl;
@@ -1103 +1001 @@
     *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) {
-      default:
-      case None:
-        break;
-      case Woodcock:
-        *output << ScaleTempStep;
-        break;
-      case Gaussian:
-        *output << ScaleTempStep;
-        break;
-      case Langevin:
-        *output << TempFrequency << "\t" << alpha;
-        break;
-      case Berendsen:
-        *output << TempFrequency;
-        break;
-      case NoseHoover:
-        *output << HooverMass;
-        break;
-    };
-    *output << "\t# Which Thermostat and its parameters to use in MD case." << endl;
     *output << "CommonWannier\t" << config::CommonWannier << "\t# Put virtual centers at indivual orbits, all common, merged by variance, to grid point, to cell center" << endl;
     *output << "SawtoothStart\t" << config::SawtoothStart << "\t# Absolute value for smooth transition at cell border " << endl;
@@ -1196 +1072 @@
     else
       result = result && mol->OutputTrajectories(output);
-    output->close();
-    output->clear();
-    delete(output);
     return result;
   } else
@@ -1206 +1079 @@
 /** Stores all elements in a MPQC input file.
  * Note that this format cannot be parsed again.
- * \param *filename name of file (without ".in" suffix!)
+ * \param output open output *file stream to write to
  * \param *mol pointer to molecule containing all atoms of the molecule 
  */
-bool config::SaveMPQC(const char *filename, molecule *mol) const
+bool config::SaveMPQC(ofstream *output, molecule *mol) const
 {
   int ElementNo = 0;
   int AtomNo;
   atom *Walker = NULL;
-  element *runner = NULL;
+  element *runner = mol->elemente->start;
   Vector *center = NULL;
-  ofstream *output = NULL;
-  stringstream *fname = NULL;
-  
-  // first without hessian
-  fname = new stringstream;
-  *fname << filename << ".in";
-  output = new ofstream(fname->str().c_str(), ios::out);
+
   *output << "% Created by MoleCuilder" << endl;
   *output << "mpqc: (" << endl;
@@ -1228 +1095 @@
   *output << "\tdo_gradient = yes" << endl;
   *output << "\tmole<CLHF>: (" << endl;
-  *output << "\t\tmaxiter = 200" << endl;
-  *output << "\t\tbasis = $:basis" << endl;
-  *output << "\t\tmolecule = $:molecule" << endl;
-  *output << "\t)" << endl;
-  *output << ")" << endl;
-  *output << "molecule<Molecule>: (" << endl;
-  *output << "\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
-  *output << "\t{ atoms geometry } = {" << endl;
+  *output << "\t\tmolecule<Molecule>: (" << endl;
+  *output << "\t\t\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
+  *output << "\t\t\t{ atoms geometry } = {" << endl;
   center = mol->DetermineCenterOfAll(output);
   // output of atoms
-  runner = mol->elemente->start;
   while (runner->next != mol->elemente->end) { // go through every element
     runner = runner->next;
@@ -1249 +1110 @@
         if (Walker->type == runner) { // if this atom fits to element
           AtomNo++;
-          *output << "\t\t" << Walker->type->symbol << " [ " << Walker->x.x[0]-center->x[0] << "\t" << Walker->x.x[1]-center->x[1] << "\t" << Walker->x.x[2]-center->x[2] << " ]" << endl;
+          *output << "\t\t\t\t" << Walker->type->symbol << " [ " << Walker->x.x[0]-center->x[0] << "\t" << Walker->x.x[1]-center->x[1] << "\t" << Walker->x.x[2]-center->x[2] << " ]" << endl;
         }
       }
@@ -1255 +1116 @@
   }
   delete(center);
-  *output << "\t}" << endl;
-  *output << ")" << endl;
-  *output << "basis<GaussianBasisSet>: (" << endl;
-  *output << "\tname = \"" << basis << "\"" << endl;
-  *output << "\tmolecule = $:molecule" << endl;
-  *output << ")" << endl;
-  output->close();
-  delete(output);
-  delete(fname);
-
-  // second with hessian
-  fname = new stringstream;
-  *fname << filename << ".hess.in";
-  output = new ofstream(fname->str().c_str(), ios::out);
-  *output << "% Created by MoleCuilder" << endl;
-  *output << "mpqc: (" << endl;
-  *output << "\tsavestate = no" << endl;
-  *output << "\tdo_gradient = yes" << endl;
-  *output << "\tmole<CLHF>: (" << endl;
-  *output << "\t\tmaxiter = 200" << endl;
-  *output << "\t\tbasis = $:basis" << endl;
-  *output << "\t\tmolecule = $:molecule" << endl;
-  *output << "\t)" << endl;
-  *output << "\tfreq<MolecularFrequencies>: (" << endl;
-  *output << "\t\tmolecule=$:molecule" << endl;
+  *output << "\t\t\t}" << endl;
+  *output << "\t\t)" << endl;
+  *output << "\t\tbasis<GaussianBasisSet>: (" << endl;
+  *output << "\t\t\tname = \"STO-3G\"" << endl;
+  *output << "\t\t\tmolecule = $:mpqc:mole:molecule" << endl;
+  *output << "\t\t)" << endl;
   *output << "\t)" << endl;
   *output << ")" << endl;
-  *output << "molecule<Molecule>: (" << endl;
-  *output << "\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
-  *output << "\t{ atoms geometry } = {" << endl;
-  center = mol->DetermineCenterOfAll(output);
-  // output of atoms
-  runner = mol->elemente->start;
-  while (runner->next != mol->elemente->end) { // go through every element
-    runner = runner->next;
-    if (mol->ElementsInMolecule[runner->Z]) { // if this element got atoms
-      ElementNo++;
-      AtomNo = 0;
-      Walker = mol->start;
-      while (Walker->next != mol->end) { // go through every atom of this element
-        Walker = Walker->next;
-        if (Walker->type == runner) { // if this atom fits to element
-          AtomNo++;
-          *output << "\t\t" << Walker->type->symbol << " [ " << Walker->x.x[0]-center->x[0] << "\t" << Walker->x.x[1]-center->x[1] << "\t" << Walker->x.x[2]-center->x[2] << " ]" << endl;
-        }
-      }
-    }
-  }
-  delete(center);
-  *output << "\t}" << endl;
-  *output << ")" << endl;
-  *output << "basis<GaussianBasisSet>: (" << endl;
-  *output << "\tname = \"3-21G\"" << endl;
-  *output << "\tmolecule = $:molecule" << endl;
-  *output << ")" << endl;
-  output->close();
-  delete(output);
-  delete(fname);
-  
   return true;
 };

src/datacreator.cpp

@@ -29 +29 @@
 }; 
 
-/** Opens a file for appending with \a *filename in \a *dir.
- * \param output file handle on return
- * \param *dir directory
- * \param *filename name of file
- * \return true if file has been opened
- */
-bool AppendOutputFile(ofstream &output, const char *dir, const char *filename)
-{
-  stringstream name;
-  name << dir << "/" << filename;
-  output.open(name.str().c_str(), ios::app);
-  if (output == NULL) {
-    cout << "Unable to open " << name.str() << " for writing, is directory correct?" << endl;
-    return false;
-  }
-  return true;
-}; 
-
 /** Plots an energy vs. order.
  * \param &Fragments EnergyMatrix class containing matrix values
@@ -63 +45 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "#Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  output << "#Order\tFrag.No.\t" << Fragments.Header << endl;
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
       for(int j=Fragments.RowCounter[ KeySet.OrderSet[BondOrder][i] ];j--;)
-        for(int k=Fragments.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];k--;)
+        for(int k=Fragments.ColumnCounter;k--;)
           Fragments.Matrix[Fragments.MatrixCounter][j][k] += Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
     }
     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
-    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
+    for (int l=0;l<Fragments.ColumnCounter;l++)
       output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter]-1 ][l];
     output << endl;
@@ -96 +78 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "#Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  output << "#Order\tFrag.No.\t" << Fragments.Header << endl;
   Fragments.SetLastMatrix(Energy.Matrix[Energy.MatrixCounter],0);
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
       for(int j=Fragments.RowCounter[ KeySet.OrderSet[BondOrder][i] ];j--;)
-        for(int k=Fragments.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];k--;)
+        for(int k=Fragments.ColumnCounter;k--;)
           Fragments.Matrix[Fragments.MatrixCounter][j][k] -= Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
     }
     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
-    for (int l=0;l<Fragments.ColumnCounter[Energy.MatrixCounter];l++)
+    for (int l=0;l<Fragments.ColumnCounter;l++)
       if (fabs(Energy.Matrix[Energy.MatrixCounter][ Energy.RowCounter[Energy.MatrixCounter]-1 ][l]) < MYEPSILON)
         output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter]-1 ][l];
@@ -133 +115 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "# Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  output << "# Order\tFrag.No.\t" << Fragments.Header << endl;
   Fragments.SetLastMatrix(0.,0);
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
@@ -139 +121 @@
     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
     CreateForce(Fragments, Fragments.MatrixCounter);
-    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
+    for (int l=0;l<Fragments.ColumnCounter;l++)
        output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter] ][l];
     output << endl;
@@ -165 +147 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "# Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  output << "# Order\tFrag.No.\t" << Fragments.Header << endl;
   Fragments.SetLastMatrix(Force.Matrix[Force.MatrixCounter],0);
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
@@ -171 +153 @@
     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
     CreateForce(Fragments, Fragments.MatrixCounter);
-    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
+    for (int l=0;l<Fragments.ColumnCounter;l++)
        output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter] ][l];
     output << endl;
@@ -198 +180 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  output << "# AtomNo\t" << Fragments.Header << endl;
   Fragments.SetLastMatrix(Force.Matrix[Force.MatrixCounter], 0);
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
@@ -204 +186 @@
     Fragments.SumSubForces(Fragments, KeySet, BondOrder, -1.);
     // errors per atom
-    output << endl << "#Order\t" << BondOrder+1 << endl;
+    output << "#Order\t" << BondOrder+1 << endl;
     for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) { 
       output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
-      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++) {
+      for (int l=0;l<Fragments.ColumnCounter;l++) {
         if (((l+1) % 3) == 0) {
           norm = 0.;
@@ -244 +226 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
+  output << "# AtomNo\t" << Fragments.Header << endl;
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     //cout << "Current order is " << BondOrder << "." << endl;
     Fragments.SumSubForces(Fragments, KeySet, BondOrder, 1.);
     // errors per atom
-    output << endl << "#Order\t" << BondOrder+1 << endl;
+    output << "#Order\t" << BondOrder+1 << endl;
     for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) { 
       output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
-      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++)
+      for (int l=0;l<Fragments.ColumnCounter;l++)
         output << scientific << Fragments.Matrix[Fragments.MatrixCounter][ j ][l] << "\t";
       output << endl;
@@ -262 +244 @@
 };
 
-
-/** Plot hessian error vs. vs atom vs. order.
- * \param &Hessian HessianMatrix containing reference values (in MatrixCounter matrix)
- * \param &Fragments HessianMatrix class containing matrix values
- * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
- * \param *prefix prefix in filename (without ending)
- * \param *msg message to be place in first line as a comment
- * \param *datum current date and time
- * \return true if file was written successfully
- */
-bool CreateDataDeltaHessianOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum) 
-{
-  stringstream filename;
-  ofstream output;
-
-  filename << prefix << ".dat";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
-  cout << msg << endl;
-  output << "# " << msg << ", created on " << datum;
-  output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
-  Fragments.SetLastMatrix(Hessian.Matrix[Hessian.MatrixCounter], 0);
-  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
-    //cout << "Current order is " << BondOrder << "." << endl;
-    Fragments.SumSubHessians(Fragments, KeySet, BondOrder, -1.);
-    // errors per atom
-    output << endl << "#Order\t" << BondOrder+1 << endl;
-    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) { 
-      output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
-      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++) {
-        output << scientific << Fragments.Matrix[Fragments.MatrixCounter][ j ][l] << "\t";
-      }
-      output << endl;
-    }
-    output << endl;
-  }
-  output.close();
-  return true;
-};
-
-/** Plot hessian error vs. vs atom vs. order in the frobenius norm.
- * \param &Hessian HessianMatrix containing reference values (in MatrixCounter matrix)
- * \param &Fragments HessianMatrix class containing matrix values
- * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
- * \param *prefix prefix in filename (without ending)
- * \param *msg message to be place in first line as a comment
- * \param *datum current date and time
- * \return true if file was written successfully
- */
-bool CreateDataDeltaFrobeniusOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum) 
-{
-  stringstream filename;
-  ofstream output;
-  double norm = 0;
-  double tmp;
-
-  filename << prefix << ".dat";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
-  cout << msg << endl;
-  output << "# " << msg << ", created on " << datum;
-  output << "# AtomNo\t";
-  Fragments.SetLastMatrix(Hessian.Matrix[Hessian.MatrixCounter], 0);
-  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
-    output << "Order" << BondOrder+1 << "\t";
-  }
-  output << endl;
-  output << Fragments.RowCounter[ Fragments.MatrixCounter ] << "\t";
-  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
-    //cout << "Current order is " << BondOrder << "." << endl;
-    Fragments.SumSubHessians(Fragments, KeySet, BondOrder, -1.);
-    // frobenius norm of errors per atom
-    norm = 0.;
-    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) { 
-      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++) {
-        tmp = Fragments.Matrix[Fragments.MatrixCounter][ j ][l];
-        norm += tmp*tmp;
-      }
-    }
-    output << scientific << sqrt(norm)/(Fragments.RowCounter[ Fragments.MatrixCounter ]*Fragments.ColumnCounter[ Fragments.MatrixCounter] ) << "\t";
-  }
-  output << endl;
-  output.close();
-  return true;
-};
-
-/** Plot hessian error vs. vs atom vs. order.
- * \param &Fragments HessianMatrix class containing matrix values
- * \param KeySet KeySetContainer class holding bond KeySetContainer::Order
- * \param *prefix prefix in filename (without ending)
- * \param *msg message to be place in first line as a comment
- * \param *datum current date and time
- * \return true if file was written successfully
- */
-bool CreateDataHessianOrderPerAtom(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum) 
-{
-  stringstream filename;
-  ofstream output;
-
-  filename << prefix << ".dat";
-  if (!OpenOutputFile(output, dir, filename.str().c_str())) return false; 
-  cout << msg << endl;
-  output << "# " << msg << ", created on " << datum;
-  output << "# AtomNo\t" << Fragments.Header[ Fragments.MatrixCounter ] << endl;
-  Fragments.SetLastMatrix(0., 0);
-  for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
-    //cout << "Current order is " << BondOrder << "." << endl;
-    Fragments.SumSubHessians(Fragments, KeySet, BondOrder, 1.);
-    // errors per atom
-    output << endl << "#Order\t" << BondOrder+1 << endl;
-    for(int j=0;j<Fragments.RowCounter[ Fragments.MatrixCounter ];j++) { 
-      output << Fragments.Indices[Fragments.MatrixCounter][j] << "\t";
-      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++)
-        output << scientific << Fragments.Matrix[Fragments.MatrixCounter][ j ][l] << "\t";
-      output << endl;
-    }
-    output << endl;
-  }
-  output.close();
-  return true;
-};
-
 /** Plot matrix vs. fragment.
  */
@@ -393 +255 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum << endl;
-  output << "#Order\tFrag.No.\t" << Fragment.Header[ Fragment.MatrixCounter ] << endl;
+  output << "#Order\tFrag.No.\t" << Fragment.Header << endl;
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
     for(int i=0;i<KeySet.FragmentsPerOrder[BondOrder];i++) {
       output << BondOrder+1 << "\t" << KeySet.OrderSet[BondOrder][i]+1;
       CreateFragment(Fragment, KeySet.OrderSet[BondOrder][i]);
-      for (int l=0;l<Fragment.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];l++)
+      for (int l=0;l<Fragment.ColumnCounter;l++)
         output << scientific << "\t" << Fragment.Matrix[ KeySet.OrderSet[BondOrder][i] ][ Fragment.RowCounter[ KeySet.OrderSet[BondOrder][i] ] ][l];
       output << endl;
@@ -417 +279 @@
     for(int i=KeySet.FragmentsPerOrder[BondOrder];i--;) {
       if (fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) < fabs(Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][1])) {
-        for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
+        for (int k=Fragments.ColumnCounter;k--;)
           Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
       }
@@ -434 +296 @@
     int i=0;
     do {  // first get a minimum value unequal to 0
-      for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
+      for (int k=Fragments.ColumnCounter;k--;)
         Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
       i++;
@@ -440 +302 @@
     for(;i<KeySet.FragmentsPerOrder[BondOrder];i++) { // then find lowest
       if (fabs(Fragments.Matrix[ Fragments.MatrixCounter ][j][1]) > fabs(Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][1])) {
-        for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
+        for (int k=Fragments.ColumnCounter;k--;)
           Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
       }
@@ -458 +320 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "#Order\tFrag.No.\t" << Fragment.Header[ Fragment.MatrixCounter ] << endl;
+  output << "#Order\tFrag.No.\t" << Fragment.Header << endl;
   // max
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
@@ -464 +326 @@
     CreateFragmentOrder(Fragment, KeySet, BondOrder);
     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
-    for (int l=0;l<Fragment.ColumnCounter[ Fragment.MatrixCounter ];l++)
+    for (int l=0;l<Fragment.ColumnCounter;l++)
       output << scientific << "\t" << Fragment.Matrix[ Fragment.MatrixCounter ][ Fragment.RowCounter[ Fragment.MatrixCounter ]-1 ][l];
     output << endl;
@@ -478 +340 @@
 void CreateEnergy(class MatrixContainer &Energy, int MatrixNumber)
 {
-  for(int k=0;k<Energy.ColumnCounter[MatrixNumber];k++)
+  for(int k=0;k<Energy.ColumnCounter;k++)
     Energy.Matrix[MatrixNumber][ Energy.RowCounter[MatrixNumber] ] [k] =  Energy.Matrix[MatrixNumber][ Energy.RowCounter[MatrixNumber]-1 ] [k];
 };
@@ -489 +351 @@
 void CreateMinimumForce(class MatrixContainer &Force, int MatrixNumber)
 {
-  for (int l=Force.ColumnCounter[MatrixNumber];l--;)
+  for (int l=Force.ColumnCounter;l--;)
     Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
-  for (int l=5;l<Force.ColumnCounter[MatrixNumber];l+=3) {
+  for (int l=5;l<Force.ColumnCounter;l+=3) {
     double stored = 0;
     int k=0;
@@ -524 +386 @@
 {
   int divisor = 0;
-  for (int l=Force.ColumnCounter[MatrixNumber];l--;)
+  for (int l=Force.ColumnCounter;l--;)
     Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
-  for (int l=5;l<Force.ColumnCounter[MatrixNumber];l+=3) {
+  for (int l=5;l<Force.ColumnCounter;l+=3) {
     double tmp = 0;
     for (int k=Force.RowCounter[MatrixNumber];k--;) {
@@ -548 +410 @@
 void CreateMaximumForce(class MatrixContainer &Force, int MatrixNumber)
 {
-  for (int l=5;l<Force.ColumnCounter[MatrixNumber];l+=3) {
+  for (int l=5;l<Force.ColumnCounter;l+=3) {
     double stored = 0;
     for (int k=Force.RowCounter[MatrixNumber];k--;) {
@@ -580 +442 @@
 void CreateVectorSumForce(class MatrixContainer &Force, int MatrixNumber)
 {
-  for (int l=Force.ColumnCounter[MatrixNumber];l--;)
+  for (int l=Force.ColumnCounter;l--;)
     Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
-  for (int l=0;l<Force.ColumnCounter[MatrixNumber];l++) {
+  for (int l=0;l<Force.ColumnCounter;l++) {
     for (int k=Force.RowCounter[MatrixNumber];k--;)
       Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] += Force.Matrix[MatrixNumber][k][l];
@@ -658 +520 @@
 void AbsEnergyPlotLine(ofstream &output, class MatrixContainer &Energy, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Energy.Header[ Energy.MatrixCounter ]);
+  stringstream line(Energy.Header);
   string token;
 
   getline(line, token, '\t');
-  for (int i=2; i<= Energy.ColumnCounter[Energy.MatrixCounter];i++) {
+  for (int i=2; i<= Energy.ColumnCounter;i++) {
     getline(line, token, '\t');
     while (token[0] == ' ') // remove leading white spaces
       token.erase(0,1);
     output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":(abs($" << i+2 << ")) " << uses;
-    if (i != (Energy.ColumnCounter[Energy.MatrixCounter]))
+    if (i != (Energy.ColumnCounter))
       output << ", \\";
     output << endl;
@@ -682 +544 @@
 void EnergyPlotLine(ofstream &output, class MatrixContainer &Energy, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Energy.Header[Energy.MatrixCounter]);
+  stringstream line(Energy.Header);
   string token;
 
   getline(line, token, '\t');
-  for (int i=1; i<= Energy.ColumnCounter[Energy.MatrixCounter];i++) {
+  for (int i=1; i<= Energy.ColumnCounter;i++) {
     getline(line, token, '\t');
     while (token[0] == ' ') // remove leading white spaces
       token.erase(0,1);
     output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":" << i+2 << " " << uses;
-    if (i != (Energy.ColumnCounter[Energy.MatrixCounter]))
+    if (i != (Energy.ColumnCounter))
       output << ", \\";
     output << endl;
@@ -706 +568 @@
 void ForceMagnitudePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Force.Header[Force.MatrixCounter]);
+  stringstream line(Force.Header);
   string token;
 
@@ -714 +576 @@
   getline(line, token, '\t');
   getline(line, token, '\t');
-  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
+  for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
     getline(line, token, '\t');
     while (token[0] == ' ') // remove leading white spaces
@@ -720 +582 @@
     token.erase(token.length(), 1);  // kill residual index char (the '0')
     output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":(sqrt($" << i+1 << "*$" << i+1 << "+$" << i+2 << "*$" << i+2 << "+$" << i+3 << "*$" << i+3 << ")) " << uses;
-    if (i != (Force.ColumnCounter[Force.MatrixCounter]-1))
+    if (i != (Force.ColumnCounter-1))
       output << ", \\";
     output << endl;
@@ -737 +599 @@
 void AbsFirstForceValuePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Force.Header[Force.MatrixCounter]);
+  stringstream line(Force.Header);
   string token;
 
@@ -745 +607 @@
   getline(line, token, '\t');
   getline(line, token, '\t');
-  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
+  for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
     getline(line, token, '\t');
     while (token[0] == ' ') // remove leading white spaces
@@ -751 +613 @@
     token.erase(token.length(), 1);  // kill residual index char (the '0')
     output << "'" << prefix << ".dat' title '" << token << "' using " << xargument << ":(abs($" << i+1 << ")) " << uses;
-    if (i != (Force.ColumnCounter[Force.MatrixCounter]-1))
+    if (i != (Force.ColumnCounter-1))
       output << ", \\";
     output << endl;
@@ -768 +630 @@
 void BoxesForcePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Force.Header[Force.MatrixCounter]);
+  stringstream line(Force.Header);
   char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
   string token;
@@ -777 +639 @@
   getline(line, token, '\t');
   getline(line, token, '\t');
-  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
+  for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
     getline(line, token, '\t');
     while (token[0] == ' ') // remove leading white spaces
@@ -783 +645 @@
     token.erase(token.length(), 1);  // kill residual index char (the '0')
     output << "'" << prefix << ".dat' title '" << token << "' using ($" << xargument << "+" << fixed << setprecision(1) << (double)((i-7)/3)*0.2 << "):(sqrt($" << i+1 << "*$" << i+1 << "+$" << i+2 << "*$" << i+2 << "+$" << i+3 << "*$" << i+3 << ")) " << uses << " " << fillcolor[(i-7)/3];
-    if (i != (Force.ColumnCounter[Force.MatrixCounter]-1))
+    if (i != (Force.ColumnCounter-1))
       output << ", \\";
     output << endl;
@@ -800 +662 @@
 void BoxesFirstForceValuePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Force.Header[Force.MatrixCounter]);
+  stringstream line(Force.Header);
   char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
   string token;
@@ -809 +671 @@
   getline(line, token, '\t');
   getline(line, token, '\t');
-  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
+  for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
     getline(line, token, '\t');
     while (token[0] == ' ') // remove leading white spaces
@@ -815 +677 @@
     token.erase(token.length(), 1);  // kill residual index char (the '0')
     output << "'" << prefix << ".dat' title '" << token << "' using ($" << xargument << "+" << fixed << setprecision(1) << (double)((i-7)/3)*0.2 << "):" << i+1 << " " << uses << " " << fillcolor[(i-7)/3];
-    if (i != (Force.ColumnCounter[Force.MatrixCounter]-1))
+    if (i != (Force.ColumnCounter-1))
       output << ", \\";
     output << endl;

src/datacreator.hpp

@@ -18 +18 @@
 
 bool OpenOutputFile(ofstream &output, const char *dir, const char *filename);
-bool AppendOutputFile(ofstream &output, const char *dir, const char *filename);
 
 bool CreateDataEnergyOrder(class EnergyMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
@@ -26 +25 @@
 bool CreateDataDeltaForcesOrder(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int));
 bool CreateDataDeltaForcesOrderPerAtom(class ForceMatrix &Force, class ForceMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
-bool CreateDataHessianOrderPerAtom(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
-bool CreateDataDeltaHessianOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
-bool CreateDataDeltaFrobeniusOrderPerAtom(class HessianMatrix &Hessian, class HessianMatrix &Fragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum); 
 bool CreateDataFragment(class MatrixContainer &ForceFragments, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateForce)(class MatrixContainer &, int));
 bool CreateDataFragmentOrder(class MatrixContainer &Fragment, class KeySetsContainer &KeySet, char *dir, char *prefix, char *msg, char *datum, void (*CreateFragmentOrder)(class MatrixContainer &, class KeySetsContainer &, int));

src/defs.hpp

@@ -16 +16 @@
 #define BONDTHRESHOLD 0.5   //!< CSD threshold in bond check which is the width of the interval whose center is the sum of the covalent radii 
 #define AtomicEnergyToKelvin 315774.67  //!< conversion factor from atomic energy to kelvin via boltzmann factor
-#define KelvinToAtomicTemperature 3.1668152e-06    //!< conversion factor for Kelvin to atomic temperature (Hartree over k_B)
-#define KelvinToeV 8.6173422e-05                   //!< conversion factor for Kelvin to Ht (k_B * T = energy), thus Boltzmann constant in eV/K
-#define AtomicMassUnitsToeV 931494088.        //!< conversion factor for atomic weight in units to mass in eV
-#define AtomicMassUnitsToHt 34480864.        //!< conversion factor for atomic weight in units to mass in Ht (protonmass/electronmass * electron_mass_in_Ht
-#define ElectronMass_Ht 18778.865            //!< electron mass in Ht
-#define ElectronMass_eV 510998.903           //!< electron mass in eV
-#define Units2Electronmass (AtomicMassUnitsToeV/ElectronMass_eV) //!< atomic mass unit in eV/ electron mass in eV = 1 822.88863
-#define Atomictime2Femtoseconds 0.024188843     //!< Atomictime in fs
-
 #define VERSIONSTRING "v1.0"
 

src/graph.cpp

@@ -7 +7 @@
 using namespace std;
 
-#include "graph.hpp"
 
-/***************************************** Implementations for graph classes ********************************/
+#include <iostream>
+#include <list>
+#include <vector>
 
-/** Constructor of class Graph.
- */
-Graph::Graph()
-{
-};
+/***************************************** Functions for class graph ********************************/
 
-/** Destructor of class Graph.
- * Destructor does release memory for nodes and edges contained in its lists as well.
- */
-Graph::~Graph()
-{
-};
 
-/** Constructor of class SubGraph.
- */
-SubGraph::SubGraph()
-{
-};
-
-/** Destructor of class SubGraph.
- * Note that destructor does not deallocate either nodes or edges! (this is done by its subgraph!)
- */
-SubGraph::~SubGraph()
-{
-};
-
-/** Constructor of class Node.
- */
-Node::Node()
-{
-};
-
-/** Destructor of class Node.
- */
-Node::~Node()
-{
-};
-
-/** Constructor of class Edge.
- */
-Edge::Edge()
-{
-};
-
-/** Destructor of class Edge.
- */
-Edge::~Edge()
-{
-};
-
+ 

src/helpers.cpp

@@ -182 +182 @@
 };
 
-/** Tests whether a given string contains a valid number or not.
- * \param *string
- * \return true - is a number, false - is not a valid number
- */
-bool IsValidNumber( const char *string) 
-{
-  int ptr = 0;
-  if ((string[ptr] == '.') || (string[ptr] == '-')) // number may be negative or start with dot
-    ptr++;
-  if ((string[ptr] >= '0') && (string[ptr] <= '9'))
-    return true;
-  return false;
-};
-
-

src/helpers.hpp

@@ -59 +59 @@
 void Free(void ** buffer, const char* output);
 char *FixedDigitNumber(const int FragmentNumber, const int digits);
-bool IsValidNumber( const char *string);
 
 /********************************************** helpful template functions *********************************/

src/joiner.cpp

@@ -19 +19 @@
   periodentafel *periode = NULL; // and a period table of all elements
   EnergyMatrix Energy;
+  EnergyMatrix Hcorrection;
+  ForceMatrix Force;
   EnergyMatrix EnergyFragments;
-  
-  EnergyMatrix Hcorrection;
   EnergyMatrix HcorrectionFragments;
-  
-  ForceMatrix Force;
   ForceMatrix ForceFragments;
-
-  HessianMatrix Hessian;
-  HessianMatrix HessianFragments;
-  
   ForceMatrix Shielding;
   ForceMatrix ShieldingPAS;
   ForceMatrix ShieldingFragments;
   ForceMatrix ShieldingPASFragments;
-  ForceMatrix Chi;
-  ForceMatrix ChiPAS;
-  ForceMatrix ChiFragments;
-  ForceMatrix ChiPASFragments;
   KeySetsContainer KeySet;  
   stringstream prefix;
   char *dir = NULL;
-  bool NoHCorrection = false;
-  bool NoHessian = false;
+  bool Hcorrected = true;
 
   cout << "Joiner" << endl;
@@ -72 +61 @@
   // ------------- Parse through all Fragment subdirs --------
   if (!Energy.ParseFragmentMatrix(argv[1], dir, EnergySuffix, 0,0)) return 1;
-  if (!Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX, 0,0)) {
-    NoHCorrection = true;
-    cout << "No HCorrection matrices found, skipping these." << endl;
-  }
+  Hcorrected = Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX, 0,0);
   if (!Force.ParseFragmentMatrix(argv[1], dir, ForcesSuffix, 0,0)) return 1;
-  if (!Hessian.ParseFragmentMatrix(argv[1], dir, HessianSuffix, 0,0)) {
-    NoHessian = true;
-    cout << "No hessian matrices found, skipping these." << endl;
-  }
   if (periode != NULL) { // also look for PAS values
     if (!Shielding.ParseFragmentMatrix(argv[1], dir, ShieldingSuffix, 1, 0)) return 1;
     if (!ShieldingPAS.ParseFragmentMatrix(argv[1], dir, ShieldingPASSuffix, 1, 0)) return 1;
-    if (!Chi.ParseFragmentMatrix(argv[1], dir, ChiSuffix, 1, 0)) return 1;
-    if (!ChiPAS.ParseFragmentMatrix(argv[1], dir, ChiPASSuffix, 1, 0)) return 1;
   }
 
   // ---------- Parse the TE Factors into an array -----------------
-  if (!Energy.InitialiseIndices()) return 1;
-  if (!NoHCorrection) 
-    Hcorrection.InitialiseIndices();
+  if (!Energy.ParseIndices()) return 1;
+  if (Hcorrected) Hcorrection.ParseIndices();
   
   // ---------- Parse the Force indices into an array ---------------
   if (!Force.ParseIndices(argv[1])) return 1;
-
-  // ---------- Parse the Hessian (=force) indices into an array ---------------
-  if (!NoHessian)
-    if (!Hessian.InitialiseIndices((class MatrixContainer *)&Force)) return 1;
 
   // ---------- Parse the shielding indices into an array ---------------
@@ -104 +79 @@
     if(!Shielding.ParseIndices(argv[1])) return 1;
     if(!ShieldingPAS.ParseIndices(argv[1])) return 1;
-    if(!Chi.ParseIndices(argv[1])) return 1;
-    if(!ChiPAS.ParseIndices(argv[1])) return 1;
   }
 
   // ---------- Parse the KeySets into an array ---------------
   if (!KeySet.ParseKeySets(argv[1], Force.RowCounter, Force.MatrixCounter)) return 1;
+
   if (!KeySet.ParseManyBodyTerms()) return 1;
-
   if (!EnergyFragments.AllocateMatrix(Energy.Header, Energy.MatrixCounter, Energy.RowCounter, Energy.ColumnCounter)) return 1;
-  if (!NoHCorrection)  
-    HcorrectionFragments.AllocateMatrix(Hcorrection.Header, Hcorrection.MatrixCounter, Hcorrection.RowCounter, Hcorrection.ColumnCounter);
+  if (Hcorrected)  HcorrectionFragments.AllocateMatrix(Hcorrection.Header, Hcorrection.MatrixCounter, Hcorrection.RowCounter, Hcorrection.ColumnCounter);
   if (!ForceFragments.AllocateMatrix(Force.Header, Force.MatrixCounter, Force.RowCounter, Force.ColumnCounter)) return 1;
-  if (!NoHessian)
-    if (!HessianFragments.AllocateMatrix(Hessian.Header, Hessian.MatrixCounter, Hessian.RowCounter, Hessian.ColumnCounter)) return 1;
   if (periode != NULL) { // also look for PAS values
     if (!ShieldingFragments.AllocateMatrix(Shielding.Header, Shielding.MatrixCounter, Shielding.RowCounter, Shielding.ColumnCounter)) return 1;
     if (!ShieldingPASFragments.AllocateMatrix(ShieldingPAS.Header, ShieldingPAS.MatrixCounter, ShieldingPAS.RowCounter, ShieldingPAS.ColumnCounter)) return 1;
-    if (!ChiFragments.AllocateMatrix(Chi.Header, Chi.MatrixCounter, Chi.RowCounter, Chi.ColumnCounter)) return 1;
-    if (!ChiPASFragments.AllocateMatrix(ChiPAS.Header, ChiPAS.MatrixCounter, ChiPAS.RowCounter, ChiPAS.ColumnCounter)) return 1;
   }
   
@@ -128 +96 @@
   if(!Energy.SetLastMatrix(0., 0)) return 1;
   if(!Force.SetLastMatrix(0., 2)) return 1;
-  if (!NoHessian)
-    if (!Hessian.SetLastMatrix(0., 0)) return 1;
   if (periode != NULL) { // also look for PAS values
     if(!Shielding.SetLastMatrix(0., 2)) return 1;
     if(!ShieldingPAS.SetLastMatrix(0., 2)) return 1;
-    if(!Chi.SetLastMatrix(0., 2)) return 1;
-    if(!ChiPAS.SetLastMatrix(0., 2)) return 1;
   }
 
@@ -144 +108 @@
     cout << "Summing energy of order " << BondOrder+1 << " ..." << endl;
     if (!EnergyFragments.SumSubManyBodyTerms(Energy, KeySet, BondOrder)) return 1;
-    if (!NoHCorrection) { 
+    if (Hcorrected) { 
       HcorrectionFragments.SumSubManyBodyTerms(Hcorrection, KeySet, BondOrder);
       if (!Energy.SumSubEnergy(EnergyFragments, &HcorrectionFragments, KeySet, BondOrder, 1.)) return 1;
-      Hcorrection.SumSubEnergy(HcorrectionFragments, NULL, KeySet, BondOrder, 1.);
+      if (Hcorrected) Hcorrection.SumSubEnergy(HcorrectionFragments, NULL, KeySet, BondOrder, 1.);
     } else 
       if (!Energy.SumSubEnergy(EnergyFragments, NULL, KeySet, BondOrder, 1.)) return 1;
@@ -154 +118 @@
     if (!ForceFragments.SumSubManyBodyTerms(Force, KeySet, BondOrder)) return 1;
     if (!Force.SumSubForces(ForceFragments, KeySet, BondOrder, 1.)) return 1;
-    // --------- sum up Hessian --------------------
-    if (!NoHessian) {
-      cout << "Summing Hessian of order " << BondOrder+1 << " ..." << endl;
-      if (!HessianFragments.SumSubManyBodyTerms(Hessian, KeySet, BondOrder)) return 1;
-      if (!Hessian.SumSubHessians(HessianFragments, KeySet, BondOrder, 1.)) return 1;
-    }
     if (periode != NULL) { // also look for PAS values
-      cout << "Summing shieldings and susceptibilities of order " << BondOrder+1 << " ..." << endl;
+      cout << "Summing shieldings of order " << BondOrder+1 << " ..." << endl;
       if (!ShieldingFragments.SumSubManyBodyTerms(Shielding, KeySet, BondOrder)) return 1;
       if (!Shielding.SumSubForces(ShieldingFragments, KeySet, BondOrder, 1.)) return 1;
       if (!ShieldingPASFragments.SumSubManyBodyTerms(ShieldingPAS, KeySet, BondOrder)) return 1;
       if (!ShieldingPAS.SumSubForces(ShieldingPASFragments, KeySet, BondOrder, 1.)) return 1;
-      if (!ChiFragments.SumSubManyBodyTerms(Chi, KeySet, BondOrder)) return 1;
-      if (!Chi.SumSubForces(ChiFragments, KeySet, BondOrder, 1.)) return 1;
-      if (!ChiPASFragments.SumSubManyBodyTerms(ChiPAS, KeySet, BondOrder)) return 1;
-      if (!ChiPAS.SumSubForces(ChiPASFragments, KeySet, BondOrder, 1.)) return 1;
     }
 
@@ -180 +134 @@
     // forces
     if (!Force.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ForcesSuffix)) return 1;
-    // hessian
-    if (!NoHessian)
-      if (!Hessian.WriteLastMatrix(argv[1], (prefix.str()).c_str(), HessianSuffix)) return 1;
     // shieldings
     if (periode != NULL) { // also look for PAS values
       if (!Shielding.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ShieldingSuffix)) return 1;
       if (!ShieldingPAS.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ShieldingPASSuffix)) return 1;
-      if (!Chi.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ChiSuffix)) return 1;
-      if (!ChiPAS.WriteLastMatrix(argv[1], (prefix.str()).c_str(), ChiPASSuffix)) return 1;
     }
   }
@@ -195 +144 @@
   prefix << dir << EnergyFragmentSuffix;
   if (!EnergyFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
-  if (!NoHCorrection) {
+  if (Hcorrected) {
     prefix.str(" ");
     prefix << dir << HcorrectionFragmentSuffix;
@@ -204 +153 @@
   if (!ForceFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
   if (!CreateDataFragment(EnergyFragments, KeySet, argv[1], FRAGMENTPREFIX ENERGYPERFRAGMENT, "fragment energy versus the Fragment No", "today", CreateEnergy)) return 1;
-  if (!NoHessian) {
-    prefix.str(" ");
-    prefix << dir << HessianFragmentSuffix;
-    if (!HessianFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
-  }
   if (periode != NULL) { // also look for PAS values
     prefix.str(" ");
@@ -216 +160 @@
     prefix << dir << ShieldingPASFragmentSuffix;
     if (!ShieldingPASFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
-    prefix.str(" ");
-    prefix << dir << ChiFragmentSuffix;
-    if (!ChiFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
-    prefix.str(" ");
-    prefix << dir << ChiPASFragmentSuffix;
-    if (!ChiPASFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
   }
 
   // write last matrices as fragments into central dir (not subdir as above), for analyzer to know index bounds
   if (!Energy.WriteLastMatrix(argv[1], dir, EnergyFragmentSuffix)) return 1;
-  if (!NoHCorrection) Hcorrection.WriteLastMatrix(argv[1], dir, HcorrectionFragmentSuffix);
+  if (Hcorrected) Hcorrection.WriteLastMatrix(argv[1], dir, HcorrectionFragmentSuffix);
   if (!Force.WriteLastMatrix(argv[1], dir, ForceFragmentSuffix)) return 1;
-  if (!NoHessian)
-    if (!Hessian.WriteLastMatrix(argv[1], dir, HessianFragmentSuffix)) return 1;
   if (periode != NULL) { // also look for PAS values
     if (!Shielding.WriteLastMatrix(argv[1], dir, ShieldingFragmentSuffix)) return 1;
     if (!ShieldingPAS.WriteLastMatrix(argv[1], dir, ShieldingPASFragmentSuffix)) return 1;
-    if (!Chi.WriteLastMatrix(argv[1], dir, ChiFragmentSuffix)) return 1;
-    if (!ChiPAS.WriteLastMatrix(argv[1], dir, ChiPASFragmentSuffix)) return 1;
   }
 

src/moleculelist.cpp

@@ -395 +395 @@
   int FragmentCounter = 0;
   ofstream output;
-  string basis("3-21G");
   
   // store the fragments as config and as xyz
@@ -456 +455 @@
     // and save as config
     sprintf(FragmentName, "%s/%s%s.conf", configuration->configpath, fragmentprefix, FragmentNumber);
+    outputFragment.open(FragmentName, ios::out);
     *out << Verbose(2) << "Saving " << fragmentprefix << " No. " << FragmentNumber << "/" << FragmentCounter-1 << " as config ...";
-    if ((intermediateResult = configuration->Save(FragmentName, ListOfMolecules[i]->elemente, ListOfMolecules[i])))
+    if ((intermediateResult = configuration->Save(&outputFragment, ListOfMolecules[i]->elemente, ListOfMolecules[i])))
       *out << " done." << endl;
     else
       *out << " failed." << endl;
-    result = result && intermediateResult;
 
     // restore old config
     configuration->SetDefaultPath(PathBackup);
 
+    result = result && intermediateResult;
+    outputFragment.close();
+    outputFragment.clear();
 
     // and save as mpqc input file
     sprintf(FragmentName, "%s/%s%s.in", configuration->configpath, fragmentprefix, FragmentNumber);
+    outputFragment.open(FragmentName, ios::out);
     *out << Verbose(2) << "Saving " << fragmentprefix << " No. " << FragmentNumber << "/" << FragmentCounter-1 << " as mpqc input ...";
-    if ((intermediateResult = configuration->SaveMPQC(FragmentName, ListOfMolecules[i])))
+    if ((intermediateResult = configuration->SaveMPQC(&outputFragment, ListOfMolecules[i])))
       *out << " done." << endl;
     else
@@ -476 +479 @@
        
     result = result && intermediateResult;
-    //outputFragment.close();
-    //outputFragment.clear();
+    outputFragment.close();
+    outputFragment.clear();
     delete(FragmentNumber);
     //Free((void **)&FragmentNumber, "MoleculeListClass::OutputConfigForListOfFragments: *FragmentNumber");

src/molecules.cpp

@@ -1 +1 @@
 /** \file molecules.cpp
- *
+ * 
  * Functions for the class molecule.
- *
+ * 
  */
 
@@ -25 +25 @@
       sum += (gsl_vector_get(x,j) - (vectors[i])->x[j])*(gsl_vector_get(x,j) - (vectors[i])->x[j]);
   }
-
+  
   return sum;
 };
@@ -34 +34 @@
  * Initialises molecule list with correctly referenced start and end, and sets molecule::last_atom to zero.
  */
-molecule::molecule(periodentafel *teil)
-{
+molecule::molecule(periodentafel *teil) 
+{ 
   // init atom chain list
-  start = new atom;
+  start = new atom; 
   end = new atom;
-  start->father = NULL;
+  start->father = NULL; 
   end->father = NULL;
   link(start,end);
@@ -46 +46 @@
   last = new bond(start, end, 1, -1);
   link(first,last);
-  // other stuff
+  // other stuff 
   MDSteps = 0;
-  last_atom = 0;
+  last_atom = 0; 
   elemente = teil;
   AtomCount = 0;
@@ -67 +67 @@
  * Initialises molecule list with correctly referenced start and end, and sets molecule::last_atom to zero.
  */
-molecule::~molecule()
+molecule::~molecule() 
 {
   if (ListOfBondsPerAtom != NULL)
@@ -78 +78 @@
   delete(last);
   delete(end);
-  delete(start);
+  delete(start); 
 };
 
 /** Adds given atom \a *pointer from molecule list.
- * Increases molecule::last_atom and gives last number to added atom and names it according to its element::abbrev and molecule::AtomCount
+ * Increases molecule::last_atom and gives last number to added atom and names it according to its element::abbrev and molecule::AtomCount 
  * \param *pointer allocated and set atom
  * \return true - succeeded, false - atom not found in list
  */
 bool molecule::AddAtom(atom *pointer)
-{
+{ 
   if (pointer != NULL) {
-    pointer->sort = &pointer->nr;
+    pointer->sort = &pointer->nr; 
     pointer->nr = last_atom++;  // increase number within molecule
     AtomCount++;
@@ -106 +106 @@
     return add(pointer, end);
   } else
-    return false;
+    return false; 
 };
 
@@ -115 +115 @@
  */
 atom * molecule::AddCopyAtom(atom *pointer)
-{
+{ 
   if (pointer != NULL) {
         atom *walker = new atom();
@@ -122 +122 @@
     walker->v.CopyVector(&pointer->v); // copy velocity
     walker->FixedIon = pointer->FixedIon;
-    walker->sort = &walker->nr;
+    walker->sort = &walker->nr; 
     walker->nr = last_atom++;  // increase number within molecule
     walker->father = pointer; //->GetTrueFather();
@@ -133 +133 @@
     return walker;
   } else
-    return NULL;
+    return NULL; 
 };
 
@@ -156 +156 @@
  *    The lengths for these are \f$f\f$ and \f$g\f$ (from triangle H1-H2-(center of H1-H2-H3)) with knowledge that
  *    the median lines in an isosceles triangle meet in the center point with a ratio 2:1.
- *    \f[ f = \frac{b}{\sqrt{3}} \qquad g = \frac{b}{2}
+ *    \f[ f = \frac{b}{\sqrt{3}} \qquad g = \frac{b}{2} 
  *    \f]
- *    as the coordination of all three atoms in the coordinate system of these three vectors:
+ *    as the coordination of all three atoms in the coordinate system of these three vectors: 
  *    \f$\pmatrix{d & f & 0}\f$, \f$\pmatrix{d & -0.5 \cdot f & g}\f$ and \f$\pmatrix{d & -0.5 \cdot f & -g}\f$.
- *
+ * 
  * \param *out output stream for debugging
- * \param *Bond pointer to bond between \a *origin and \a *replacement
- * \param *TopOrigin son of \a *origin of upper level molecule (the atom added to this molecule as a copy of \a *origin)
+ * \param *Bond pointer to bond between \a *origin and \a *replacement 
+ * \param *TopOrigin son of \a *origin of upper level molecule (the atom added to this molecule as a copy of \a *origin) 
  * \param *origin pointer to atom which acts as the origin for scaling the added hydrogen to correct bond length
  * \param *replacement pointer to the atom which shall be copied as a hydrogen atom in this molecule
@@ -191 +191 @@
   InBondvector.SubtractVector(&TopOrigin->x);
   bondlength = InBondvector.Norm();
-
+   
    // is greater than typical bond distance? Then we have to correct periodically
    // the problem is not the H being out of the box, but InBondvector have the wrong direction
-   // due to TopReplacement or Origin being on the wrong side!
-  if (bondlength > BondDistance) {
+   // due to TopReplacement or Origin being on the wrong side! 
+  if (bondlength > BondDistance) { 
 //    *out << Verbose(4) << "InBondvector is: ";
 //    InBondvector.Output(out);
@@ -215 +215 @@
 //    *out << endl;
   } // periodic correction finished
-
+  
   InBondvector.Normalize();
   // get typical bond length and store as scale factor for later
   BondRescale = TopOrigin->type->HBondDistance[TopBond->BondDegree-1];
   if (BondRescale == -1) {
-    cerr << Verbose(3) << "ERROR: There is no typical hydrogen bond distance in replacing bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") of degree " << TopBond->BondDegree << "!" << endl;
-    return false;
-    BondRescale = bondlength;
+    cerr << Verbose(3) << "WARNING: There is no typical bond distance for bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") of degree " << TopBond->BondDegree << "!" << endl;
+    BondRescale = bondlength; 
   } else {
     if (!IsAngstroem)
@@ -273 +272 @@
       if (FirstOtherAtom != NULL) { // then we just have this double bond and the plane does not matter at all
 //        *out << Verbose(3) << "Regarding the double bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") to be constructed: Taking " << FirstOtherAtom->Name << " and " << SecondOtherAtom->Name << " along with " << TopOrigin->Name << " to determine orthogonal plane." << endl;
-
+        
         // determine the plane of these two with the *origin
         AllWentWell = AllWentWell && Orthovector1.MakeNormalVector(&TopOrigin->x, &FirstOtherAtom->x, &SecondOtherAtom->x);
@@ -286 +285 @@
       Orthovector1.Normalize();
       //*out << Verbose(3) << "ReScaleCheck: " << Orthovector1.Norm() << " and " << InBondvector.Norm() << "." << endl;
-
+      
       // create the two Hydrogens ...
       FirstOtherAtom = new atom();
@@ -300 +299 @@
       bondangle = TopOrigin->type->HBondAngle[1];
       if (bondangle == -1) {
-        *out << Verbose(3) << "ERROR: There is no typical hydrogen bond angle in replacing bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") of degree " << TopBond->BondDegree << "!" << endl;
-        return false;
+        *out << Verbose(3) << "WARNING: There is no typical bond angle for bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") of degree " << TopBond->BondDegree << "!" << endl;
         bondangle = 0;
       }
@@ -318 +316 @@
         SecondOtherAtom->x.x[i] = InBondvector.x[i] * cos(bondangle) + Orthovector1.x[i] * (-sin(bondangle));
       }
-      FirstOtherAtom->x.Scale(&BondRescale);  // rescale by correct BondDistance
+      FirstOtherAtom->x.Scale(&BondRescale);  // rescale by correct BondDistance 
       SecondOtherAtom->x.Scale(&BondRescale);
       //*out << Verbose(3) << "ReScaleCheck: " << FirstOtherAtom->x.Norm() << " and " << SecondOtherAtom->x.Norm() << "." << endl;
       for(int i=NDIM;i--;) { // and make relative to origin atom
-        FirstOtherAtom->x.x[i] += TopOrigin->x.x[i];
+        FirstOtherAtom->x.x[i] += TopOrigin->x.x[i]; 
         SecondOtherAtom->x.x[i] += TopOrigin->x.x[i];
       }
@@ -365 +363 @@
 //      *out << endl;
       AllWentWell = AllWentWell && Orthovector2.MakeNormalVector(&InBondvector, &Orthovector1);
-//      *out << Verbose(3) << "Orthovector2: ";
+//      *out << Verbose(3) << "Orthovector2: "; 
 //      Orthovector2.Output(out);
 //      *out << endl;
-
+      
       // create correct coordination for the three atoms
       alpha = (TopOrigin->type->HBondAngle[2])/180.*M_PI/2.;  // retrieve triple bond angle from database
@@ -380 +378 @@
       factors[0] = d;
       factors[1] = f;
-      factors[2] = 0.;
+      factors[2] = 0.; 
       FirstOtherAtom->x.LinearCombinationOfVectors(&InBondvector, &Orthovector1, &Orthovector2, factors);
       factors[1] = -0.5*f;
-      factors[2] = g;
+      factors[2] = g; 
       SecondOtherAtom->x.LinearCombinationOfVectors(&InBondvector, &Orthovector1, &Orthovector2, factors);
-      factors[2] = -g;
+      factors[2] = -g; 
       ThirdOtherAtom->x.LinearCombinationOfVectors(&InBondvector, &Orthovector1, &Orthovector2, factors);
 
@@ -437 +435 @@
  */
 bool molecule::AddXYZFile(string filename)
-{
+{ 
   istringstream *input = NULL;
   int NumberOfAtoms = 0; // atom number in xyz read
@@ -446 +444 @@
   string line;    // currently parsed line
   double x[3];    // atom coordinates
-
+  
   xyzfile.open(filename.c_str());
   if (!xyzfile)
@@ -454 +452 @@
   input = new istringstream(line);
   *input >> NumberOfAtoms;
-  cout << Verbose(0) << "Parsing " << NumberOfAtoms << " atoms in file." << endl;
+  cout << Verbose(0) << "Parsing " << NumberOfAtoms << " atoms in file." << endl; 
   getline(xyzfile,line,'\n'); // Read comment
   cout << Verbose(1) << "Comment: " << line << endl;
-
+  
   if (MDSteps == 0) // no atoms yet present
     MDSteps++;
@@ -491 +489 @@
   xyzfile.close();
   delete(input);
-  return true;
+  return true; 
 };
 
@@ -503 +501 @@
   atom *LeftAtom = NULL, *RightAtom = NULL;
   atom *Walker = NULL;
-
+  
   // copy all atoms
   Walker = start;
@@ -510 +508 @@
     CurrentAtom = copy->AddCopyAtom(Walker);
   }
-
+  
   // copy all bonds
   bond *Binder = first;
@@ -534 +532 @@
       copy->NoCyclicBonds++;
     NewBond->Type = Binder->Type;
-  }
+  }  
   // correct fathers
   Walker = copy->start;
@@ -551 +549 @@
     copy->CreateListOfBondsPerAtom((ofstream *)&cout);
   }
-
+  
   return copy;
 };
@@ -576 +574 @@
 
 /** Remove bond from bond chain list.
- * \todo Function not implemented yet
+ * \todo Function not implemented yet 
  * \param *pointer bond pointer
  * \return true - bound found and removed, false - bond not found/removed
@@ -588 +586 @@
 
 /** Remove every bond from bond chain list that atom \a *BondPartner is a constituent of.
- * \todo Function not implemented yet
+ * \todo Function not implemented yet 
  * \param *BondPartner atom to be removed
  * \return true - bounds found and removed, false - bonds not found/removed
@@ -621 +619 @@
   Vector *min = new Vector;
   Vector *max = new Vector;
-
+  
   // gather min and max for each axis
   ptr = start->next;  // start at first in list
@@ -667 +665 @@
 {
   Vector *min = new Vector;
-
+  
 //  *out << Verbose(3) << "Begin of CenterEdge." << endl;
   atom *ptr = start->next;  // start at first in list
@@ -683 +681 @@
       }
     }
-//    *out << Verbose(4) << "Maximum is ";
+//    *out << Verbose(4) << "Maximum is "; 
 //    max->Output(out);
 //    *out << ", Minimum is ";
@@ -691 +689 @@
     max->AddVector(min);
     Translate(min);
-  }
+  } 
   delete(min);
 //  *out << Verbose(3) << "End of CenterEdge." << endl;
-};
+}; 
 
 /** Centers the center of the atoms at (0,0,0).
@@ -704 +702 @@
   int Num = 0;
   atom *ptr = start->next;  // start at first in list
-
+ 
   for(int i=NDIM;i--;) // zero center vector
     center->x[i] = 0.;
-
+    
   if (ptr != end) {   //list not empty?
     while (ptr->next != end) {  // continue with second if present
       ptr = ptr->next;
       Num++;
-      center->AddVector(&ptr->x);
+      center->AddVector(&ptr->x);       
     }
     center->Scale(-1./Num); // divide through total number (and sign for direction)
     Translate(center);
   }
-};
+}; 
 
 /** Returns vector pointing to center of gravity.
@@ -729 +727 @@
   Vector tmp;
   double Num = 0;
-
+  
   a->Zero();
 
@@ -737 +735 @@
       Num += 1.;
       tmp.CopyVector(&ptr->x);
-      a->AddVector(&tmp);
+      a->AddVector(&tmp);       
     }
     a->Scale(-1./Num); // divide through total mass (and sign for direction)
@@ -757 +755 @@
         Vector tmp;
   double Num = 0;
-
+        
         a->Zero();
 
@@ -766 +764 @@
       tmp.CopyVector(&ptr->x);
       tmp.Scale(ptr->type->mass);  // scale by mass
-      a->AddVector(&tmp);
+      a->AddVector(&tmp);       
     }
     a->Scale(-1./Num); // divide through total mass (and sign for direction)
@@ -789 +787 @@
     Translate(center);
   }
-};
+}; 
 
 /** Scales all atoms by \a *factor.
@@ -803 +801 @@
       Trajectories[ptr].R.at(j).Scale(factor);
     ptr->x.Scale(factor);
-  }
-};
-
-/** Translate all atoms by given vector.
+  }      
+};
+
+/** Translate all atoms by given vector. 
  * \param trans[] translation vector.
  */
@@ -818 +816 @@
       Trajectories[ptr].R.at(j).Translate(trans);
     ptr->x.Translate(trans);
-  }
-};
-
-/** Mirrors all atoms against a given plane.
+  }      
+};
+
+/** Mirrors all atoms against a given plane. 
  * \param n[] normal vector of mirror plane.
  */
@@ -833 +831 @@
       Trajectories[ptr].R.at(j).Mirror(n);
     ptr->x.Mirror(n);
-  }
+  }      
 };
 
@@ -847 +845 @@
   bool flag;
   Vector Testvector, Translationvector;
-
+  
   do {
     Center.Zero();
@@ -863 +861 @@
           if (Walker->nr < Binder->GetOtherAtom(Walker)->nr) // otherwise we shift one to, the other fro and gain nothing
             for (int j=0;j<NDIM;j++) {
-              tmp = Walker->x.x[j] - Binder->GetOtherAtom(Walker)->x.x[j];
+              tmp = Walker->x.x[j] - Binder->GetOtherAtom(Walker)->x.x[j]; 
               if ((fabs(tmp)) > BondDistance) {
                 flag = false;
@@ -879 +877 @@
         cout << Verbose(1) << "vector is: ";
         Testvector.Output((ofstream *)&cout);
-        cout << endl;
+        cout << endl;     
 #ifdef ADDHYDROGEN
         // now also change all hydrogens
@@ -892 +890 @@
             cout << Verbose(1) << "Hydrogen vector is: ";
             Testvector.Output((ofstream *)&cout);
-            cout << endl;
+            cout << endl;     
           }
         }
@@ -914 +912 @@
 
         CenterGravity(out, CenterOfGravity);
-
-        // reset inertia tensor
+        
+        // reset inertia tensor 
         for(int i=0;i<NDIM*NDIM;i++)
                 InertiaTensor[i] = 0.;
-
+        
         // sum up inertia tensor
         while (ptr->next != end) {
@@ -943 +941 @@
         }
         *out << endl;
-
+        
         // diagonalize to determine principal axis system
         gsl_eigen_symmv_workspace *T = gsl_eigen_symmv_alloc(NDIM);
@@ -952 +950 @@
         gsl_eigen_symmv_free(T);
         gsl_eigen_symmv_sort(eval, evec, GSL_EIGEN_SORT_ABS_DESC);
-
+        
         for(int i=0;i<NDIM;i++) {
                 *out << Verbose(1) << "eigenvalue = " << gsl_vector_get(eval, i);
                 *out << ", eigenvector = (" << evec->data[i * evec->tda + 0] << "," << evec->data[i * evec->tda + 1] << "," << evec->data[i * evec->tda + 2] << ")" << endl;
         }
-
+        
         // check whether we rotate or not
         if (DoRotate) {
-          *out << Verbose(1) << "Transforming molecule into PAS ... ";
+          *out << Verbose(1) << "Transforming molecule into PAS ... "; 
           // the eigenvectors specify the transformation matrix
           ptr = start;
@@ -972 +970 @@
 
           // summing anew for debugging (resulting matrix has to be diagonal!)
-          // reset inertia tensor
+          // reset inertia tensor 
     for(int i=0;i<NDIM*NDIM;i++)
       InertiaTensor[i] = 0.;
-
+    
     // sum up inertia tensor
     ptr = start;
@@ -1002 +1000 @@
     *out << endl;
         }
-
+        
         // free everything
         delete(CenterOfGravity);
@@ -1019 +1017 @@
  * \sa molecule::MinimiseConstrainedPotential(), molecule::VerletForceIntegration()
  * \param *out output stream for debugging
- * \param *PermutationMap gives target ptr for each atom, array of size molecule::AtomCount (this is "x" in \f$ V^{con}(x) \f$ )
+ * \param *PermutationMap gives target ptr for each atom, array of size molecule::AtomCount (this is "x" in \f$V^{con}(x)\f$)
  * \param startstep start configuration (MDStep in molecule::trajectories)
  * \param endstep end configuration (MDStep in molecule::trajectories)
@@ -1481 +1479 @@
  * \param *out output stream for debugging
  * \param *file filename
- * \param config structure with config::Deltat, config::IsAngstroem, config::DoConstrained
  * \param delta_t time step width in atomic units
  * \param IsAngstroem whether coordinates are in angstroem (true) or bohrradius (false)
@@ -1488 +1485 @@
  * \todo This is not yet checked if it is correctly working with DoConstrained set to true.
  */
-bool molecule::VerletForceIntegration(ofstream *out, char *file, config &configuration)
-{
+bool molecule::VerletForceIntegration(ofstream *out, char *file, double delta_t, bool IsAngstroem, int DoConstrained)
+{
+  element *runner = elemente->start;
   atom *walker = NULL;
+  int AtomNo;
   ifstream input(file);
   string token;
   stringstream item;
-  double IonMass, Vector[NDIM], ConstrainedPotentialEnergy, ActualTemp;
+  double a, IonMass, Vector[NDIM], ConstrainedPotentialEnergy;
   ForceMatrix Force;
 
   CountElements();  // make sure ElementsInMolecule is up to date
-
+  
   // check file
   if (input == NULL) {
@@ -1524 +1523 @@
       }
     // solve a constrained potential if we are meant to
-    if (configuration.DoConstrainedMD) {
+    if (DoConstrained) {
       // calculate forces and potential
       atom **PermutationMap = NULL;
-      ConstrainedPotentialEnergy = MinimiseConstrainedPotential(out, PermutationMap,configuration.DoConstrainedMD, 0, configuration.GetIsAngstroem());
-      EvaluateConstrainedForces(out, configuration.DoConstrainedMD, 0, PermutationMap, &Force);
+      ConstrainedPotentialEnergy = MinimiseConstrainedPotential(out, PermutationMap, DoConstrained, 0, IsAngstroem);
+      EvaluateConstrainedForces(out, DoConstrained, 0, PermutationMap, &Force);
       Free((void **)&PermutationMap, "molecule::MinimiseConstrainedPotential: *PermutationMap");
     }
     
     // and perform Verlet integration for each atom with position, velocity and force vector
-    walker = start;
-    while (walker->next != end) { // go through every atom of this element
-      walker = walker->next;
-      //a = configuration.Deltat*0.5/walker->type->mass;        // (F+F_old)/2m = a and thus: v = (F+F_old)/2m * t = (F + F_old) * a
-      // check size of vectors
-      if (Trajectories[walker].R.size() <= (unsigned int)(MDSteps)) {
-        //out << "Increasing size for trajectory array of " << *walker << " to " << (size+10) << "." << endl;
-        Trajectories[walker].R.resize(MDSteps+10);
-        Trajectories[walker].U.resize(MDSteps+10);
-        Trajectories[walker].F.resize(MDSteps+10);
-      }
-      
-      // Update R (and F)
-      for (int d=0; d<NDIM; d++) {
-        Trajectories[walker].F.at(MDSteps).x[d] = -Force.Matrix[0][walker->nr][d+5]*(configuration.GetIsAngstroem() ? AtomicLengthToAngstroem : 1.);
-        Trajectories[walker].R.at(MDSteps).x[d] = Trajectories[walker].R.at(MDSteps-1).x[d];
-        Trajectories[walker].R.at(MDSteps).x[d] += configuration.Deltat*(Trajectories[walker].U.at(MDSteps-1).x[d]);     // s(t) = s(0) + v * deltat + 1/2 a * deltat^2 
-        Trajectories[walker].R.at(MDSteps).x[d] += 0.5*configuration.Deltat*configuration.Deltat*(Trajectories[walker].F.at(MDSteps).x[d]/walker->type->mass);     // F = m * a and s = 0.5 * F/m * t^2 = F * a * t
-      }
-      // Update U
-      for (int d=0; d<NDIM; d++) {
-        Trajectories[walker].U.at(MDSteps).x[d] = Trajectories[walker].U.at(MDSteps-1).x[d]; 
-        Trajectories[walker].U.at(MDSteps).x[d] += configuration.Deltat * (Trajectories[walker].F.at(MDSteps).x[d]+Trajectories[walker].F.at(MDSteps-1).x[d]/walker->type->mass); // v = F/m * t
-      }
-//      out << "Integrated position&velocity of step " << (MDSteps) << ": ("; 
-//      for (int d=0;d<NDIM;d++)
-//        out << Trajectories[walker].R.at(MDSteps).x[d] << " ";          // next step
-//      out << ")\t(";
-//      for (int d=0;d<NDIM;d++)
-//        cout << Trajectories[walker].U.at(MDSteps).x[d] << " ";          // next step
-//      out << ")" << endl;
-            // next atom
-    }
-  }
-  // correct velocities (rather momenta) so that center of mass remains motionless
-  for(int d=0;d<NDIM;d++)
-    Vector[d] = 0.;
-  IonMass = 0.;
-  walker = start;
-  while (walker->next != end) { // go through every atom
-    walker = walker->next;
-    IonMass += walker->type->mass;  // sum up total mass
-    for(int d=0;d<NDIM;d++) {
-      Vector[d] += Trajectories[walker].U.at(MDSteps).x[d]*walker->type->mass;
-    }
-  }
-  // correct velocities (rather momenta) so that center of mass remains motionless
-  for(int d=0;d<NDIM;d++)
-    Vector[d] /= IonMass;
-  ActualTemp = 0.;
-  walker = start;
-  while (walker->next != end) { // go through every atom of this element
-    walker = walker->next;
-    for(int d=0;d<NDIM;d++) {
-      Trajectories[walker].U.at(MDSteps).x[d] -= Vector[d];
-      ActualTemp += 0.5 * walker->type->mass * Trajectories[walker].U.at(MDSteps).x[d] * Trajectories[walker].U.at(MDSteps).x[d];
-    }
-  }
-  Thermostats(configuration, ActualTemp, Berendsen);
-  MDSteps++;
-
-
-  // exit
-  return true;
-};
-
-/** Implementation of various thermostats.
- * All these thermostats apply an additional force which has the following forms:
- * -# Woodcock
- *  \f$p_i \rightarrow \sqrt{\frac{T_0}{T}} \cdot p_i\f$
- * -# Gaussian
- *  \f$ \frac{ \sum_i \frac{p_i}{m_i} \frac{\partial V}{\partial q_i}} {\sum_i \frac{p^2_i}{m_i}} \cdot p_i\f$
- * -# Langevin
- *  \f$p_{i,n} \rightarrow \sqrt{1-\alpha^2} p_{i,0} + \alpha p_r\f$  
- * -# Berendsen
- *  \f$p_i \rightarrow \left [ 1+ \frac{\delta t}{\tau_T} \left ( \frac{T_0}{T} \right ) \right ]^{\frac{1}{2}} \cdot p_i\f$
- * -# Nose-Hoover
- *  \f$\zeta p_i \f$ with \f$\frac{\partial \zeta}{\partial t} = \frac{1}{M_s} \left ( \sum^N_{i=1} \frac{p_i^2}{m_i} - g k_B T \right )\f$
- * These Thermostats either simply rescale the velocities, thus this function should be called after ion velocities have been updated, and/or
- * have a constraint force acting additionally on the ions. In the latter case, the ion speeds have to be modified
- * belatedly and the constraint force set.
- * \param *P Problem at hand
- * \param i which of the thermostats to take: 0 - none, 1 - Woodcock, 2 - Gaussian, 3 - Langevin, 4 - Berendsen, 5 - Nose-Hoover
- * \sa InitThermostat()
- */
-void molecule::Thermostats(config &configuration, double ActualTemp, int Thermostat)
-{
-  double ekin = 0.;
-  double E = 0., G = 0.;
-  double delta_alpha = 0.;
-  double ScaleTempFactor;
-  double sigma;
-  double IonMass;
-  int d;
-  gsl_rng * r;
-  const gsl_rng_type * T;
-  double *U = NULL, *F = NULL, FConstraint[NDIM];
-  atom *walker = NULL;
-  
-  // calculate scale configuration
-  ScaleTempFactor = configuration.TargetTemp/ActualTemp;
-    
-  // differentating between the various thermostats
-  switch(Thermostat) {
-     case None:
-      cout << Verbose(2) <<  "Applying no thermostat..." << endl;
-      break;
-     case Woodcock:
-      if ((configuration.ScaleTempStep > 0) && ((MDSteps-1) % configuration.ScaleTempStep == 0)) {
-        cout << Verbose(2) <<  "Applying Woodcock thermostat..." << endl;
+    runner = elemente->start;
+    while (runner->next != elemente->end) { // go through every element
+      runner = runner->next;
+      IonMass = runner->mass;
+      a = delta_t*0.5/IonMass;        // (F+F_old)/2m = a and thus: v = (F+F_old)/2m * t = (F + F_old) * a
+      if (ElementsInMolecule[runner->Z]) { // if this element got atoms
+        AtomNo = 0;
         walker = start;
         while (walker->next != end) { // go through every atom of this element
           walker = walker->next;
-          IonMass = walker->type->mass;
-          U = Trajectories[walker].U.at(MDSteps).x;
-          if (walker->FixedIon == 0) // even FixedIon moves, only not by other's forces
-            for (d=0; d<NDIM; d++) {
-              U[d] *= sqrt(ScaleTempFactor);
-              ekin += 0.5*IonMass * U[d]*U[d];
+          if (walker->type == runner) { // if this atom fits to element
+            // check size of vectors
+            if (Trajectories[walker].R.size() <= (unsigned int)(MDSteps)) {
+              //out << "Increasing size for trajectory array of " << *walker << " to " << (size+10) << "." << endl;
+              Trajectories[walker].R.resize(MDSteps+10);
+              Trajectories[walker].U.resize(MDSteps+10);
+              Trajectories[walker].F.resize(MDSteps+10);
             }
-        }
-      }
-      break;
-     case Gaussian:
-      cout << Verbose(2) <<  "Applying Gaussian thermostat..." << endl;
-      walker = start;
-      while (walker->next != end) { // go through every atom of this element
-        walker = walker->next;
-        IonMass = walker->type->mass;
-        U = Trajectories[walker].U.at(MDSteps).x;
-        F = Trajectories[walker].F.at(MDSteps).x;
-        if (walker->FixedIon == 0) // even FixedIon moves, only not by other's forces
-          for (d=0; d<NDIM; d++) {
-            G += U[d] * F[d]; 
-            E += U[d]*U[d]*IonMass;
-          }
-      }
-      cout << Verbose(1) << "Gaussian Least Constraint constant is " << G/E << "." << endl;
-      walker = start;
-      while (walker->next != end) { // go through every atom of this element
-        walker = walker->next;
-        IonMass = walker->type->mass;
-        U = Trajectories[walker].U.at(MDSteps).x;
-        F = Trajectories[walker].F.at(MDSteps).x;
-        if (walker->FixedIon == 0) // even FixedIon moves, only not by other's forces
-          for (d=0; d<NDIM; d++) {
-            FConstraint[d] = (G/E) * (U[d]*IonMass);
-            U[d] += configuration.Deltat/IonMass * (FConstraint[d]);
-            ekin += IonMass * U[d]*U[d];
-          }
-      }
-      break;
-     case Langevin:
-      cout << Verbose(2) <<  "Applying Langevin thermostat..." << endl;
-      // init random number generator
-      gsl_rng_env_setup();
-      T = gsl_rng_default;
-      r = gsl_rng_alloc (T);
-      // Go through each ion
-      walker = start;
-      while (walker->next != end) { // go through every atom of this element
-        walker = walker->next;
-        IonMass = walker->type->mass;
-        sigma  = sqrt(configuration.TargetTemp/IonMass); // sigma = (k_b T)/m (Hartree/atomicmass = atomiclength/atomictime)
-        U = Trajectories[walker].U.at(MDSteps).x;
-        F = Trajectories[walker].F.at(MDSteps).x;
-        if (walker->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.)) {  
-            cout << Verbose(3) << "Particle " << *walker << " 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
-            for (d=0; d<NDIM; d++) {
-              U[d] = gsl_ran_gaussian (r, sigma);
+            
+            // Update R (and F)
+            for (int d=0; d<NDIM; d++) {
+              Trajectories[walker].F.at(MDSteps).x[d] = -Force.Matrix[0][AtomNo][d+5]*(IsAngstroem ? AtomicLengthToAngstroem : 1.);
+              Trajectories[walker].R.at(MDSteps).x[d] = Trajectories[walker].R.at(MDSteps-1).x[d];
+              Trajectories[walker].R.at(MDSteps).x[d] += delta_t*(Trajectories[walker].U.at(MDSteps-1).x[d]);
+              Trajectories[walker].R.at(MDSteps).x[d] += delta_t*a*(Trajectories[walker].F.at(MDSteps).x[d]);     // F = m * a and s = 0.5 * F/m * t^2 = F * a * t
             }
-            cout << sqrt(U[0]*U[0]+U[1]*U[1]+U[2]*U[2]) << endl;
-          }
-          for (d=0; d<NDIM; d++)
-            ekin += 0.5*IonMass * U[d]*U[d];
-        }
-      }
-      break;
-     case Berendsen:
-      cout << Verbose(2) <<  "Applying Berendsen-VanGunsteren thermostat..." << endl;
-      walker = start;
-      while (walker->next != end) { // go through every atom of this element
-        walker = walker->next;
-        IonMass = walker->type->mass;
-        U = Trajectories[walker].U.at(MDSteps).x;
-        F = Trajectories[walker].F.at(MDSteps).x;
-        if (walker->FixedIon == 0) { // even FixedIon moves, only not by other's forces
-          for (d=0; d<NDIM; d++) {
-            U[d] *= sqrt(1+(configuration.Deltat/configuration.TempFrequency)*(ScaleTempFactor-1));
-            ekin += 0.5*IonMass * U[d]*U[d];
+            // Update U
+            for (int d=0; d<NDIM; d++) {
+              Trajectories[walker].U.at(MDSteps).x[d] = Trajectories[walker].U.at(MDSteps-1).x[d]; 
+              Trajectories[walker].U.at(MDSteps).x[d] += a * (Trajectories[walker].F.at(MDSteps).x[d]+Trajectories[walker].F.at(MDSteps-1).x[d]);
+            }
+//            out << "Integrated position&velocity of step " << (MDSteps) << ": ("; 
+//            for (int d=0;d<NDIM;d++)
+//              out << Trajectories[walker].R.at(MDSteps).x[d] << " ";          // next step
+//            out << ")\t(";
+//            for (int d=0;d<NDIM;d++)
+//              cout << Trajectories[walker].U.at(MDSteps).x[d] << " ";          // next step
+//            out << ")" << endl;
+            // next atom
+            AtomNo++;
           }
         }
       }
-      break;
-     case NoseHoover:
-      cout << Verbose(2) <<  "Applying Nose-Hoover thermostat..." << endl;
-      // dynamically evolve alpha (the additional degree of freedom)
-      delta_alpha = 0.;
-      walker = start;
-      while (walker->next != end) { // go through every atom of this element
-        walker = walker->next;
-        IonMass = walker->type->mass;
-        U = Trajectories[walker].U.at(MDSteps).x;
-        if (walker->FixedIon == 0) { // even FixedIon moves, only not by other's forces
-          for (d=0; d<NDIM; d++) {
-            delta_alpha += U[d]*U[d]*IonMass;
-          }
-        }
-      }
-      delta_alpha = (delta_alpha - (3.*AtomCount+1.) * configuration.TargetTemp)/(configuration.HooverMass*Units2Electronmass);
-      configuration.alpha += delta_alpha*configuration.Deltat;
-      cout << Verbose(3) << "alpha = " << delta_alpha << " * " << configuration.Deltat << " = " << configuration.alpha << "." << endl;
-      // apply updated alpha as additional force
-      walker = start;
-      while (walker->next != end) { // go through every atom of this element
-        walker = walker->next;
-        IonMass = walker->type->mass;
-        U = Trajectories[walker].U.at(MDSteps).x;
-        if (walker->FixedIon == 0) { // even FixedIon moves, only not by other's forces
-          for (d=0; d<NDIM; d++) {
-              FConstraint[d] = - configuration.alpha * (U[d] * IonMass);
-              U[d] += configuration.Deltat/IonMass * (FConstraint[d]);
-              ekin += (0.5*IonMass) * U[d]*U[d];
-            }
-        }
-      }
-      break;
-  }    
-  cout << Verbose(1) << "Kinetic energy is " << ekin << "." << endl;
+    }
+  }
+//  // correct velocities (rather momenta) so that center of mass remains motionless
+//  for(int d=0;d<NDIM;d++)
+//    Vector[d] = 0.;
+//  IonMass = 0.;
+//  walker = start;
+//  while (walker->next != end) { // go through every atom
+//    walker = walker->next;
+//    IonMass += walker->type->mass;  // sum up total mass
+//    for(int d=0;d<NDIM;d++) {
+//      Vector[d] += Trajectories[walker].U.at(MDSteps).x[d]*walker->type->mass;
+//    }
+//  }
+//  walker = start;
+//  while (walker->next != end) { // go through every atom of this element
+//    walker = walker->next;
+//    for(int d=0;d<NDIM;d++) {
+//      Trajectories[walker].U.at(MDSteps).x[d] -= Vector[d]*walker->type->mass/IonMass;
+//    }
+//  }
+  MDSteps++;
+
+  
+  // exit
+  return true;
 };
 
@@ -1786 +1622 @@
     ptr = ptr->next;
     tmp = ptr->x.x[0];
-    ptr->x.x[0] =  cos(alpha) * tmp + sin(alpha) * ptr->x.x[2];
+    ptr->x.x[0] =  cos(alpha) * tmp + sin(alpha) * ptr->x.x[2]; 
     ptr->x.x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x.x[2];
     for (int j=0;j<MDSteps;j++) {
       tmp = Trajectories[ptr].R.at(j).x[0];
-      Trajectories[ptr].R.at(j).x[0] =  cos(alpha) * tmp + sin(alpha) * Trajectories[ptr].R.at(j).x[2];
+      Trajectories[ptr].R.at(j).x[0] =  cos(alpha) * tmp + sin(alpha) * Trajectories[ptr].R.at(j).x[2]; 
       Trajectories[ptr].R.at(j).x[2] = -sin(alpha) * tmp + cos(alpha) * Trajectories[ptr].R.at(j).x[2];
     }
-  }
+  }      
   // rotate n vector
   tmp = n->x[0];
@@ -1801 +1637 @@
   n->Output((ofstream *)&cout);
   cout << endl;
-
+  
   // rotate on z-y plane
   ptr = start;
@@ -1809 +1645 @@
     ptr = ptr->next;
     tmp = ptr->x.x[1];
-    ptr->x.x[1] =  cos(alpha) * tmp + sin(alpha) * ptr->x.x[2];
+    ptr->x.x[1] =  cos(alpha) * tmp + sin(alpha) * ptr->x.x[2]; 
     ptr->x.x[2] = -sin(alpha) * tmp + cos(alpha) * ptr->x.x[2];
     for (int j=0;j<MDSteps;j++) {
       tmp = Trajectories[ptr].R.at(j).x[1];
-      Trajectories[ptr].R.at(j).x[1] =  cos(alpha) * tmp + sin(alpha) * Trajectories[ptr].R.at(j).x[2];
+      Trajectories[ptr].R.at(j).x[1] =  cos(alpha) * tmp + sin(alpha) * Trajectories[ptr].R.at(j).x[2]; 
       Trajectories[ptr].R.at(j).x[2] = -sin(alpha) * tmp + cos(alpha) * Trajectories[ptr].R.at(j).x[2];
     }
-  }
+  }      
   // rotate n vector (for consistency check)
   tmp = n->x[1];
   n->x[1] =  cos(alpha) * tmp +  sin(alpha) * n->x[2];
   n->x[2] = -sin(alpha) * tmp +  cos(alpha) * n->x[2];
-
+  
   cout << Verbose(1) << "alignment vector after second rotation: ";
   n->Output((ofstream *)&cout);
@@ -1832 +1668 @@
  * \return true - succeeded, false - atom not found in list
  */
-bool molecule::RemoveAtom(atom *pointer)
-{
+bool molecule::RemoveAtom(atom *pointer)  
+{ 
   if (ElementsInMolecule[pointer->type->Z] != 0)  // this would indicate an error
     ElementsInMolecule[pointer->type->Z]--;  // decrease number of atom of this element
   else
-    cerr << "ERROR: Atom " << pointer->Name << " is of element " << pointer->type->Z << " but the entry in the table of the molecule is 0!" << endl;
+    cerr << "ERROR: Atom " << pointer->Name << " is of element " << pointer->type->Z << " but the entry in the table of the molecule is 0!" << endl; 
   if (ElementsInMolecule[pointer->type->Z] == 0)  // was last atom of this element?
     ElementCount--;
@@ -1847 +1683 @@
  * \return true - succeeded, false - atom not found in list
  */
-bool molecule::CleanupMolecule()
-{
-  return (cleanup(start,end) && cleanup(first,last));
+bool molecule::CleanupMolecule() 
+{ 
+  return (cleanup(start,end) && cleanup(first,last)); 
 };
 
@@ -1863 +1699 @@
   } else {
     cout << Verbose(0) << "Atom not found in list." << endl;
-    return NULL;
+    return NULL;  
   }
 };
@@ -1912 +1748 @@
   struct lsq_params *par = (struct lsq_params *)params;
   atom *ptr = par->mol->start;
-
+  
   // initialize vectors
   a.x[0] = gsl_vector_get(x,0);
@@ -1942 +1778 @@
 {
     int np = 6;
-
+    
    const gsl_multimin_fminimizer_type *T =
      gsl_multimin_fminimizer_nmsimplex;
@@ -1948 +1784 @@
    gsl_vector *ss;
    gsl_multimin_function minex_func;
-
+ 
    size_t iter = 0, i;
    int status;
    double size;
-
+ 
    /* Initial vertex size vector */
    ss = gsl_vector_alloc (np);
-
+ 
    /* Set all step sizes to 1 */
    gsl_vector_set_all (ss, 1.0);
-
+ 
    /* Starting point */
    par->x = gsl_vector_alloc (np);
    par->mol = this;
-
+ 
    gsl_vector_set (par->x, 0, 0.0);  // offset
    gsl_vector_set (par->x, 1, 0.0);
@@ -1969 +1805 @@
    gsl_vector_set (par->x, 4, 0.0);
    gsl_vector_set (par->x, 5, 1.0);
-
+ 
    /* Initialize method and iterate */
    minex_func.f = &LeastSquareDistance;
    minex_func.n = np;
    minex_func.params = (void *)par;
-
+ 
    s = gsl_multimin_fminimizer_alloc (T, np);
    gsl_multimin_fminimizer_set (s, &minex_func, par->x, ss);
-
+ 
    do
      {
        iter++;
        status = gsl_multimin_fminimizer_iterate(s);
-
+ 
        if (status)
          break;
-
+ 
        size = gsl_multimin_fminimizer_size (s);
        status = gsl_multimin_test_size (size, 1e-2);
-
+ 
        if (status == GSL_SUCCESS)
          {
            printf ("converged to minimum at\n");
          }
-
+ 
        printf ("%5d ", (int)iter);
        for (i = 0; i < (size_t)np; i++)
@@ -2002 +1838 @@
      }
    while (status == GSL_CONTINUE && iter < 100);
-
+ 
   for (i=0;i<(size_t)np;i++)
     gsl_vector_set(par->x, i, gsl_vector_get(s->x, i));
@@ -2019 +1855 @@
   int ElementNo, AtomNo;
   CountElements();
-
+  
   if (out == NULL) {
     return false;
@@ -2054 +1890 @@
   int ElementNo, AtomNo;
   CountElements();
-
+  
   if (out == NULL) {
     return false;
@@ -2101 +1937 @@
   atom *Walker = start;
   while (Walker->next != end) {
-    Walker = Walker->next;
+    Walker = Walker->next; 
 #ifdef ADDHYDROGEN
     if (Walker->type->Z != 1) {   // regard only non-hydrogen
@@ -2132 +1968 @@
   int No = 0;
   time_t now;
-
+  
   now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
   walker = start;
@@ -2159 +1995 @@
 {
   atom *walker = NULL;
-  int AtomNo = 0, ElementNo;
+  int No = 0;
   time_t now;
-  element *runner = NULL;
-
+  
   now = time((time_t *)NULL);   // Get the system time and put it into 'now' as 'calender time'
   walker = start;
   while (walker->next != end) { // go through every atom and count
     walker = walker->next;
-    AtomNo++;
+    No++;
   }
   if (out != NULL) {
-    *out << AtomNo << "\n\tCreated by molecuilder on " << ctime(&now);
-    ElementNo = 0;
-    runner = elemente->start;
-    while (runner->next != elemente->end) { // go through every element
-                runner = runner->next;
-      if (ElementsInMolecule[runner->Z]) { // if this element got atoms
-        ElementNo++;
-        walker = start;
-        while (walker->next != end) { // go through every atom of this element
-          walker = walker->next;
-          if (walker->type == runner) { // if this atom fits to element
-            walker->OutputXYZLine(out);
-          }
-        }
-      }
+    *out << No << "\n\tCreated by molecuilder on " << ctime(&now);
+    walker = start;
+    while (walker->next != end) { // go through every atom of this element
+      walker = walker->next;
+      walker->OutputXYZLine(out);
     }
     return true;
@@ -2215 +2040 @@
               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++;
+                NoNonHydrogen++; 
               Free((void **)&Walker->Name, "molecule::CountAtoms: *walker->Name");
               Walker->Name = (char *) Malloc(sizeof(char)*6, "molecule::CountAtoms: *walker->Name");
@@ -2223 +2048 @@
             }
     } else
-        *out << Verbose(3) << "AtomCount is still " << AtomCount << ", thus counting nothing." << endl;
+        *out << Verbose(3) << "AtomCount is still " << AtomCount << ", thus counting nothing." << endl; 
   }
 };
@@ -2235 +2060 @@
         ElementsInMolecule[i] = 0;
         ElementCount = 0;
-
+        
   atom *walker = start;
   while (walker->next != end) {
@@ -2271 +2096 @@
     Binder = Binder->next;
     if (Binder->Cyclic)
-      No++;
+      No++;    
   }
   delete(BackEdgeStack);
@@ -2329 +2154 @@
 
 /** Creates an adjacency list of the molecule.
- * We obtain an outside file with the indices of atoms which are bondmembers.
- */
-void molecule::CreateAdjacencyList2(ofstream *out, ifstream *input)
-{
-
-        // 1 We will parse bonds out of the dbond file created by tremolo.
-                        int atom1, atom2, temp;
-                        atom *Walker, *OtherWalker;
-
-                if (!input)
-                {
-                        cout << Verbose(1) << "Opening silica failed \n";
-                };
-
-                        *input >> ws >> atom1;
-                        *input >> ws >> atom2;
-                cout << Verbose(1) << "Scanning file\n";
-                while (!input->eof()) // Check whether we read everything already
-                {
-                                *input >> ws >> atom1;
-                                *input >> ws >> atom2;
-                        if(atom2<atom1) //Sort indices of atoms in order
-                        {
-                                temp=atom1;
-                                atom1=atom2;
-                                atom2=temp;
-                        };
-
-                        Walker=start;
-                        while(Walker-> nr != atom1) // Find atom corresponding to first index
-                        {
-                                Walker = Walker->next;
-                        };
-                        OtherWalker = Walker->next;
-                        while(OtherWalker->nr != atom2) // Find atom corresponding to second index
-                        {
-                                OtherWalker= OtherWalker->next;
-                        };
-                        AddBond(Walker, OtherWalker); //Add the bond between the two atoms with respective indices.
-                        
-                }
-
-                CreateListOfBondsPerAtom(out);
-
-};
-
-
-/** Creates an adjacency list of the molecule.
  * Generally, we use the CSD approach to bond recognition, that is the the distance
  * between two atoms A and B must be within [Rcov(A)+Rcov(B)-t,Rcov(A)+Rcov(B)+t] with
- * a threshold t = 0.4 Angstroem.
+ * a threshold t = 0.4 Angstroem. 
  * To make it O(N log N) the function uses the linked-cell technique as follows:
  * The procedure is step-wise:
@@ -2396 +2173 @@
 void molecule::CreateAdjacencyList(ofstream *out, double bonddistance, bool IsAngstroem)
 {
-
   atom *Walker = NULL, *OtherWalker = NULL, *Candidate = NULL;
   int No, NoBonds, CandidateBondNo;
@@ -2412 +2188 @@
     cleanup(first,last);
   }
-
+        
   // count atoms in molecule = dimension of matrix (also give each unique name and continuous numbering)
   CountAtoms(out);
@@ -2431 +2207 @@
     for (int i=NumberCells;i--;)
       CellList[i] = NULL;
-
+  
     // 2b. put all atoms into its corresponding list
     Walker = start;
@@ -2452 +2228 @@
       if (CellList[index] == NULL)  // allocate molecule if not done
         CellList[index] = new molecule(elemente);
-      OtherWalker = CellList[index]->AddCopyAtom(Walker); // add a copy of walker to this atom, father will be walker for later reference
-      //*out << Verbose(1) << "Copy Atom is " << *OtherWalker << "." << endl;
+      OtherWalker = CellList[index]->AddCopyAtom(Walker); // add a copy of walker to this atom, father will be walker for later reference 
+      //*out << Verbose(1) << "Copy Atom is " << *OtherWalker << "." << endl; 
     }
     //for (int i=0;i<NumberCells;i++)
       //*out << Verbose(1) << "Cell number " << i << ": " << CellList[i] << "." << endl;
-
-
+      
     // 3a. go through every cell
     for (N[0]=divisor[0];N[0]--;)
@@ -2471 +2246 @@
               Walker = Walker->next;
               //*out << Verbose(0) << "Current Atom is " << *Walker << "." << endl;
-              // 3c. check for possible bond between each atom in this and every one in the 27 cells
+              // 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 (n[1]=-1;n[1]<=1;n[1]++)
@@ -2503 +2278 @@
           }
         }
-
-
-
     // 4. free the cell again
     for (int i=NumberCells;i--;)
@@ -2512 +2284 @@
       }
     Free((void **)&CellList, "molecule::CreateAdjacencyList - ** CellList");
-
+    
     // create the adjacency list per atom
     CreateListOfBondsPerAtom(out);
-
+                
     // correct Bond degree of each bond by checking both bond partners for a mismatch between valence and current sum of bond degrees,
     // iteratively increase the one first where the other bond partner has the fewest number of bonds (i.e. in general bonds oxygene
@@ -2574 +2346 @@
     *out << endl;
   } else
-        *out << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl;
+        *out << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl; 
   *out << Verbose(0) << "End of CreateAdjacencyList." << endl;
   Free((void **)&matrix, "molecule::CreateAdjacencyList: *matrix");
-
-};
-
-
+};
 
 /** Performs a Depth-First search on this molecule.
@@ -2601 +2370 @@
   bond *Binder = NULL;
   bool BackStepping = false;
-
+  
   *out << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl;
-
+  
   ResetAllBondsToUnused();
   ResetAllAtomNumbers();
@@ -2616 +2385 @@
     LeafWalker->Leaf = new molecule(elemente);
     LeafWalker->Leaf->AddCopyAtom(Root);
-
+    
     OldGraphNr = CurrentGraphNr;
     Walker = Root;
@@ -2627 +2396 @@
           AtomStack->Push(Walker);
           CurrentGraphNr++;
-        }
+        }      
         do { // (3) if Walker has no unused egdes, go to (5)
           BackStepping = false; // reset backstepping flag for (8)
@@ -2661 +2430 @@
           Binder = NULL;
       } while (1);  // (2)
-
+      
       // if we came from backstepping, yet there were no more unused bonds, we end up here with no Ancestor, because Walker is Root! Then we are finished!
       if ((Walker == Root) && (Binder == NULL))
         break;
-
-      // (5) if Ancestor of Walker is ...
+        
+      // (5) if Ancestor of Walker is ... 
       *out << Verbose(1) << "(5) Number of Walker[" << Walker->Name << "]'s Ancestor[" << Walker->Ancestor->Name << "] is " << Walker->Ancestor->GraphNr << "." << endl;
       if (Walker->Ancestor->GraphNr != Root->GraphNr) {
@@ -2709 +2478 @@
         } while (OtherAtom != Walker);
         ComponentNumber++;
-
+    
         // (11) Root is separation vertex,  set Walker to Root and go to (4)
         Walker = Root;
@@ -2722 +2491 @@
 
     // From OldGraphNr to CurrentGraphNr ranges an disconnected subgraph
-    *out << Verbose(0) << "Disconnected subgraph ranges from " << OldGraphNr << " to " << CurrentGraphNr << "." << endl;
+    *out << Verbose(0) << "Disconnected subgraph ranges from " << OldGraphNr << " to " << CurrentGraphNr << "." << endl;    
     LeafWalker->Leaf->Output(out);
     *out << endl;
@@ -2730 +2499 @@
       //*out << Verbose(1) << "Current next subgraph root candidate is " << Root->Name << "." << endl;
       if (Root->GraphNr != -1) // if already discovered, step on
-        Root = Root->next;
+        Root = Root->next; 
     }
   }
@@ -2752 +2521 @@
     *out << " with Lowpoint " << Walker->LowpointNr << " and Graph Nr. " << Walker->GraphNr << "." << endl;
   }
-
+  
   *out << Verbose(1) << "Final graph info for each bond is:" << endl;
   Binder = first;
@@ -2763 +2532 @@
     *out << ((Binder->rightatom->SeparationVertex) ? "SP," : "") << "L" << Binder->rightatom->LowpointNr << " G" << Binder->rightatom->GraphNr << " Comp.";
     OutputComponentNumber(out, Binder->rightatom);
-    *out << ">." << endl;
+    *out << ">." << endl; 
     if (Binder->Cyclic) // cyclic ??
       *out << Verbose(3) << "Lowpoint at each side are equal: CYCLIC!" << endl;
@@ -2778 +2547 @@
  * the other our initial Walker - and do a Breadth First Search for the Root. We mark down each Predecessor and as soon as
  * we have found the Root via BFS, we may climb back the closed cycle via the Predecessors. Thereby we mark atoms and bonds
- * as cyclic and print out the cycles.
+ * as cyclic and print out the cycles. 
  * \param *out output stream for debugging
  * \param *BackEdgeStack stack with all back edges found during DFS scan. Beware: This stack contains the bonds from the total molecule, not from the subgraph!
@@ -2789 +2558 @@
   int *ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CyclicStructureAnalysis: *ShortestPathList");
   enum Shading *ColorList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::CyclicStructureAnalysis: *ColorList");
-  class StackClass<atom *> *BFSStack = new StackClass<atom *> (AtomCount);   // will hold the current ring
+  class StackClass<atom *> *BFSStack = new StackClass<atom *> (AtomCount);   // will hold the current ring 
   class StackClass<atom *> *TouchedStack = new StackClass<atom *> (AtomCount);   // contains all "touched" atoms (that need to be reset after BFS loop)
   atom *Walker = NULL, *OtherAtom = NULL, *Root = NULL;
@@ -2804 +2573 @@
   *out << Verbose(1) << "Back edge list - ";
   BackEdgeStack->Output(out);
-
+  
   *out << Verbose(1) << "Analysing cycles ... " << endl;
   NumCycles = 0;
@@ -2810 +2579 @@
     BackEdge = BackEdgeStack->PopFirst();
     // this is the target
-    Root = BackEdge->leftatom;
+    Root = BackEdge->leftatom;  
     // this is the source point
-    Walker = BackEdge->rightatom;
+    Walker = BackEdge->rightatom; 
     ShortestPathList[Walker->nr] = 0;
     BFSStack->ClearStack();  // start with empty BFS stack
@@ -2826 +2595 @@
         if (Binder != BackEdge) { // only walk along DFS spanning tree (otherwise we always find SP of one being backedge Binder)
           OtherAtom = Binder->GetOtherAtom(Walker);
-#ifdef ADDHYDROGEN
+#ifdef ADDHYDROGEN          
           if (OtherAtom->type->Z != 1) {
 #endif
@@ -2835 +2604 @@
               PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
               ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
-              *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+              *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " lightgray, its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl; 
               //if (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr]) { // Check for maximum distance
                 *out << Verbose(3) << "Putting OtherAtom into queue." << endl;
@@ -2845 +2614 @@
             if (OtherAtom == Root)
               break;
-#ifdef ADDHYDROGEN
+#ifdef ADDHYDROGEN          
           } else {
             *out << Verbose(2) << "Skipping hydrogen atom " << *OtherAtom << "." << endl;
@@ -2883 +2652 @@
       }
     } while ((!BFSStack->IsEmpty()) && (OtherAtom != Root) && (OtherAtom != NULL)); // || (ShortestPathList[OtherAtom->nr] < MinimumRingSize[Walker->GetTrueFather()->nr])));
-
+    
     if (OtherAtom == Root) {
       // now climb back the predecessor list and thus find the cycle members
@@ -2911 +2680 @@
       *out << Verbose(1) << "No ring containing " << *Root << " with length equal to or smaller than " << MinimumRingSize[Walker->GetTrueFather()->nr] << " found." << endl;
     }
-
+    
     // now clean the lists
     while (!TouchedStack->IsEmpty()){
@@ -2921 +2690 @@
   }
   if (MinRingSize != -1) {
-    // go over all atoms
+    // go over all atoms 
     Root = start;
     while(Root->next != end) {
       Root = Root->next;
-
+      
       if (MinimumRingSize[Root->GetTrueFather()->nr] == AtomCount) { // check whether MinimumRingSize is set, if not BFS to next where it is
         Walker = Root;
@@ -2962 +2731 @@
           }
           ColorList[Walker->nr] = black;
-          //*out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+          //*out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl; 
         }
-
+    
         // now clean the lists
         while (!TouchedStack->IsEmpty()){
@@ -3013 +2782 @@
 void molecule::OutputComponentNumber(ofstream *out, atom *vertex)
 {
-  for(int i=0;i<NumberOfBondsPerAtom[vertex->nr];i++)
+  for(int i=0;i<NumberOfBondsPerAtom[vertex->nr];i++) 
     *out << vertex->ComponentNr[i] << "  ";
 };
@@ -3091 +2860 @@
 {
   int c = 0;
-  int FragmentCount;
+  int FragmentCount; 
   // get maximum bond degree
   atom *Walker = start;
@@ -3101 +2870 @@
   *out << Verbose(1) << "Upper limit for this subgraph is " << FragmentCount << " for " << NoNonHydrogen << " non-H atoms with maximum bond degree of " << c << "." << endl;
   return FragmentCount;
-};
+};  
 
 /** Scans a single line for number and puts them into \a KeySet.
  * \param *out output stream for debugging
  * \param *buffer buffer to scan
- * \param &CurrentSet filled KeySet on return
+ * \param &CurrentSet filled KeySet on return 
  * \return true - at least one valid atom id parsed, false - CurrentSet is empty
  */
@@ -3114 +2883 @@
   int AtomNr;
   int status = 0;
-
+  
   line.str(buffer);
   while (!line.eof()) {
@@ -3150 +2919 @@
   double TEFactor;
   char *filename = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::ParseKeySetFile - filename");
-
+  
   if (FragmentList == NULL) { // check list pointer
     FragmentList = new Graph;
   }
-
+  
   // 1st pass: open file and read
   *out << Verbose(1) << "Parsing the KeySet file ... " << endl;
@@ -3183 +2952 @@
     status = false;
   }
-
+  
   // 2nd pass: open TEFactors file and read
   *out << Verbose(1) << "Parsing the TEFactors file ... " << endl;
@@ -3195 +2964 @@
         InputFile >> TEFactor;
         (*runner).second.second = TEFactor;
-        *out << Verbose(2) << "Setting " << ++NumberOfFragments << " fragment's TEFactor to " << (*runner).second.second << "." << endl;
+        *out << Verbose(2) << "Setting " << ++NumberOfFragments << " fragment's TEFactor to " << (*runner).second.second << "." << endl; 
       } else {
         status = false;
@@ -3236 +3005 @@
   if(output != NULL) {
     for(Graph::iterator runner = KeySetList.begin(); runner != KeySetList.end(); runner++) {
-      for (KeySet::iterator sprinter = (*runner).first.begin();sprinter != (*runner).first.end(); sprinter++) {
+      for (KeySet::iterator sprinter = (*runner).first.begin();sprinter != (*runner).first.end(); sprinter++) { 
         if (sprinter != (*runner).first.begin())
           output << "\t";
@@ -3302 +3071 @@
     status = false;
   }
-
+  
   return status;
 };
@@ -3311 +3080 @@
  * \param **ListOfAtoms allocated (molecule::AtomCount) and filled lookup table for ids (Atom::nr) to *Atom
  * \return true - structure is equal, false - not equivalence
- */
+ */ 
 bool molecule::CheckAdjacencyFileAgainstMolecule(ofstream *out, char *path, atom **ListOfAtoms)
 {
@@ -3318 +3087 @@
   bool status = true;
   char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
-
+  
   filename << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
   File.open(filename.str().c_str(), ios::out);
@@ -3377 +3146 @@
   *out << endl;
   Free((void **)&buffer, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
-
+  
   return status;
 };
@@ -3399 +3168 @@
   for(int i=AtomCount;i--;)
     AtomMask[i] = false;
-
+  
   if (Order < 0) { // adaptive increase of BondOrder per site
     if (AtomMask[AtomCount] == true)  // break after one step
@@ -3439 +3208 @@
           line >> ws >> Value; // skip time entry
           line >> ws >> Value;
-          No -= 1;  // indices start at 1 in file, not 0
+          No -= 1;  // indices start at 1 in file, not 0 
           //*out << Verbose(2) << " - yields (" << No << "," << Value << ", " << FragOrder << ")" << endl;
 
@@ -3448 +3217 @@
             // as the smallest number in each set has always been the root (we use global id to keep the doubles away), seek smallest and insert into AtomMask
             pair <map<int, pair<double,int> >::iterator, bool> InsertedElement = AdaptiveCriteriaList.insert( make_pair(*((*marker).second.begin()), pair<double,int>( fabs(Value), FragOrder) ));
-            map<int, pair<double,int> >::iterator PresentItem = InsertedElement.first;
+            map<int, pair<double,int> >::iterator PresentItem = InsertedElement.first; 
             if (!InsertedElement.second) { // this root is already present
-              if ((*PresentItem).second.second < FragOrder)  // if order there is lower, update entry with higher-order term
-                //if ((*PresentItem).second.first < (*runner).first)    // as higher-order terms are not always better, we skip this part (which would always include this site into adaptive increase)
+              if ((*PresentItem).second.second < FragOrder)  // if order there is lower, update entry with higher-order term 
+                //if ((*PresentItem).second.first < (*runner).first)    // as higher-order terms are not always better, we skip this part (which would always include this site into adaptive increase) 
                 {  // if value is smaller, update value and order
                 (*PresentItem).second.first = fabs(Value);
@@ -3489 +3258 @@
         Walker = FindAtom(No);
         //if (Walker->AdaptiveOrder < MinimumRingSize[Walker->nr]) {
-          *out << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", setting entry " << No << " of Atom mask to true." << endl;
+          *out << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", setting entry " << No << " of Atom mask to true." << endl; 
           AtomMask[No] = true;
           status = true;
         //} else
-          //*out << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", however MinimumRingSize of " << MinimumRingSize[Walker->nr] << " does not allow further adaptive increase." << endl;
+          //*out << Verbose(2) << "Root " << No << " is still above threshold (10^{" << Order <<"}: " << runner->first << ", however MinimumRingSize of " << MinimumRingSize[Walker->nr] << " does not allow further adaptive increase." << endl; 
       }
       // close and done
@@ -3527 +3296 @@
     if ((Order == 0) && (AtomMask[AtomCount] == false))  // single stepping, just check
       status = true;
-
+      
     if (!status) {
       if (Order == 0)
@@ -3535 +3304 @@
     }
   }
-
+  
   // print atom mask for debugging
   *out << "              ";
@@ -3544 +3313 @@
     *out << (AtomMask[i] ? "t" : "f");
   *out << endl;
-
+ 
   return status;
 };
@@ -3558 +3327 @@
   int AtomNo = 0;
   atom *Walker = NULL;
-
+  
   if (SortIndex != NULL) {
     *out << Verbose(1) << "SortIndex is " << SortIndex << " and not NULL as expected." << endl;
@@ -3616 +3385 @@
   atom **ListOfAtoms = NULL;
   atom ***ListOfLocalAtoms = NULL;
-  bool *AtomMask = NULL;
-
+  bool *AtomMask = NULL; 
+  
   *out << endl;
 #ifdef ADDHYDROGEN
@@ -3626 +3395 @@
 
   // ++++++++++++++++++++++++++++ INITIAL STUFF: Bond structure analysis, file parsing, ... ++++++++++++++++++++++++++++++++++++++++++
-
+  
   // ===== 1. Check whether bond structure is same as stored in files ====
-
+  
   // fill the adjacency list
   CreateListOfBondsPerAtom(out);
@@ -3634 +3403 @@
   // create lookup table for Atom::nr
   FragmentationToDo = FragmentationToDo && CreateFatherLookupTable(out, start, end, ListOfAtoms, AtomCount);
-
+  
   // === compare it with adjacency file ===
-  FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(out, configuration->configpath, ListOfAtoms);
+  FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(out, configuration->configpath, ListOfAtoms); 
   Free((void **)&ListOfAtoms, "molecule::FragmentMolecule - **ListOfAtoms");
 
@@ -3659 +3428 @@
 //      else
 //        *out << "\t" << ListOfLocalAtoms[FragmentCounter][i]->Name;
-    *out << Verbose(0) << "Gathering local back edges for subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl;
     MolecularWalker->Leaf->PickLocalBackEdges(out, ListOfLocalAtoms[FragmentCounter++], BackEdgeStack, LocalBackEdgeStack);
-    *out << Verbose(0) << "Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl;
     MolecularWalker->Leaf->CyclicStructureAnalysis(out, LocalBackEdgeStack, MinimumRingSize);
-    *out << Verbose(0) << "Done with Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl;
     delete(LocalBackEdgeStack);
   }
@@ -3685 +3451 @@
     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()
-    // ===== 6b. fill RootStack for each subgraph (second adaptivity check) =====
+    // ===== 6b. fill RootStack for each subgraph (second adaptivity check) ===== 
     Subgraphs->next->FillRootStackForSubgraphs(out, RootStack, AtomMask, (FragmentCounter = 0));
 
@@ -3694 +3460 @@
       MolecularWalker = MolecularWalker->next;
       *out << Verbose(1) << "Fragmenting subgraph " << MolecularWalker << "." << endl;
-      //MolecularWalker->Leaf->OutputListOfBonds(out);  // output ListOfBondsPerAtom for debugging
+      // output ListOfBondsPerAtom for debugging
+      MolecularWalker->Leaf->OutputListOfBonds(out);
       if (MolecularWalker->Leaf->first->next != MolecularWalker->Leaf->last) {
+      
         // call BOSSANOVA method
         *out << Verbose(0) << endl << " ========== BOND ENERGY of subgraph " << FragmentCounter << " ========================= " << endl;
@@ -3715 +3483 @@
   // ===== 8a. translate list into global numbers (i.e. ones that are valid in "this" molecule, not in MolecularWalker->Leaf)
   Subgraphs->next->TranslateIndicesToGlobalIDs(out, FragmentList, (FragmentCounter = 0), TotalNumberOfKeySets, TotalGraph);
-
+  
   // free subgraph memory again
   FragmentCounter = 0;
@@ -3740 +3508 @@
     }
     *out << k << "/" << BondFragments->NumberOfMolecules << " fragments generated from the keysets." << endl;
-
+    
     // ===== 9. Save fragments' configuration and keyset files et al to disk ===
     if (BondFragments->NumberOfMolecules != 0) {
       // create the SortIndex from BFS labels to order in the config file
       CreateMappingLabelsToConfigSequence(out, SortIndex);
-
+      
       *out << Verbose(1) << "Writing " << BondFragments->NumberOfMolecules << " possible bond fragmentation configs" << endl;
       if (BondFragments->OutputConfigForListOfFragments(out, FRAGMENTPREFIX, configuration, SortIndex, true, true))
@@ -3751 +3519 @@
       else
         *out << Verbose(1) << "Some config writing failed." << endl;
-
+  
       // store force index reference file
       BondFragments->StoreForcesFile(out, configuration->configpath, SortIndex);
-
-      // store keysets file
+      
+      // store keysets file 
       StoreKeySetFile(out, TotalGraph, configuration->configpath);
-
-      // store Adjacency file
+  
+      // store Adjacency file 
       StoreAdjacencyToFile(out, configuration->configpath);
-
+  
       // store Hydrogen saturation correction file
       BondFragments->AddHydrogenCorrection(out, configuration->configpath);
-
+      
       // store adaptive orders into file
       StoreOrderAtSiteFile(out, configuration->configpath);
-
+      
       // restore orbital and Stop values
       CalculateOrbitals(*configuration);
-
+      
       // free memory for bond part
       *out << Verbose(1) << "Freeing bond memory" << endl;
       delete(FragmentList); // remove bond molecule from memory
-      Free((void **)&SortIndex, "molecule::FragmentMolecule: *SortIndex");
+      Free((void **)&SortIndex, "molecule::FragmentMolecule: *SortIndex"); 
     } else
       *out << Verbose(1) << "FragmentList is zero on return, splitting failed." << endl;
-  //} else
+  //} else 
   //  *out << Verbose(1) << "No fragments to store." << endl;
   *out << Verbose(0) << "End of bond fragmentation." << endl;
@@ -3805 +3573 @@
   do {  // go through all bonds and push local ones
     Walker = ListOfLocalAtoms[Binder->leftatom->nr];  // get one atom in the reference molecule
-    if (Walker != NULL) // if this Walker exists in the subgraph ...
-        for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {    // go through the local list of bonds
-        OtherAtom = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
-              if (OtherAtom == ListOfLocalAtoms[Binder->rightatom->nr]) { // found the bond
-                LocalStack->Push(ListOfBondsPerAtom[Walker->nr][i]);
-                *out << Verbose(3) << "Found local edge " << *(ListOfBondsPerAtom[Walker->nr][i]) << "." << endl;
-                break;
-            }
-        }
+    if (Walker == NULL) // if this Walker exists in the subgraph ... 
+      continue;
+    for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {    // go through the local list of bonds
+      OtherAtom = ListOfBondsPerAtom[Walker->nr][i]->GetOtherAtom(Walker);
+      if (OtherAtom == ListOfLocalAtoms[Binder->rightatom->nr]) { // found the bond
+        LocalStack->Push(ListOfBondsPerAtom[Walker->nr][i]);
+        break;
+      }
+    }
     Binder = ReferenceStack->PopFirst();  // loop the stack for next item
-    *out << Verbose(3) << "Current candidate edge " << Binder << "." << endl;
     ReferenceStack->Push(Binder);
   } while (FirstBond != Binder);
@@ -3894 +3661 @@
       Walker->AdaptiveOrder = OrderArray[Walker->nr];
       Walker->MaxOrder = MaxArray[Walker->nr];
-      *out << Verbose(2) << *Walker << " gets order " << (int)Walker->AdaptiveOrder << " and is " << (!Walker->MaxOrder ? "not " : " ") << "maxed." << endl;
+      *out << Verbose(2) << *Walker << " gets order " << (int)Walker->AdaptiveOrder << " and is " << (!Walker->MaxOrder ? "not " : " ") << "maxed." << endl; 
     }
     file.close();
@@ -3905 +3672 @@
   Free((void **)&OrderArray, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
   Free((void **)&MaxArray, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
-
+  
   *out << Verbose(1) << "End of ParseOrderAtSiteFromFile" << endl;
   return status;
@@ -3971 +3738 @@
     }
     *out << " -- TotalDegree: " << TotalDegree << endl;
-  }
+  }      
   *out << Verbose(1) << "End of Creating ListOfBondsPerAtom." << endl << endl;
 };
@@ -3977 +3744 @@
 /** Adds atoms up to \a BondCount distance from \a *Root and notes them down in \a **AddedAtomList.
  * Gray vertices are always enqueued in an StackClass<atom *> FIFO queue, the rest is usual BFS with adding vertices found was
- * white and putting into queue.
+ * white and putting into queue. 
  * \param *out output stream for debugging
  * \param *Mol Molecule class to add atoms to
@@ -3986 +3753 @@
  * \param BondOrder maximum distance for vertices to add
  * \param IsAngstroem lengths are in angstroem or bohrradii
- */
+ */  
 void molecule::BreadthFirstSearchAdd(ofstream *out, molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem)
 {
@@ -4012 +3779 @@
   }
   ShortestPathList[Root->nr] = 0;
-
+  
   // and go on ... Queue always contains all lightgray vertices
   while (!AtomStack->IsEmpty()) {
@@ -4020 +3787 @@
     // followed by n+1 till top of stack.
     Walker = AtomStack->PopFirst(); // pop oldest added
-    *out << Verbose(1) << "Current Walker is: " << Walker->Name << ", and has " << NumberOfBondsPerAtom[Walker->nr] << " bonds." << endl;
+    *out << Verbose(1) << "Current Walker is: " << Walker->Name << ", and has " << NumberOfBondsPerAtom[Walker->nr] << " bonds." << endl; 
     for(int i=0;i<NumberOfBondsPerAtom[Walker->nr];i++) {
       Binder = ListOfBondsPerAtom[Walker->nr][i];
@@ -4027 +3794 @@
         *out << Verbose(2) << "Current OtherAtom is: " << OtherAtom->Name << " for bond " << *Binder << "." << endl;
         if (ColorList[OtherAtom->nr] == white) {
-          if (Binder != Bond) // let other atom white if it's via Root bond. In case it's cyclic it has to be reached again (yet Root is from OtherAtom already black, thus no problem)
+          if (Binder != Bond) // let other atom white if it's via Root bond. In case it's cyclic it has to be reached again (yet Root is from OtherAtom already black, thus no problem) 
             ColorList[OtherAtom->nr] = lightgray;
           PredecessorList[OtherAtom->nr] = Walker;  // Walker is the predecessor
           ShortestPathList[OtherAtom->nr] = ShortestPathList[Walker->nr]+1;
-          *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " " << ((ColorList[OtherAtom->nr] == white) ? "white" : "lightgray") << ", its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl;
+          *out << Verbose(2) << "Coloring OtherAtom " << OtherAtom->Name << " " << ((ColorList[OtherAtom->nr] == white) ? "white" : "lightgray") << ", its predecessor is " << Walker->Name << " and its Shortest Path is " << ShortestPathList[OtherAtom->nr] << " egde(s) long." << endl; 
           if ((((ShortestPathList[OtherAtom->nr] < BondOrder) && (Binder != Bond))) ) { // Check for maximum distance
             *out << Verbose(3);
@@ -4069 +3836 @@
               } else {
 #ifdef ADDHYDROGEN
-                if (!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
-                  exit(1);
+                Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem);
 #endif
               }
@@ -4079 +3845 @@
           // This has to be a cyclic bond, check whether it's present ...
           if (AddedBondList[Binder->nr] == NULL) {
-            if ((Binder != Bond) && (Binder->Cyclic) && (((ShortestPathList[Walker->nr]+1) < BondOrder))) {
+            if ((Binder != Bond) && (Binder->Cyclic) && (((ShortestPathList[Walker->nr]+1) < BondOrder))) { 
               AddedBondList[Binder->nr] = Mol->AddBond(AddedAtomList[Walker->nr], AddedAtomList[OtherAtom->nr], Binder->BondDegree);
               AddedBondList[Binder->nr]->Cyclic = Binder->Cyclic;
@@ -4085 +3851 @@
             } else { // if it's root bond it has to broken (otherwise we would not create the fragments)
 #ifdef ADDHYDROGEN
-              if(!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
-                exit(1);
+              Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem);
 #endif
             }
@@ -4094 +3859 @@
     }
     ColorList[Walker->nr] = black;
-    *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
+    *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl; 
   }
   Free((void **)&PredecessorList, "molecule::BreadthFirstSearchAdd: **PredecessorList");
@@ -4118 +3883 @@
 
   *out << Verbose(2) << "Begin of BuildInducedSubgraph." << endl;
-
+  
   // reset parent list
   *out << Verbose(3) << "Resetting ParentList." << endl;
   for (int i=Father->AtomCount;i--;)
     ParentList[i] = NULL;
-
+  
   // fill parent list with sons
   *out << Verbose(3) << "Filling Parent List." << endl;
@@ -4164 +3929 @@
  * \param *&Leaf KeySet to look through
  * \param *&ShortestPathList list of the shortest path to decide which atom to suggest as removal candidate in the end
- * \param index of the atom suggested for removal
+ * \param index of the atom suggested for removal 
  */
 int molecule::LookForRemovalCandidate(ofstream *&out, KeySet *&Leaf, int *&ShortestPathList)
@@ -4170 +3935 @@
   atom *Runner = NULL;
   int SP, Removal;
-
+  
   *out << Verbose(2) << "Looking for removal candidate." << endl;
   SP = -1; //0;  // not -1, so that Root is never removed
@@ -4188 +3953 @@
 /** Stores a fragment from \a KeySet into \a molecule.
  * First creates the minimal set of atoms from the KeySet, then creates the bond structure from the complete
- * molecule and adds missing hydrogen where bonds were cut.
+ * molecule and adds missing hydrogen where bonds were cut. 
  * \param *out output stream for debugging messages
- * \param &Leaflet pointer to KeySet structure
+ * \param &Leaflet pointer to KeySet structure 
  * \param IsAngstroem whether we have Ansgtroem or bohrradius
  * \return pointer to constructed molecule
@@ -4201 +3966 @@
   bool LonelyFlag = false;
   int size;
-
+  
 //  *out << Verbose(1) << "Begin of StoreFragmentFromKeyset." << endl;
-
+  
   Leaf->BondDistance = BondDistance;
   for(int i=NDIM*2;i--;)
-    Leaf->cell_size[i] = cell_size[i];
+    Leaf->cell_size[i] = cell_size[i]; 
 
   // initialise SonList (indicates when we need to replace a bond with hydrogen instead)
@@ -4219 +3984 @@
     size++;
   }
-
+  
   // create the bonds between all: Make it an induced subgraph and add hydrogen
 //  *out << Verbose(2) << "Creating bonds from father graph (i.e. induced subgraph creation)." << endl;
@@ -4229 +3994 @@
     if (SonList[FatherOfRunner->nr] != NULL)  {  // check if this, our father, is present in list
       // create all bonds
-      for (int i=0;i<NumberOfBondsPerAtom[FatherOfRunner->nr];i++) { // go through every bond of father
+      for (int i=0;i<NumberOfBondsPerAtom[FatherOfRunner->nr];i++) { // go through every bond of father 
         OtherFather = ListOfBondsPerAtom[FatherOfRunner->nr][i]->GetOtherAtom(FatherOfRunner);
 //        *out << Verbose(2) << "Father " << *FatherOfRunner << " of son " << *SonList[FatherOfRunner->nr] << " is bound to " << *OtherFather;
         if (SonList[OtherFather->nr] != NULL) {
-//          *out << ", whose son is " << *SonList[OtherFather->nr] << "." << endl;
+//          *out << ", whose son is " << *SonList[OtherFather->nr] << "." << endl; 
           if (OtherFather->nr > FatherOfRunner->nr) { // add bond (nr check is for adding only one of both variants: ab, ba)
 //            *out << Verbose(3) << "Adding Bond: ";
-//            *out <<
+//            *out << 
             Leaf->AddBond(Runner, SonList[OtherFather->nr], ListOfBondsPerAtom[FatherOfRunner->nr][i]->BondDegree);
 //            *out << "." << endl;
             //NumBonds[Runner->nr]++;
-          } else {
+          } else { 
 //            *out << Verbose(3) << "Not adding bond, labels in wrong order." << endl;
           }
           LonelyFlag = false;
         } else {
-//          *out << ", who has no son in this fragment molecule." << endl;
+//          *out << ", who has no son in this fragment molecule." << endl; 
 #ifdef ADDHYDROGEN
           //*out << Verbose(3) << "Adding Hydrogen to " << Runner->Name << " and a bond in between." << endl;
-          if(!Leaf->AddHydrogenReplacementAtom(out, ListOfBondsPerAtom[FatherOfRunner->nr][i], Runner, FatherOfRunner, OtherFather, ListOfBondsPerAtom[FatherOfRunner->nr],NumberOfBondsPerAtom[FatherOfRunner->nr], IsAngstroem))
-            exit(1);
+          Leaf->AddHydrogenReplacementAtom(out, ListOfBondsPerAtom[FatherOfRunner->nr][i], Runner, FatherOfRunner, OtherFather, ListOfBondsPerAtom[FatherOfRunner->nr],NumberOfBondsPerAtom[FatherOfRunner->nr], IsAngstroem);
 #endif
           //NumBonds[Runner->nr] += ListOfBondsPerAtom[FatherOfRunner->nr][i]->BondDegree;
@@ -4263 +4027 @@
     while ((Runner->next != Leaf->end) && (Runner->next->type->Z == 1)) // skip added hydrogen
       Runner = Runner->next;
-#endif
+#endif       
   }
   Leaf->CreateListOfBondsPerAtom(out);
@@ -4296 +4060 @@
   StackClass<atom *> *TouchedStack = new StackClass<atom *>((int)pow(4,Order)+2); // number of atoms reached from one with maximal 4 bonds plus Root itself
   StackClass<atom *> *SnakeStack = new StackClass<atom *>(Order+1); // equal to Order is not possible, as then the StackClass<atom *> cannot discern between full and empty stack!
-  MoleculeLeafClass *Leaflet = NULL, *TempLeaf = NULL;
+  MoleculeLeafClass *Leaflet = NULL, *TempLeaf = NULL; 
   MoleculeListClass *FragmentList = NULL;
   atom *Walker = NULL, *OtherAtom = NULL, *Root = NULL, *Removal = NULL;
@@ -4346 +4110 @@
                 // clear snake stack
           SnakeStack->ClearStack();
-    //SnakeStack->TestImplementation(out, start->next);
+    //SnakeStack->TestImplementation(out, start->next);    
 
     ///// INNER LOOP ////////////
@@ -4367 +4131 @@
         }
         if (ShortestPathList[Walker->nr] == -1) {
-          ShortestPathList[Walker->nr] = ShortestPathList[PredecessorList[Walker->nr]->nr]+1;
+          ShortestPathList[Walker->nr] = ShortestPathList[PredecessorList[Walker->nr]->nr]+1; 
           TouchedStack->Push(Walker); // mark every atom for lists cleanup later, whose shortest path has been changed
         }
@@ -4405 +4169 @@
                                 OtherAtom = Binder->GetOtherAtom(Walker);
             if ((Labels[OtherAtom->nr] != -1) && (Labels[OtherAtom->nr] < Labels[Root->nr])) { // we don't step up to labels bigger than us
-              *out << "Label " << Labels[OtherAtom->nr] << " is smaller than Root's " << Labels[Root->nr] << "." << endl;
+              *out << "Label " << Labels[OtherAtom->nr] << " is smaller than Root's " << Labels[Root->nr] << "." << endl; 
               //ColorVertexList[OtherAtom->nr] = lightgray;    // mark as explored
             } else { // otherwise check its colour and element
                                 if (
 #ifdef ADDHYDROGEN
-              (OtherAtom->type->Z != 1) &&
+              (OtherAtom->type->Z != 1) && 
 #endif
                     (ColorEdgeList[Binder->nr] == white)) {  // skip hydrogen, look for unexplored vertices
@@ -4420 +4184 @@
                 //} else {
                 //  *out << Verbose(3) << "Predecessor of " << OtherAtom->Name << " is " << PredecessorList[OtherAtom->nr]->Name << "." << endl;
-                //}
+                //} 
                 Walker = OtherAtom;
                 break;
               } else {
-                if (OtherAtom->type->Z == 1)
+                if (OtherAtom->type->Z == 1) 
                   *out << "Links to a hydrogen atom." << endl;
-                else
+                else                 
                   *out << "Bond has not white but " << GetColor(ColorEdgeList[Binder->nr]) << " color." << endl;
               }
@@ -4436 +4200 @@
           *out << Verbose(3) << "We have gone too far, stepping back to " << Walker->Name << "." << endl;
         }
-                        if (Walker != OtherAtom) {      // if no white neighbours anymore, color it black
+                        if (Walker != OtherAtom) {      // if no white neighbours anymore, color it black 
           *out << Verbose(2) << "Coloring " << Walker->Name << " black." << endl;
                                 ColorVertexList[Walker->nr] = black;
@@ -4443 +4207 @@
       }
         } while ((Walker != Root) || (ColorVertexList[Root->nr] != black));
-    *out << Verbose(2) << "Inner Looping is finished." << endl;
+    *out << Verbose(2) << "Inner Looping is finished." << endl;    
 
     // if we reset all AtomCount atoms, we have again technically O(N^2) ...
@@ -4459 +4223 @@
     }
   }
-  *out << Verbose(1) << "Outer Looping over all vertices is done." << endl;
+  *out << Verbose(1) << "Outer Looping over all vertices is done." << endl; 
 
   // copy together
-  *out << Verbose(1) << "Copying all fragments into MoleculeList structure." << endl;
+  *out << Verbose(1) << "Copying all fragments into MoleculeList structure." << endl; 
   FragmentList = new MoleculeListClass(FragmentCounter, AtomCount);
   RunningIndex = 0;
@@ -4533 +4297 @@
 
   NumCombinations = 1 << SetDimension;
-
+  
   // Hier muessen von 1 bis NumberOfBondsPerAtom[Walker->nr] alle Kombinationen
   // von Endstuecken (aus den Bonds) hinzugefￜￜgt werden und fￜￜr verbleibende ANOVAOrder
   // rekursiv GraphCrawler in der nￜￜchsten Ebene aufgerufen werden
-
+  
   *out << Verbose(1+verbosity) << "Begin of SPFragmentGenerator." << endl;
   *out << Verbose(1+verbosity) << "We are " << RootDistance << " away from Root, which is " << *FragmentSearch->Root << ", SubOrder is " << SubOrder << ", SetDimension is " << SetDimension << " and this means " <<  NumCombinations-1 << " combination(s)." << endl;
 
-  // initialised touched list (stores added atoms on this level)
+  // initialised touched list (stores added atoms on this level) 
   *out << Verbose(1+verbosity) << "Clearing touched list." << endl;
   for (TouchedIndex=SubOrder+1;TouchedIndex--;)  // empty touched list
     TouchedList[TouchedIndex] = -1;
   TouchedIndex = 0;
-
+  
   // create every possible combination of the endpieces
   *out << Verbose(1+verbosity) << "Going through all combinations of the power set." << endl;
@@ -4554 +4318 @@
     for (int j=SetDimension;j--;)
       bits += (i & (1 << j)) >> j;
-
+      
     *out << Verbose(1+verbosity) << "Current set is " << Binary(i | (1 << SetDimension)) << ", number of bits is " << bits << "." << endl;
     if (bits <= SubOrder) { // if not greater than additional atoms allowed on stack, continue
@@ -4562 +4326 @@
         bit = ((i & (1 << j)) != 0);  // mask the bit for the j-th bond
         if (bit) {  // if bit is set, we add this bond partner
-                OtherWalker = BondsSet[j]->rightatom;   // rightatom is always the one more distant, i.e. the one to add
+                OtherWalker = BondsSet[j]->rightatom;   // rightatom is always the one more distant, i.e. the one to add 
           //*out << Verbose(1+verbosity) << "Current Bond is " << ListOfBondsPerAtom[Walker->nr][i] << ", checking on " << *OtherWalker << "." << endl;
           *out << Verbose(2+verbosity) << "Adding " << *OtherWalker << " with nr " << OtherWalker->nr << "." << endl;
-          TestKeySetInsert = FragmentSearch->FragmentSet->insert(OtherWalker->nr);
+          TestKeySetInsert = FragmentSearch->FragmentSet->insert(OtherWalker->nr); 
           if (TestKeySetInsert.second) {
             TouchedList[TouchedIndex++] = OtherWalker->nr;  // note as added
@@ -4578 +4342 @@
         }
       }
-
-      SpaceLeft = SubOrder - Added ;// SubOrder - bits; // due to item's maybe being already present, this does not work anymore
+      
+      SpaceLeft = SubOrder - Added ;// SubOrder - bits; // due to item's maybe being already present, this does not work anymore 
       if (SpaceLeft > 0) {
         *out << Verbose(1+verbosity) << "There's still some space left on stack: " << SpaceLeft << "." << endl;
@@ -4607 +4371 @@
           }
           *out << Verbose(2+verbosity) << "Calling subset generator " << SP << " away from root " << *FragmentSearch->Root << " with sub set dimension " << SubSetDimension << "." << endl;
-          SPFragmentGenerator(out, FragmentSearch, SP, BondsList, SubSetDimension, SubOrder-bits);
+          SPFragmentGenerator(out, FragmentSearch, SP, BondsList, SubSetDimension, SubOrder-bits);  
           Free((void **)&BondsList, "molecule::SPFragmentGenerator: **BondsList");
         }
@@ -4616 +4380 @@
         *out << Verbose(2) << "Found a new fragment[" << FragmentSearch->FragmentCounter << "], local nr.s are: ";
         for(KeySet::iterator runner = FragmentSearch->FragmentSet->begin(); runner != FragmentSearch->FragmentSet->end(); runner++)
-          *out << (*runner) << " ";
+          *out << (*runner) << " "; 
         *out << endl;
         //if (!CheckForConnectedSubgraph(out, FragmentSearch->FragmentSet))
@@ -4624 +4388 @@
         //Removal = StoreFragmentFromStack(out, FragmentSearch->Root, FragmentSearch->Leaflet, FragmentSearch->FragmentStack, FragmentSearch->ShortestPathList, &FragmentSearch->FragmentCounter, FragmentSearch->configuration);
       }
-
+      
       // --3-- remove all added items in this level from snake stack
       *out << Verbose(1+verbosity) << "Removing all items that were added on this SP level " << RootDistance << "." << endl;
@@ -4635 +4399 @@
       *out << Verbose(2) << "Remaining local nr.s on snake stack are: ";
       for(KeySet::iterator runner = FragmentSearch->FragmentSet->begin(); runner != FragmentSearch->FragmentSet->end(); runner++)
-        *out << (*runner) << " ";
+        *out << (*runner) << " "; 
       *out << endl;
       TouchedIndex = 0; // set Index to 0 for list of atoms added on this level
@@ -4642 +4406 @@
     }
   }
-  Free((void **)&TouchedList, "molecule::SPFragmentGenerator: *TouchedList");
+  Free((void **)&TouchedList, "molecule::SPFragmentGenerator: *TouchedList");  
   *out << Verbose(1+verbosity) << "End of SPFragmentGenerator, " << RootDistance << " away from Root " << *FragmentSearch->Root << " and SubOrder is " << SubOrder << "." << endl;
 };
@@ -4651 +4415 @@
  * \return true - connected, false - disconnected
  * \note this is O(n^2) for it's just a bug checker not meant for permanent use!
- */
+ */ 
 bool molecule::CheckForConnectedSubgraph(ofstream *out, KeySet *Fragment)
 {
@@ -4657 +4421 @@
   bool BondStatus = false;
   int size;
-
+  
   *out << Verbose(1) << "Begin of CheckForConnectedSubgraph" << endl;
   *out << Verbose(2) << "Disconnected atom: ";
-
+  
   // count number of atoms in graph
   size = 0;
@@ -4706 +4470 @@
  * \param *out output stream for debugging
  * \param Order bond order (limits BFS exploration and "number of digits" in power set generation
- * \param FragmentSearch UniqueFragments structure containing TEFactor, root atom and so on
+ * \param FragmentSearch UniqueFragments structure containing TEFactor, root atom and so on 
  * \param RestrictedKeySet Restricted vertex set to use in context of molecule
  * \return number of inserted fragments
  * \note ShortestPathList in FragmentSearch structure is probably due to NumberOfAtomsSPLevel and SP not needed anymore
  */
-int molecule::PowerSetGenerator(ofstream *out, int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet)
+int molecule::PowerSetGenerator(ofstream *out, int Order, struct UniqueFragments &FragmentSearch, KeySet RestrictedKeySet) 
 {
   int SP, AtomKeyNr;
@@ -4732 +4496 @@
     FragmentSearch.BondsPerSPCount[i] = 0;
   FragmentSearch.BondsPerSPCount[0] = 1;
-  Binder = new bond(FragmentSearch.Root, FragmentSearch.Root);
+  Binder = new bond(FragmentSearch.Root, FragmentSearch.Root); 
   add(Binder, FragmentSearch.BondsPerSPList[1]);
-
+  
   // do a BFS search to fill the SP lists and label the found vertices
   // Actually, we should construct a spanning tree vom the root atom and select all edges therefrom and put them into
   // according shortest path lists. However, we don't. Rather we fill these lists right away, as they do form a spanning
   // tree already sorted into various SP levels. That's why we just do loops over the depth (CurrentSP) and breadth
-  // (EdgeinSPLevel) of this tree ...
+  // (EdgeinSPLevel) of this tree ... 
   // In another picture, the bonds always contain a direction by rightatom being the one more distant from root and hence
   // naturally leftatom forming its predecessor, preventing the BFS"seeker" from continuing in the wrong direction.
@@ -4792 +4556 @@
     }
   }
-
+  
   // outputting all list for debugging
   *out << Verbose(0) << "Printing all found lists." << endl;
@@ -4801 +4565 @@
       Binder = Binder->next;
       *out << Verbose(2) << *Binder << endl;
-    }
-  }
-
+    } 
+  }
+  
   // creating fragments with the found edge sets  (may be done in reverse order, faster)
   SP = -1;  // the Root <-> Root edge must be subtracted!
@@ -4810 +4574 @@
     while (Binder->next != FragmentSearch.BondsPerSPList[2*i+1]) {
       Binder = Binder->next;
-      SP ++;
+      SP ++; 
     }
   }
@@ -4817 +4581 @@
     // start with root (push on fragment stack)
     *out << Verbose(0) << "Starting fragment generation with " << *FragmentSearch.Root << ", local nr is " << FragmentSearch.Root->nr << "." << endl;
-    FragmentSearch.FragmentSet->clear();
+    FragmentSearch.FragmentSet->clear();  
     *out << Verbose(0) << "Preparing subset for this root and calling generator." << endl;
     // prepare the subset and call the generator
     BondsList = (bond **) Malloc(sizeof(bond *)*FragmentSearch.BondsPerSPCount[0], "molecule::PowerSetGenerator: **BondsList");
     BondsList[0] = FragmentSearch.BondsPerSPList[0]->next;  // on SP level 0 there's only the root bond
-
+    
     SPFragmentGenerator(out, &FragmentSearch, 0, BondsList, FragmentSearch.BondsPerSPCount[0], Order);
-
+    
     Free((void **)&BondsList, "molecule::PowerSetGenerator: **BondsList");
   } else {
@@ -4833 +4597 @@
   // remove root from stack
   *out << Verbose(0) << "Removing root again from stack." << endl;
-  FragmentSearch.FragmentSet->erase(FragmentSearch.Root->nr);
+  FragmentSearch.FragmentSet->erase(FragmentSearch.Root->nr);    
 
   // free'ing the bonds lists
@@ -4852 +4616 @@
   }
 
-  // return list
+  // return list  
   *out << Verbose(0) << "End of PowerSetGenerator." << endl;
   return (FragmentSearch.FragmentCounter - Counter);
@@ -4883 +4647 @@
     // remove bonds that are beyond bonddistance
     for(int i=NDIM;i--;)
-      Translationvector.x[i] = 0.;
+      Translationvector.x[i] = 0.; 
     // scan all bonds
     Binder = first;
@@ -4930 +4694 @@
         }
       }
-      // re-add bond
+      // re-add bond    
       link(Binder, OtherBinder);
     } else {
@@ -4984 +4748 @@
         IteratorB++;
       } // end of while loop
-    }// end of check in case of equal sizes
+    }// end of check in case of equal sizes 
   }
   return false; // if we reach this point, they are equal
@@ -5028 +4792 @@
  * \param graph1 first (dest) graph
  * \param graph2 second (source) graph
- * \param *counter keyset counter that gets increased
+ * \param *counter keyset counter that gets increased 
  */
 inline void InsertGraphIntoGraph(ofstream *out, Graph &graph1, Graph &graph2, int *counter)
@@ -5073 +4837 @@
   int RootKeyNr, RootNr;
   struct UniqueFragments FragmentSearch;
-
+  
   *out << Verbose(0) << "Begin of FragmentBOSSANOVA." << endl;
 
@@ -5096 +4860 @@
     Walker = Walker->next;
     CompleteMolecule.insert(Walker->GetTrueFather()->nr);
-  }
+  } 
 
   // this can easily be seen: if Order is 5, then the number of levels for each lower order is the total sum of the number of levels above, as
@@ -5110 +4874 @@
     //if ((MinimumRingSize[Walker->GetTrueFather()->nr] != -1) && (Walker->GetTrueFather()->AdaptiveOrder+1 > MinimumRingSize[Walker->GetTrueFather()->nr])) {
     //  *out << Verbose(0) << "Bond order " << Walker->GetTrueFather()->AdaptiveOrder << " of Root " << *Walker << " greater than or equal to Minimum Ring size of " << MinimumRingSize << " found is not allowed." << endl;
-    //} else
+    //} else 
     {
       // increase adaptive order by one
       Walker->GetTrueFather()->AdaptiveOrder++;
       Order = Walker->AdaptiveOrder = Walker->GetTrueFather()->AdaptiveOrder;
-
+  
       // initialise Order-dependent entries of UniqueFragments structure
       FragmentSearch.BondsPerSPList = (bond **) Malloc(sizeof(bond *)*Order*2, "molecule::PowerSetGenerator: ***BondsPerSPList");
@@ -5122 +4886 @@
         FragmentSearch.BondsPerSPList[2*i] = new bond();    // start node
         FragmentSearch.BondsPerSPList[2*i+1] = new bond();  // end node
-        FragmentSearch.BondsPerSPList[2*i]->next = FragmentSearch.BondsPerSPList[2*i+1];     // intertwine these two
+        FragmentSearch.BondsPerSPList[2*i]->next = FragmentSearch.BondsPerSPList[2*i+1];     // intertwine these two 
         FragmentSearch.BondsPerSPList[2*i+1]->previous = FragmentSearch.BondsPerSPList[2*i];
         FragmentSearch.BondsPerSPCount[i] = 0;
-      }
-
+      }  
+  
       // allocate memory for all lower level orders in this 1D-array of ptrs
       NumLevels = 1 << (Order-1); // (int)pow(2,Order);
@@ -5132 +4896 @@
       for (int i=0;i<NumLevels;i++)
         FragmentLowerOrdersList[RootNr][i] = NULL;
-
+      
       // create top order where nothing is reduced
       *out << Verbose(0) << "==============================================================================================================" << endl;
       *out << Verbose(0) << "Creating KeySets of Bond Order " << Order << " for " << *Walker << ", " << (RootStack.size()-RootNr) << " Roots remaining." << endl; // , NumLevels is " << NumLevels << "
-
+  
       // Create list of Graphs of current Bond Order (i.e. F_{ij})
       FragmentLowerOrdersList[RootNr][0] =  new Graph;
@@ -5149 +4913 @@
         // we don't have to dive into suborders! These keysets are all already created on lower orders!
         // this was all ancient stuff, when we still depended on the TEFactors (and for those the suborders were needed)
-
+        
 //        if ((NumLevels >> 1) > 0) {
 //          // create lower order fragments
@@ -5156 +4920 @@
 //          for (int source=0;source<(NumLevels >> 1);source++) { // 1-terms don't need any more splitting, that's why only half is gone through (shift again)
 //            // step down to next order at (virtual) boundary of powers of 2 in array
-//            while (source >= (1 << (Walker->AdaptiveOrder-Order))) // (int)pow(2,Walker->AdaptiveOrder-Order))
+//            while (source >= (1 << (Walker->AdaptiveOrder-Order))) // (int)pow(2,Walker->AdaptiveOrder-Order))    
 //              Order--;
 //            *out << Verbose(0) << "Current Order is: " << Order << "." << endl;
@@ -5163 +4927 @@
 //              *out << Verbose(0) << "--------------------------------------------------------------------------------------------------------------" << endl;
 //              *out << Verbose(0) << "Current SubOrder is: " << SubOrder << " with source " << source << " to destination " << dest << "." << endl;
-//
+//        
 //              // every molecule is split into a list of again (Order - 1) molecules, while counting all molecules
 //              //*out << Verbose(1) << "Splitting the " << (*FragmentLowerOrdersList[RootNr][source]).size() << " molecules of the " << source << "th cell in the array." << endl;
@@ -5194 +4958 @@
       RootStack.push_back(RootKeyNr); // put back on stack
       RootNr++;
-
+  
       // free Order-dependent entries of UniqueFragments structure for next loop cycle
       Free((void **)&FragmentSearch.BondsPerSPCount, "molecule::PowerSetGenerator: *BondsPerSPCount");
@@ -5200 +4964 @@
         delete(FragmentSearch.BondsPerSPList[2*i]);
         delete(FragmentSearch.BondsPerSPList[2*i+1]);
-      }
+      }  
       Free((void **)&FragmentSearch.BondsPerSPList, "molecule::PowerSetGenerator: ***BondsPerSPList");
     }
@@ -5211 +4975 @@
   Free((void **)&FragmentSearch.ShortestPathList, "molecule::PowerSetGenerator: *ShortestPathList");
   delete(FragmentSearch.FragmentSet);
-
-  // now, FragmentLowerOrdersList is complete, it looks - for BondOrder 5 - as this (number is the ANOVA Order of the terms therein)
+  
+  // now, FragmentLowerOrdersList is complete, it looks - for BondOrder 5 - as this (number is the ANOVA Order of the terms therein) 
   // 5433222211111111
   // 43221111
@@ -5232 +4996 @@
     RootKeyNr = RootStack.front();
     RootStack.pop_front();
-    Walker = FindAtom(RootKeyNr);
+    Walker = FindAtom(RootKeyNr); 
     NumLevels = 1 << (Walker->AdaptiveOrder - 1);
     for(int i=0;i<NumLevels;i++) {
@@ -5245 +5009 @@
   Free((void **)&FragmentLowerOrdersList, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
   Free((void **)&NumMoleculesOfOrder, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
-
+  
   *out << Verbose(0) << "End of FragmentBOSSANOVA." << endl;
 };
@@ -5279 +5043 @@
   atom *Walker = NULL;
   bool result = true; // status of comparison
-
-  *out << Verbose(3) << "Begin of IsEqualToWithinThreshold." << endl;
+  
+  *out << Verbose(3) << "Begin of IsEqualToWithinThreshold." << endl; 
   /// first count both their atoms and elements and update lists thereby ...
   //*out << Verbose(0) << "Counting atoms, updating list" << endl;
@@ -5327 +5091 @@
     if (CenterOfGravity.Distance(&OtherCenterOfGravity) > threshold) {
       *out << Verbose(4) << "Centers of gravity don't match." << endl;
-      result = false;
-    }
-  }
-
+      result = false;  
+    }
+  }
+  
   /// ... then make a list with the euclidian distance to this center for each atom of both molecules
   if (result) {
@@ -5346 +5110 @@
       OtherDistances[Walker->nr] = OtherCenterOfGravity.Distance(&Walker->x);
     }
-
+  
     /// ... sort each list (using heapsort (o(N log N)) from GSL)
     *out << Verbose(5) << "Sorting distances" << endl;
@@ -5357 +5121 @@
     for(int i=AtomCount;i--;)
       PermutationMap[PermMap[i]] = (int) OtherPermMap[i];
-
+    
     /// ... and compare them step by step, whether the difference is individiually(!) below \a threshold for all
     *out << Verbose(4) << "Comparing distances" << endl;
@@ -5368 +5132 @@
     Free((void **)&PermMap, "molecule::IsEqualToWithinThreshold: *PermMap");
     Free((void **)&OtherPermMap, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
-
+      
     /// free memory
     Free((void **)&Distances, "molecule::IsEqualToWithinThreshold: Distances");
@@ -5376 +5140 @@
       result = false;
     }
-  }
+  } 
   /// return pointer to map if all distances were below \a threshold
   *out << Verbose(3) << "End of IsEqualToWithinThreshold." << endl;
@@ -5385 +5149 @@
     *out << Verbose(3) << "Result: Not equal." << endl;
     return NULL;
-  }
+  } 
 };
 
@@ -5440 +5204 @@
  * \param *output output stream of temperature file
  * \return file written (true), failure on writing file (false)
- */
+ */ 
 bool molecule::OutputTemperatureFromTrajectories(ofstream *out, int startstep, int endstep, ofstream *output)
 {
@@ -5448 +5212 @@
   if (output == NULL)
     return false;
-  else
+  else 
     *output << "# Step Temperature [K] Temperature [a.u.]" << endl;
   for (int step=startstep;step < endstep; step++) { // loop over all time steps

src/molecules.hpp

@@ -1 +1 @@
 /** \file molecules.hpp
  *
- * Class definitions of atom and molecule, element and periodentafel
+ * Class definitions of atom and molecule, element and periodentafel 
  */
 
@@ -16 +16 @@
 #include <gsl/gsl_multimin.h>
 #include <gsl/gsl_vector.h>
-#include <gsl/gsl_randist.h>
 
 // STL headers
@@ -56 +55 @@
 #define BoundariesTestPair pair< Boundaries::iterator, bool>
 
-#define PointMap map < int, class BoundaryPointSet * >
-#define PointPair pair < int, class BoundaryPointSet * >
-#define PointTestPair pair < PointMap::iterator, bool >
-
-#define LineMap map < int, class BoundaryLineSet * >
-#define LinePair pair < int, class BoundaryLineSet * >
-#define LineTestPair pair < LineMap::iterator, bool >
-
-#define TriangleMap map < int, class BoundaryTriangleSet * >
-#define TrianglePair pair < int, class BoundaryTriangleSet * >
-#define TriangleTestPair pair < TrianglePair::iterator, bool >
+#define PointMap map < int, class BoundaryPointSet * > 
+#define PointPair pair < int, class BoundaryPointSet * > 
+#define PointTestPair pair < PointMap::iterator, bool > 
+
+#define LineMap map < int, class BoundaryLineSet * > 
+#define LinePair pair < int, class BoundaryLineSet * > 
+#define LineTestPair pair < LinePair::iterator, bool > 
+
+#define TriangleMap map < int, class BoundaryTriangleSet * > 
+#define TrianglePair pair < int, class BoundaryTriangleSet * > 
+#define TriangleTestPair pair < TrianglePair::iterator, bool > 
 
 #define DistanceMultiMap multimap <double, pair < PointMap::iterator, PointMap::iterator> >
@@ -88 +87 @@
 //bool operator < (KeySet SubgraphA, KeySet SubgraphB);   //note: this declaration is important, otherwise normal < is used (producing wrong order)
 inline void InsertFragmentIntoGraph(ofstream *out, struct UniqueFragments *Fragment); // Insert a KeySet into a Graph
-inline void InsertGraphIntoGraph(ofstream *out, Graph &graph1, Graph &graph2, int *counter);  // Insert all KeySet's in a Graph into another Graph
+inline void InsertGraphIntoGraph(ofstream *out, Graph &graph1, Graph &graph2, int *counter);  // Insert all KeySet's in a Graph into another Graph 
 int CompareDoubles (const void * a, const void * b);
 
@@ -142 +141 @@
     unsigned char AdaptiveOrder;  //!< current present bond order at site (0 means "not set")
     bool MaxOrder;  //!< whether this atom as a root in fragmentation still creates more fragments on higher orders or not
-
+  
   atom();
   ~atom();
-
+  
   bool Output(int ElementNo, int AtomNo, ofstream *out) const;
   bool OutputXYZLine(ofstream *out) const;
   atom *GetTrueFather();
   bool Compare(atom &ptr);
-
+  
   private:
 };
 
-ostream & operator << (ostream &ost, const atom &a);
+ostream & operator << (ostream &ost, atom &a);
 
 /** Bonds between atoms.
@@ -171 +170 @@
     int nr;           //!< unique number in a molecule, updated by molecule::CreateAdjacencyList()
     bool Cyclic;      //!< flag whether bond is part of a cycle or not, given in DepthFirstSearchAnalysis()
-    enum EdgeType Type;//!< whether this is a tree or back edge
-
+    enum EdgeType Type;//!< whether this is a tree or back edge 
+        
   atom * GetOtherAtom(atom *Atom) const;
   bond * GetFirstBond();
   bond * GetLastBond();
-
+  
   bool MarkUsed(enum Shading color);
   enum Shading IsUsed();
@@ -182 +181 @@
   bool Contains(const atom *ptr);
   bool Contains(const int nr);
-
+  
   bond();
   bond(atom *left, atom *right);
@@ -188 +187 @@
   bond(atom *left, atom *right, int degree, int number);
   ~bond();
-
-  private:
+    
+  private: 
     enum Shading Used;        //!< marker in depth-first search, DepthFirstSearchAnalysis()
 };
 
-
-ostream & operator << (ostream &ost, const bond &b);
+ostream & operator << (ostream &ost, bond &b);
 
 class MoleculeLeafClass;
-
-
-#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.
@@ -226 +219 @@
     int NoCyclicBonds;  //!< number of cyclic bonds in molecule, by DepthFirstSearchAnalysis()
     double BondDistance;  //!< typical bond distance used in CreateAdjacencyList() and furtheron
-
+  
   molecule(periodentafel *teil);
   ~molecule();
-
+  
   /// remove atoms from molecule.
   bool AddAtom(atom *pointer);
@@ -238 +231 @@
   atom * AddCopyAtom(atom *pointer);
   bool AddXYZFile(string filename);
-  bool AddHydrogenReplacementAtom(ofstream *out, bond *Bond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bond **BondList, int NumBond, bool IsAngstroem);
+  bool AddHydrogenReplacementAtom(ofstream *out, bond *Bond, atom *BottomOrigin, atom *TopOrigin, atom *TopReplacement, bond **BondList, int NumBond, bool IsAngstroem);  
   bond * AddBond(atom *first, atom *second, int degree);
   bool RemoveBond(bond *pointer);
   bool RemoveBonds(atom *BondPartner);
-
+    
   /// Find atoms.
-  atom * FindAtom(int Nr) const;
+  atom * FindAtom(int Nr) const; 
   atom * AskAtom(string text);
 
@@ -252 +245 @@
   void CalculateOrbitals(class config &configuration);
   bool CenterInBox(ofstream *out, Vector *BoxLengths);
-  void CenterEdge(ofstream *out, Vector *max);
-  void CenterOrigin(ofstream *out, Vector *max);
+  void CenterEdge(ofstream *out, Vector *max); 
+  void CenterOrigin(ofstream *out, Vector *max); 
   void CenterGravity(ofstream *out, Vector *max);
   void Translate(const Vector *x);
@@ -267 +260 @@
         void PrincipalAxisSystem(ofstream *out, bool DoRotate);
         double VolumeOfConvexEnvelope(ofstream *out, bool IsAngstroem);
-        
-  bool VerletForceIntegration(ofstream *out, char *file, config &configuration);
-  void Thermostats(config &configuration, double ActualTemp, int Thermostat);
-
-  double ConstrainedPotential(ofstream *out, atom **permutation, int start, int end, double *constants, bool IsAngstroem);
-  double MinimiseConstrainedPotential(ofstream *out, atom **&permutation, int startstep, int endstep, bool IsAngstroem);
-  void EvaluateConstrainedForces(ofstream *out, int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force);
-  bool LinearInterpolationBetweenConfiguration(ofstream *out, int startstep, int endstep, const char *prefix, config &configuration); 
+        bool VerletForceIntegration(ofstream *out, char *file, double delta_t, bool IsAngstroem, int DoConstrained);
+        double ConstrainedPotential(ofstream *out, atom **permutation, int start, int end, double *constants, bool IsAngstroem);
+        double MinimiseConstrainedPotential(ofstream *out, atom **&permutation, int startstep, int endstep, bool IsAngstroem);
+        void EvaluateConstrainedForces(ofstream *out, int startstep, int endstep, atom **PermutationMap, ForceMatrix *Force);
+        bool LinearInterpolationBetweenConfiguration(ofstream *out, int startstep, int endstep, const char *prefix, config &configuration); 
         
   bool CheckBounds(const Vector *x) const;
   void GetAlignvector(struct lsq_params * par) const;
 
-  /// Initialising routines in fragmentation
-  void CreateAdjacencyList2(ofstream *out, ifstream *output);
+  /// Initialising routines in fragmentation  
   void CreateAdjacencyList(ofstream *out, double bonddistance, bool IsAngstroem);
   void CreateListOfBondsPerAtom(ofstream *out);
-
+  
   // Graph analysis
   MoleculeLeafClass * DepthFirstSearchAnalysis(ofstream *out, class StackClass<bond *> *&BackEdgeStack);
@@ -299 +288 @@
 
   molecule *CopyMolecule();
-
+  
   /// Fragment molecule by two different approaches:
   int FragmentMolecule(ofstream *out, int Order, config *configuration);
@@ -321 +310 @@
   int LookForRemovalCandidate(ofstream *&out, KeySet *&Leaf, int *&ShortestPathList);
   int GuesstimateFragmentCount(ofstream *out, int order);
-
-  // Recognize doubly appearing molecules in a list of them
+          
+  // Recognize doubly appearing molecules in a list of them   
   int * IsEqualToWithinThreshold(ofstream *out, molecule *OtherMolecule, double threshold);
   int * GetFatherSonAtomicMap(ofstream *out, molecule *OtherMolecule);
-
+        
   // Output routines.
   bool Output(ofstream *out);
@@ -346 +335 @@
     int NumberOfMolecules;        //!< Number of entries in \a **FragmentList and of to be returned one.
     int NumberOfTopAtoms;         //!< Number of atoms in the molecule from which all fragments originate
-
+    
   MoleculeListClass();
   MoleculeListClass(int Num, int NumAtoms);
@@ -356 +345 @@
   bool OutputConfigForListOfFragments(ofstream *out, const char *fragmentprefix, config *configuration, int *SortIndex, bool DoPeriodic, bool DoCentering);
   void Output(ofstream *out);
-
+  
   private:
 };
@@ -366 +355 @@
 class MoleculeLeafClass {
   public:
-    molecule *Leaf;                   //!< molecule of this leaf
+    molecule *Leaf;                   //!< molecule of this leaf 
     //MoleculeLeafClass *UpLeaf;        //!< Leaf one level up
     //MoleculeLeafClass *DownLeaf;      //!< First leaf one level down
@@ -402 +391 @@
     bool FastParsing;
     double Deltat;
-    string basis;
-
     int DoConstrainedMD;
     int MaxOuterStep;
-    int Thermostat;
-    int *ThermostatImplemented;
-    char **ThermostatNames;
-    double TempFrequency;
-    double alpha;
-    double HooverMass;
-    double TargetTemp;
-    int ScaleTempStep;
     
     private:
@@ -419 +398 @@
     char *defaultpath;
     char *pseudopotpath;
-
+    
     int DoOutVis;
     int DoOutMes;
@@ -434 +413 @@
     int UseAddGramSch;
     int Seed;
-
+    
     int OutVisStep;
     int OutSrcStep;
+    double TargetTemp;
+    int ScaleTempStep;
     int MaxPsiStep;
     double EpsWannier;
-
+    
     int MaxMinStep;
     double RelEpsTotalEnergy;
@@ -448 +429 @@
     double InitRelEpsKineticEnergy;
     int InitMaxMinGapStopStep;
-
+    
     //double BoxLength[NDIM*NDIM];
-
+    
     double ECut;
     int MaxLevel;
@@ -459 +440 @@
     int RTActualUse;
     int AddPsis;
-
+    
     double RCut;
     int StructOpt;
@@ -466 +447 @@
     int MaxTypes;
 
-
+  
   int ParseForParameter(int verbose, ifstream *file, const char *name, int sequential, int const xth, int const yth, int type, void *value, int repetition, int critical);
-
+  
   public:
   config();
@@ -477 +458 @@
   void LoadOld(char *filename, periodentafel *periode, molecule *mol);
   void RetrieveConfigPathAndName(string filename);
-  bool Save(const char *filename, periodentafel *periode, molecule *mol) const;
-  bool SaveMPQC(const char *filename, molecule *mol) const;
+  bool Save(ofstream *file, periodentafel *periode, molecule *mol) const;
+  bool SaveMPQC(ofstream *file, molecule *mol) const;
   void Edit(molecule *mol);
   bool GetIsAngstroem() const;
   char *GetDefaultPath() const;
   void SetDefaultPath(const char *path);
-  void InitThermostats(ifstream *source);
 };
 

src/orbitals.db

@@ -18 +18 @@
 18      0
 19      1
-20      4
+20      2
 21      3
 22      4

src/parser.cpp

@@ -56 +56 @@
 MatrixContainer::MatrixContainer() {
   Indices = NULL;
-  Header = (char **) Malloc(sizeof(char)*1, "MatrixContainer::MatrixContainer: **Header");
+  Header = (char *) Malloc(sizeof(char)*1023, "MatrixContainer::MatrixContainer: *Header");
   Matrix = (double ***) Malloc(sizeof(double **)*(1), "MatrixContainer::MatrixContainer: ***Matrix"); // one more each for the total molecule
   RowCounter = (int *) Malloc(sizeof(int)*(1), "MatrixContainer::MatrixContainer: *RowCounter");
-  ColumnCounter = (int *) Malloc(sizeof(int)*(1), "MatrixContainer::MatrixContainer: *ColumnCounter");
-  Header[0] = NULL;
   Matrix[0] = NULL;
   RowCounter[0] = -1;
   MatrixCounter = 0;
-  ColumnCounter[0] = -1;
+  ColumnCounter = 0;
 };
 
@@ -72 +70 @@
   if (Matrix != NULL) {
     for(int i=MatrixCounter;i--;) {
-      if ((ColumnCounter != NULL) && (RowCounter != NULL)) {
+      if (RowCounter != NULL) {
           for(int j=RowCounter[i]+1;j--;)
             Free((void **)&Matrix[i][j], "MatrixContainer::~MatrixContainer: *Matrix[][]");
@@ -78 +76 @@
       }
     }
-    if ((ColumnCounter != NULL) && (RowCounter != NULL) && (Matrix[MatrixCounter] != NULL))
+    if ((RowCounter != NULL) && (Matrix[MatrixCounter] != NULL))
       for(int j=RowCounter[MatrixCounter]+1;j--;)
         Free((void **)&Matrix[MatrixCounter][j], "MatrixContainer::~MatrixContainer: *Matrix[MatrixCounter][]");
@@ -91 +89 @@
   Free((void **)&Indices, "MatrixContainer::~MatrixContainer: **Indices"); 
   
-  if (Header != NULL)
-    for(int i=MatrixCounter+1;i--;)
-      Free((void **)&Header[i], "MatrixContainer::~MatrixContainer: *Header[]");
-  Free((void **)&Header, "MatrixContainer::~MatrixContainer: **Header");
+  Free((void **)&Header, "MatrixContainer::~MatrixContainer: *Header");
   Free((void **)&RowCounter, "MatrixContainer::~MatrixContainer: *RowCounter");
-  Free((void **)&ColumnCounter, "MatrixContainer::~MatrixContainer: *RowCounter");
-};
-
-/** Either copies index matrix from another MatrixContainer or initialises with trivial mapping if NULL.
- * This either copies the index matrix or just maps 1 to 1, 2 to 2 and so on for all fragments.
- * \param *Matrix pointer to other MatrixContainer
- * \return true - copy/initialisation sucessful, false - dimension false for copying
- */
-bool MatrixContainer::InitialiseIndices(class MatrixContainer *Matrix) 
-{
-  cout << "Initialising indices";
-  if (Matrix == NULL) {
-    cout << " with trivial mapping." << endl;
-    Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "MatrixContainer::InitialiseIndices: **Indices");
-    for(int i=MatrixCounter+1;i--;) {
-      Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
-      for(int j=RowCounter[i];j--;)
-        Indices[i][j] = j;
-    }
-  } else {
-    cout << " from other MatrixContainer." << endl;
-    if (MatrixCounter != Matrix->MatrixCounter)
-      return false;
-    Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "MatrixContainer::InitialiseIndices: **Indices");
-    for(int i=MatrixCounter+1;i--;) {
-      if (RowCounter[i] != Matrix->RowCounter[i])
-        return false;
-      Indices[i] = (int *) Malloc(sizeof(int)*Matrix->RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
-      for(int j=Matrix->RowCounter[i];j--;) {
-        Indices[i][j] = Matrix->Indices[i][j];
-        //cout << Indices[i][j] << "\t";
-      }
-      //cout << endl;
-    }
-  }
-  return true; 
-};
+};
+
 
 /** Parsing a number of matrices.
@@ -160 +120 @@
     return false;
   }
-
-  // parse header
-  Header[MatrixNr] = (char *) Malloc(sizeof(char)*1024, "MatrixContainer::ParseMatrix: *Header[]");
+  
+  // skip some initial lines
   for (int m=skiplines+1;m--;)
-    input.getline(Header[MatrixNr], 1023);
+    input.getline(Header, 1023);
   
   // scan header for number of columns
-  line.str(Header[MatrixNr]);
+  line.str(Header);
   for(int k=skipcolumns;k--;)
-    line >> Header[MatrixNr];
+    line >> Header;
   //cout << line.str() << endl;
-  ColumnCounter[MatrixNr]=0;
+  ColumnCounter=0;
   while ( getline(line,token, '\t') ) {
     if (token.length() > 0)
-      ColumnCounter[MatrixNr]++;
+      ColumnCounter++;
   }
   //cout << line.str() << endl;
-  //cout << "ColumnCounter[" << MatrixNr << "]: " << ColumnCounter[MatrixNr] << "." << endl;
-  if (ColumnCounter[MatrixNr] == 0)
-    cerr << "ColumnCounter[" << MatrixNr << "]: " << ColumnCounter[MatrixNr] << " from file " << name << ", this is probably an error!" << endl;
+  //cout << "ColumnCounter: " << ColumnCounter << "." << endl;
+  if (ColumnCounter == 0)
+    cerr << "ColumnCounter: " << ColumnCounter << " from file " << name << ", this is probably an error!" << endl;
   
   // scan rest for number of rows/lines
@@ -196 +155 @@
   
   // allocate matrix if it's not zero dimension in one direction
-  if ((ColumnCounter[MatrixNr] > 0) && (RowCounter[MatrixNr] > -1)) {
-    Matrix[MatrixNr] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixNr]+1), "MatrixContainer::ParseMatrix: **Matrix[]");
+  if ((ColumnCounter > 0) && (RowCounter[MatrixNr] > -1)) {
+    Matrix[MatrixNr] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixNr]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
   
     // parse in each entry for this matrix
@@ -203 +162 @@
     input.seekg(ios::beg);
     for (int m=skiplines+1;m--;)
-      input.getline(Header[MatrixNr], 1023);    // skip header
-    line.str(Header[MatrixNr]);
+      input.getline(Header, 1023);    // skip header
+    line.str(Header);
     for(int k=skipcolumns;k--;)  // skip columns in header too
       line >> filename;
-    strncpy(Header[MatrixNr], line.str().c_str(), 1023);  
+    strncpy(Header, line.str().c_str(), 1023);  
     for(int j=0;j<RowCounter[MatrixNr];j++) {
-      Matrix[MatrixNr][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[][]");
+      Matrix[MatrixNr][j] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
       input.getline(filename, 1023);
       stringstream lines(filename);
@@ -215 +174 @@
       for(int k=skipcolumns;k--;)
         lines >> filename;
-      for(int k=0;(k<ColumnCounter[MatrixNr]) && (!lines.eof());k++) {
+      for(int k=0;(k<ColumnCounter) && (!lines.eof());k++) {
         lines >> Matrix[MatrixNr][j][k];
         //cout << " " << setprecision(2) << Matrix[MatrixNr][j][k];;
       }
       //cout << endl;
-      Matrix[MatrixNr][ RowCounter[MatrixNr] ] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[RowCounter[MatrixNr]][]");
-      for(int j=ColumnCounter[MatrixNr];j--;)
+      Matrix[MatrixNr][ RowCounter[MatrixNr] ] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[RowCounter[MatrixNr]][]");
+      for(int j=ColumnCounter;j--;)
         Matrix[MatrixNr][ RowCounter[MatrixNr] ][j] = 0.;
     }
   } else {
-    cerr << "ERROR: Matrix nr. " << MatrixNr << " has column and row count of (" << ColumnCounter[MatrixNr] << "," << RowCounter[MatrixNr] << "), could not allocate nor parse!" << endl; 
+    cerr << "ERROR: Matrix nr. " << MatrixNr << " has column and row count of (" << ColumnCounter << "," << RowCounter[MatrixNr] << "), could not allocate nor parse!" << endl; 
   }
   input.close();
@@ -274 +233 @@
   
   cout << "Parsing through each fragment and retrieving " << prefix << suffix << "." << endl;
-  Header = (char **) ReAlloc(Header, sizeof(char *)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: **Header"); // one more each for the total molecule
   Matrix = (double ***) ReAlloc(Matrix, sizeof(double **)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: ***Matrix"); // one more each for the total molecule
   RowCounter = (int *) ReAlloc(RowCounter, sizeof(int)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: *RowCounter");
-  ColumnCounter = (int *) ReAlloc(ColumnCounter, sizeof(int)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: *ColumnCounter");
   for(int i=MatrixCounter+1;i--;) {
     Matrix[i] = NULL;
-    Header[i] = NULL;
     RowCounter[i] = -1;
-    ColumnCounter[i] = -1;
   }
   for(int i=0; i < MatrixCounter;i++) {
@@ -297 +252 @@
 
 /** Allocates and resets the memory for a number \a MCounter of matrices.
- * \param **GivenHeader Header line for each matrix
+ * \param *GivenHeader Header line
  * \param MCounter number of matrices
  * \param *RCounter number of rows for each matrix
- * \param *CCounter number of columns for each matrix
+ * \param CCounter number of columns for all matrices
  * \return Allocation successful 
  */
-bool MatrixContainer::AllocateMatrix(char **GivenHeader, int MCounter, int *RCounter, int *CCounter)
-{
+bool MatrixContainer::AllocateMatrix(char *GivenHeader, int MCounter, int *RCounter, int CCounter)
+{
+  Header = (char *) Malloc(sizeof(char)*1024, "MatrixContainer::ParseFragmentMatrix: *EnergyHeader");
+  strncpy(Header, GivenHeader, 1023);
+
   MatrixCounter = MCounter;
-  Header = (char **) Malloc(sizeof(char *)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: *Header");
-  Matrix = (double ***) Malloc(sizeof(double **)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: ***Matrix"); // one more each for the total molecule
-  RowCounter = (int *) Malloc(sizeof(int)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: *RowCounter");
-  ColumnCounter = (int *) Malloc(sizeof(int)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: *ColumnCounter");
+  ColumnCounter = CCounter;
+  Matrix = (double ***) Malloc(sizeof(double **)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: ***Matrix"); // one more each for the total molecule
+  RowCounter = (int *) Malloc(sizeof(int)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: *RowCounter");
   for(int i=MatrixCounter+1;i--;) {
-    Header[i] = (char *) Malloc(sizeof(char)*1024, "MatrixContainer::AllocateMatrix: *Header[i]");
-    strncpy(Header[i], GivenHeader[i], 1023);
     RowCounter[i] = RCounter[i];
-    ColumnCounter[i] = CCounter[i];
-    Matrix[i] = (double **) Malloc(sizeof(double *)*(RowCounter[i]+1), "MatrixContainer::AllocateMatrix: **Matrix[]");  
+    Matrix[i] = (double **) Malloc(sizeof(double *)*(RowCounter[i]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");  
     for(int j=RowCounter[i]+1;j--;) {
-      Matrix[i][j] = (double *) Malloc(sizeof(double)*ColumnCounter[i], "MatrixContainer::AllocateMatrix: *Matrix[][]");
-      for(int k=ColumnCounter[i];k--;)
+      Matrix[i][j] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      for(int k=ColumnCounter;k--;)
         Matrix[i][j][k] = 0.;
     }
@@ -332 +286 @@
   for(int i=MatrixCounter+1;i--;)
     for(int j=RowCounter[i]+1;j--;)
-      for(int k=ColumnCounter[i];k--;)
+      for(int k=ColumnCounter;k--;)
         Matrix[i][j][k] = 0.;
    return true;
@@ -345 +299 @@
   for(int i=MatrixCounter+1;i--;)
     for(int j=RowCounter[i]+1;j--;)
-      for(int k=ColumnCounter[i];k--;)
+      for(int k=ColumnCounter;k--;)
         if (fabs(Matrix[i][j][k]) > max)
           max = fabs(Matrix[i][j][k]);
@@ -361 +315 @@
   for(int i=MatrixCounter+1;i--;)
     for(int j=RowCounter[i]+1;j--;)
-      for(int k=ColumnCounter[i];k--;)
+      for(int k=ColumnCounter;k--;)
         if (fabs(Matrix[i][j][k]) < min)
           min = fabs(Matrix[i][j][k]);
@@ -377 +331 @@
 {
   for(int j=RowCounter[MatrixCounter]+1;j--;)
-    for(int k=skipcolumns;k<ColumnCounter[MatrixCounter];k++)
+    for(int k=skipcolumns;k<ColumnCounter;k++)
       Matrix[MatrixCounter][j][k] = value;
    return true;
@@ -390 +344 @@
 {
   for(int j=RowCounter[MatrixCounter]+1;j--;)
-    for(int k=skipcolumns;k<ColumnCounter[MatrixCounter];k++)
+    for(int k=skipcolumns;k<ColumnCounter;k++)
       Matrix[MatrixCounter][j][k] = values[j][k];
    return true;
 };
 
-/** Sums the entries with each factor and put into last element of \a ***Matrix.
+/** Sums the energy with each factor and put into last element of \a ***Energies.
  * Sums over "E"-terms to create the "F"-terms
- * \param Matrix MatrixContainer with matrices (LevelCounter by *ColumnCounter) with all the energies.
+ * \param Matrix MatrixContainer with matrices (LevelCounter by ColumnCounter) with all the energies.
  * \param KeySet KeySetContainer with bond Order and association mapping of each fragment to an order
  * \param Order bond order
@@ -430 +384 @@
               }
               if (Order == SubOrder) { // equal order is always copy from Energies
-                for(int l=ColumnCounter[ KeySet.OrderSet[SubOrder][j] ];l--;) // then adds/subtract each column 
+                for(int l=ColumnCounter;l--;) // then adds/subtract each column 
                   Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][m][l] += MatrixValues.Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l];
               } else {
-                for(int l=ColumnCounter[ KeySet.OrderSet[SubOrder][j] ];l--;)
+                for(int l=ColumnCounter;l--;)
                   Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][m][l] -= Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l];
               }
             }
-            //if ((ColumnCounter[ KeySet.OrderSet[SubOrder][j] ]>1) && (RowCounter[0]-1 >= 1))
+            //if ((ColumnCounter>1) && (RowCounter[0]-1 >= 1))
              //cout << "Fragments[ KeySet.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySet.OrderSet[Order][CurrentFragment] << " ][" << RowCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][RowCounter[0]-1][1] << endl;
           }
@@ -472 +426 @@
       return false;
     }
-    output << Header[i] << endl;
+    output << Header << endl;
     for(int j=0;j<RowCounter[i];j++) {
-      for(int k=0;k<ColumnCounter[i];k++)
+      for(int k=0;k<ColumnCounter;k++)
         output << scientific << Matrix[i][j][k] << "\t";
       output << endl;
@@ -501 +455 @@
     return false;
   }
-  output << Header[MatrixCounter] << endl;
+  output << Header << endl;
   for(int j=0;j<RowCounter[MatrixCounter];j++) {
-    for(int k=0;k<ColumnCounter[MatrixCounter];k++)
+    for(int k=0;k<ColumnCounter;k++)
       output << scientific << Matrix[MatrixCounter][j][k] << "\t";
     output << endl;
@@ -513 +467 @@
 // ======================================= CLASS EnergyMatrix =============================
 
+/** Create a trivial energy index mapping.
+ * This just maps 1 to 1, 2 to 2 and so on for all fragments.
+ * \return creation sucessful
+ */
+bool EnergyMatrix::ParseIndices() 
+{
+  cout << "Parsing energy indices." << endl;
+  Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "EnergyMatrix::ParseIndices: **Indices");
+  for(int i=MatrixCounter+1;i--;) {
+    Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "EnergyMatrix::ParseIndices: *Indices[]");
+    for(int j=RowCounter[i];j--;)
+      Indices[i][j] = j;
+  } 
+  return true; 
+};
+
 /** Sums the energy with each factor and put into last element of \a EnergyMatrix::Matrix.
  * Sums over the "F"-terms in ANOVA decomposition.
- * \param Matrix MatrixContainer with matrices (LevelCounter by *ColumnCounter) with all the energies.
+ * \param Matrix MatrixContainer with matrices (LevelCounter by ColumnCounter) with all the energies.
  * \param CorrectionFragments MatrixContainer with hydrogen saturation correction per fragments
  * \param KeySet KeySetContainer with bond Order and association mapping of each fragment to an order
@@ -528 +498 @@
     for(int i=KeySet.FragmentsPerOrder[Order];i--;)
       for(int j=RowCounter[ KeySet.OrderSet[Order][i] ];j--;)
-        for(int k=ColumnCounter[ KeySet.OrderSet[Order][i] ];k--;)
+        for(int k=ColumnCounter;k--;)
           Matrix[MatrixCounter][j][k] += sign*Fragments.Matrix[ KeySet.OrderSet[Order][i] ][j][k];
   else
     for(int i=KeySet.FragmentsPerOrder[Order];i--;)
       for(int j=RowCounter[ KeySet.OrderSet[Order][i] ];j--;)
-        for(int k=ColumnCounter[ KeySet.OrderSet[Order][i] ];k--;)
+        for(int k=ColumnCounter;k--;)
           Matrix[MatrixCounter][j][k] += sign*(Fragments.Matrix[ KeySet.OrderSet[Order][i] ][j][k] + CorrectionFragments->Matrix[ KeySet.OrderSet[Order][i] ][j][k]);
   return true;
@@ -554 +524 @@
     // count maximum of columns
     RowCounter[MatrixCounter] = 0;
-    ColumnCounter[MatrixCounter] = 0;
-    for(int j=0; j < MatrixCounter;j++) { // (energy matrix might be bigger than number of atoms in terms of rows)
+    for(int j=0; j < MatrixCounter;j++) // (energy matrix might be bigger than number of atoms in terms of rows)
       if (RowCounter[j] > RowCounter[MatrixCounter])
         RowCounter[MatrixCounter] = RowCounter[j];
-      if (ColumnCounter[j] > ColumnCounter[MatrixCounter])  // take maximum of all for last matrix
-        ColumnCounter[MatrixCounter] = ColumnCounter[j];
-    }
     // allocate last plus one matrix
-    cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl;
+    cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter << " columns." << endl;
     Matrix[MatrixCounter] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixCounter]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
     for(int j=0;j<=RowCounter[MatrixCounter];j++)
-      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
     
     // try independently to parse global energysuffix file if present
@@ -623 +589 @@
 
 /** Sums the forces and puts into last element of \a ForceMatrix::Matrix.
- * \param Matrix MatrixContainer with matrices (LevelCounter by *ColumnCounter) with all the energies.
+ * \param Matrix MatrixContainer with matrices (LevelCounter by ColumnCounter) with all the energies.
  * \param KeySet KeySetContainer with bond Order and association mapping of each fragment to an order
  * \param Order bond order
@@ -643 +609 @@
       if (j != -1) {
         //if (j == 0) cout << "Summing onto ion 0, type 0 from fragment " << FragmentNr << ", ion " << l << "." << endl;
-        for(int k=2;k<ColumnCounter[MatrixCounter];k++)
+        for(int k=2;k<ColumnCounter;k++)
           Matrix[MatrixCounter][j][k] += sign*Fragments.Matrix[ FragmentNr ][l][k];
       }
@@ -689 +655 @@
     RowCounter[MatrixCounter]++;    // nr start at 0, count starts at 1
     input.close();
-
-    ColumnCounter[MatrixCounter] = 0;
-    for(int j=0; j < MatrixCounter;j++) { // (energy matrix might be bigger than number of atoms in terms of rows)
-      if (ColumnCounter[j] > ColumnCounter[MatrixCounter])  // take maximum of all for last matrix
-        ColumnCounter[MatrixCounter] = ColumnCounter[j];
-    }
   
     // allocate last plus one matrix
-    cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl;
+    cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter << " columns." << endl;
     Matrix[MatrixCounter] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixCounter]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
     for(int j=0;j<=RowCounter[MatrixCounter];j++)
-      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
-
-    // try independently to parse global forcesuffix file if present
-    strncpy(filename, name, 1023);
-    strncat(filename, prefix, 1023-strlen(filename));
-    strncat(filename, suffix.c_str(), 1023-strlen(filename));
-    ParseMatrix(filename, skiplines, skipcolumns, MatrixCounter);
-  }
- 
-
-  return status;
-};
-
-// ======================================= CLASS HessianMatrix =============================
-
-/** Parsing force Indices of each fragment
- * \param *name directory with \a ForcesFile
- * \return parsing successful 
- */
-bool HessianMatrix::ParseIndices(char *name) 
-{
-  ifstream input;
-  char *FragmentNumber = NULL;
-  char filename[1023];
-  stringstream line;
-  
-  cout << "Parsing hessian indices for " << MatrixCounter << " matrices." << endl;
-  Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "HessianMatrix::ParseIndices: **Indices");
-  line << name << FRAGMENTPREFIX << FORCESFILE;
-  input.open(line.str().c_str(), ios::in);
-  //cout << "Opening " << line.str() << " ... "  << input << endl;
-  if (input == NULL) {
-    cout << endl << "Unable to open " << line.str() << ", is the directory correct?" << endl;
-    return false;
-  }
-  for (int i=0;(i<MatrixCounter) && (!input.eof());i++) {
-    // get the number of atoms for this fragment
-    input.getline(filename, 1023);
-    line.str(filename);
-    // parse the values
-    Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "HessianMatrix::ParseIndices: *Indices[]");
-    FragmentNumber = FixedDigitNumber(MatrixCounter, i);
-    //cout << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
-    Free((void **)&FragmentNumber, "HessianMatrix::ParseIndices: *FragmentNumber");
-    for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
-      line >> Indices[i][j];
-      //cout << " " << Indices[i][j];
-    }
-    //cout << endl;
-  }
-  Indices[MatrixCounter] = (int *) Malloc(sizeof(int)*RowCounter[MatrixCounter], "HessianMatrix::ParseIndices: *Indices[]");
-  for(int j=RowCounter[MatrixCounter];j--;) {
-    Indices[MatrixCounter][j] = j;
-  }
-  input.close();
-  return true;
-};
-
-
-/** Sums the hessian entries and puts into last element of \a HessianMatrix::Matrix.
- * \param Matrix MatrixContainer with matrices (LevelCounter by *ColumnCounter) with all the energies.
- * \param KeySet KeySetContainer with bond Order and association mapping of each fragment to an order
- * \param Order bond order
- *  \param sign +1 or -1
- * \return true if summing was successful
- */
-bool HessianMatrix::SumSubHessians(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, int Order, double sign)
-{
-  int FragmentNr;
-  // sum forces
-  for(int i=0;i<KeySet.FragmentsPerOrder[Order];i++) {
-    FragmentNr = KeySet.OrderSet[Order][i];
-    for(int l=0;l<RowCounter[ FragmentNr ];l++) {
-      int j = Indices[ FragmentNr ][l];
-      if (j > RowCounter[MatrixCounter]) {
-        cerr << "Current hessian index " << j << " is greater than " << RowCounter[MatrixCounter] << ", where i=" << i << ", Order=" << Order << ", l=" << l << " and FragmentNr=" << FragmentNr << "!" << endl;
-        return false;
-      }
-      if (j != -1) {
-        for(int m=0;m<ColumnCounter[ FragmentNr ];m++) {
-          int k = Indices[ FragmentNr ][m];
-          if (k > ColumnCounter[MatrixCounter]) {
-            cerr << "Current hessian index " << k << " is greater than " << ColumnCounter[MatrixCounter] << ", where m=" << m << ", j=" << j << ", i=" << i << ", Order=" << Order << ", l=" << l << " and FragmentNr=" << FragmentNr << "!" << endl;
-            return false;
-          }
-          if (k != -1) {
-                //cout << "Adding " << sign*Fragments.Matrix[ FragmentNr ][l][m] << " from [" << l << "][" << m << "] onto [" << j << "][" << k << "]." << endl;
-            Matrix[MatrixCounter][j][k] += sign*Fragments.Matrix[ FragmentNr ][l][m];
-          }
-        }
-      }
-    }
-  }
-  return true;
-};
-
-/** Constructor for class HessianMatrix.
- */
-HessianMatrix::HessianMatrix() : MatrixContainer() 
-{
-   IsSymmetric = true;
-}
-
-/** Sums the hessian entries with each factor and put into last element of \a ***Matrix.
- * Sums over "E"-terms to create the "F"-terms
- * \param Matrix MatrixContainer with matrices (LevelCounter by *ColumnCounter) with all the energies.
- * \param KeySet KeySetContainer with bond Order and association mapping of each fragment to an order
- * \param Order bond order
- * \return true if summing was successful
- */
-bool HessianMatrix::SumSubManyBodyTerms(class MatrixContainer &MatrixValues, class KeySetsContainer &KeySet, int Order)
-{
-  // go through each order
-  for (int CurrentFragment=0;CurrentFragment<KeySet.FragmentsPerOrder[Order];CurrentFragment++) {
-    //cout << "Current Fragment is " << CurrentFragment << "/" << KeySet.OrderSet[Order][CurrentFragment] << "." << endl;
-    // then go per order through each suborder and pick together all the terms that contain this fragment
-    for(int SubOrder=0;SubOrder<=Order;SubOrder++) { // go through all suborders up to the desired order
-      for (int j=0;j<KeySet.FragmentsPerOrder[SubOrder];j++) { // go through all possible fragments of size suborder
-        if (KeySet.Contains(KeySet.OrderSet[Order][CurrentFragment], KeySet.OrderSet[SubOrder][j])) {
-          //cout << "Current other fragment is " << j << "/" << KeySet.OrderSet[SubOrder][j] << "." << endl;
-          // if the fragment's indices are all in the current fragment
-          for(int k=0;k<RowCounter[ KeySet.OrderSet[SubOrder][j] ];k++) { // go through all atoms in this fragment
-            int m = MatrixValues.Indices[ KeySet.OrderSet[SubOrder][j] ][k];
-            //cout << "Current row index is " << k << "/" << m << "." << endl;
-            if (m != -1) { // if it's not an added hydrogen
-              for (int l=0;l<RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ];l++) { // look for the corresponding index in the current fragment
-                //cout << "Comparing " << m << " with " << MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][l] << "." << endl;
-                if (m == MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][l]) {
-                  m = l;
-                  break;  
-                }
-              }
-              //cout << "Corresponding row index for " << k << " in CurrentFragment is " << m << "." << endl;
-              if (m > RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ]) {
-                cerr << "In fragment No. " << KeySet.OrderSet[Order][CurrentFragment]   << " current row index " << m << " is greater than " << RowCounter[ KeySet.OrderSet[Order][CurrentFragment] ] << "!" << endl;
-                return false;
-              }
-              
-              for(int l=0;l<ColumnCounter[ KeySet.OrderSet[SubOrder][j] ];l++) { 
-                int n = MatrixValues.Indices[ KeySet.OrderSet[SubOrder][j] ][l];
-                //cout << "Current column index is " << l << "/" << n << "." << endl;
-                if (n != -1) { // if it's not an added hydrogen
-                  for (int p=0;p<ColumnCounter[ KeySet.OrderSet[Order][CurrentFragment] ];p++) { // look for the corresponding index in the current fragment
-                    //cout << "Comparing " << n << " with " << MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][p] << "." << endl;
-                    if (n == MatrixValues.Indices[ KeySet.OrderSet[Order][CurrentFragment] ][p]) {
-                      n = p;
-                      break;  
-                    }
-                  }
-                  //cout << "Corresponding column index for " << l << " in CurrentFragment is " << n << "." << endl;
-                  if (n > ColumnCounter[ KeySet.OrderSet[Order][CurrentFragment] ]) {
-                    cerr << "In fragment No. " << KeySet.OrderSet[Order][CurrentFragment]   << " current column index " << n << " is greater than " << ColumnCounter[ KeySet.OrderSet[Order][CurrentFragment] ] << "!" << endl;
-                    return false;
-                  }
-                  if (Order == SubOrder) { // equal order is always copy from Energies
-                        //cout << "Adding " << MatrixValues.Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l] << " from [" << k << "][" << l << "] onto [" << m << "][" << n << "]." << endl;
-                    Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][m][n] += MatrixValues.Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l];
-                  } else {
-                        //cout << "Subtracting " << Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l] << " from [" << k << "][" << l << "] onto [" << m << "][" << n << "]." << endl;
-                    Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][m][n] -= Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l];
-                  }
-                }
-              }
-            }
-            //if ((ColumnCounter[ KeySet.OrderSet[SubOrder][j] ]>1) && (RowCounter[0]-1 >= 1))
-             //cout << "Fragments[ KeySet.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySet.OrderSet[Order][CurrentFragment] << " ][" << RowCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][RowCounter[0]-1][1] << endl;
-          }
-        } else {
-          //cout << "Fragment " << KeySet.OrderSet[SubOrder][j] << " is not contained in fragment " << KeySet.OrderSet[Order][CurrentFragment] << "." << endl;
-        }
-      }
-    }
-   //cout << "Final Fragments[ KeySet.OrderSet[" << Order << "][" << CurrentFragment << "]=" << KeySet.OrderSet[Order][CurrentFragment] << " ][" << KeySet.AtomCounter[0]-1 << "][" << 1 << "] = " <<  Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][KeySet.AtomCounter[0]-1][1] << endl;
-  }
-  
-  return true;
-};
-
-/** Calls MatrixContainer::ParseFragmentMatrix() and additionally allocates last plus one matrix.
- * \param *name directory with files
- * \param *prefix prefix of each matrix file
- * \param *suffix suffix of each matrix file
- * \param skiplines number of inital lines to skip
- * \param skiplines number of inital columns to skip
- * \return parsing successful
- */ 
-bool HessianMatrix::ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns)
-{
-  char filename[1023];
-  ifstream input;
-  stringstream file;
-  int nr;
-  bool status = MatrixContainer::ParseFragmentMatrix(name, prefix, suffix, skiplines, skipcolumns);
-
-  if (status) {
-    // count number of atoms for last plus one matrix
-    file << name << FRAGMENTPREFIX << KEYSETFILE;
-    input.open(file.str().c_str(), ios::in);
-    if (input == NULL) {
-      cout << endl << "Unable to open " << file.str() << ", is the directory correct?" << endl;
-      return false;
-    }
-    RowCounter[MatrixCounter] = 0;
-    ColumnCounter[MatrixCounter] = 0;
-    while (!input.eof()) {
-      input.getline(filename, 1023);
-      stringstream zeile(filename);
-      while (!zeile.eof()) {
-        zeile >> nr;
-        //cout << "Current index: " << nr << "." << endl;
-        if (nr > RowCounter[MatrixCounter]) {
-          RowCounter[MatrixCounter] = nr;
-          ColumnCounter[MatrixCounter] = nr;
-        }
-      }
-    }
-    RowCounter[MatrixCounter]++;    // nr start at 0, count starts at 1
-    ColumnCounter[MatrixCounter]++;    // nr start at 0, count starts at 1
-    input.close();
-  
-    // allocate last plus one matrix
-    cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl;
-    Matrix[MatrixCounter] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixCounter]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
-    for(int j=0;j<=RowCounter[MatrixCounter];j++)
-      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
 
     // try independently to parse global forcesuffix file if present

src/parser.hpp

@@ -19 +19 @@
 
 #define EnergySuffix ".energy.all"
-#define EnergyFragmentSuffix ".energyfragment.all"
+#define HcorrectionSuffix ".Hcorrection.all"
 #define ForcesSuffix ".forces.all"
-#define ForceFragmentSuffix ".forcefragment.all"
-#define HcorrectionSuffix ".Hcorrection.all"
-#define HcorrectionFragmentSuffix ".Hcorrectionfragment.all"
-#define HessianSuffix ".hessian_xx.all"
-#define HessianFragmentSuffix ".hessianfragment_xx.all"
-#define OrderSuffix ".Order"
 #define ShieldingSuffix ".sigma_all.csv"
 #define ShieldingPASSuffix ".sigma_all_PAS.csv"
 #define ShieldingFragmentSuffix ".sigma_all_fragment.all"
 #define ShieldingPASFragmentSuffix ".sigma_all_PAS_fragment.all"
-#define ChiSuffix ".chi_all.csv"
-#define ChiPASSuffix ".chi_all_PAS.csv"
-#define ChiFragmentSuffix ".chi_all_fragment.all"
-#define ChiPASFragmentSuffix ".chi_all_PAS_fragment.all"
 #define TimeSuffix ".speed"
+#define EnergyFragmentSuffix ".energyfragment.all"
+#define HcorrectionFragmentSuffix ".Hcorrectionfragment.all"
+#define ForceFragmentSuffix ".forcefragment.all"
+#define OrderSuffix ".Order"
 
 // ======================================= FUNCTIONS ==========================================
@@ -49 +43 @@
     double ***Matrix;
     int **Indices;
-    char **Header;
+    char *Header;
     int MatrixCounter;
     int *RowCounter;
-    int *ColumnCounter;
+    int ColumnCounter;
   
   MatrixContainer();
   ~MatrixContainer();
   
-  bool InitialiseIndices(class MatrixContainer *Matrix = NULL);
   bool ParseMatrix(const char *name, int skiplines, int skipcolumns, int MatrixNr);
   virtual bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
-  bool AllocateMatrix(char **GivenHeader, int MCounter, int *RCounter, int *CCounter);
+  bool AllocateMatrix(char *GivenHeader, int MCounter, int *RCounter, int CCounter);
   bool ResetMatrix();
   double FindMinValue();
@@ -77 +70 @@
 class EnergyMatrix : public MatrixContainer {
   public:
+    bool ParseIndices();
     bool SumSubEnergy(class EnergyMatrix &Fragments, class EnergyMatrix *CorrectionFragments, class KeySetsContainer &KeySet, int Order, double sign);
     bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
@@ -88 +82 @@
     bool SumSubForces(class ForceMatrix &Fragments, class KeySetsContainer &KeySet, int Order, double sign);
     bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
-};
-
-// ======================================= CLASS HessianMatrix =============================
-
-class HessianMatrix : public MatrixContainer { 
-  public: 
-    HessianMatrix();
-    //~HessianMatrix();
-    bool ParseIndices(char *name);
-    bool SumSubManyBodyTerms(class MatrixContainer &MatrixValues, class KeySetsContainer &KeySet, int Order);
-    bool SumSubHessians(class HessianMatrix &Fragments, class KeySetsContainer &KeySet, int Order, double sign);
-    bool ParseFragmentMatrix(char *name, char *prefix, string suffix, int skiplines, int skipcolumns);
-  private:
-    bool IsSymmetric;
 };
 

src/periodentafel.cpp

@@ -1 +1 @@
 /** \file periodentafel.cpp
- *
+ * 
  * Function implementations for the class periodentafel.
- *
+ * 
  */
 
@@ -14 +14 @@
  * Initialises start and end of list and resets periodentafel::checkliste to false.
  */
-periodentafel::periodentafel()
-{
-  start = new element;
-  end = new element;
-  start->previous = NULL;
-  start->next = end;
-  end->previous = start;
+periodentafel::periodentafel() 
+{ 
+  start = new element; 
+  end = new element; 
+  start->previous = NULL; 
+  start->next = end; 
+  end->previous = start; 
   end->next = NULL;
 };
@@ -27 +27 @@
  * Removes every element and afterwards deletes start and end of list.
  */
-periodentafel::~periodentafel()
-{
-  CleanupPeriodtable();
-  delete(end);
-  delete(start);
-};
+periodentafel::~periodentafel() 
+{ 
+  CleanupPeriodtable(); 
+  delete(end); 
+  delete(start); 
+}; 
 
 /** Adds element to period table list
@@ -38 +38 @@
  * \return true - succeeded, false - does not occur
  */
-bool periodentafel::AddElement(element *pointer)
-{
+bool periodentafel::AddElement(element *pointer) 
+{ 
   pointer->sort = &pointer->Z;
   if (pointer->Z < 1 && pointer->Z >= MAX_ELEMENTS)
     cout << Verbose(0) << "Invalid Z number!\n";
-  return add(pointer, end);
+  return add(pointer, end); 
 };
 
@@ -50 +50 @@
  * \return true - succeeded, false - element not found
  */
-bool periodentafel::RemoveElement(element *pointer)
-{
-  return remove(pointer, start, end);
+bool periodentafel::RemoveElement(element *pointer) 
+{ 
+  return remove(pointer, start, end); 
 };
 
@@ -58 +58 @@
  * \return true - succeeded, false - does not occur
  */
-bool periodentafel::CleanupPeriodtable()
-{
-  return cleanup(start,end);
+bool periodentafel::CleanupPeriodtable() 
+{ 
+  return cleanup(start,end); 
 };
 
@@ -76 +76 @@
     cout << Verbose(0) << "Mass: " << endl;
     cin >> walker->mass;
-    walker->Z = Z;
-    cout << Verbose(0) << "Atomic number: " << walker->Z << endl;
+    walker->Z = Z;  
+    cout << Verbose(0) << "Atomic number: " << walker->Z << endl;  
     cout << Verbose(0) << "Name [max 64 chars]: " << endl;
     cin >> walker->name;
@@ -105 +105 @@
 /** Asks for element number and returns pointer to element
  */
-element * periodentafel::AskElement()
+element * periodentafel::AskElement() 
 {
   element *walker = NULL;
@@ -117 +117 @@
 };
 
+
 /** Prints period table to given stream.
  * \param output stream
- */
+ */ 
 bool periodentafel::Output(ofstream *output) const
 {
@@ -130 +131 @@
     }
     return result;
-  } else
+  } else 
     return false;
 };
@@ -137 +138 @@
  * \param *output output stream
  * \param *checkliste elements table for this molecule
- */
+ */ 
 bool periodentafel::Checkout(ofstream *output, const int *checkliste) const
 {
@@ -151 +152 @@
       if ((walker != NULL) && (walker->Z > 0) && (walker->Z < MAX_ELEMENTS) && (checkliste[walker->Z])) {
         walker->No = No;
-        result = result && walker->Checkout(output, No++, checkliste[walker->Z]);
+        result = result && walker->Checkout(output, No++, checkliste[walker->Z]);      
       }
     }
     return result;
-  } else
+  } else 
     return false;
 };
+
 
 /** Loads element list from file.
@@ -169 +171 @@
   bool status = true;
   bool otherstatus = true;
-  char filename[255];
-
+  char *filename = new char[MAXSTRINGSIZE];
+  
   // fill elements DB
   strncpy(filename, path, MAXSTRINGSIZE);
@@ -223 +225 @@
   if (infile != NULL) {
     while (!infile.eof()) {
+        infile >> tmp;
+        infile >> ws;
+        infile >> FindElement((int)tmp)->Valence;
+        infile >> ws;
+        //cout << 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
+  strncpy(filename, path, MAXSTRINGSIZE);
+  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
+  strncat(filename, STANDARDORBITALDB, MAXSTRINGSIZE-strlen(filename));
+  infile.open(filename);
+  if (infile != NULL) {
+    while (!infile.eof()) {
       infile >> tmp;
       infile >> ws;
-      infile >> FindElement((int)tmp)->Valence;
-      infile >> ws;
-      //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->Valence << " valence electrons." << endl;
+      infile >> FindElement((int)tmp)->NoValenceOrbitals;
+      infile >> ws;
+      //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->NoValenceOrbitals << " number of singly occupied valence orbitals." << endl;
     }
     infile.close();
@@ -233 +253 @@
   } else
     otherstatus = false;
-
-  // fill valence DB per element
-  strncpy(filename, path, MAXSTRINGSIZE);
-  strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));
-  strncat(filename, STANDARDORBITALDB, MAXSTRINGSIZE-strlen(filename));
-  infile.open(filename);
-  if (infile != NULL) {
-    while (!infile.eof()) {
-      infile >> tmp;
-      infile >> ws;
-      infile >> FindElement((int)tmp)->NoValenceOrbitals;
-      infile >> ws;
-      //cout << 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
   strncpy(filename, path, MAXSTRINGSIZE);
@@ -259 +261 @@
   if (infile != NULL) {
     while (!infile.eof()) {
-      infile >> tmp;
+        infile >> tmp;
       ptr = FindElement((int)tmp);
-      infile >> ws;
+        infile >> ws;
       infile >> ptr->HBondDistance[0];
       infile >> ptr->HBondDistance[1];
       infile >> ptr->HBondDistance[2];
-      infile >> ws;
+        infile >> ws;
       //cout << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->HBondDistance[0] << " Angstrom typical distance to hydrogen." << endl;
     }
@@ -272 +274 @@
   } else
     otherstatus = false;
-
+  
   // fill H-BondAngle DB per element
   strncpy(filename, path, MAXSTRINGSIZE);
@@ -292 +294 @@
   } else
     otherstatus = false;
-
+  
   if (!otherstatus)
-    cerr << "WARNING: Something went wrong while parsing the other databases!" << endl;
-
+    cerr << "ERROR: Something went wrong while parsing the databases!" << endl;
+  
   return status;
 };
@@ -306 +308 @@
   ofstream f;
   char filename[MAXSTRINGSIZE];
-
+  
   strncpy(filename, path, MAXSTRINGSIZE);
   strncat(filename, "/", MAXSTRINGSIZE-strlen(filename));

src/valence.db

@@ -18 +18 @@
 18      0.80000000000000E+01
 19      0.30000000000000E+01
-20      0.40000000000000E+01
+20      0.20000000000000E+01
 21      0.30000000000000E+01
 22      0.40000000000000E+01

src/vector.cpp

@@ -1 +1 @@
 /** \file vector.cpp
- *
+ * 
  * Function implementations for the class vector.
- *
- */
-
+ * 
+ */
+ 
 #include "molecules.hpp"
-
+ 
 
 /************************************ Functions for class vector ************************************/
@@ -22 +22 @@
 Vector::~Vector() {};
 
-/** Calculates square of distance between this and another vector.
+/** Calculates distance between this and another vector.
  * \param *y array to second vector
  * \return \f$| x - y |^2\f$
  */
-double Vector::DistanceSquared(const Vector *y) const
+double Vector::Distance(const Vector *y) const
 {
   double res = 0.;
   for (int i=NDIM;i--;)
     res += (x[i]-y->x[i])*(x[i]-y->x[i]);
-  return (res);
-};
-
-/** Calculates distance between this and another vector.
- * \param *y array to second vector
- * \return \f$| x - y |\f$
- */
-double Vector::Distance(const Vector *y) const
-{
-  double res = 0.;
-  for (int i=NDIM;i--;)
-    res += (x[i]-y->x[i])*(x[i]-y->x[i]);
-  return (sqrt(res));
+  return (res);  
 };
 
@@ -81 +69 @@
         if (tmp < res) res = tmp;
       }
-  return (res);
+  return (res);  
 };
 
@@ -124 +112 @@
   for (int i=NDIM;i--;)
     res += x[i]*y->x[i];
-  return (res);
-};
-
-
-/** Calculates VectorProduct between this and another vector.
- *  -# returns the Product in place of vector from which it was initiated
- *  -# ATTENTION: Only three dim.
- *  \param *y array to vector with which to calculate crossproduct
- *  \return \f$ x \times y \f&
- */
-void Vector::VectorProduct(const Vector *y)
-{
-  Vector tmp;
-  tmp.x[0] = x[1]* (y->x[2]) - x[2]* (y->x[1]);
-  tmp.x[1] = x[2]* (y->x[0]) - x[0]* (y->x[2]);
-  tmp.x[2] = x[0]* (y->x[1]) - x[1]* (y->x[0]);
-  this->CopyVector(&tmp);
-
-};
-
+  return (res);  
+};
 
 /** projects this vector onto plane defined by \a *y.
- * \param *y normal vector of plane
+ * \param *y array to normal vector of plane
  * \return \f$\langle x, y \rangle\f$
  */
@@ -153 +123 @@
   Vector tmp;
   tmp.CopyVector(y);
-  tmp.Normalize();
-  tmp.Scale(ScalarProduct(&tmp));
+  tmp.Scale(Projection(y));
   this->SubtractVector(&tmp);
 };
@@ -175 +144 @@
   for (int i=NDIM;i--;)
     res += this->x[i]*this->x[i];
-  return (sqrt(res));
+  return (sqrt(res));  
 };
 
@@ -209 +178 @@
  */
 void Vector::Init(double x1, double x2, double x3)
-{
+{ 
   x[0] = x1;
   x[1] = x2;
@@ -219 +188 @@
  * \return \f$\acos\bigl(frac{\langle x, y \rangle}{|x||y|}\bigr)\f$
  */
-double Vector::Angle(const Vector *y) const
-{
-  return acos(this->ScalarProduct(y)/Norm()/y->Norm());
+double Vector::Angle(Vector *y) const
+{
+  return acos(this->ScalarProduct(y)/Norm()/y->Norm()); 
 };
 
@@ -269 +238 @@
 
 /** Sums two vectors \a  and \b component-wise.
- * \param a first vector
+ * \param a first vector 
  * \param b second vector
  * \return a + b
@@ -282 +251 @@
 
 /** Factors given vector \a a times \a m.
- * \param a vector
+ * \param a vector 
  * \param m factor
  * \return a + b
@@ -313 +282 @@
 };
 
-/** Prints a 3dim vector to a stream.
- * \param ost output stream
- * \param v Vector to be printed
- * \return output stream
- */
-ostream& operator<<(ostream& ost,Vector& m)
-{
-  ost << "(";
-  for (int i=0;i<NDIM;i++) {
-    ost << m.x[i];
-    if (i != 2)
-      ost << ",";
-  }
-  ost << ")";
+ofstream& operator<<(ofstream& ost,Vector& m)
+{
+        m.Output(&ost);
         return ost;
 };
@@ -351 +309 @@
 };
 
-/** Translate atom by given vector.
+/** Translate atom by given vector. 
  * \param trans[] translation vector.
  */
@@ -358 +316 @@
   for (int i=NDIM;i--;)
     x[i] += trans->x[i];
-};
+}; 
 
 /** Do a matrix multiplication.
@@ -397 +355 @@
     B[7] = -detAReci*RDET2(A[0],A[1],A[6],A[7]);    // A_32
     B[8] =  detAReci*RDET2(A[0],A[1],A[3],A[4]);    // A_33
-
+  
     // do the matrix multiplication
     C.x[0] = B[0]*x[0]+B[3]*x[1]+B[6]*x[2];
@@ -421 +379 @@
 {
   for(int i=NDIM;i--;)
-    x[i] = factors[0]*x1->x[i] + factors[1]*x2->x[i] + factors[2]*x3->x[i];
-};
-
-/** Mirrors atom against a given plane.
+    x[i] = factors[0]*x1->x[i] + factors[1]*x2->x[i] + factors[2]*x3->x[i]; 
+};
+
+/** Mirrors atom against a given plane. 
  * \param n[] normal vector of mirror plane.
  */
@@ -440 +398 @@
   Output((ofstream *)&cout);
   cout << endl;
-};
+}; 
 
 /** Calculates normal vector for three given vectors (being three points in space).
@@ -472 +430 @@
   this->x[2] = (x1.x[0]*x2.x[1] - x1.x[1]*x2.x[0]);
   Normalize();
-
+  
   return true;
 };
@@ -530 +488 @@
 /** Creates this vector as one of the possible orthonormal ones to the given one.
  * Just scan how many components of given *vector are unequal to zero and
- * try to get the skp of both to be zero accordingly.
+ * try to get the skp of both to be zero accordingly.  
  * \param *vector given vector
  * \return true - success, false - failure (null vector given)
@@ -551 +509 @@
       Components[Last++] = j;
   cout << Verbose(4) << Last << " Components != 0: (" << Components[0] << "," << Components[1] << "," << Components[2] << ")" << endl;
-
+        
   switch(Last) {
     case 3:  // threecomponent system
@@ -564 +522 @@
     case 1: // one component system
       // set sole non-zero component to 0, and one of the other zero component pendants to 1
-      x[(Components[0]+2)%NDIM] = 0.;
-      x[(Components[0]+1)%NDIM] = 1.;
-      x[Components[0]] = 0.;
+      x[(Components[0]+2)%NDIM] = 0.;   
+      x[(Components[0]+1)%NDIM] = 1.;   
+      x[Components[0]] = 0.;   
       return true;
       break;
@@ -583 +541 @@
 {
 //  cout << Verbose(3) << "For comparison: ";
-//  cout << "A " << A->Projection(this) << "\t";
-//  cout << "B " << B->Projection(this) << "\t";
-//  cout << "C " << C->Projection(this) << "\t";
+//  cout << "A " << A->Projection(this) << "\t"; 
+//  cout << "B " << B->Projection(this) << "\t"; 
+//  cout << "C " << C->Projection(this) << "\t"; 
 //  cout << endl;
   return A->Projection(this);
@@ -595 +553 @@
  * \return true if success, false if failed due to linear dependency
  */
-bool Vector::LSQdistance(Vector **vectors, int num)
+bool Vector::LSQdistance(Vector **vectors, int num) 
 {
         int j;
-
+                                
         for (j=0;j<num;j++) {
                 cout << Verbose(1) << j << "th atom's vector: ";
@@ -607 +565 @@
   int np = 3;
         struct LSQ_params par;
-
+    
    const gsl_multimin_fminimizer_type *T =
      gsl_multimin_fminimizer_nmsimplex;
@@ -613 +571 @@
    gsl_vector *ss, *y;
    gsl_multimin_function minex_func;
-
+ 
    size_t iter = 0, i;
    int status;
    double size;
-
+ 
    /* Initial vertex size vector */
    ss = gsl_vector_alloc (np);
    y = gsl_vector_alloc (np);
-
+ 
    /* Set all step sizes to 1 */
    gsl_vector_set_all (ss, 1.0);
-
+ 
    /* Starting point */
    par.vectors = vectors;
          par.num = num;
-
+        
          for (i=NDIM;i--;)
-                gsl_vector_set(y, i, (vectors[0]->x[i] - vectors[1]->x[i])/2.);
-
+                gsl_vector_set(y, i, (vectors[0]->x[i] - vectors[1]->x[i])/2.); 
+         
    /* Initialize method and iterate */
    minex_func.f = &LSQ;
    minex_func.n = np;
    minex_func.params = (void *)&par;
-
+ 
    s = gsl_multimin_fminimizer_alloc (T, np);
    gsl_multimin_fminimizer_set (s, &minex_func, y, ss);
-
+ 
    do
      {
        iter++;
        status = gsl_multimin_fminimizer_iterate(s);
-
+ 
        if (status)
          break;
-
+ 
        size = gsl_multimin_fminimizer_size (s);
        status = gsl_multimin_test_size (size, 1e-2);
-
+ 
        if (status == GSL_SUCCESS)
          {
            printf ("converged to minimum at\n");
          }
-
+ 
        printf ("%5d ", (int)iter);
        for (i = 0; i < (size_t)np; i++)
@@ -664 +622 @@
      }
    while (status == GSL_CONTINUE && iter < 100);
-
+ 
   for (i=(size_t)np;i--;)
     this->x[i] = gsl_vector_get(s->x, i);
@@ -730 +688 @@
  * \param alpha first angle
  * \param beta second angle
- * \param c norm of final vector
+ * \param c norm of final vector 
  * \return a vector with \f$\langle x1,x2 \rangle=A\f$, \f$\langle x1,y \rangle = B\f$ and with norm \a c.
- * \bug this is not yet working properly
+ * \bug this is not yet working properly 
  */
 bool Vector::SolveSystem(Vector *x1, Vector *x2, Vector *y, double alpha, double beta, double c)
@@ -748 +706 @@
   if (fabs(x1->x[0]) < MYEPSILON) { // check for zero components for the later flipping and back-flipping
     if (fabs(x1->x[1]) > MYEPSILON) {
-      flag = 1;
+      flag = 1;    
     } else if (fabs(x1->x[2]) > MYEPSILON) {
        flag = 2;
@@ -781 +739 @@
   // now comes the case system
   D1 = -y->x[0]/x1->x[0]*x1->x[1]+y->x[1];
-  D2 = -y->x[0]/x1->x[0]*x1->x[2]+y->x[2];
+  D2 = -y->x[0]/x1->x[0]*x1->x[2]+y->x[2]; 
   D3 = y->x[0]/x1->x[0]*A-B1;
   cout << Verbose(2) << "D1 " << D1 << "\tD2 " << D2 << "\tD3 " << D3 << "\n";
   if (fabs(D1) < MYEPSILON) {
-    cout << Verbose(2) << "D1 == 0!\n";
+    cout << Verbose(2) << "D1 == 0!\n"; 
     if (fabs(D2) > MYEPSILON) {
-      cout << Verbose(3) << "D2 != 0!\n";
+      cout << Verbose(3) << "D2 != 0!\n"; 
       x[2] = -D3/D2;
       E1 = A/x1->x[0] + x1->x[2]/x1->x[0]*D3/D2;
@@ -797 +755 @@
       cout << Verbose(3) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
       if (fabs(F1) < MYEPSILON) {
-        cout << Verbose(4) << "F1 == 0!\n";
+        cout << Verbose(4) << "F1 == 0!\n"; 
         cout << Verbose(4) << "Gleichungssystem linear\n";
-        x[1] = F3/(2.*F2);
+        x[1] = F3/(2.*F2); 
       } else {
         p = F2/F1;
         q = p*p - F3/F1;
-        cout << Verbose(4) << "p " << p << "\tq " << q << endl;
+        cout << Verbose(4) << "p " << p << "\tq " << q << endl;  
         if (q < 0) {
           cout << Verbose(4) << "q < 0" << endl;
@@ -824 +782 @@
     cout << Verbose(2) << "F1 " << F1 << "\tF2 " << F2 << "\tF3 " << F3 << "\n";
     if (fabs(F1) < MYEPSILON) {
-      cout << Verbose(3) << "F1 == 0!\n";
+      cout << Verbose(3) << "F1 == 0!\n"; 
       cout << Verbose(3) << "Gleichungssystem linear\n";
-      x[2] = F3/(2.*F2);
+      x[2] = F3/(2.*F2);     
     } else {
       p = F2/F1;
       q = p*p - F3/F1;
-      cout << Verbose(3) << "p " << p << "\tq " << q << endl;
+      cout << Verbose(3) << "p " << p << "\tq " << q << endl;  
       if (q < 0) {
         cout << Verbose(3) << "q < 0" << endl;
@@ -874 +832 @@
     }
     cout << Verbose(2) << i << ": sign matrix is " << sign[0] << "\t" << sign[1] << "\t" << sign[2] << "\n";
-    // apply sign matrix
+    // apply sign matrix 
     for (j=NDIM;j--;)
       x[j] *= sign[j];
@@ -880 +838 @@
     ang = x2->Angle (this);
     cout << Verbose(1) << i << "th angle " << ang << "\tbeta " << cos(beta) << " :\t";
-    if (fabs(ang - cos(beta)) < MYEPSILON) {
+    if (fabs(ang - cos(beta)) < MYEPSILON) {  
       break;
     }

src/vector.hpp

@@ -7 +7 @@
  * basically, just a x[3] but with helpful functions
  */
-class Vector {
+class Vector {   
   public:
     double x[NDIM];
@@ -16 +16 @@
 
   double Distance(const Vector *y) const;
-  double DistanceSquared(const Vector *y) const;
   double PeriodicDistance(const Vector *y, const double *cell_size) const;
   double ScalarProduct(const Vector *y) const;
   double Projection(const Vector *y) const;
   double Norm() const ;
-  double Angle(const Vector *y) const;
+  double Angle(Vector *y) const;
 
   void AddVector(const Vector *y);
@@ -27 +26 @@
   void CopyVector(const Vector *y);
   void RotateVector(const Vector *y, const double alpha);
-  void VectorProduct(const Vector *y);
   void ProjectOntoPlane(const Vector *y);
-  void Zero();
+  void Zero(); 
   void One(double one);
   void Init(double x1, double x2, double x3);
@@ -42 +40 @@
   void KeepPeriodic(ofstream *out, double *matrix);
   void LinearCombinationOfVectors(const Vector *x1, const Vector *x2, const Vector *x3, double *factors);
-
+  
   double CutsPlaneAt(Vector *A, Vector *B, Vector *C);
   bool GetOneNormalVector(const Vector *x1);
@@ -55 +53 @@
 };
 
-ostream & operator << (ostream& ost, Vector &m);
-//Vector& operator+=(Vector& a, const Vector& b);
-//Vector& operator*=(Vector& a, const double m);
-//Vector& operator*(const Vector& a, const double m);
-//Vector& operator+(const Vector& a, const Vector& b);
+ofstream& operator<<(ofstream& ost, Vector& m);
+Vector& operator+=(Vector& a, const Vector& b);
+Vector& operator*=(Vector& a, const double m);
+Vector& operator*(const Vector& a, const double m);
+Vector& operator+(const Vector& a, const Vector& b);
 
 #endif /*VECTOR_HPP_*/

tests/testsuite.at

@@ -12 +12 @@
 AT_CHECK([../../molecuilder -h], 0, [stdout], [ignore])
 AT_CHECK([fgrep "Give this help screen" stdout], 0, [ignore], [ignore])
-AT_CHECK([../../molecuilder -e], 0, [ignore], [stderr])
-AT_CHECK([fgrep "Not enough or invalid arguments" stderr], 0, [ignore], [ignore])
-AT_CHECK([../../molecuilder test.conf], 0, [stdout], [stderr])
-AT_CHECK([fgrep "Element list loading failed" stdout], 0, [ignore], [ignore])
 AT_CLEANUP
 
@@ -42 +38 @@
 AT_CHECK([../../molecuilder -e ./ <input], 0, [ignore], [ignore])
 AT_CHECK([diff main_pcp_linux test.conf], 0, [ignore], [ignore])
-# 4. test some more configuration
-AT_CHECK([../../molecuilder test.conf -e ./ -t -s -b -F -E -c -b -a -U -T -u], 0, [ignore], [stderr])
-AT_CHECK([fgrep -c "Not enough or invalid" stderr], 0, [10
-], [ignore])
 AT_CLEANUP