Changes in / [fcbfc8:631dcb]

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# (added)
• src/#makefile# (added)
• src/#molecules.hpp# (added)
• src/Hbondangle.db (modified) (1 diff, 1 prop)
• src/Hbonddistance.db (modified) (1 diff, 1 prop)
• src/Makefile.am (modified) (1 prop)
• src/ReMapDBondFileFromXYZ.py (added)
• src/TAGS (added)
• src/analyzer.cpp (modified) (13 diffs, 1 prop)
• src/atom.cpp (modified) (1 prop)
• src/bond.cpp (modified) (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) (7 diffs, 1 prop)
• src/datacreator.cpp (modified) (36 diffs, 1 prop)
• src/datacreator.hpp (modified) (2 diffs, 1 prop)
• src/defs.hpp (modified) (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 (added)
• src/helpers.cpp (modified) (1 diff, 1 prop)
• src/helpers.hpp (modified) (1 diff, 1 prop)
• src/joiner.cpp (modified) (9 diffs, 1 prop)
• src/moleculelist.cpp (modified) (3 diffs, 1 prop)
• src/molecules.cpp (modified) (207 diffs, 1 prop)
• src/molecules.hpp (modified) (23 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) (33 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 @@
-../../m4/ac_doxygen.m4
+# 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/acx_compilerflags.m4

@@ -1 @@
-../../m4/acx_compilerflags.m4
+# 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"
+
+])

src/Hbondangle.db

@@ -4 +4 @@
 7       180     110     106.67
 8       180     104.5   -1
-14      180     120     109.5
+14      180     120     109.47
 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/analyzer.cpp

@@ -25 +25 @@
   periodentafel *periode = NULL; // and a period table of all elements
   EnergyMatrix Energy;
+  EnergyMatrix EnergyFragments;
+  ForceMatrix Force;
+  ForceMatrix ForceFragments;
+  HessianMatrix Hessian;
+  HessianMatrix HessianFragments;
   EnergyMatrix Hcorrection;
-  ForceMatrix Force;
+  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;
@@ -49 +55 @@
   stringstream yrange;
   char *dir = NULL;
-  bool Hcorrected = true;
-  double norm;
+  bool NoHCorrection = false;
+  bool NoHessian = false;
+  bool NoTime = false;
   int counter;
   
@@ -84 +91 @@
   // ------------- Parse through all Fragment subdirs --------
   if (!Energy.ParseFragmentMatrix(argv[1], dir, EnergySuffix,0,0)) return 1;
-  Hcorrected = Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX,0,0);
+  if (!Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX,0,0)) {
+    NoHCorrection = true;
+    cout << "No HCorrection file found, skipping these." << endl;
+  }
+  
   if (!Force.ParseFragmentMatrix(argv[1], dir, ForcesSuffix,0,0)) return 1;
-  if (!Time.ParseFragmentMatrix(argv[1], dir, TimeSuffix, 10,1)) 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 (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.ParseIndices()) return 1;
-  if (Hcorrected) Hcorrection.ParseIndices();
+  if (!Energy.InitialiseIndices()) return 1;
+  if (!NoHCorrection) 
+    Hcorrection.InitialiseIndices();
   
   // ---------- 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.ParseIndices(argv[1])) 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;
+  }
 
   // ---------- Parse the shielding indices into an array ---------------
@@ -105 +133 @@
     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;
   }
 
@@ -113 +151 @@
   // ---------- Parse fragment files created by 'joiner' into an array -------------
   if (!EnergyFragments.ParseFragmentMatrix(argv[1], dir, EnergyFragmentSuffix,0,0)) return 1;
-  if (Hcorrected) HcorrectionFragments.ParseFragmentMatrix(argv[1], dir, HcorrectionFragmentSuffix,0,0);
+  if (!NoHCorrection) 
+    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;
   }
 
@@ -126 +169 @@
   filename << argv[3] << "/" << "energy-forces.all";
   output.open(filename.str().c_str(), ios::out);
-  output << endl << "Total Energy" << endl << "==============" << endl << Energy.Header << endl;
+  output << endl << "Total Energy" << endl << "==============" << endl << Energy.Header[Energy.MatrixCounter] << endl;
   for(int j=0;j<Energy.RowCounter[Energy.MatrixCounter];j++) {
-    for(int k=0;k<Energy.ColumnCounter;k++)
+    for(int k=0;k<Energy.ColumnCounter[Energy.MatrixCounter];k++)
       output << scientific << Energy.Matrix[ Energy.MatrixCounter ][j][k] << "\t";
     output << endl;
@@ -134 +177 @@
   output << endl;
   
-  output << endl << "Total Forces" << endl << "===============" << endl << Force.Header << endl;
+  output << endl << "Total Forces" << endl << "===============" << endl << Force.Header[Force.MatrixCounter] << endl;
   for(int j=0;j<Force.RowCounter[Force.MatrixCounter];j++) {
-    for(int k=0;k<Force.ColumnCounter;k++)
+    for(int k=0;k<Force.ColumnCounter[Force.MatrixCounter];k++)
       output << scientific << Force.Matrix[ Force.MatrixCounter ][j][k] << "\t";
     output << endl;
@@ -142 +185 @@
   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 << endl;
+    output << endl << "Total Shieldings" << endl << "===============" << endl << Shielding.Header[Hessian.MatrixCounter] << endl;
     for(int j=0;j<Shielding.RowCounter[Shielding.MatrixCounter];j++) {
-      for(int k=0;k<Shielding.ColumnCounter;k++)
+      for(int k=0;k<Shielding.ColumnCounter[Shielding.MatrixCounter];k++)
         output << scientific << Shielding.Matrix[ Shielding.MatrixCounter ][j][k] << "\t";
       output << endl;
@@ -151 +204 @@
     output << endl;
   
-    output << endl << "Total Shieldings PAS" << endl << "===============" << endl << ShieldingPAS.Header << endl;
+    output << endl << "Total Shieldings PAS" << endl << "===============" << endl << ShieldingPAS.Header[ShieldingPAS.MatrixCounter] << endl;
     for(int j=0;j<ShieldingPAS.RowCounter[ShieldingPAS.MatrixCounter];j++) {
-      for(int k=0;k<ShieldingPAS.ColumnCounter;k++)
+      for(int k=0;k<ShieldingPAS.ColumnCounter[ShieldingPAS.MatrixCounter];k++)
         output << scientific << ShieldingPAS.Matrix[ ShieldingPAS.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 << 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[Chi.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.close();
-  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];
+  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];
 
   // +++++++++++++++ ANALYZING ++++++++++++++++++++++++++++++
@@ -180 +252 @@
   // +++++++++++++++++++++++++++++++++++++++ Plotting Simtime vs Bond Order
   // +++++++++++++++++++++++++++++++++++++++ Plotting Delta Simtime vs Bond Order
-  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();
+  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 (!OpenOutputFile(output, argv[3], "ShieldingPAS-Atom.dat" )) return false;
-    output << "#" << ShieldingPAS.Header << endl;
+    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++) {
-      for(int k=0;k<ShieldingPAS.ColumnCounter;k++)
-        output << scientific << ShieldingPAS.Matrix[ ShieldingPAS.MatrixCounter ][j][k]*(((k>1) && (k<6))? 1.e6 : 1.) << "\t";
-      output << endl;
-    }
-    output << endl << endl; // another two newlines to partition the data
-    for(int j=0;j<ShieldingPASFragments.RowCounter[ShieldingPASFragments.MatrixCounter];j++) {
-      for(int k=0;k<ShieldingPASFragments.ColumnCounter;k++)
-        output << scientific << ShieldingPASFragments.Matrix[ ShieldingPASFragments.MatrixCounter ][j][k]*(((k>1) && (k<6))? 1.e6 : 1.) << "\t";
-      output << endl;
-    }
-    output << endl;
-  }
-  output.close();
+      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();
+  }
 
   
@@ -251 +351 @@
   // ++++++++++++++++++++++++++++++++++++++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;
@@ -296 +404 @@
   yrange.str("[1e-8:1e+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;
+  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 deviation in energy to full QM
@@ -380 +490 @@
   // +++++++++++++++++++++++++++++++=Ploting approximated and true shielding for each atom
   if (periode != NULL) { // also look for PAS values
-    if(!OpenOutputFile(output, argv[3], "ShieldingPAS-Atom.pyx")) return 1;
-    CreatePlotHeader(output, "ShieldingPAS-Atom", 1, "top right", NULL, NULL,  1, 5, "nuclei index", "chemical shielding value [ppm]");
-    output << "plot \\" << endl;  
-    output << "'ShieldingPAS-Atom.dat' index 0 title 'DFT' using 2:6 with linespoints, \\" << endl;
-    output << "'ShieldingPAS-Atom.dat' index 1 title 'BOSSANOVA' using 2:6 with linespoints" << endl;
+    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();  
   }
 

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 =================================
 
@@ -8 +14 @@
   LinesCount = 0;
   Nr = -1;
-};
+}
+;
 
 BoundaryPointSet::BoundaryPointSet(atom *Walker)
@@ -15 +22 @@
   LinesCount = 0;
   Nr = Walker->nr;
-};
+}
+;
 
 BoundaryPointSet::~BoundaryPointSet()
@@ -21 +29 @@
   cout << Verbose(5) << "Erasing point nr. " << Nr << "." << endl;
   node = NULL;
-};
-
-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) );
-  }
+  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));
+    }
   LinesCount++;
-};
-
-ostream & operator << (ostream &ost, BoundaryPointSet &a) 
+}
+;
+
+ostream &
+operator <<(ostream &ost, BoundaryPointSet &a)
 {
   ost << "[" << a.Nr << "|" << a.node->Name << "]";
   return ost;
-};
+}
+;
 
 // ======================================== Lines on Boundary =================================
@@ -44 +62 @@
 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)
@@ -57 +76 @@
   SetEndpointsOrdered(endpoints, Point[0], Point[1]);
   // add this line to the hash maps of both endpoints
-  Point[0]->AddLine(this);
-  Point[1]->AddLine(this);
+  Point[0]->AddLine(this); //Taken out, to check whether we can avoid unwanted double adding.
+  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;
-      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) );
+        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));
   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 =================================
@@ -97 +128 @@
 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
@@ -110 +144 @@
   // 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 
-    }
+  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);
-    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)
+        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)
 {
   // 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(&NormalVector) > 0)
+  if (endpoints[0]->node->x.Projection(&OtherVector) > 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 =================================
@@ -174 +226 @@
  * \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.
@@ -201 +261 @@
  * \param *mol molecule structure representing the cluster
  */
-Boundaries * GetBoundaryPoints(ofstream *out, molecule *mol)
+Boundaries *
+GetBoundaryPoints(ofstream *out, molecule *mol)
 {
   atom *Walker = NULL;
@@ -207 +268 @@
   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) {
-      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;
+  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;
+      // 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;
+                    }
+                }
+            }
         }
-        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.
@@ -375 +469 @@
  * \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;
-      }
-    }
-  }
-  *out << Verbose(0) << "RESULT: The biggest diameters are " << GreatestDiameter[0] << " and " << GreatestDiameter[1] << " and " << GreatestDiameter[2] << " " << (IsAngstroem ? "angstrom" : "atomiclength") << "." << 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;
 
   // 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, config *configuration, Boundaries *BoundaryPtr, molecule *mol) 
+double
+VolumeOfConvexEnvelope(ofstream *out, ofstream *tecplot, config *configuration,
+    Boundaries *BoundaryPtr, molecule *mol)
 {
   bool IsAngstroem = configuration->GetIsAngstroem();
@@ -469 +690 @@
   double volume = 0.;
   double PyramidVolume = 0.;
-  double G,h;
-  Vector x,y;
-  double a,b,c;
+  double G, h;
+  Vector x, y;
+  double a, b, c;
+
+  //Find_non_convex_border(out, tecplot, *TesselStruct, mol); // Is now called from command line.
 
   // 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;
-  }
-  
+  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;
+  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;
   // 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);
-  }
+  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);
 
   // 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.
@@ -564 +815 @@
  * \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();
@@ -574 +827 @@
   double clustervolume;
   if (ClusterVolume == 0)
-    clustervolume = VolumeOfConvexEnvelope(out, configuration, BoundaryPoints, mol);
-  else 
+    clustervolume = VolumeOfConvexEnvelope(out, NULL, 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];
 
@@ -587 +843 @@
   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);
-  } 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 = (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
+        }
+
+      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 ===========================================
@@ -648 +934 @@
 Tesselation::Tesselation()
 {
-  PointsOnBoundaryCount = 0; 
-  LinesOnBoundaryCount = 0; 
+  PointsOnBoundaryCount = 0;
+  LinesOnBoundaryCount = 0;
   TrianglesOnBoundaryCount = 0;
-};
+  TriangleFilesWritten = 0;
+}
+;
 
 /** Constructor of class Tesselation.
@@ -658 +946 @@
 Tesselation::~Tesselation()
 {
-  for (TriangleMap::iterator runner = TrianglesOnBoundary.begin(); runner != TrianglesOnBoundary.end(); runner++) {
-    delete(runner->second);
-  }
-};
+        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;
+        }
+}
+;
 
 /** Gueses first starting triangle of the convex envelope.
@@ -667 +975 @@
  * \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;
-  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. take three smallest distance that form a triangle
-  // we take the smallest distance as the base line
+  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)));
+            }
+        }
+    }
+  //    // 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
   DistanceMultiMap::iterator baseline = DistanceMMap.begin();
-  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;
-};
-
+  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);
+    }
+}
+;
 
 /** Tesselates the convex envelope of a cluster from a single starting triangle.
@@ -749 +1147 @@
  * \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;
@@ -755 +1155 @@
   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;
+  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++;
               }
-            }
+            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
           }
-        // 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;
-};
+        else
+          *out << Verbose(2) << "Baseline candidate " << *(baseline->second)
+              << " has a triangle count of "
+              << baseline->second->TrianglesCount << "." << endl;
+    }
+  while (flag);
+
+}
+;
 
 /** Adds an atom to the tesselation::PointsOnBoundary list.
  * \param *Walker atom to add
  */
-void Tesselation::AddPoint(atom *Walker)
-{
+void
+Tesselation::AddPoint(atom *Walker)
+{
+  PointTestPair InsertUnique;
   BPS[0] = new class BoundaryPointSet(Walker);
-  PointsOnBoundary.insert( PointPair(Walker->nr, BPS[0]) );
-  PointsOnBoundaryCount++;
+  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);
+};
+

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;
 };
@@ -74 +75 @@
 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];
@@ -91 +100 @@
     int LinesOnBoundaryCount;
     int TrianglesOnBoundaryCount;
+    int TriangleFilesWritten;
 };
 
@@ -99 +109 @@
 
 
-double VolumeOfConvexEnvelope(ofstream *out, config *configuration, Boundaries *BoundaryPoints, molecule *mol);
+double VolumeOfConvexEnvelope(ofstream *out, ofstream *tecplot, 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;
+  Vector x, y, helper;
   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
-      mol->SetBoxDimension(&(x+y*2));  // update Box of atoms by boundary
+      helper.CopyVector(&y);
+      helper.Scale(2.);
+      helper.AddVector(&x);
+      mol->SetBoxDimension(&helper);  // update Box of atoms by boundary
       break;
     case 'd':
@@ -327 +330 @@
   cout << Verbose(0) << "INPUT: ";
   cin >> choice;
-  
+
   switch (choice) {
     default:
@@ -346 +349 @@
       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];
@@ -363 +366 @@
         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: ";
@@ -369 +372 @@
       cout << Verbose(0) << endl;
       n.Normalize();
-      break;       
+      break;
   };
   cout << Verbose(0) << "Alignment vector: ";
@@ -385 +388 @@
   Vector n;
   char choice;  // menu choice char
-  
+
   cout << Verbose(0) << "===========MIRROR ATOMS=========================" << endl;
   cout << Verbose(0) << " a - state three atoms defining mirror plane" << endl;
@@ -394 +397 @@
   cout << Verbose(0) << "INPUT: ";
   cin >> choice;
-  
+
   switch (choice) {
     default:
@@ -413 +416 @@
       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: ";
@@ -433 +436 @@
   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;
@@ -442 +445 @@
   cout << Verbose(0) << "INPUT: ";
   cin >> choice;
-  
+
   switch (choice) {
     default:
@@ -475 +478 @@
           mol->RemoveAtom(first);
       }
-      break;          
+      break;
   };
   //mol->Output((ofstream *)&cout);
@@ -492 +495 @@
   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;
@@ -514 +517 @@
       for (int i=MAX_ELEMENTS;i--;)
         min[i] = 0.;
-        
-      second = mol->start;   
+
+      second = mol->start;
       while ((second->next != mol->end)) {
         second = second->next; // advance
@@ -526 +529 @@
         }
         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: ");
@@ -556 +559 @@
       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':
@@ -569 +572 @@
     case 'e':
         cout << Verbose(0) << "Evaluating volume of the convex envelope.";
-        VolumeOfConvexEnvelope((ofstream *)&cout, configuration, NULL, mol);
+        VolumeOfConvexEnvelope((ofstream *)&cout, NULL, configuration, NULL, mol);
         break;
     case 'f':
@@ -600 +603 @@
   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: ";
@@ -609 +612 @@
     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;
 };
@@ -623 +626 @@
   atom *Walker = mol->start;
   int i, comp, counter=0;
-  
+
   // generate some KeySets
   cout << "Generating KeySets." << endl;
@@ -637 +640 @@
   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;
@@ -646 +649 @@
   TestSets[mol->AtomCount].insert(mol->end->previous->previous->previous->nr);
 
-  // constructing Graph structure  
+  // constructing Graph structure
   cout << "Generating Subgraph class." << endl;
   Graph Subgraphs;
@@ -657 +660 @@
   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;
@@ -663 +666 @@
     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;
@@ -674 +677 @@
       if ((*key) > comp)
         cout << (*key) << " ";
-      else 
+      else
         cout << (*key) << "! ";
       comp = (*key);
@@ -694 +697 @@
   char filename[MAXSTRINGSIZE];
   ofstream output;
+  string basis("3-21G");
 
   cout << Verbose(0) << "Storing configuration ... " << endl;
@@ -699 +703 @@
   mol->CalculateOrbitals(*configuration);
   configuration->InitMaxMinStopStep = configuration->MaxMinStopStep = configuration->MaxPsiDouble;
-  if (ConfigFileName != NULL) {
+  strcpy(filename, ConfigFileName);
+  if (ConfigFileName != NULL) { // test the file name
     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(&output, periode, mol))
+  if (configuration->Save(filename, periode, mol))
     cout << "successful." << endl;
   else
     cout << "failed." << endl;
-  output.close();
-  output.clear();
-  
+
   // and save to xyz file
   if (ConfigFileName != NULL) {
@@ -724 +731 @@
     strcat(filename, ".xyz");
     output.open(filename, ios::trunc);
-  } 
+  }
   cout << Verbose(0) << "Saving of XYZ file ";
   if (mol->MDSteps <= 1) {
@@ -739 +746 @@
   output.close();
   output.clear();
-  
+
   // and save as MPQC configuration
-  if (ConfigFileName != NULL) {
+  if (ConfigFileName != NULL)
     strcpy(filename, ConfigFileName);
-    strcat(filename, ".in");
-    output.open(filename, ios::trunc);
-  }
-  if (output == NULL) {
+  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(&output, mol))
+  if (configuration->SaveMPQC(filename, 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;
@@ -790 +789 @@
   int argptr;
   PathToDatabases = LocalPath;
-  
+
   if (argc > 1) { // config file specified as option
     // 1. : Parse options that just set variables or print help
@@ -803 +802 @@
           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;
@@ -817 +818 @@
             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-o\tGet volume of the convex envelope (and store to tecplot file)." << 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-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;
@@ -823 +825 @@
             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;
@@ -841 +843 @@
             break;
           case 'e':
-            cout << "Using " << argv[argptr] << " as elements database." << endl;
-            PathToDatabases = argv[argptr];
-            argptr+=1;
+            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;
+            }
             break;
           case 'n':
@@ -856 +862 @@
         argptr++;
     } while (argptr < argc);
-    
+
     // 2. Parse the element database
     if (periode->LoadPeriodentafel(PathToDatabases)) {
@@ -865 +871 @@
       return 1;
     }
-    
+
     // 3. Find config file name and parse if possible
     if (argv[1][0] != '-') {
@@ -904 +910 @@
     } else
       config_present = absent;
-    
+
     // 4. parse again through options, now for those depending on elements db and config presence
     argptr = 1;
@@ -915 +921 @@
             case 'p':
               ExitFlag = 1;
-              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;
+              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;
+                  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;
-              } else
-                cerr << Verbose(1) << "Could not find the specified element." << endl; 
-              argptr+=4;
+              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;
+              }
               break;
             default:   // no match? Don't step on (this is done in next switch's default)
@@ -948 +964 @@
         if (config_present == present) {
           switch(argv[argptr-1][1]) {
-            case 'D': 
+            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':
               ExitFlag = 1;
               {
@@ -979 +1005 @@
                 delete[](MinimumRingSize);
               }
-              argptr+=1;
+              //argptr+=1;
               break;
             case 'E':
               ExitFlag = 1;
-              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;
+              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;
             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);
@@ -1000 +1063 @@
                 output->close();
                 delete(output);
+                argptr+=1;
               }
-              argptr+=1;
               break;
             case 'L':
@@ -1015 +1078 @@
             case 'P':
               ExitFlag = 1;
-              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;
-                if (configuration.DoConstrainedMD)
-                  // increase source step in expectancy of a new step in the config
-                  configuration.DoConstrainedMD++;
+              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;
               }
-              argptr+=1;
               break;
             case 't':
               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;
+              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;
+              }
               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];
+              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.;
+              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.;
+              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':
@@ -1107 +1192 @@
             case 'f':
               ExitFlag = 1;
-              cout << "Fragmenting molecule with bond distance " << argv[argptr] << " angstroem, order of " << argv[argptr+1] << "." << endl;
-              if (argc >= argptr+2) {
+              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 << Verbose(0) << "Creating connection matrix..." << endl;
                 start = clock();
@@ -1118 +1206 @@
                 end = clock();
                 cout << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
-                argptr+=1;
-              } else {
-                cerr << "Not enough arguments for fragmentation: -f <max. bond distance> <bond order>" << endl;
+                argptr+=2;
               }
               break;
@@ -1139 +1225 @@
             case 'o':
               ExitFlag = 1;
-              SaveFlag = true;
-              cout << Verbose(0) << "Evaluating volume of the convex envelope.";
-              VolumeOfConvexEnvelope((ofstream *)&cout, &configuration, NULL, mol);
+              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;
+              }
               break;
             case 'U':
               ExitFlag = 1;
-              volume = atof(argv[argptr++]);
-              cout << Verbose(0) << "Using " << volume << " angstrom^3 as the volume instead of convex envelope one's." << endl;  
+              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;
+              }
             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;
@@ -1164 +1270 @@
 //                  repetition[i] = 1;
 //                }
-                PrepareClustersinWater((ofstream *)&cout, &configuration, mol, volume, density);
+                PrepareClustersinWater((ofstream *)&cout, &configuration, mol, volume, density);  // if volume == 0, will calculate from ConvexEnvelope
               }
               break;
             case 'd':
               ExitFlag = 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++;
+              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;
                   }
-                  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, ...)
+                  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, ...)
+                      }
+                    }
+                    // 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;
                   }
-                  // 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; 
                 }
               }
@@ -1279 +1390 @@
   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.) {
@@ -1293 +1404 @@
   // 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;
@@ -1312 +1423 @@
     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;
@@ -1324 +1435 @@
     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;
@@ -1347 +1458 @@
         }
         //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: ";
@@ -1361 +1472 @@
        delete[](factor);
        break;
-       
+
       case 'd': // duplicate the periodic cell along a given axis, given times
         cout << Verbose(0) << "State the axis [(+-)123]: ";
@@ -1367 +1478 @@
         cout << Verbose(0) << "State the factor: ";
         cin >> faktor;
-        
+
         mol->CountAtoms((ofstream *)&cout);  // recount atoms
         if (mol->AtomCount != 0) {  // if there is more than none
@@ -1408 +1519 @@
             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;
@@ -1435 +1546 @@
         MirrorAtoms(mol);
         break;
-       
+
       case 'o': // create the connection matrix
         {
@@ -1456 +1567 @@
         }
         break;
-        
+
       case 'p': // parse and XYZ file
         cout << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
@@ -1465 +1576 @@
         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);
@@ -1477 +1588 @@
 
       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;
@@ -1492 +1603 @@
           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

@@ -31 +31 @@
   configpath[0]='\0';
   configname[0]='\0';
+  basis="3-21G";
+  
 
   strcpy(ThermostatNames[0],"None");
@@ -1073 +1075 @@
 
 /** Stores all elements of config structure from which they can be re-read.
- * \param output open output *file stream to write to
+ * \param *filename name of file
  * \param *periode pointer to a periodentafel class with all elements
  * \param *mol pointer to molecule containing all atoms of the molecule 
  */
-bool config::Save(ofstream *output, periodentafel *periode, molecule *mol) const
+bool config::Save(const char *filename, 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;
@@ -1192 +1196 @@
     else
       result = result && mol->OutputTrajectories(output);
+    output->close();
+    output->clear();
+    delete(output);
     return result;
   } else
@@ -1199 +1206 @@
 /** Stores all elements in a MPQC input file.
  * Note that this format cannot be parsed again.
- * \param output open output *file stream to write to
+ * \param *filename name of file (without ".in" suffix!)
  * \param *mol pointer to molecule containing all atoms of the molecule 
  */
-bool config::SaveMPQC(ofstream *output, molecule *mol) const
+bool config::SaveMPQC(const char *filename, molecule *mol) const
 {
   int ElementNo = 0;
   int AtomNo;
   atom *Walker = NULL;
-  element *runner = mol->elemente->start;
+  element *runner = NULL;
   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;
@@ -1215 +1228 @@
   *output << "\tdo_gradient = yes" << endl;
   *output << "\tmole<CLHF>: (" << endl;
-  *output << "\t\tmolecule<Molecule>: (" << endl;
-  *output << "\t\t\tunit = " << (IsAngstroem ? "angstrom" : "bohr" ) << endl;
-  *output << "\t\t\t{ atoms geometry } = {" << 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;
   center = mol->DetermineCenterOfAll(output);
   // output of atoms
+  runner = mol->elemente->start;
   while (runner->next != mol->elemente->end) { // go through every element
     runner = runner->next;
@@ -1230 +1249 @@
         if (Walker->type == runner) { // if this atom fits to element
           AtomNo++;
-          *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;
+          *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;
         }
       }
@@ -1236 +1255 @@
   }
   delete(center);
-  *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 << "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)" << 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
@@ -45 +63 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "#Order\tFrag.No.\t" << Fragments.Header << endl;
+  output << "#Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << 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;k--;)
+        for(int k=Fragments.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];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;l++)
+    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
       output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter]-1 ][l];
     output << endl;
@@ -78 +96 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "#Order\tFrag.No.\t" << Fragments.Header << endl;
+  output << "#Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << 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;k--;)
+        for(int k=Fragments.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];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;l++)
+    for (int l=0;l<Fragments.ColumnCounter[Energy.MatrixCounter];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];
@@ -115 +133 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "# Order\tFrag.No.\t" << Fragments.Header << endl;
+  output << "# Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
   Fragments.SetLastMatrix(0.,0);
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
@@ -121 +139 @@
     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
     CreateForce(Fragments, Fragments.MatrixCounter);
-    for (int l=0;l<Fragments.ColumnCounter;l++)
+    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
        output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter] ][l];
     output << endl;
@@ -147 +165 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "# Order\tFrag.No.\t" << Fragments.Header << endl;
+  output << "# Order\tFrag.No.\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
   Fragments.SetLastMatrix(Force.Matrix[Force.MatrixCounter],0);
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
@@ -153 +171 @@
     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
     CreateForce(Fragments, Fragments.MatrixCounter);
-    for (int l=0;l<Fragments.ColumnCounter;l++)
+    for (int l=0;l<Fragments.ColumnCounter[Fragments.MatrixCounter];l++)
        output << scientific << "\t" << Fragments.Matrix[Fragments.MatrixCounter][ Fragments.RowCounter[Fragments.MatrixCounter] ][l];
     output << endl;
@@ -180 +198 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "# AtomNo\t" << Fragments.Header << endl;
+  output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << endl;
   Fragments.SetLastMatrix(Force.Matrix[Force.MatrixCounter], 0);
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
@@ -186 +204 @@
     Fragments.SumSubForces(Fragments, KeySet, BondOrder, -1.);
     // errors per atom
-    output << "#Order\t" << BondOrder+1 << endl;
+    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;l++) {
+      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++) {
         if (((l+1) % 3) == 0) {
           norm = 0.;
@@ -226 +244 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "# AtomNo\t" << Fragments.Header << endl;
+  output << "# AtomNo\t" << Fragments.Header[Fragments.MatrixCounter] << 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 << "#Order\t" << BondOrder+1 << endl;
+    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;l++)
+      for (int l=0;l<Fragments.ColumnCounter[ Fragments.MatrixCounter ];l++)
         output << scientific << Fragments.Matrix[Fragments.MatrixCounter][ j ][l] << "\t";
       output << endl;
@@ -244 +262 @@
 };
 
+
+/** 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.
  */
@@ -255 +393 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum << endl;
-  output << "#Order\tFrag.No.\t" << Fragment.Header << endl;
+  output << "#Order\tFrag.No.\t" << Fragment.Header[ Fragment.MatrixCounter ] << 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;l++)
+      for (int l=0;l<Fragment.ColumnCounter[ KeySet.OrderSet[BondOrder][i] ];l++)
         output << scientific << "\t" << Fragment.Matrix[ KeySet.OrderSet[BondOrder][i] ][ Fragment.RowCounter[ KeySet.OrderSet[BondOrder][i] ] ][l];
       output << endl;
@@ -279 +417 @@
     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;k--;)
+        for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
           Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
       }
@@ -296 +434 @@
     int i=0;
     do {  // first get a minimum value unequal to 0
-      for (int k=Fragments.ColumnCounter;k--;)
+      for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
         Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
       i++;
@@ -302 +440 @@
     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;k--;)
+        for (int k=Fragments.ColumnCounter[ Fragments.MatrixCounter ];k--;)
           Fragments.Matrix[ Fragments.MatrixCounter ][j][k] = Fragments.Matrix[ KeySet.OrderSet[BondOrder][i] ][j][k];
       }
@@ -320 +458 @@
   cout << msg << endl;
   output << "# " << msg << ", created on " << datum;
-  output << "#Order\tFrag.No.\t" << Fragment.Header << endl;
+  output << "#Order\tFrag.No.\t" << Fragment.Header[ Fragment.MatrixCounter ] << endl;
   // max
   for (int BondOrder=0;BondOrder<KeySet.Order;BondOrder++) {
@@ -326 +464 @@
     CreateFragmentOrder(Fragment, KeySet, BondOrder);
     output << BondOrder+1 << "\t" << KeySet.FragmentsPerOrder[BondOrder];
-    for (int l=0;l<Fragment.ColumnCounter;l++)
+    for (int l=0;l<Fragment.ColumnCounter[ Fragment.MatrixCounter ];l++)
       output << scientific << "\t" << Fragment.Matrix[ Fragment.MatrixCounter ][ Fragment.RowCounter[ Fragment.MatrixCounter ]-1 ][l];
     output << endl;
@@ -340 +478 @@
 void CreateEnergy(class MatrixContainer &Energy, int MatrixNumber)
 {
-  for(int k=0;k<Energy.ColumnCounter;k++)
+  for(int k=0;k<Energy.ColumnCounter[MatrixNumber];k++)
     Energy.Matrix[MatrixNumber][ Energy.RowCounter[MatrixNumber] ] [k] =  Energy.Matrix[MatrixNumber][ Energy.RowCounter[MatrixNumber]-1 ] [k];
 };
@@ -351 +489 @@
 void CreateMinimumForce(class MatrixContainer &Force, int MatrixNumber)
 {
-  for (int l=Force.ColumnCounter;l--;)
+  for (int l=Force.ColumnCounter[MatrixNumber];l--;)
     Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
-  for (int l=5;l<Force.ColumnCounter;l+=3) {
+  for (int l=5;l<Force.ColumnCounter[MatrixNumber];l+=3) {
     double stored = 0;
     int k=0;
@@ -386 +524 @@
 {
   int divisor = 0;
-  for (int l=Force.ColumnCounter;l--;)
+  for (int l=Force.ColumnCounter[MatrixNumber];l--;)
     Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
-  for (int l=5;l<Force.ColumnCounter;l+=3) {
+  for (int l=5;l<Force.ColumnCounter[MatrixNumber];l+=3) {
     double tmp = 0;
     for (int k=Force.RowCounter[MatrixNumber];k--;) {
@@ -410 +548 @@
 void CreateMaximumForce(class MatrixContainer &Force, int MatrixNumber)
 {
-  for (int l=5;l<Force.ColumnCounter;l+=3) {
+  for (int l=5;l<Force.ColumnCounter[MatrixNumber];l+=3) {
     double stored = 0;
     for (int k=Force.RowCounter[MatrixNumber];k--;) {
@@ -442 +580 @@
 void CreateVectorSumForce(class MatrixContainer &Force, int MatrixNumber)
 {
-  for (int l=Force.ColumnCounter;l--;)
+  for (int l=Force.ColumnCounter[MatrixNumber];l--;)
     Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] = 0.;
-  for (int l=0;l<Force.ColumnCounter;l++) {
+  for (int l=0;l<Force.ColumnCounter[MatrixNumber];l++) {
     for (int k=Force.RowCounter[MatrixNumber];k--;)
       Force.Matrix[MatrixNumber][ Force.RowCounter[MatrixNumber] ][l] += Force.Matrix[MatrixNumber][k][l];
@@ -520 +658 @@
 void AbsEnergyPlotLine(ofstream &output, class MatrixContainer &Energy, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Energy.Header);
+  stringstream line(Energy.Header[ Energy.MatrixCounter ]);
   string token;
 
   getline(line, token, '\t');
-  for (int i=2; i<= Energy.ColumnCounter;i++) {
+  for (int i=2; i<= Energy.ColumnCounter[Energy.MatrixCounter];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))
+    if (i != (Energy.ColumnCounter[Energy.MatrixCounter]))
       output << ", \\";
     output << endl;
@@ -544 +682 @@
 void EnergyPlotLine(ofstream &output, class MatrixContainer &Energy, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Energy.Header);
+  stringstream line(Energy.Header[Energy.MatrixCounter]);
   string token;
 
   getline(line, token, '\t');
-  for (int i=1; i<= Energy.ColumnCounter;i++) {
+  for (int i=1; i<= Energy.ColumnCounter[Energy.MatrixCounter];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))
+    if (i != (Energy.ColumnCounter[Energy.MatrixCounter]))
       output << ", \\";
     output << endl;
@@ -568 +706 @@
 void ForceMagnitudePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Force.Header);
+  stringstream line(Force.Header[Force.MatrixCounter]);
   string token;
 
@@ -576 +714 @@
   getline(line, token, '\t');
   getline(line, token, '\t');
-  for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
+  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
     getline(line, token, '\t');
     while (token[0] == ' ') // remove leading white spaces
@@ -582 +720 @@
     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-1))
+    if (i != (Force.ColumnCounter[Force.MatrixCounter]-1))
       output << ", \\";
     output << endl;
@@ -599 +737 @@
 void AbsFirstForceValuePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Force.Header);
+  stringstream line(Force.Header[Force.MatrixCounter]);
   string token;
 
@@ -607 +745 @@
   getline(line, token, '\t');
   getline(line, token, '\t');
-  for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
+  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
     getline(line, token, '\t');
     while (token[0] == ' ') // remove leading white spaces
@@ -613 +751 @@
     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-1))
+    if (i != (Force.ColumnCounter[Force.MatrixCounter]-1))
       output << ", \\";
     output << endl;
@@ -630 +768 @@
 void BoxesForcePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Force.Header);
+  stringstream line(Force.Header[Force.MatrixCounter]);
   char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
   string token;
@@ -639 +777 @@
   getline(line, token, '\t');
   getline(line, token, '\t');
-  for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
+  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
     getline(line, token, '\t');
     while (token[0] == ' ') // remove leading white spaces
@@ -645 +783 @@
     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-1))
+    if (i != (Force.ColumnCounter[Force.MatrixCounter]-1))
       output << ", \\";
     output << endl;
@@ -662 +800 @@
 void BoxesFirstForceValuePlotLine(ofstream &output, class MatrixContainer &Force, const char *prefix, const char *xargument, const char *uses)
 {
-  stringstream line(Force.Header);
+  stringstream line(Force.Header[Force.MatrixCounter]);
   char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
   string token;
@@ -671 +809 @@
   getline(line, token, '\t');
   getline(line, token, '\t');
-  for (int i=7; i< Force.ColumnCounter;i+=NDIM) {
+  for (int i=7; i< Force.ColumnCounter[Force.MatrixCounter];i+=NDIM) {
     getline(line, token, '\t');
     while (token[0] == ' ') // remove leading white spaces
@@ -677 +815 @@
     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-1))
+    if (i != (Force.ColumnCounter[Force.MatrixCounter]-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); 
@@ -25 +26 @@
 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/graph.cpp

@@ -7 +7 @@
 using namespace std;
 
+#include "graph.hpp"
 
-#include <iostream>
-#include <list>
-#include <vector>
+/***************************************** Implementations for graph classes ********************************/
 
-/***************************************** Functions for class graph ********************************/
+/** Constructor of class Graph.
+ */
+Graph::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 EnergyFragments;
+  
   EnergyMatrix Hcorrection;
+  EnergyMatrix HcorrectionFragments;
+  
   ForceMatrix Force;
-  EnergyMatrix EnergyFragments;
-  EnergyMatrix HcorrectionFragments;
   ForceMatrix ForceFragments;
+
+  HessianMatrix Hessian;
+  HessianMatrix HessianFragments;
+  
   ForceMatrix Shielding;
   ForceMatrix ShieldingPAS;
   ForceMatrix ShieldingFragments;
   ForceMatrix ShieldingPASFragments;
+  EnergyMatrix Chi;
+  EnergyMatrix ChiPAS;
+  EnergyMatrix ChiFragments;
+  EnergyMatrix ChiPASFragments;
   KeySetsContainer KeySet;  
   stringstream prefix;
   char *dir = NULL;
-  bool Hcorrected = true;
+  bool NoHCorrection = false;
+  bool NoHessian = false;
 
   cout << "Joiner" << endl;
@@ -61 +72 @@
   // ------------- Parse through all Fragment subdirs --------
   if (!Energy.ParseFragmentMatrix(argv[1], dir, EnergySuffix, 0,0)) return 1;
-  Hcorrected = Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX, 0,0);
+  if (!Hcorrection.ParseFragmentMatrix(argv[1], "", HCORRECTIONSUFFIX, 0,0)) {
+    NoHCorrection = true;
+    cout << "No HCorrection matrices found, skipping these." << endl;
+  }
   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.ParseIndices()) return 1;
-  if (Hcorrected) Hcorrection.ParseIndices();
+  if (!Energy.InitialiseIndices()) return 1;
+  if (!NoHCorrection) 
+    Hcorrection.InitialiseIndices();
   
   // ---------- 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 ---------------
   if (periode != NULL) { // also look for PAS values
     if(!Shielding.ParseIndices(argv[1])) return 1;
     if(!ShieldingPAS.ParseIndices(argv[1])) return 1;
+    //if(!Chi.ParseIndices()) return 1;
+    //if(!ChiPAS.ParseIndices()) 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 (Hcorrected)  HcorrectionFragments.AllocateMatrix(Hcorrection.Header, Hcorrection.MatrixCounter, Hcorrection.RowCounter, Hcorrection.ColumnCounter);
+  if (!NoHCorrection)  
+    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;
   }
   
@@ -96 +128 @@
   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;
   }
 
@@ -108 +144 @@
     cout << "Summing energy of order " << BondOrder+1 << " ..." << endl;
     if (!EnergyFragments.SumSubManyBodyTerms(Energy, KeySet, BondOrder)) return 1;
-    if (Hcorrected) { 
+    if (!NoHCorrection) { 
       HcorrectionFragments.SumSubManyBodyTerms(Hcorrection, KeySet, BondOrder);
       if (!Energy.SumSubEnergy(EnergyFragments, &HcorrectionFragments, KeySet, BondOrder, 1.)) return 1;
-      if (Hcorrected) Hcorrection.SumSubEnergy(HcorrectionFragments, NULL, KeySet, BondOrder, 1.);
+      Hcorrection.SumSubEnergy(HcorrectionFragments, NULL, KeySet, BondOrder, 1.);
     } else 
       if (!Energy.SumSubEnergy(EnergyFragments, NULL, KeySet, BondOrder, 1.)) return 1;
@@ -118 +154 @@
     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 of order " << BondOrder+1 << " ..." << endl;
+      cout << "Summing shieldings and susceptibilities 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.SumSubEnergy(ChiFragments, NULL, KeySet, BondOrder, 1.)) return 1;
+      if (!ChiPASFragments.SumSubManyBodyTerms(ChiPAS, KeySet, BondOrder)) return 1;
+      if (!ChiPAS.SumSubEnergy(ChiPASFragments, NULL,KeySet, BondOrder, 1.)) return 1;
     }
 
@@ -134 +180 @@
     // 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;
     }
   }
@@ -144 +195 @@
   prefix << dir << EnergyFragmentSuffix;
   if (!EnergyFragments.WriteTotalFragments(argv[1], (prefix.str()).c_str())) return 1;
-  if (Hcorrected) {
+  if (!NoHCorrection) {
     prefix.str(" ");
     prefix << dir << HcorrectionFragmentSuffix;
@@ -153 +204 @@
   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(" ");
@@ -160 +216 @@
     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 (Hcorrected) Hcorrection.WriteLastMatrix(argv[1], dir, HcorrectionFragmentSuffix);
+  if (!NoHCorrection) 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
@@ -455 +456 @@
     // 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(&outputFragment, ListOfMolecules[i]->elemente, ListOfMolecules[i])))
+    if ((intermediateResult = configuration->Save(FragmentName, 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(&outputFragment, ListOfMolecules[i])))
+    if ((intermediateResult = configuration->SaveMPQC(FragmentName, ListOfMolecules[i])))
       *out << " done." << endl;
     else
@@ -479 +476 @@
        
     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) << "WARNING: There is no typical bond distance for bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") of degree " << TopBond->BondDegree << "!" << endl;
-    BondRescale = bondlength; 
+    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;
   } else {
     if (!IsAngstroem)
@@ -272 +273 @@
       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);
@@ -285 +286 @@
       Orthovector1.Normalize();
       //*out << Verbose(3) << "ReScaleCheck: " << Orthovector1.Norm() << " and " << InBondvector.Norm() << "." << endl;
-      
+
       // create the two Hydrogens ...
       FirstOtherAtom = new atom();
@@ -299 +300 @@
       bondangle = TopOrigin->type->HBondAngle[1];
       if (bondangle == -1) {
-        *out << Verbose(3) << "WARNING: There is no typical bond angle for bond (" << TopOrigin->Name << "<->" << TopReplacement->Name << ") of degree " << TopBond->BondDegree << "!" << endl;
+        *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;
         bondangle = 0;
       }
@@ -316 +318 @@
         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];
       }
@@ -363 +365 @@
 //      *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
@@ -378 +380 @@
       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);
 
@@ -435 +437 @@
  */
 bool molecule::AddXYZFile(string filename)
-{ 
+{
   istringstream *input = NULL;
   int NumberOfAtoms = 0; // atom number in xyz read
@@ -444 +446 @@
   string line;    // currently parsed line
   double x[3];    // atom coordinates
-  
+
   xyzfile.open(filename.c_str());
   if (!xyzfile)
@@ -452 +454 @@
   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++;
@@ -489 +491 @@
   xyzfile.close();
   delete(input);
-  return true; 
+  return true;
 };
 
@@ -501 +503 @@
   atom *LeftAtom = NULL, *RightAtom = NULL;
   atom *Walker = NULL;
-  
+
   // copy all atoms
   Walker = start;
@@ -508 +510 @@
     CurrentAtom = copy->AddCopyAtom(Walker);
   }
-  
+
   // copy all bonds
   bond *Binder = first;
@@ -532 +534 @@
       copy->NoCyclicBonds++;
     NewBond->Type = Binder->Type;
-  }  
+  }
   // correct fathers
   Walker = copy->start;
@@ -549 +551 @@
     copy->CreateListOfBondsPerAtom((ofstream *)&cout);
   }
-  
+
   return copy;
 };
@@ -574 +576 @@
 
 /** 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
@@ -586 +588 @@
 
 /** 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
@@ -619 +621 @@
   Vector *min = new Vector;
   Vector *max = new Vector;
-  
+
   // gather min and max for each axis
   ptr = start->next;  // start at first in list
@@ -665 +667 @@
 {
   Vector *min = new Vector;
-  
+
 //  *out << Verbose(3) << "Begin of CenterEdge." << endl;
   atom *ptr = start->next;  // start at first in list
@@ -681 +683 @@
       }
     }
-//    *out << Verbose(4) << "Maximum is "; 
+//    *out << Verbose(4) << "Maximum is ";
 //    max->Output(out);
 //    *out << ", Minimum is ";
@@ -689 +691 @@
     max->AddVector(min);
     Translate(min);
-  } 
+  }
   delete(min);
 //  *out << Verbose(3) << "End of CenterEdge." << endl;
-}; 
+};
 
 /** Centers the center of the atoms at (0,0,0).
@@ -702 +704 @@
   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.
@@ -727 +729 @@
   Vector tmp;
   double Num = 0;
-  
+
   a->Zero();
 
@@ -735 +737 @@
       Num += 1.;
       tmp.CopyVector(&ptr->x);
-      a->AddVector(&tmp);       
+      a->AddVector(&tmp);
     }
     a->Scale(-1./Num); // divide through total mass (and sign for direction)
@@ -755 +757 @@
         Vector tmp;
   double Num = 0;
-        
+
         a->Zero();
 
@@ -764 +766 @@
       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)
@@ -787 +789 @@
     Translate(center);
   }
-}; 
+};
 
 /** Scales all atoms by \a *factor.
@@ -801 +803 @@
       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.
  */
@@ -816 +818 @@
       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.
  */
@@ -831 +833 @@
       Trajectories[ptr].R.at(j).Mirror(n);
     ptr->x.Mirror(n);
-  }      
+  }
 };
 
@@ -845 +847 @@
   bool flag;
   Vector Testvector, Translationvector;
-  
+
   do {
     Center.Zero();
@@ -861 +863 @@
           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;
@@ -877 +879 @@
         cout << Verbose(1) << "vector is: ";
         Testvector.Output((ofstream *)&cout);
-        cout << endl;     
+        cout << endl;
 #ifdef ADDHYDROGEN
         // now also change all hydrogens
@@ -890 +892 @@
             cout << Verbose(1) << "Hydrogen vector is: ";
             Testvector.Output((ofstream *)&cout);
-            cout << endl;     
+            cout << endl;
           }
         }
@@ -912 +914 @@
 
         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) {
@@ -941 +943 @@
         }
         *out << endl;
-        
+
         // diagonalize to determine principal axis system
         gsl_eigen_symmv_workspace *T = gsl_eigen_symmv_alloc(NDIM);
@@ -950 +952 @@
         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;
@@ -970 +972 @@
 
           // 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;
@@ -1000 +1002 @@
     *out << endl;
         }
-        
+
         // free everything
         delete(CenterOfGravity);
@@ -1489 +1491 @@
 {
   atom *walker = NULL;
-  int AtomNo;
   ifstream input(file);
   string token;
   stringstream item;
-  double a, IonMass, Vector[NDIM], ConstrainedPotentialEnergy, ActualTemp;
+  double IonMass, Vector[NDIM], ConstrainedPotentialEnergy, ActualTemp;
   ForceMatrix Force;
 
   CountElements();  // make sure ElementsInMolecule is up to date
-  
+
   // check file
   if (input == NULL) {
@@ -1578 +1579 @@
     }
   }
+  // correct velocities (rather momenta) so that center of mass remains motionless
   for(int d=0;d<NDIM;d++)
     Vector[d] /= IonMass;
@@ -1592 +1594 @@
   MDSteps++;
 
-  
+
   // exit
   return true;
 };
-
 
 /** Implementation of various thermostats.
@@ -1785 +1786 @@
     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];
@@ -1800 +1801 @@
   n->Output((ofstream *)&cout);
   cout << endl;
-  
+
   // rotate on z-y plane
   ptr = start;
@@ -1808 +1809 @@
     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);
@@ -1831 +1832 @@
  * \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--;
@@ -1846 +1847 @@
  * \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));
 };
 
@@ -1862 +1863 @@
   } else {
     cout << Verbose(0) << "Atom not found in list." << endl;
-    return NULL;  
+    return NULL;
   }
 };
@@ -1911 +1912 @@
   struct lsq_params *par = (struct lsq_params *)params;
   atom *ptr = par->mol->start;
-  
+
   // initialize vectors
   a.x[0] = gsl_vector_get(x,0);
@@ -1941 +1942 @@
 {
     int np = 6;
-    
+
    const gsl_multimin_fminimizer_type *T =
      gsl_multimin_fminimizer_nmsimplex;
@@ -1947 +1948 @@
    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);
@@ -1968 +1969 @@
    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++)
@@ -2001 +2002 @@
      }
    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));
@@ -2018 +2019 @@
   int ElementNo, AtomNo;
   CountElements();
-  
+
   if (out == NULL) {
     return false;
@@ -2053 +2054 @@
   int ElementNo, AtomNo;
   CountElements();
-  
+
   if (out == NULL) {
     return false;
@@ -2100 +2101 @@
   atom *Walker = start;
   while (Walker->next != end) {
-    Walker = Walker->next; 
+    Walker = Walker->next;
 #ifdef ADDHYDROGEN
     if (Walker->type->Z != 1) {   // regard only non-hydrogen
@@ -2131 +2132 @@
   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;
@@ -2158 +2159 @@
 {
   atom *walker = NULL;
-  int No = 0;
+  int AtomNo = 0, ElementNo;
   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;
-    No++;
+    AtomNo++;
   }
   if (out != NULL) {
-    *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);
+    *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);
+          }
+        }
+      }
     }
     return true;
@@ -2203 +2215 @@
               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");
@@ -2211 +2223 @@
             }
     } else
-        *out << Verbose(3) << "AtomCount is still " << AtomCount << ", thus counting nothing." << endl; 
+        *out << Verbose(3) << "AtomCount is still " << AtomCount << ", thus counting nothing." << endl;
   }
 };
@@ -2223 +2235 @@
         ElementsInMolecule[i] = 0;
         ElementCount = 0;
-        
+
   atom *walker = start;
   while (walker->next != end) {
@@ -2259 +2271 @@
     Binder = Binder->next;
     if (Binder->Cyclic)
-      No++;    
+      No++;
   }
   delete(BackEdgeStack);
@@ -2317 +2329 @@
 
 /** 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:
@@ -2336 +2396 @@
 void molecule::CreateAdjacencyList(ofstream *out, double bonddistance, bool IsAngstroem)
 {
+
   atom *Walker = NULL, *OtherWalker = NULL, *Candidate = NULL;
   int No, NoBonds, CandidateBondNo;
@@ -2344 +2405 @@
   Vector x;
   int FalseBondDegree = 0;
- 
+  
   BondDistance = bonddistance; // * ((IsAngstroem) ? 1. : 1./AtomicLengthToAngstroem);
   *out << Verbose(0) << "Begin of CreateAdjacencyList." << endl;
@@ -2351 +2412 @@
     cleanup(first,last);
   }
-        
+
   // count atoms in molecule = dimension of matrix (also give each unique name and continuous numbering)
   CountAtoms(out);
@@ -2370 +2431 @@
     for (int i=NumberCells;i--;)
       CellList[i] = NULL;
-  
+
     // 2b. put all atoms into its corresponding list
     Walker = start;
@@ -2391 +2452 @@
       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]--;)
@@ -2409 +2471 @@
               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]++)
@@ -2441 +2503 @@
           }
         }
+
+
+
     // 4. free the cell again
     for (int i=NumberCells;i--;)
@@ -2447 +2512 @@
       }
     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
@@ -2509 +2574 @@
     *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.
@@ -2533 +2601 @@
   bond *Binder = NULL;
   bool BackStepping = false;
-  
+
   *out << Verbose(0) << "Begin of DepthFirstSearchAnalysis" << endl;
-  
+
   ResetAllBondsToUnused();
   ResetAllAtomNumbers();
@@ -2548 +2616 @@
     LeafWalker->Leaf = new molecule(elemente);
     LeafWalker->Leaf->AddCopyAtom(Root);
-    
+
     OldGraphNr = CurrentGraphNr;
     Walker = Root;
@@ -2559 +2627 @@
           AtomStack->Push(Walker);
           CurrentGraphNr++;
-        }      
+        }
         do { // (3) if Walker has no unused egdes, go to (5)
           BackStepping = false; // reset backstepping flag for (8)
@@ -2593 +2661 @@
           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) {
@@ -2641 +2709 @@
         } while (OtherAtom != Walker);
         ComponentNumber++;
-    
+
         // (11) Root is separation vertex,  set Walker to Root and go to (4)
         Walker = Root;
@@ -2654 +2722 @@
 
     // 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;
@@ -2662 +2730 @@
       //*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;
     }
   }
@@ -2684 +2752 @@
     *out << " with Lowpoint " << Walker->LowpointNr << " and Graph Nr. " << Walker->GraphNr << "." << endl;
   }
-  
+
   *out << Verbose(1) << "Final graph info for each bond is:" << endl;
   Binder = first;
@@ -2695 +2763 @@
     *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;
@@ -2710 +2778 @@
  * 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!
@@ -2721 +2789 @@
   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;
@@ -2733 +2801 @@
     ColorList[i] = white;
   }
-  
+ 
   *out << Verbose(1) << "Back edge list - ";
   BackEdgeStack->Output(out);
-  
+
   *out << Verbose(1) << "Analysing cycles ... " << endl;
   NumCycles = 0;
@@ -2742 +2810 @@
     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
@@ -2758 +2826 @@
         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
@@ -2767 +2835 @@
               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;
@@ -2777 +2845 @@
             if (OtherAtom == Root)
               break;
-#ifdef ADDHYDROGEN          
+#ifdef ADDHYDROGEN
           } else {
             *out << Verbose(2) << "Skipping hydrogen atom " << *OtherAtom << "." << endl;
@@ -2815 +2883 @@
       }
     } 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
@@ -2843 +2911 @@
       *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()){
@@ -2853 +2921 @@
   }
   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;
@@ -2894 +2962 @@
           }
           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()){
@@ -2945 +3013 @@
 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] << "  ";
 };
@@ -3023 +3091 @@
 {
   int c = 0;
-  int FragmentCount; 
+  int FragmentCount;
   // get maximum bond degree
   atom *Walker = start;
@@ -3033 +3101 @@
   *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
  */
@@ -3046 +3114 @@
   int AtomNr;
   int status = 0;
-  
+
   line.str(buffer);
   while (!line.eof()) {
@@ -3082 +3150 @@
   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;
@@ -3115 +3183 @@
     status = false;
   }
-  
+
   // 2nd pass: open TEFactors file and read
   *out << Verbose(1) << "Parsing the TEFactors file ... " << endl;
@@ -3127 +3195 @@
         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;
@@ -3168 +3236 @@
   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";
@@ -3234 +3302 @@
     status = false;
   }
-  
+
   return status;
 };
@@ -3243 +3311 @@
  * \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)
 {
@@ -3250 +3318 @@
   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);
@@ -3309 +3377 @@
   *out << endl;
   Free((void **)&buffer, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
-  
+
   return status;
 };
@@ -3331 +3399 @@
   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
@@ -3371 +3439 @@
           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;
 
@@ -3380 +3448 @@
             // 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);
@@ -3421 +3489 @@
         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
@@ -3459 +3527 @@
     if ((Order == 0) && (AtomMask[AtomCount] == false))  // single stepping, just check
       status = true;
-      
+
     if (!status) {
       if (Order == 0)
@@ -3467 +3535 @@
     }
   }
-  
+
   // print atom mask for debugging
   *out << "              ";
@@ -3476 +3544 @@
     *out << (AtomMask[i] ? "t" : "f");
   *out << endl;
- 
+
   return status;
 };
@@ -3490 +3558 @@
   int AtomNo = 0;
   atom *Walker = NULL;
-  
+
   if (SortIndex != NULL) {
     *out << Verbose(1) << "SortIndex is " << SortIndex << " and not NULL as expected." << endl;
@@ -3548 +3616 @@
   atom **ListOfAtoms = NULL;
   atom ***ListOfLocalAtoms = NULL;
-  bool *AtomMask = NULL; 
-  
+  bool *AtomMask = NULL;
+
   *out << endl;
 #ifdef ADDHYDROGEN
@@ -3558 +3626 @@
 
   // ++++++++++++++++++++++++++++ INITIAL STUFF: Bond structure analysis, file parsing, ... ++++++++++++++++++++++++++++++++++++++++++
-  
+
   // ===== 1. Check whether bond structure is same as stored in files ====
-  
+
   // fill the adjacency list
   CreateListOfBondsPerAtom(out);
@@ -3566 +3634 @@
   // 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");
 
@@ -3591 +3659 @@
 //      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);
   }
@@ -3614 +3685 @@
     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));
 
@@ -3623 +3694 @@
       MolecularWalker = MolecularWalker->next;
       *out << Verbose(1) << "Fragmenting subgraph " << MolecularWalker << "." << endl;
-      // output ListOfBondsPerAtom for debugging
-      MolecularWalker->Leaf->OutputListOfBonds(out);
+      //MolecularWalker->Leaf->OutputListOfBonds(out);  // output ListOfBondsPerAtom for debugging
       if (MolecularWalker->Leaf->first->next != MolecularWalker->Leaf->last) {
-      
         // call BOSSANOVA method
         *out << Verbose(0) << endl << " ========== BOND ENERGY of subgraph " << FragmentCounter << " ========================= " << endl;
@@ -3646 +3715 @@
   // ===== 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;
@@ -3671 +3740 @@
     }
     *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))
@@ -3682 +3751 @@
       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;
@@ -3736 +3805 @@
   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 ... 
-      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;
-      }
-    }
+    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;
+            }
+        }
     Binder = ReferenceStack->PopFirst();  // loop the stack for next item
+    *out << Verbose(3) << "Current candidate edge " << Binder << "." << endl;
     ReferenceStack->Push(Binder);
   } while (FirstBond != Binder);
@@ -3824 +3894 @@
       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();
@@ -3835 +3905 @@
   Free((void **)&OrderArray, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
   Free((void **)&MaxArray, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
-  
+
   *out << Verbose(1) << "End of ParseOrderAtSiteFromFile" << endl;
   return status;
@@ -3901 +3971 @@
     }
     *out << " -- TotalDegree: " << TotalDegree << endl;
-  }      
+  }
   *out << Verbose(1) << "End of Creating ListOfBondsPerAtom." << endl << endl;
 };
@@ -3907 +3977 @@
 /** 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
@@ -3916 +3986 @@
  * \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)
 {
@@ -3942 +4012 @@
   }
   ShortestPathList[Root->nr] = 0;
-  
+
   // and go on ... Queue always contains all lightgray vertices
   while (!AtomStack->IsEmpty()) {
@@ -3950 +4020 @@
     // 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];
@@ -3957 +4027 @@
         *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);
@@ -3999 +4069 @@
               } else {
 #ifdef ADDHYDROGEN
-                Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem);
+                if (!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
+                  exit(1);
 #endif
               }
@@ -4008 +4079 @@
           // 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;
@@ -4014 +4085 @@
             } else { // if it's root bond it has to broken (otherwise we would not create the fragments)
 #ifdef ADDHYDROGEN
-              Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem);
+              if(!Mol->AddHydrogenReplacementAtom(out, Binder, AddedAtomList[Walker->nr], Walker, OtherAtom, ListOfBondsPerAtom[Walker->nr], NumberOfBondsPerAtom[Walker->nr], IsAngstroem))
+                exit(1);
 #endif
             }
@@ -4022 +4094 @@
     }
     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");
@@ -4046 +4118 @@
 
   *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;
@@ -4092 +4164 @@
  * \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)
@@ -4098 +4170 @@
   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
@@ -4116 +4188 @@
 /** 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
@@ -4129 +4201 @@
   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)
@@ -4147 +4219 @@
     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;
@@ -4157 +4229 @@
     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;
-          Leaf->AddHydrogenReplacementAtom(out, ListOfBondsPerAtom[FatherOfRunner->nr][i], Runner, FatherOfRunner, OtherFather, ListOfBondsPerAtom[FatherOfRunner->nr],NumberOfBondsPerAtom[FatherOfRunner->nr], IsAngstroem);
+          if(!Leaf->AddHydrogenReplacementAtom(out, ListOfBondsPerAtom[FatherOfRunner->nr][i], Runner, FatherOfRunner, OtherFather, ListOfBondsPerAtom[FatherOfRunner->nr],NumberOfBondsPerAtom[FatherOfRunner->nr], IsAngstroem))
+            exit(1);
 #endif
           //NumBonds[Runner->nr] += ListOfBondsPerAtom[FatherOfRunner->nr][i]->BondDegree;
@@ -4190 +4263 @@
     while ((Runner->next != Leaf->end) && (Runner->next->type->Z == 1)) // skip added hydrogen
       Runner = Runner->next;
-#endif       
+#endif
   }
   Leaf->CreateListOfBondsPerAtom(out);
@@ -4223 +4296 @@
   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;
@@ -4273 +4346 @@
                 // clear snake stack
           SnakeStack->ClearStack();
-    //SnakeStack->TestImplementation(out, start->next);    
+    //SnakeStack->TestImplementation(out, start->next);
 
     ///// INNER LOOP ////////////
@@ -4294 +4367 @@
         }
         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
         }
@@ -4332 +4405 @@
                                 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
@@ -4347 +4420 @@
                 //} 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;
               }
@@ -4363 +4436 @@
           *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;
@@ -4370 +4443 @@
       }
         } 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) ...
@@ -4386 +4459 @@
     }
   }
-  *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;
@@ -4460 +4533 @@
 
   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;
@@ -4481 +4554 @@
     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
@@ -4489 +4562 @@
         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
@@ -4505 +4578 @@
         }
       }
-      
-      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;
@@ -4534 +4607 @@
           }
           *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");
         }
@@ -4543 +4616 @@
         *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))
@@ -4551 +4624 @@
         //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;
@@ -4562 +4635 @@
       *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
@@ -4569 +4642 @@
     }
   }
-  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;
 };
@@ -4578 +4651 @@
  * \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)
 {
@@ -4584 +4657 @@
   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;
@@ -4633 +4706 @@
  * \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;
@@ -4659 +4732 @@
     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.
@@ -4719 +4792 @@
     }
   }
-  
+
   // outputting all list for debugging
   *out << Verbose(0) << "Printing all found lists." << endl;
@@ -4728 +4801 @@
       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!
@@ -4737 +4810 @@
     while (Binder->next != FragmentSearch.BondsPerSPList[2*i+1]) {
       Binder = Binder->next;
-      SP ++; 
+      SP ++;
     }
   }
@@ -4744 +4817 @@
     // 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 {
@@ -4760 +4833 @@
   // 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
@@ -4779 +4852 @@
   }
 
-  // return list  
+  // return list
   *out << Verbose(0) << "End of PowerSetGenerator." << endl;
   return (FragmentSearch.FragmentCounter - Counter);
@@ -4810 +4883 @@
     // remove bonds that are beyond bonddistance
     for(int i=NDIM;i--;)
-      Translationvector.x[i] = 0.; 
+      Translationvector.x[i] = 0.;
     // scan all bonds
     Binder = first;
@@ -4857 +4930 @@
         }
       }
-      // re-add bond    
+      // re-add bond
       link(Binder, OtherBinder);
     } else {
@@ -4911 +4984 @@
         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
@@ -4955 +5028 @@
  * \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)
@@ -5000 +5073 @@
   int RootKeyNr, RootNr;
   struct UniqueFragments FragmentSearch;
-  
+
   *out << Verbose(0) << "Begin of FragmentBOSSANOVA." << endl;
 
@@ -5023 +5096 @@
     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
@@ -5037 +5110 @@
     //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");
@@ -5049 +5122 @@
         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);
@@ -5059 +5132 @@
       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;
@@ -5076 +5149 @@
         // 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
@@ -5083 +5156 @@
 //          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;
@@ -5090 +5163 @@
 //              *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;
@@ -5121 +5194 @@
       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");
@@ -5127 +5200 @@
         delete(FragmentSearch.BondsPerSPList[2*i]);
         delete(FragmentSearch.BondsPerSPList[2*i+1]);
-      }  
+      }
       Free((void **)&FragmentSearch.BondsPerSPList, "molecule::PowerSetGenerator: ***BondsPerSPList");
     }
@@ -5138 +5211 @@
   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
@@ -5159 +5232 @@
     RootKeyNr = RootStack.front();
     RootStack.pop_front();
-    Walker = FindAtom(RootKeyNr); 
+    Walker = FindAtom(RootKeyNr);
     NumLevels = 1 << (Walker->AdaptiveOrder - 1);
     for(int i=0;i<NumLevels;i++) {
@@ -5172 +5245 @@
   Free((void **)&FragmentLowerOrdersList, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
   Free((void **)&NumMoleculesOfOrder, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
-  
+
   *out << Verbose(0) << "End of FragmentBOSSANOVA." << endl;
 };
@@ -5206 +5279 @@
   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;
@@ -5254 +5327 @@
     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) {
@@ -5273 +5346 @@
       OtherDistances[Walker->nr] = OtherCenterOfGravity.Distance(&Walker->x);
     }
-  
+
     /// ... sort each list (using heapsort (o(N log N)) from GSL)
     *out << Verbose(5) << "Sorting distances" << endl;
@@ -5284 +5357 @@
     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;
@@ -5295 +5368 @@
     Free((void **)&PermMap, "molecule::IsEqualToWithinThreshold: *PermMap");
     Free((void **)&OtherPermMap, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
-      
+
     /// free memory
     Free((void **)&Distances, "molecule::IsEqualToWithinThreshold: Distances");
@@ -5303 +5376 @@
       result = false;
     }
-  } 
+  }
   /// return pointer to map if all distances were below \a threshold
   *out << Verbose(3) << "End of IsEqualToWithinThreshold." << endl;
@@ -5312 +5385 @@
     *out << Verbose(3) << "Result: Not equal." << endl;
     return NULL;
-  } 
+  }
 };
 
@@ -5367 +5440 @@
  * \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)
 {
@@ -5375 +5448 @@
   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
  */
 
@@ -56 +56 @@
 #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 < LinePair::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 < LineMap::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 +88 @@
 //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 +142 @@
     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:
 };
@@ -171 +171 @@
     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 +182 @@
   bool Contains(const atom *ptr);
   bool Contains(const int nr);
-  
+
   bond();
   bond(atom *left, atom *right);
@@ -188 +188 @@
   bond(atom *left, atom *right, int degree, int number);
   ~bond();
-    
-  private: 
+
+  private:
     enum Shading Used;        //!< marker in depth-first search, DepthFirstSearchAnalysis()
 };
@@ -226 +226 @@
     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 +238 @@
   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 +252 @@
   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);
@@ -268 +268 @@
         double VolumeOfConvexEnvelope(ofstream *out, bool IsAngstroem);
         
-        bool VerletForceIntegration(ofstream *out, char *file, config &configuration);
+  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); 
+  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  
+  /// Initialising routines in fragmentation
+  void CreateAdjacencyList2(ofstream *out, ifstream *output);
   void CreateAdjacencyList(ofstream *out, double bonddistance, bool IsAngstroem);
   void CreateListOfBondsPerAtom(ofstream *out);
-  
+
   // Graph analysis
   MoleculeLeafClass * DepthFirstSearchAnalysis(ofstream *out, class StackClass<bond *> *&BackEdgeStack);
@@ -298 +299 @@
 
   molecule *CopyMolecule();
-  
+
   /// Fragment molecule by two different approaches:
   int FragmentMolecule(ofstream *out, int Order, config *configuration);
@@ -320 +321 @@
   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);
@@ -345 +346 @@
     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);
@@ -355 +356 @@
   bool OutputConfigForListOfFragments(ofstream *out, const char *fragmentprefix, config *configuration, int *SortIndex, bool DoPeriodic, bool DoCentering);
   void Output(ofstream *out);
-  
+
   private:
 };
@@ -365 +366 @@
 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
@@ -401 +402 @@
     bool FastParsing;
     double Deltat;
+    string basis;
+
     int DoConstrainedMD;
     int MaxOuterStep;
@@ -416 +419 @@
     char *defaultpath;
     char *pseudopotpath;
-    
+
     int DoOutVis;
     int DoOutMes;
@@ -431 +434 @@
     int UseAddGramSch;
     int Seed;
-    
+
     int OutVisStep;
     int OutSrcStep;
     int MaxPsiStep;
     double EpsWannier;
-    
+
     int MaxMinStep;
     double RelEpsTotalEnergy;
@@ -445 +448 @@
     double InitRelEpsKineticEnergy;
     int InitMaxMinGapStopStep;
-    
+
     //double BoxLength[NDIM*NDIM];
-    
+
     double ECut;
     int MaxLevel;
@@ -456 +459 @@
     int RTActualUse;
     int AddPsis;
-    
+
     double RCut;
     int StructOpt;
@@ -463 +466 @@
     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();
@@ -474 +477 @@
   void LoadOld(char *filename, periodentafel *periode, molecule *mol);
   void RetrieveConfigPathAndName(string filename);
-  bool Save(ofstream *file, periodentafel *periode, molecule *mol) const;
-  bool SaveMPQC(ofstream *file, molecule *mol) const;
+  bool Save(const char *filename, periodentafel *periode, molecule *mol) const;
+  bool SaveMPQC(const char *filename, molecule *mol) const;
   void Edit(molecule *mol);
   bool GetIsAngstroem() const;

src/orbitals.db

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

src/parser.cpp

@@ -56 +56 @@
 MatrixContainer::MatrixContainer() {
   Indices = NULL;
-  Header = (char *) Malloc(sizeof(char)*1023, "MatrixContainer::MatrixContainer: *Header");
+  Header = (char **) Malloc(sizeof(char)*1, "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;
+  ColumnCounter[0] = -1;
 };
 
@@ -70 +72 @@
   if (Matrix != NULL) {
     for(int i=MatrixCounter;i--;) {
-      if (RowCounter != NULL) {
+      if ((ColumnCounter != NULL) && (RowCounter != NULL)) {
           for(int j=RowCounter[i]+1;j--;)
             Free((void **)&Matrix[i][j], "MatrixContainer::~MatrixContainer: *Matrix[][]");
@@ -76 +78 @@
       }
     }
-    if ((RowCounter != NULL) && (Matrix[MatrixCounter] != NULL))
+    if ((ColumnCounter != NULL) && (RowCounter != NULL) && (Matrix[MatrixCounter] != NULL))
       for(int j=RowCounter[MatrixCounter]+1;j--;)
         Free((void **)&Matrix[MatrixCounter][j], "MatrixContainer::~MatrixContainer: *Matrix[MatrixCounter][]");
@@ -89 +91 @@
   Free((void **)&Indices, "MatrixContainer::~MatrixContainer: **Indices"); 
   
-  Free((void **)&Header, "MatrixContainer::~MatrixContainer: *Header");
+  if (Header != NULL)
+    for(int i=MatrixCounter+1;i--;)
+      Free((void **)&Header[i], "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.
@@ -120 +160 @@
     return false;
   }
-  
-  // skip some initial lines
+
+  // parse header
+  Header[MatrixNr] = (char *) Malloc(sizeof(char)*1024, "MatrixContainer::ParseMatrix: *Header[]");
   for (int m=skiplines+1;m--;)
-    input.getline(Header, 1023);
+    input.getline(Header[MatrixNr], 1023);
   
   // scan header for number of columns
-  line.str(Header);
+  line.str(Header[MatrixNr]);
   for(int k=skipcolumns;k--;)
-    line >> Header;
+    line >> Header[MatrixNr];
   //cout << line.str() << endl;
-  ColumnCounter=0;
+  ColumnCounter[MatrixNr]=0;
   while ( getline(line,token, '\t') ) {
     if (token.length() > 0)
-      ColumnCounter++;
+      ColumnCounter[MatrixNr]++;
   }
   //cout << line.str() << endl;
-  //cout << "ColumnCounter: " << ColumnCounter << "." << endl;
-  if (ColumnCounter == 0)
-    cerr << "ColumnCounter: " << ColumnCounter << " from file " << name << ", this is probably an error!" << 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;
   
   // scan rest for number of rows/lines
@@ -155 +196 @@
   
   // allocate matrix if it's not zero dimension in one direction
-  if ((ColumnCounter > 0) && (RowCounter[MatrixNr] > -1)) {
-    Matrix[MatrixNr] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixNr]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+  if ((ColumnCounter[MatrixNr] > 0) && (RowCounter[MatrixNr] > -1)) {
+    Matrix[MatrixNr] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixNr]+1), "MatrixContainer::ParseMatrix: **Matrix[]");
   
     // parse in each entry for this matrix
@@ -162 +203 @@
     input.seekg(ios::beg);
     for (int m=skiplines+1;m--;)
-      input.getline(Header, 1023);    // skip header
-    line.str(Header);
+      input.getline(Header[MatrixNr], 1023);    // skip header
+    line.str(Header[MatrixNr]);
     for(int k=skipcolumns;k--;)  // skip columns in header too
       line >> filename;
-    strncpy(Header, line.str().c_str(), 1023);  
+    strncpy(Header[MatrixNr], line.str().c_str(), 1023);  
     for(int j=0;j<RowCounter[MatrixNr];j++) {
-      Matrix[MatrixNr][j] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixNr][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[][]");
       input.getline(filename, 1023);
       stringstream lines(filename);
@@ -174 +215 @@
       for(int k=skipcolumns;k--;)
         lines >> filename;
-      for(int k=0;(k<ColumnCounter) && (!lines.eof());k++) {
+      for(int k=0;(k<ColumnCounter[MatrixNr]) && (!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, "MatrixContainer::ParseFragmentMatrix: *Matrix[RowCounter[MatrixNr]][]");
-      for(int j=ColumnCounter;j--;)
+      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] ][j] = 0.;
     }
   } else {
-    cerr << "ERROR: Matrix nr. " << MatrixNr << " has column and row count of (" << ColumnCounter << "," << RowCounter[MatrixNr] << "), could not allocate nor parse!" << endl; 
+    cerr << "ERROR: Matrix nr. " << MatrixNr << " has column and row count of (" << ColumnCounter[MatrixNr] << "," << RowCounter[MatrixNr] << "), could not allocate nor parse!" << endl; 
   }
   input.close();
@@ -233 +274 @@
   
   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++) {
@@ -252 +297 @@
 
 /** Allocates and resets the memory for a number \a MCounter of matrices.
- * \param *GivenHeader Header line
+ * \param **GivenHeader Header line for each matrix
  * \param MCounter number of matrices
  * \param *RCounter number of rows for each matrix
- * \param CCounter number of columns for all matrices
+ * \param *CCounter number of columns for each matrix
  * \return Allocation successful 
  */
-bool MatrixContainer::AllocateMatrix(char *GivenHeader, int MCounter, int *RCounter, int CCounter)
-{
-  Header = (char *) Malloc(sizeof(char)*1024, "MatrixContainer::ParseFragmentMatrix: *EnergyHeader");
-  strncpy(Header, GivenHeader, 1023);
-
+bool MatrixContainer::AllocateMatrix(char **GivenHeader, int MCounter, int *RCounter, int *CCounter)
+{
   MatrixCounter = MCounter;
-  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");
+  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");
   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];
-    Matrix[i] = (double **) Malloc(sizeof(double *)*(RowCounter[i]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");  
+    ColumnCounter[i] = CCounter[i];
+    Matrix[i] = (double **) Malloc(sizeof(double *)*(RowCounter[i]+1), "MatrixContainer::AllocateMatrix: **Matrix[]");  
     for(int j=RowCounter[i]+1;j--;) {
-      Matrix[i][j] = (double *) Malloc(sizeof(double)*ColumnCounter, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
-      for(int k=ColumnCounter;k--;)
+      Matrix[i][j] = (double *) Malloc(sizeof(double)*ColumnCounter[i], "MatrixContainer::AllocateMatrix: *Matrix[][]");
+      for(int k=ColumnCounter[i];k--;)
         Matrix[i][j][k] = 0.;
     }
@@ -286 +332 @@
   for(int i=MatrixCounter+1;i--;)
     for(int j=RowCounter[i]+1;j--;)
-      for(int k=ColumnCounter;k--;)
+      for(int k=ColumnCounter[i];k--;)
         Matrix[i][j][k] = 0.;
    return true;
@@ -299 +345 @@
   for(int i=MatrixCounter+1;i--;)
     for(int j=RowCounter[i]+1;j--;)
-      for(int k=ColumnCounter;k--;)
+      for(int k=ColumnCounter[i];k--;)
         if (fabs(Matrix[i][j][k]) > max)
           max = fabs(Matrix[i][j][k]);
@@ -315 +361 @@
   for(int i=MatrixCounter+1;i--;)
     for(int j=RowCounter[i]+1;j--;)
-      for(int k=ColumnCounter;k--;)
+      for(int k=ColumnCounter[i];k--;)
         if (fabs(Matrix[i][j][k]) < min)
           min = fabs(Matrix[i][j][k]);
@@ -331 +377 @@
 {
   for(int j=RowCounter[MatrixCounter]+1;j--;)
-    for(int k=skipcolumns;k<ColumnCounter;k++)
+    for(int k=skipcolumns;k<ColumnCounter[MatrixCounter];k++)
       Matrix[MatrixCounter][j][k] = value;
    return true;
@@ -344 +390 @@
 {
   for(int j=RowCounter[MatrixCounter]+1;j--;)
-    for(int k=skipcolumns;k<ColumnCounter;k++)
+    for(int k=skipcolumns;k<ColumnCounter[MatrixCounter];k++)
       Matrix[MatrixCounter][j][k] = values[j][k];
    return true;
 };
 
-/** Sums the energy with each factor and put into last element of \a ***Energies.
+/** Sums the 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 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
@@ -384 +430 @@
               }
               if (Order == SubOrder) { // equal order is always copy from Energies
-                for(int l=ColumnCounter;l--;) // then adds/subtract each column 
+                for(int l=ColumnCounter[ KeySet.OrderSet[SubOrder][j] ];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;l--;)
+                for(int l=ColumnCounter[ KeySet.OrderSet[SubOrder][j] ];l--;)
                   Matrix[ KeySet.OrderSet[Order][CurrentFragment] ][m][l] -= Matrix[ KeySet.OrderSet[SubOrder][j] ][k][l];
               }
             }
-            //if ((ColumnCounter>1) && (RowCounter[0]-1 >= 1))
+            //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;
           }
@@ -426 +472 @@
       return false;
     }
-    output << Header << endl;
+    output << Header[i] << endl;
     for(int j=0;j<RowCounter[i];j++) {
-      for(int k=0;k<ColumnCounter;k++)
+      for(int k=0;k<ColumnCounter[i];k++)
         output << scientific << Matrix[i][j][k] << "\t";
       output << endl;
@@ -455 +501 @@
     return false;
   }
-  output << Header << endl;
+  output << Header[MatrixCounter] << endl;
   for(int j=0;j<RowCounter[MatrixCounter];j++) {
-    for(int k=0;k<ColumnCounter;k++)
+    for(int k=0;k<ColumnCounter[MatrixCounter];k++)
       output << scientific << Matrix[MatrixCounter][j][k] << "\t";
     output << endl;
@@ -467 +513 @@
 // ======================================= 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
@@ -498 +528 @@
     for(int i=KeySet.FragmentsPerOrder[Order];i--;)
       for(int j=RowCounter[ KeySet.OrderSet[Order][i] ];j--;)
-        for(int k=ColumnCounter;k--;)
+        for(int k=ColumnCounter[ KeySet.OrderSet[Order][i] ];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;k--;)
+        for(int k=ColumnCounter[ KeySet.OrderSet[Order][i] ];k--;)
           Matrix[MatrixCounter][j][k] += sign*(Fragments.Matrix[ KeySet.OrderSet[Order][i] ][j][k] + CorrectionFragments->Matrix[ KeySet.OrderSet[Order][i] ][j][k]);
   return true;
@@ -524 +554 @@
     // count maximum of columns
     RowCounter[MatrixCounter] = 0;
-    for(int j=0; j < MatrixCounter;j++) // (energy matrix might be bigger than number of atoms in terms of rows)
+    ColumnCounter[MatrixCounter] = 0;
+    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 << " columns." << endl;
+    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, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
     
     // try independently to parse global energysuffix file if present
@@ -589 +623 @@
 
 /** 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
@@ -609 +643 @@
       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;k++)
+        for(int k=2;k<ColumnCounter[MatrixCounter];k++)
           Matrix[MatrixCounter][j][k] += sign*Fragments.Matrix[ FragmentNr ][l][k];
       }
@@ -655 +689 @@
     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 << " columns." << endl;
+    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, "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      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[][]");
 
     // try independently to parse global forcesuffix file if present

src/parser.hpp

@@ -19 +19 @@
 
 #define EnergySuffix ".energy.all"
+#define EnergyFragmentSuffix ".energyfragment.all"
+#define ForcesSuffix ".forces.all"
+#define ForceFragmentSuffix ".forcefragment.all"
 #define HcorrectionSuffix ".Hcorrection.all"
-#define ForcesSuffix ".forces.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 ==========================================
@@ -43 +49 @@
     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();
@@ -70 +77 @@
 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);
@@ -82 +88 @@
     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
 {
@@ -131 +130 @@
     }
     return result;
-  } else 
+  } else
     return false;
 };
@@ -138 +137 @@
  * \param *output output stream
  * \param *checkliste elements table for this molecule
- */ 
+ */
 bool periodentafel::Checkout(ofstream *output, const int *checkliste) const
 {
@@ -152 +151 @@
       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.
@@ -171 +169 @@
   bool status = true;
   bool otherstatus = true;
-  char *filename = new char[MAXSTRINGSIZE];
-  
+  char filename[255];
+
   // fill elements DB
   strncpy(filename, path, MAXSTRINGSIZE);
@@ -225 +223 @@
   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 >> 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();
@@ -253 +251 @@
   } else
     otherstatus = false;
-  
+
   // fill H-BondDistance DB per element
   strncpy(filename, path, MAXSTRINGSIZE);
@@ -261 +259 @@
   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;
     }
@@ -274 +272 @@
   } else
     otherstatus = false;
-  
+
   // fill H-BondAngle DB per element
   strncpy(filename, path, MAXSTRINGSIZE);
@@ -294 +292 @@
   } else
     otherstatus = false;
-  
+
   if (!otherstatus)
-    cerr << "ERROR: Something went wrong while parsing the databases!" << endl;
-  
+    cerr << "WARNING: Something went wrong while parsing the other databases!" << endl;
+
   return status;
 };
@@ -308 +306 @@
   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.20000000000000E+01
+20      0.40000000000000E+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 ************************************/
@@ -21 +21 @@
  */
 Vector::~Vector() {};
+
+/** Calculates square of 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 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 |^2\f$
+ * \return \f$| x - y |\f$
  */
 double Vector::Distance(const Vector *y) const
@@ -31 +43 @@
   for (int i=NDIM;i--;)
     res += (x[i]-y->x[i])*(x[i]-y->x[i]);
-  return (res);  
+  return (sqrt(res));
 };
 
@@ -69 +81 @@
         if (tmp < res) res = tmp;
       }
-  return (res);  
+  return (res);
 };
 
@@ -112 +124 @@
   for (int i=NDIM;i--;)
     res += x[i]*y->x[i];
-  return (res);  
-};
+  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);
+
+};
+
 
 /** projects this vector onto plane defined by \a *y.
- * \param *y array to normal vector of plane
+ * \param *y normal vector of plane
  * \return \f$\langle x, y \rangle\f$
  */
@@ -123 +153 @@
   Vector tmp;
   tmp.CopyVector(y);
-  tmp.Scale(Projection(y));
+  tmp.Normalize();
+  tmp.Scale(ScalarProduct(&tmp));
   this->SubtractVector(&tmp);
 };
@@ -144 +175 @@
   for (int i=NDIM;i--;)
     res += this->x[i]*this->x[i];
-  return (sqrt(res));  
+  return (sqrt(res));
 };
 
@@ -178 +209 @@
  */
 void Vector::Init(double x1, double x2, double x3)
-{ 
+{
   x[0] = x1;
   x[1] = x2;
@@ -188 +219 @@
  * \return \f$\acos\bigl(frac{\langle x, y \rangle}{|x||y|}\bigr)\f$
  */
-double Vector::Angle(Vector *y) const
-{
-  return acos(this->ScalarProduct(y)/Norm()/y->Norm()); 
+double Vector::Angle(const Vector *y) const
+{
+  return acos(this->ScalarProduct(y)/Norm()/y->Norm());
 };
 
@@ -238 +269 @@
 
 /** Sums two vectors \a  and \b component-wise.
- * \param a first vector 
+ * \param a first vector
  * \param b second vector
  * \return a + b
@@ -251 +282 @@
 
 /** Factors given vector \a a times \a m.
- * \param a vector 
+ * \param a vector
  * \param m factor
  * \return a + b
@@ -282 +313 @@
 };
 
-ofstream& operator<<(ofstream& ost,Vector& m)
-{
-        m.Output(&ost);
+/** 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 << ")";
         return ost;
 };
@@ -309 +351 @@
 };
 
-/** Translate atom by given vector. 
+/** Translate atom by given vector.
  * \param trans[] translation vector.
  */
@@ -316 +358 @@
   for (int i=NDIM;i--;)
     x[i] += trans->x[i];
-}; 
+};
 
 /** Do a matrix multiplication.
@@ -355 +397 @@
     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];
@@ -379 +421 @@
 {
   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.
  */
@@ -398 +440 @@
   Output((ofstream *)&cout);
   cout << endl;
-}; 
+};
 
 /** Calculates normal vector for three given vectors (being three points in space).
@@ -430 +472 @@
   this->x[2] = (x1.x[0]*x2.x[1] - x1.x[1]*x2.x[0]);
   Normalize();
-  
+
   return true;
 };
@@ -488 +530 @@
 /** 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)
@@ -509 +551 @@
       Components[Last++] = j;
   cout << Verbose(4) << Last << " Components != 0: (" << Components[0] << "," << Components[1] << "," << Components[2] << ")" << endl;
-        
+
   switch(Last) {
     case 3:  // threecomponent system
@@ -522 +564 @@
     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;
@@ -541 +583 @@
 {
 //  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);
@@ -553 +595 @@
  * \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: ";
@@ -565 +607 @@
   int np = 3;
         struct LSQ_params par;
-    
+
    const gsl_multimin_fminimizer_type *T =
      gsl_multimin_fminimizer_nmsimplex;
@@ -571 +613 @@
    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++)
@@ -622 +664 @@
      }
    while (status == GSL_CONTINUE && iter < 100);
- 
+
   for (i=(size_t)np;i--;)
     this->x[i] = gsl_vector_get(s->x, i);
@@ -688 +730 @@
  * \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)
@@ -706 +748 @@
   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;
@@ -739 +781 @@
   // 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;
@@ -755 +797 @@
       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;
@@ -782 +824 @@
     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;
@@ -832 +874 @@
     }
     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];
@@ -838 +880 @@
     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(Vector *y) const;
+  double Angle(const Vector *y) const;
 
   void AddVector(const Vector *y);
@@ -26 +27 @@
   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);
@@ -40 +42 @@
   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);
@@ -53 +55 @@
 };
 
-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);
+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);
 
 #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
 
@@ -38 +42 @@
 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