Diff [9fe36bb58ae84b51bb9fe0b8a94b9434f7bf9e41:b8d1aeb22373c5d1fad99d7977d1fe361a9c5313] for / – MoleCuilder

TabularUnified src/Actions/small_actions.cpp ¶

r9fe36b	rb8d1aeb
53	53	return NAME;
54	54	}
	55

TabularUnified src/Makefile.am ¶

-              r9fe36b
+              rb8d1aeb
 ATOMSOURCE = atom.cpp atom_atominfo.cpp atom_bondedparticle.cpp atom_bondedparticleinfo.cpp atom_graphnode.cpp atom_graphnodeinfo.cpp atom_particleinfo.cpp atom_trajectoryparticle.cpp atom_trajectoryparticleinfo.cpp
 ATOMHEADER = atom.hpp atom_atominfo.hpp atom_bondedparticle.hpp atom_bondedparticleinfo.hpp atom_graphnode.hpp atom_graphnodeinfo.hpp atom_particleinfo.hpp atom_trajectoryparticle.hpp atom_trajectoryparticleinfo.hpp
+LINALGSOURCE = gslmatrix.cpp gslvector.cpp linearsystemofequations.cpp
+LINALGHEADER = gslmatrix.hpp gslvector.hpp linearsystemofequations.hpp
 ANALYSISSOURCE = analysis_bonds.cpp analysis_correlation.cpp
 …
 QTUI_DEFS =
 SOURCE = ${ANALYSISSOURCE} ${ATOMSOURCE} ${PATTERNSOURCE} bond.cpp bondgraph.cpp boundary.cpp config.cpp element.cpp ellipsoid.cpp errorlogger.cpp graph.cpp helpers.cpp leastsquaremin.cpp linkedcell.cpp log.cpp logger.cpp memoryusageobserver.cpp moleculelist.cpp molecule.cpp molecule_dynamics.cpp molecule_fragmentation.cpp molecule_geometry.cpp molecule_graph.cpp molecule_pointcloud.cpp parser.cpp periodentafel.cpp tesselation.cpp tesselationhelpers.cpp vector.cpp verbose.cpp
 HEADER = ${ANALYSISHEADER} ${ATOMHEADER} ${PATTERNHEADER} bond.hpp bondgraph.hpp boundary.hpp config.hpp defs.hpp element.hpp ellipsoid.hpp errorlogger.hpp graph.hpp helpers.hpp leastsquaremin.hpp linkedcell.hpp lists.hpp log.hpp logger.hpp memoryallocator.hpp memoryusageobserver.hpp molecule.hpp molecule_template.hpp parser.hpp periodentafel.hpp stackclass.hpp tesselation.hpp tesselationhelpers.hpp vector.hpp verbose.hpp
+SOURCE = ${ANALYSISSOURCE} ${ATOMSOURCE} ${PATTERNSOURCE} bond.cpp bondgraph.cpp boundary.cpp config.cpp element.cpp ellipsoid.cpp errorlogger.cpp graph.cpp helpers.cpp info.cpp leastsquaremin.cpp linkedcell.cpp log.cpp logger.cpp memoryusageobserver.cpp moleculelist.cpp molecule.cpp molecule_dynamics.cpp molecule_fragmentation.cpp molecule_geometry.cpp molecule_graph.cpp molecule_pointcloud.cpp parser.cpp periodentafel.cpp tesselation.cpp tesselationhelpers.cpp vector.cpp verbose.cpp
+HEADER = ${ANALYSISHEADER} ${ATOMHEADER} ${PATTERNHEADER} bond.hpp bondgraph.hpp boundary.hpp config.hpp defs.hpp element.hpp ellipsoid.hpp errorlogger.hpp graph.hpp helpers.hpp info.hpp leastsquaremin.hpp linkedcell.hpp lists.hpp log.hpp logger.hpp memoryallocator.hpp memoryusageobserver.hpp molecule.hpp molecule_template.hpp parser.hpp periodentafel.hpp stackclass.hpp tesselation.hpp tesselationhelpers.hpp vector.hpp verbose.hpp
 BOOST_LIB = $(BOOST_LDFLAGS) $(BOOST_MPL_LIB)
 INCLUDES = -I$(top_srcdir)/src/unittests
 noinst_LIBRARIES = libmolecuilder.a libmenu.a
+noinst_LIBRARIES = libmolecuilder.a libgslwrapper.a libmenu.a
 bin_PROGRAMS = molecuilder molecuildergui joiner analyzer
 molecuilderdir = ${bindir}
 libmolecuilder_a_SOURCES = ${SOURCE} ${HEADER}
 libmenu_a_SOURCES = ${UISOURCE} ${UIHEADER}
+libgslwrapper_a_SOURCES = ${LINALGSOURCE} ${LINALGHEADER}
 molecuilder_DATA = elements.db valence.db orbitals.db Hbonddistance.db Hbondangle.db
 molecuilder_LDFLAGS = $(BOOST_LIB)
+molecuilder_SOURCES = ${FACTORYSOURCE} menu.cpp builder.cpp
+molecuilder_LDADD = libmolecuilder.a libmenu.a
+molecuilder_SOURCES = ${FACTORYSOURCE} menu.cpp builder.cpp
+molecuilder_SOURCES += $(srcdir)/version.c
+molecuilder_LDADD = libmolecuilder.a libgslwrapper.a libmenu.a
 #Stuff for building the GUI using QT
 molecuildergui_SOURCES = ${QTUISOURCE} ${FACTORYSOURCE} menu.cpp builder.cpp
+molecuildergui_SOURCES += $(srcdir)/version.c
 molecuildergui_CXXFLAGS = ${QT_CXXFLAGS} ${GLU_CXXFLAGS} -DUSE_GUI_QT
 molecuildergui_LDFLAGS = $(BOOST_LIB) ${QT_LDFLAGS} ${GLU_LDFLAGS}
 molecuildergui_LDADD = libmolecuilder.a libmenu.a ${QT_LDADD} ${QT_LIB_GUI} -lQtOpenGL ${GLU_LIBS}
+molecuildergui_LDADD = libmolecuilder.a libgslwrapper.a libmenu.a ${QT_LDADD} ${QT_LIB_GUI} -lQtOpenGL ${GLU_LIBS}
 joiner_SOURCES = joiner.cpp datacreator.cpp parser.cpp datacreator.hpp helpers.hpp parser.hpp periodentafel.hpp
 joiner_LDADD = libmolecuilder.a
 …
 #EXTRA_DIST = ${molecuilder_DATA}
+FORCE:
+$(srcdir)/.git-version: FORCE
+        @if (test -d $(top_srcdir)/../.git && cd $(srcdir) && git describe HEAD) > .git-version-t 2>/dev/null \
+          && ! diff .git-version-t $(srcdir)/.git-version >/dev/null 2>&1; then \
+          mv -f .git-version-t $(srcdir)/.git-version; \
+        else \
+          rm -f .git-version-t; \
+        fi
+EXTRA_DIST = $(srcdir)/.git-version
+$(srcdir)/version.c: $(srcdir)/.git-version
+        echo "const char *ESPACKVersion = \"$(PACKAGE_NAME) -- git version: "`cat $(srcdir)/.git-version`"\";" > $@

TabularUnified src/UIElements/Dialog.cpp ¶

-              r9fe36b
+              rb8d1aeb
 #include "UIElements/Dialog.hpp"
+#include "vector.hpp"
 using namespace std;
 …
+}
+// Double Queries
+Dialog::DoubleQuery::DoubleQuery(string title,double *_target) :
+    Query(title), target(_target)
+{}
+Dialog::DoubleQuery::~DoubleQuery() {};
+void Dialog::DoubleQuery::setResult() {
+  *target = tmp;
+}
 // Molecule Queries
 …
   *target = tmp;
+}
+// Vector Queries
+Dialog::VectorQuery::VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check) :
+  Query(title), target(_target), cellSize(_cellSize), check(_check)
+{
+tmp = new Vector();
+}
+Dialog::VectorQuery::~VectorQuery()
+{
+  delete tmp;
+}
+void Dialog::VectorQuery::setResult() {
+  *target = *tmp;
+}

TabularUnified src/UIElements/Dialog.hpp ¶

-              r9fe36b
+              rb8d1aeb
 class MoleculeListClass;
 class molecule;
+class Vector;
 class Dialog
 …
   virtual void queryInt(const char *, int *)=0;
+  virtual void queryDouble(const char*,double *)=0;
   virtual void queryString(const char*, std::string *)=0;
   virtual void queryMolecule(const char*,molecule**,MoleculeListClass*)=0;
+  virtual void queryVector(const char*,Vector *,const double *const,bool)=0;
   virtual bool display();
 …
   };
+  class DoubleQuery : public Query {
+  public:
+    DoubleQuery(std::string title,double *_target);
+    ~DoubleQuery();
+    virtual bool handle()=0;
+    virtual void setResult();
+  protected:
+    double tmp;
+  private:
+    double *target;
+  };
   class StringQuery : public Query {
   public:
 …
     std::string *target;
   };
   class MoleculeQuery : public Query {
 …
   };
+  class VectorQuery : public Query {
+  public:
+      VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check);
+      ~VectorQuery();
+      virtual bool handle()=0;
+      virtual void setResult();
+    protected:
+      Vector *tmp;
+      const double *const cellSize;
+      bool check;
+    private:
+      Vector *target;
+  };
 void registerQuery(Query* query);

TabularUnified src/UIElements/QT4/QTDialog.cpp ¶

-              r9fe36b
+              rb8d1aeb
 #include <string>
 #include <sstream>
+#include <limits>
 #include <Qt/qboxlayout.h>
 #include <Qt/qlabel.h>
 #include <Qt/qspinbox.h>
+#include <QtGui/QDoubleSpinBox>
 #include <Qt/qlineedit.h>
 #include <Qt/qdialogbuttonbox.h>
 …
+}
+void QTDialog::queryDouble(const char* title, double* target){
+  registerQuery(new DoubleQTQuery(title,target,inputLayout,this));
+}
 void QTDialog::queryString(const char* title, std::string *target)
+{
 …
   registerQuery(new MoleculeQTQuery(title,target,molecules,inputLayout,this));
+}
+void QTDialog::queryVector(const char* title, Vector *target,const double *const cellSize, bool check) {
+  registerQuery(new VectorQTQuery(title,target,cellSize,check,inputLayout,this));
+}
+/************************** Query Objects *******************************/
 QTDialog::IntQTQuery::IntQTQuery(string _title,int *_target,QBoxLayout *_parent,QTDialog *_dialog) :
 …
 bool QTDialog::IntQTQuery::handle()
+{
+  return true;
+}
+QTDialog::DoubleQTQuery::DoubleQTQuery(string title,double *_target,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::DoubleQuery(title,_target),
+    parent(_parent)
+{
+  thisLayout = new QHBoxLayout();
+  titleLabel = new QLabel(QString(getTitle().c_str()));
+  inputBox = new QDoubleSpinBox();
+  inputBox->setValue(0);
+  inputBox->setRange(-numeric_limits<double>::max(),numeric_limits<double>::max());
+  inputBox->setDecimals(3);
+  parent->addLayout(thisLayout);
+  thisLayout->addWidget(titleLabel);
+  thisLayout->addWidget(inputBox);
+  pipe = new DoubleQTQueryPipe(&tmp,_dialog);
+  pipe->update(inputBox->value());
+  connect(inputBox,SIGNAL(valueChanged(double)),pipe,SLOT(update(double)));
+}
+QTDialog::DoubleQTQuery::~DoubleQTQuery()
+{
+  delete pipe;
+}
+bool QTDialog::DoubleQTQuery::handle() {
   return true;
+}
 …
+}
+QTDialog::VectorQTQuery::VectorQTQuery(std::string title, Vector *_target, const double *const _cellSize, bool _check,QBoxLayout *_parent,QTDialog *_dialog) :
+    Dialog::VectorQuery(title,_target,_cellSize,_check),
+    parent(_parent)
+{
+  // About the j: I don't know why it was done this way, but it was used this way in Vector::AskPosition, so I reused it
+  int j = -1;
+  const char *coords[3] = {"x:","y:","z:"};
+  mainLayout= new QHBoxLayout();
+  titleLabel = new QLabel(QString(getTitle().c_str()));
+  mainLayout->addWidget(titleLabel);
+  subLayout = new QVBoxLayout();
+  mainLayout->addLayout(subLayout);
+  for(int i=0; i<3; i++) {
+    j+=i+1;
+    coordLayout[i] = new QHBoxLayout();
+    subLayout->addLayout(coordLayout[i]);
+    coordLabel[i] = new QLabel(QString(coords[i]));
+    coordLayout[i]->addWidget(coordLabel[i]);
+    coordInput[i] = new QDoubleSpinBox();
+    coordInput[i]->setRange(0,cellSize[j]);
+    coordInput[i]->setDecimals(3);
+    coordLayout[i]->addWidget(coordInput[i]);
+    pipe[i] = new DoubleQTQueryPipe(&((*tmp)[i]),_dialog);
+    pipe[i]->update(coordInput[i]->value());
+    connect(coordInput[i],SIGNAL(valueChanged(double)),pipe[i],SLOT(update(double)));
+  }
+  parent->addLayout(mainLayout);
+}
+QTDialog::VectorQTQuery::~VectorQTQuery()
+{}
+bool QTDialog::VectorQTQuery::handle() {
+  return true;
+}
 /*************************** Plumbing *******************************/
 …
 void IntQTQueryPipe::update(int newInt) {
   (*content) = newInt;
+  dialog->update();
+}
+DoubleQTQueryPipe::DoubleQTQueryPipe(double *_content, QTDialog *_dialog) :
+  content(_content),
+  dialog(_dialog)
+{}
+DoubleQTQueryPipe::~DoubleQTQueryPipe()
+{}
+void DoubleQTQueryPipe::update(double newDbl) {
+  (*content) = newDbl;
   dialog->update();
+}

TabularUnified src/UIElements/QT4/QTDialog.hpp ¶

-              r9fe36b
+              rb8d1aeb
 class QLabel;
 class QSpinBox;
+class QDoubleSpinBox;
 class QLineEdit;
 class QComboBox;
 …
 class StringQTQueryPipe;
 class IntQTQueryPipe;
+class DoubleQTQueryPipe;
 class MoleculeQTQueryPipe;
 …
   virtual void queryInt(const char *, int *);
   virtual void queryString(const char*, std::string *);
+  virtual void queryDouble(const char*,double *);
   virtual void queryMolecule(const char*,molecule**,MoleculeListClass*);
+  virtual void queryVector(const char*,Vector *,const double *const,bool);
   virtual bool display();
 …
       IntQTQueryPipe *pipe;
+    };
+    class DoubleQTQuery : public Dialog::DoubleQuery {
+    public:
+      DoubleQTQuery(std::string title, double *_target,QBoxLayout *_parent,QTDialog *_dialog);
+      ~DoubleQTQuery();
+      virtual bool handle();
+    private:
+      QBoxLayout *parent;
+      QBoxLayout *thisLayout;
+      QLabel *titleLabel;
+      QDoubleSpinBox *inputBox;
+      DoubleQTQueryPipe *pipe;
     };
 …
       MoleculeQTQueryPipe *pipe;
+    };
+    class VectorQTQuery : public Dialog::VectorQuery {
+    public:
+      VectorQTQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check,QBoxLayout *,QTDialog *);
+      ~VectorQTQuery();
+      virtual bool handle();
+    private:
+      QBoxLayout *parent;
+      QBoxLayout *mainLayout;
+      QLabel *titleLabel;
+      QBoxLayout *subLayout;
+      QBoxLayout *coordLayout[3];
+      QLabel *coordLabel[3];
+      QDoubleSpinBox *coordInput[3];
+      DoubleQTQueryPipe *pipe[3];
     };
 …
 };
+class DoubleQTQueryPipe : public QWidget {
+  Q_OBJECT
+public:
+  DoubleQTQueryPipe(double *_content, QTDialog *_dialog);
+  ~DoubleQTQueryPipe();
+public slots:
+  void update(double);
+private:
+  double *content;
+  QTDialog *dialog;
+};
 class MoleculeQTQueryPipe : public QWidget {

TabularUnified src/UIElements/TextDialog.cpp ¶

-              r9fe36b
+              rb8d1aeb
+}
+void TextDialog::queryDouble(const char* title, double* target){
+  registerQuery(new DoubleTextQuery(title,target));
+}
 void TextDialog::queryString(const char* title, string* target){
   registerQuery(new StringTextQuery(title,target));
 …
 void TextDialog::queryMolecule(const char* title, molecule **target, MoleculeListClass *molecules) {
   registerQuery(new MoleculeTextQuery(title,target,molecules));
+}
+void TextDialog::queryVector(const char* title, Vector *target,const double *const cellSize, bool check) {
+  registerQuery(new VectorTextQuery(title,target,cellSize,check));
+}
 …
+}
+TextDialog::DoubleTextQuery::DoubleTextQuery(string title,double *_target) :
+    Dialog::DoubleQuery(title,_target)
+{}
+TextDialog::DoubleTextQuery::~DoubleTextQuery() {}
+bool TextDialog::DoubleTextQuery::handle() {
+  Log() << Verbose(0) << getTitle();
+  cin >> tmp;
+  return true;
+}
 TextDialog::MoleculeTextQuery::MoleculeTextQuery(string title, molecule **_target, MoleculeListClass *_molecules) :
     Dialog::MoleculeQuery(title,_target,_molecules)
 …
   return (idxOfMol!=-1);
+}
+TextDialog::VectorTextQuery::VectorTextQuery(std::string title, Vector *_target, const double *const _cellSize, bool _check) :
+    Dialog::VectorQuery(title,_target,_cellSize,_check)
+{}
+TextDialog::VectorTextQuery::~VectorTextQuery()
+{}
+bool TextDialog::VectorTextQuery::handle() {
+ tmp->AskPosition(cellSize,check);
+ return true;
+}

TabularUnified src/UIElements/TextDialog.hpp ¶

-              r9fe36b
+              rb8d1aeb
   virtual void queryInt(const char *, int *);
   virtual void queryString(const char*, std::string *);
+  virtual void queryDouble(const char*, double*);
   virtual void queryMolecule(const char*,molecule**,MoleculeListClass*);
+  virtual void queryVector(const char*,Vector *,const double * const,bool);
 protected:
 …
     IntTextQuery(std::string title, int *_target);
     ~IntTextQuery();
+    virtual bool handle();
+  };
+  class DoubleTextQuery : public Dialog::DoubleQuery {
+  public:
+    DoubleTextQuery(std::string title, double *_target);
+    ~DoubleTextQuery();
     virtual bool handle();
   };
 …
     virtual bool handle();
   };
+  class VectorTextQuery : public Dialog::VectorQuery {
+  public:
+    VectorTextQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check);
+    ~VectorTextQuery();
+    virtual bool handle();
+  };
 };

TabularUnified src/analysis_correlation.cpp ¶

-              r9fe36b
+              rb8d1aeb
 #include "analysis_correlation.hpp"
 #include "element.hpp"
+#include "info.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 …
 PairCorrelationMap *PairCorrelation(MoleculeListClass * const &molecules, const element * const type1, const element * const type2 )
+{
+  Info FunctionInfo(__func__);
   PairCorrelationMap *outmap = NULL;
   double distance = 0.;
 …
 PairCorrelationMap *PeriodicPairCorrelation(MoleculeListClass * const &molecules, const element * const type1, const element * const type2, const int ranges[NDIM] )
+{
+  Info FunctionInfo(__func__);
   PairCorrelationMap *outmap = NULL;
   double distance = 0.;
 …
 CorrelationToPointMap *CorrelationToPoint(MoleculeListClass * const &molecules, const element * const type, const Vector *point )
+{
+  Info FunctionInfo(__func__);
   CorrelationToPointMap *outmap = NULL;
   double distance = 0.;
 …
 CorrelationToPointMap *PeriodicCorrelationToPoint(MoleculeListClass * const &molecules, const element * const type, const Vector *point, const int ranges[NDIM] )
+{
+  Info FunctionInfo(__func__);
   CorrelationToPointMap *outmap = NULL;
   double distance = 0.;
 …
 CorrelationToSurfaceMap *CorrelationToSurface(MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC )
+{
+  Info FunctionInfo(__func__);
   CorrelationToSurfaceMap *outmap = NULL;
   double distance = 0;
 …
         Log() << Verbose(3) << "Current atom is " << *Walker << "." << endl;
         if ((type == NULL) || (Walker->type == type)) {
           triangle = Surface->FindClosestTriangleToPoint(Walker->node, LC );
+          triangle = Surface->FindClosestTriangleToVector(Walker->node, LC );
           if (triangle != NULL) {
             distance = DistanceToTrianglePlane(Walker->node, triangle);
 …
 CorrelationToSurfaceMap *PeriodicCorrelationToSurface(MoleculeListClass * const &molecules, const element * const type, const Tesselation * const Surface, const LinkedCell *LC, const int ranges[NDIM] )
+{
+  Info FunctionInfo(__func__);
   CorrelationToSurfaceMap *outmap = NULL;
   double distance = 0;
 …
+  }
   outmap = new CorrelationToSurfaceMap;
+  double ShortestDistance = 0.;
+  BoundaryTriangleSet *ShortestTriangle = NULL;
   for (MoleculeList::const_iterator MolWalker = molecules->ListOfMolecules.begin(); MolWalker != molecules->ListOfMolecules.end(); MolWalker++)
     if ((*MolWalker)->ActiveFlag) {
 …
           periodicX.MatrixMultiplication(FullInverseMatrix);  // x now in [0,1)^3
           // go through every range in xyz and get distance
+          ShortestDistance = -1.;
           for (n[0]=-ranges[0]; n[0] <= ranges[0]; n[0]++)
             for (n[1]=-ranges[1]; n[1] <= ranges[1]; n[1]++)
 …
                 checkX.AddVector(&periodicX);
                 checkX.MatrixMultiplication(FullMatrix);
+                triangle = Surface->FindClosestTriangleToPoint(&checkX, LC );
+                if (triangle != NULL) {
+                  distance = DistanceToTrianglePlane(&checkX, triangle);
+                  outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(distance, pair<atom *, BoundaryTriangleSet*> (Walker, triangle) ) );
+                triangle = Surface->FindClosestTriangleToVector(&checkX, LC);
+                distance = Surface->GetDistanceSquaredToTriangle(checkX, triangle);
+                if ((ShortestDistance == -1.) || (distance < ShortestDistance)) {
+                  ShortestDistance = distance;
+                  ShortestTriangle = triangle;
+                }
+          }
+              }
+          // insert
+          ShortestDistance = sqrt(ShortestDistance);
+          outmap->insert ( pair<double, pair<atom *, BoundaryTriangleSet*> >(ShortestDistance, pair<atom *, BoundaryTriangleSet*> (Walker, ShortestTriangle) ) );
+          //Log() << Verbose(1) << "INFO: Inserting " << Walker << " with distance " << ShortestDistance << " to " << *ShortestTriangle << "." << endl;
+        }
+      }
 …
 double GetBin ( const double value, const double BinWidth, const double BinStart )
+{
+  Info FunctionInfo(__func__);
   double bin =(double) (floor((value - BinStart)/BinWidth));
   return (bin*BinWidth+BinStart);
 …
 void OutputCorrelation( ofstream * const file, const BinPairMap * const map )
+{
+  Info FunctionInfo(__func__);
   *file << "# BinStart\tCount" << endl;
   for (BinPairMap::const_iterator runner = map->begin(); runner != map->end(); ++runner) {
 …
 void OutputPairCorrelation( ofstream * const file, const PairCorrelationMap * const map )
+{
+  Info FunctionInfo(__func__);
   *file << "# BinStart\tAtom1\tAtom2" << endl;
   for (PairCorrelationMap::const_iterator runner = map->begin(); runner != map->end(); ++runner) {
 …
 void OutputCorrelationToPoint( ofstream * const file, const CorrelationToPointMap * const map )
+{
+  Info FunctionInfo(__func__);
   *file << "# BinStart\tAtom::x[i]-point.x[i]" << endl;
   for (CorrelationToPointMap::const_iterator runner = map->begin(); runner != map->end(); ++runner) {
 …
 void OutputCorrelationToSurface( ofstream * const file, const CorrelationToSurfaceMap * const map )
+{
+  Info FunctionInfo(__func__);
   *file << "# BinStart\tTriangle" << endl;
   for (CorrelationToSurfaceMap::const_iterator runner = map->begin(); runner != map->end(); ++runner) {
     *file << runner->first << "\t" << *(runner->second.second) << endl;
+  }
 };
+    *file << runner->first << "\t" << *(runner->second.first) << "\t" << *(runner->second.second) << endl;
+  }
+};

TabularUnified src/analysis_correlation.hpp ¶

-              r9fe36b
+              rb8d1aeb
 double GetBin ( const double value, const double BinWidth, const double BinStart );
 void OutputCorrelation( ofstream * const file, const BinPairMap * const map );
 void OutputPairCorrelation( ofstream * const file, const BinPairMap * const map );
 void OutputCorrelationToPoint( ofstream * const file, const BinPairMap * const map );
 void OutputCorrelationToSurface( ofstream * const file, const BinPairMap * const map );
+void OutputPairCorrelation( ofstream * const file, const PairCorrelationMap * const map );
+void OutputCorrelationToPoint( ofstream * const file, const CorrelationToPointMap * const map );
+void OutputCorrelationToSurface( ofstream * const file, const CorrelationToSurfaceMap * const map );

TabularUnified src/analyzer.cpp ¶

r9fe36b	rb8d1aeb
7	7
8	8	//============================ INCLUDES ===========================
	9
	10	#include <cstring>
9	11
10	12	#include "datacreator.hpp"

TabularUnified src/atom_bondedparticle.cpp ¶

-              r9fe36b
+              rb8d1aeb
   bond *CandidateBond = NULL;
+  NoBonds = CountBonds();
   //Log() << Verbose(3) << "Walker " << *this << ": " << (int)this->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
-  NoBonds = CountBonds();
   if ((int)(type->NoValenceOrbitals) > NoBonds) { // we have a mismatch, check all bonding partners for mismatch
     for (BondList::const_iterator Runner = ListOfBonds.begin(); Runner != ListOfBonds.end(); (++Runner)) {
       OtherWalker = (*Runner)->GetOtherAtom(this);
       OtherNoBonds = OtherWalker->CountBonds();
       //Log() << Verbose(3) << "OtherWalker " << *OtherWalker << ": " << (int)OtherWalker->type->NoValenceOrbitals << " > " << NoBonds << "?" << endl;
       if ((int)(OtherWalker->type->NoValenceOrbitals) > NoBonds) { // check if possible candidate
+      //Log() << Verbose(3) << "OtherWalker " << *OtherWalker << ": " << (int)OtherWalker->type->NoValenceOrbitals << " > " << OtherNoBonds << "?" << endl;
+      if ((int)(OtherWalker->type->NoValenceOrbitals) > OtherNoBonds) { // check if possible candidate
         if ((CandidateBond == NULL) || (ListOfBonds.size() > OtherWalker->ListOfBonds.size())) { // pick the one with fewer number of bonds first
           CandidateBond = (*Runner);
 …
     if ((CandidateBond != NULL)) {
       CandidateBond->BondDegree++;
       Log() << Verbose(2) << "Increased bond degree for bond " << *CandidateBond << "." << endl;
+      //Log() << Verbose(2) << "Increased bond degree for bond " << *CandidateBond << "." << endl;
     } else {
       //Log() << Verbose(2) << "Could not find correct degree for atom " << *this << "." << endl;
+      eLog() << Verbose(2) << "Could not find correct degree for atom " << *this << "." << endl;
       FalseBondDegree++;
+    }

TabularUnified src/bondgraph.cpp ¶

-              r9fe36b
+              rb8d1aeb
 #include "bondgraph.hpp"
 #include "element.hpp"
+#include "info.hpp"
 #include "log.hpp"
 #include "molecule.hpp"
 …
 /** Parses the bond lengths in a given file and puts them int a matrix form.
  * Allocates \a MatrixContainer for BondGraph::BondLengthMatrix, using MatrixContainer::ParseMatrix(),
  * but only if parsing is successfull. Otherwise variable is left as NULL.
+ * but only if parsing is successful. Otherwise variable is left as NULL.
  * \param *out output stream for debugging
  * \param filename file with bond lengths to parse
 …
 bool BondGraph::LoadBondLengthTable(const string &filename)
+{
+  Info FunctionInfo(__func__);
   bool status = true;
   MatrixContainer *TempContainer = NULL;
 …
   // parse in matrix
+  status = TempContainer->ParseMatrix(filename.c_str(), 0, 1, 0);
+  if (status = TempContainer->ParseMatrix(filename.c_str(), 0, 1, 0)) {
+    Log() << Verbose(1) << "Parsing bond length matrix successful." << endl;
+  } else {
+    eLog() << Verbose(1) << "Parsing bond length matrix failed." << endl;
+  }
   // find greatest distance

TabularUnified src/boundary.cpp ¶

-              r9fe36b
+              rb8d1aeb
 #include "element.hpp"
 #include "helpers.hpp"
+#include "info.hpp"
 #include "linkedcell.hpp"
 #include "log.hpp"
 …
 double *GetDiametersOfCluster(const Boundaries *BoundaryPtr, const molecule *mol, Tesselation *&TesselStruct, const bool IsAngstroem)
+{
+        Info FunctionInfo(__func__);
   // get points on boundary of NULL was given as parameter
   bool BoundaryFreeFlag = false;
 …
   } else {
     BoundaryPoints = BoundaryPtr;
     Log() << Verbose(1) << "Using given boundary points set." << endl;
+    Log() << Verbose(0) << "Using given boundary points set." << endl;
+  }
   // determine biggest "diameter" of cluster for each axis
 …
           //Log() << Verbose(1) << "Current component is " << component << ", Othercomponent is " << Othercomponent << "." << endl;
           for (Boundaries::const_iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
               //Log() << Verbose(2) << "Current runner is " << *(runner->second.second) << "." << endl;
+              //Log() << Verbose(1) << "Current runner is " << *(runner->second.second) << "." << endl;
               // seek for the neighbours pair where the Othercomponent sign flips
               Neighbour = runner;
 …
                   DistanceVector.CopyVector(&runner->second.second->x);
                   DistanceVector.SubtractVector(&Neighbour->second.second->x);
                   //Log() << Verbose(3) << "OldComponent is " << OldComponent << ", new one is " << DistanceVector.x[Othercomponent] << "." << endl;
+                  //Log() << Verbose(2) << "OldComponent is " << OldComponent << ", new one is " << DistanceVector.x[Othercomponent] << "." << endl;
                 } while ((runner != Neighbour) && (fabs(OldComponent / fabs(
                   OldComponent) - DistanceVector.x[Othercomponent] / fabs(
 …
                     OtherNeighbour = BoundaryPoints[axis].end();
                   OtherNeighbour--;
                   //Log() << Verbose(2) << "The pair, where the sign of OtherComponent flips, is: " << *(Neighbour->second.second) << " and " << *(OtherNeighbour->second.second) << "." << endl;
+                  //Log() << Verbose(1) << "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);
                   //Log() << Verbose(2) << "Distances to Neighbour and OtherNeighbour are " << DistanceVector.x[component] << " and " << OtherVector.x[component] << "." << endl;
                   //Log() << Verbose(2) << "OtherComponents to Neighbour and OtherNeighbour are " << DistanceVector.x[Othercomponent] << " and " << OtherVector.x[Othercomponent] << "." << endl;
+                  //Log() << Verbose(1) << "Distances to Neighbour and OtherNeighbour are " << DistanceVector.x[component] << " and " << OtherVector.x[component] << "." << endl;
+                  //Log() << Verbose(1) << "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]);
 …
                       * OtherVector.x[component]) / (w1 + w2));
                   // mark if it has greater diameter
                   //Log() << Verbose(2) << "Comparing current greatest " << GreatestDiameter[component] << " to new " << tmp << "." << endl;
+                  //Log() << Verbose(1) << "Comparing current greatest " << GreatestDiameter[component] << " to new " << tmp << "." << endl;
                   GreatestDiameter[component] = (GreatestDiameter[component]
                       > tmp) ? GreatestDiameter[component] : tmp;
                 } //else
               //Log() << Verbose(2) << "Saw no sign flip, probably top or bottom node." << endl;
+              //Log() << Verbose(1) << "Saw no sign flip, probably top or bottom node." << endl;
+            }
+        }
 …
 Boundaries *GetBoundaryPoints(const molecule *mol, Tesselation *&TesselStruct)
+{
+        Info FunctionInfo(__func__);
   atom *Walker = NULL;
   PointMap PointsOnBoundary;
 …
   double angle = 0.;
-  Log() << Verbose(1) << "Finding all boundary points." << endl;
   // 3a. Go through every axis
   for (int axis = 0; axis < NDIM; axis++) {
 …
         angle = 0.; // otherwise it's a vector in Axis Direction and unimportant for boundary issues
       //Log() << Verbose(2) << "Checking sign in quadrant : " << ProjectedVector.Projection(&AngleReferenceNormalVector) << "." << endl;
+      //Log() << Verbose(1) << "Checking sign in quadrant : " << ProjectedVector.Projection(&AngleReferenceNormalVector) << "." << endl;
       if (ProjectedVector.ScalarProduct(&AngleReferenceNormalVector) > 0) {
         angle = 2. * M_PI - angle;
+      }
       Log() << Verbose(2) << "Inserting " << *Walker << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl;
+      Log() << Verbose(1) << "Inserting " << *Walker << ": (r, alpha) = (" << radius << "," << angle << "): " << ProjectedVector << endl;
       BoundaryTestPair = BoundaryPoints[axis].insert(BoundariesPair(angle, DistancePair (radius, Walker)));
       if (!BoundaryTestPair.second) { // same point exists, check first r, then distance of original vectors to center of gravity
 …
     // printing all inserted for debugging
     //    {
     //      Log() << Verbose(2) << "Printing list of candidates for axis " << axis << " which we have inserted so far." << endl;
+    //      Log() << Verbose(1) << "Printing list of candidates for axis " << axis << " which we have inserted so far." << endl;
     //      int i=0;
     //      for(Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
     //        if (runner != BoundaryPoints[axis].begin())
     //          Log() << Verbose(2) << ", " << i << ": " << *runner->second.second;
+    //          Log() << Verbose(0) << ", " << i << ": " << *runner->second.second;
     //        else
     //          Log() << Verbose(2) << i << ": " << *runner->second.second;
+    //          Log() << Verbose(0) << i << ": " << *runner->second.second;
     //        i++;
     //      }
     //      Log() << Verbose(2) << endl;
+    //      Log() << Verbose(0) << endl;
     //    }
     // 3c. throw out points whose distance is less than the mean of left and right neighbours
 …
           SideA.SubtractVector(MolCenter);
           SideA.ProjectOntoPlane(&AxisVector);
           //          Log() << Verbose(0) << "SideA: " << SideA << endl;
+          //          Log() << Verbose(1) << "SideA: " << SideA << endl;
           SideB.CopyVector(&right->second.second->x);
           SideB.SubtractVector(MolCenter);
           SideB.ProjectOntoPlane(&AxisVector);
           //          Log() << Verbose(0) << "SideB: " << SideB << endl;
+          //          Log() << Verbose(1) << "SideB: " << SideB << endl;
           SideC.CopyVector(&left->second.second->x);
           SideC.SubtractVector(&right->second.second->x);
           SideC.ProjectOntoPlane(&AxisVector);
           //          Log() << Verbose(0) << "SideC: " << SideC << endl;
+          //          Log() << Verbose(1) << "SideC: " << SideC << endl;
           SideH.CopyVector(&runner->second.second->x);
           SideH.SubtractVector(MolCenter);
           SideH.ProjectOntoPlane(&AxisVector);
           //          Log() << Verbose(0) << "SideH: " << SideH << endl;
+          //          Log() << Verbose(1) << "SideH: " << SideH << endl;
           // calculate each length
 …
           const double delta = SideC.Angle(&SideH);
           const double MinDistance = a * sin(beta) / (sin(delta)) * (((alpha < M_PI / 2.) || (gamma < M_PI / 2.)) ? 1. : -1.);
           //Log() << 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;
+          //Log() << Verbose(1) << " 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;
           Log() << 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)) < -MYEPSILON) {
 …
 void FindConvexBorder(const molecule* mol, Tesselation *&TesselStruct, const LinkedCell *LCList, const char *filename)
+{
+        Info FunctionInfo(__func__);
   bool BoundaryFreeFlag = false;
   Boundaries *BoundaryPoints = NULL;
-  Log() << Verbose(1) << "Begin of FindConvexBorder" << endl;
   if (TesselStruct != NULL) // free if allocated
 …
       BoundaryPoints = GetBoundaryPoints(mol, TesselStruct);
   } else {
       Log() << Verbose(1) << "Using given boundary points set." << endl;
+      Log() << Verbose(0) << "Using given boundary points set." << endl;
+  }
 …
   for (int axis=0; axis < NDIM; axis++)
+    {
       Log() << Verbose(2) << "Printing list of candidates for axis " << axis << " which we have inserted so far." << endl;
+      Log() << Verbose(1) << "Printing list of candidates for axis " << axis << " which we have inserted so far." << endl;
       int i=0;
       for(Boundaries::iterator runner = BoundaryPoints[axis].begin(); runner != BoundaryPoints[axis].end(); runner++) {
         if (runner != BoundaryPoints[axis].begin())
           Log() << Verbose(2) << ", " << i << ": " << *runner->second.second;
+          Log() << Verbose(0) << ", " << i << ": " << *runner->second.second;
         else
           Log() << Verbose(2) << i << ": " << *runner->second.second;
+          Log() << Verbose(0) << i << ": " << *runner->second.second;
         i++;
+      }
       Log() << Verbose(2) << endl;
+      Log() << Verbose(0) << endl;
+    }
 …
           eLog() << Verbose(2) << "Point " << *(runner->second.second) << " is already present!" << endl;
   Log() << Verbose(2) << "I found " << TesselStruct->PointsOnBoundaryCount << " points on the convex boundary." << endl;
+  Log() << Verbose(0) << "I found " << TesselStruct->PointsOnBoundaryCount << " points on the convex boundary." << endl;
   // now we have the whole set of edge points in the BoundaryList
 …
   //  Log() << Verbose(1) << "Listing PointsOnBoundary:";
   //  for(PointMap::iterator runner = PointsOnBoundary.begin(); runner != PointsOnBoundary.end(); runner++) {
   //    Log() << Verbose(1) << " " << *runner->second;
+  //    Log() << Verbose(0) << " " << *runner->second;
   //  }
   //  Log() << Verbose(1) << endl;
+  //  Log() << Verbose(0) << endl;
   // 3a. guess starting triangle
 …
   // 3c. check whether all atoms lay inside the boundary, if not, add to boundary points, segment triangle into three with the new point
   if (!TesselStruct->InsertStraddlingPoints(mol, LCList))
     Log() << Verbose(1) << "Insertion of straddling points failed!" << endl;
   Log() << Verbose(2) << "I created " << TesselStruct->TrianglesOnBoundary.size() << " intermediate triangles with " << TesselStruct->LinesOnBoundary.size() << " lines and " << TesselStruct->PointsOnBoundary.size() << " points." << endl;
+    eLog() << Verbose(1) << "Insertion of straddling points failed!" << endl;
+  Log() << Verbose(0) << "I created " << TesselStruct->TrianglesOnBoundary.size() << " intermediate triangles with " << TesselStruct->LinesOnBoundary.size() << " lines and " << TesselStruct->PointsOnBoundary.size() << " points." << endl;
   // 4. Store triangles in tecplot file
 …
 //    Log() << Verbose(1) << "Correction of concave tesselpoints failed!" << endl;
   Log() << Verbose(2) << "I created " << TesselStruct->TrianglesOnBoundary.size() << " triangles with " << TesselStruct->LinesOnBoundary.size() << " lines and " << TesselStruct->PointsOnBoundary.size() << " points." << endl;
+  Log() << Verbose(0) << "I created " << TesselStruct->TrianglesOnBoundary.size() << " triangles with " << TesselStruct->LinesOnBoundary.size() << " lines and " << TesselStruct->PointsOnBoundary.size() << " points." << endl;
   // 4. Store triangles in tecplot file
 …
   if (BoundaryFreeFlag)
     delete[] (BoundaryPoints);
-  Log() << Verbose(1) << "End of FindConvexBorder" << endl;
 };
 …
 bool RemoveAllBoundaryPoints(class Tesselation *&TesselStruct, const molecule * const mol, const char * const filename)
+{
+        Info FunctionInfo(__func__);
   int i=0;
   char number[MAXSTRINGSIZE];
 …
   PointMap::iterator PointRunner;
   while (!TesselStruct->PointsOnBoundary.empty()) {
     Log() << Verbose(2) << "Remaining points are: ";
+    Log() << Verbose(1) << "Remaining points are: ";
     for (PointMap::iterator PointSprinter = TesselStruct->PointsOnBoundary.begin(); PointSprinter != TesselStruct->PointsOnBoundary.end(); PointSprinter++)
       Log() << Verbose(2) << *(PointSprinter->second) << "\t";
     Log() << Verbose(2) << endl;
+      Log() << Verbose(0) << *(PointSprinter->second) << "\t";
+    Log() << Verbose(0) << endl;
     PointRunner = TesselStruct->PointsOnBoundary.begin();
 …
 double ConvexizeNonconvexEnvelope(class Tesselation *&TesselStruct, const molecule * const mol, const char * const filename)
+{
+        Info FunctionInfo(__func__);
   double volume = 0;
   class BoundaryPointSet *point = NULL;
 …
   int run = 0;
-  Log() << Verbose(0) << "Begin of ConvexizeNonconvexEnvelope" << endl;
   // check whether there is something to work on
   if (TesselStruct == NULL) {
 …
       for (LineMap::iterator LineRunner = point->lines.begin(); LineRunner != point->lines.end(); LineRunner++) {
         line = LineRunner->second;
         Log() << Verbose(2) << "INFO: Current line of point " << *point << " is " << *line << "." << endl;
+        Log() << Verbose(1) << "INFO: Current line of point " << *point << " is " << *line << "." << endl;
         if (!line->CheckConvexityCriterion()) {
           // remove the point if needed
 …
   // end
+  Log() << Verbose(1) << "Volume is " << volume << "." << endl;
+  Log() << Verbose(0) << "End of ConvexizeNonconvexEnvelope" << endl;
+  Log() << Verbose(0) << "Volume is " << volume << "." << endl;
   return volume;
 };
 …
 double VolumeOfConvexEnvelope(class Tesselation *TesselStruct, class config *configuration)
+{
+        Info FunctionInfo(__func__);
   bool IsAngstroem = configuration->GetIsAngstroem();
   double volume = 0.;
 …
   // 6a. Every triangle forms a pyramid with the center of gravity as its peak, sum up the volumes
-  Log() << 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
 …
       const double h = x.Norm(); // distance of CoG to triangle
       const double PyramidVolume = (1. / 3.) * G * h; // this formula holds for _all_ pyramids (independent of n-edge base or (not) centered peak)
       Log() << Verbose(2) << "Area of triangle is " << setprecision(10) << G << " "
+      Log() << Verbose(1) << "Area of triangle is " << setprecision(10) << G << " "
           << (IsAngstroem ? "angstrom" : "atomiclength") << "^2, height is "
           << h << " and the volume is " << PyramidVolume << " "
 …
  * \param *out output stream for debugging
  * \param *mol molecule with atoms and bonds
  * \param *&TesselStruct Tesselation with boundary triangles
+ * \param *TesselStruct Tesselation with boundary triangles
  * \param *filename prefix of filename
  * \param *extraSuffix intermediate suffix
  */
 void StoreTrianglesinFile(const molecule * const mol, const Tesselation *&TesselStruct, const char *filename, const char *extraSuffix)
+void StoreTrianglesinFile(const molecule * const mol, const Tesselation * const TesselStruct, const char *filename, const char *extraSuffix)
+{
+        Info FunctionInfo(__func__);
   // 4. Store triangles in tecplot file
   if (filename != NULL) {
 …
       OutputName.append(TecplotSuffix);
       ofstream *tecplot = new ofstream(OutputName.c_str());
       WriteTecplotFile(tecplot, TesselStruct, mol, 0);
+      WriteTecplotFile(tecplot, TesselStruct, mol, -1);
       tecplot->close();
       delete(tecplot);
 …
 void PrepareClustersinWater(config *configuration, molecule *mol, double ClusterVolume, double celldensity)
+{
+        Info FunctionInfo(__func__);
   bool IsAngstroem = true;
   double *GreatestDiameter = NULL;
 …
  * \param configuration contains box dimensions
  * \param distance[NDIM] distance between filling molecules in each direction
+ * \param boundary length of boundary zone between molecule and filling mollecules
+ * \param epsilon distance to surface which is not filled
  * \param RandAtomDisplacement maximum distance for random displacement per atom
  * \param RandMolDisplacement maximum distance for random displacement per filler molecule
 …
  * \return *mol pointer to new molecule with filled atoms
  */
 molecule * FillBoxWithMolecule(MoleculeListClass *List, molecule *filler, config &configuration, double distance[NDIM], double RandomAtomDisplacement, double RandomMolDisplacement, bool DoRandomRotation)
+molecule * FillBoxWithMolecule(MoleculeListClass *List, molecule *filler, config &configuration, const double distance[NDIM], const double boundary, const double RandomAtomDisplacement, const double RandomMolDisplacement, const bool DoRandomRotation)
+{
+        Info FunctionInfo(__func__);
   molecule *Filling = new molecule(filler->elemente);
   Vector CurrentPosition;
 …
   class Tesselation *TesselStruct[List->ListOfMolecules.size()];
-  Log() << Verbose(0) << "Begin of FillBoxWithMolecule" << endl;
   i=0;
   for (MoleculeList::iterator ListRunner = List->ListOfMolecules.begin(); ListRunner != List->ListOfMolecules.end(); ListRunner++) {
     Log() << Verbose(1) << "Pre-creating linked cell lists for molecule " << *ListRunner << "." << endl;
+    LCList[i] = new LinkedCell((*ListRunner), 5.); // get linked cell list
+    if (TesselStruct[i] == NULL) {
+      Log() << Verbose(1) << "Pre-creating tesselation for molecule " << *ListRunner << "." << endl;
+      FindNonConvexBorder((*ListRunner), TesselStruct[i], (const LinkedCell *&)LCList[i], 5., NULL);
+    }
+    LCList[i] = new LinkedCell((*ListRunner), 10.); // get linked cell list
+    Log() << Verbose(1) << "Pre-creating tesselation for molecule " << *ListRunner << "." << endl;
+    TesselStruct[i] = NULL;
+    FindNonConvexBorder((*ListRunner), TesselStruct[i], (const LinkedCell *&)LCList[i], 5., NULL);
     i++;
+  }
 …
   FillerDistance.Init(distance[0], distance[1], distance[2]);
   FillerDistance.InverseMatrixMultiplication(M);
+  Log() << Verbose(1) << "INFO: Grid steps are ";
+  for(int i=0;i<NDIM;i++) {
+  for(int i=0;i<NDIM;i++)
     N[i] = (int) ceil(1./FillerDistance.x[i]);
+    Log() << Verbose(1) << N[i];
+    if (i != NDIM-1)
+      Log() << Verbose(1)<< ", ";
+    else
+      Log() << Verbose(1) << "." << endl;
+  }
+  Log() << Verbose(1) << "INFO: Grid steps are " << N[0] << ", " << N[1] << ", " << N[2] << "." << endl;
   // go over [0,1]^3 filler grid
 …
           // get linked cell list
           if (TesselStruct[i] == NULL) {
             eLog() << Verbose(1) << "TesselStruct of " << (*ListRunner) << " is NULL. Didn't we pre-create it?" << endl;
+            eLog() << Verbose(0) << "TesselStruct of " << (*ListRunner) << " is NULL. Didn't we pre-create it?" << endl;
             FillIt = false;
           } else {
+            FillIt = FillIt && (!TesselStruct[i]->IsInnerPoint(CurrentPosition, LCList[i]));
+            const double distance = (TesselStruct[i]->GetDistanceSquaredToSurface(CurrentPosition, LCList[i]));
+            FillIt = FillIt && (distance > boundary*boundary);
+            if (FillIt) {
+              Log() << Verbose(1) << "INFO: Position at " << CurrentPosition << " is outer point." << endl;
+            } else {
+              Log() << Verbose(1) << "INFO: Position at " << CurrentPosition << " is inner point or within boundary." << endl;
+              break;
+            }
             i++;
+          }
 …
           for (int i=0;i<NDIM;i++)
             FillerTranslations.x[i] = RandomMolDisplacement*(rand()/(RAND_MAX/2.) - 1.);
           Log() << Verbose(3) << "INFO: Translating this filler by " << FillerTranslations << "." << endl;
+          Log() << Verbose(2) << "INFO: Translating this filler by " << FillerTranslations << "." << endl;
           // go through all atoms
 …
+      }
   Free(&M);
+  // output to file
+  TesselStruct[0]->LastTriangle = NULL;
+  StoreTrianglesinFile(Filling, TesselStruct[0], "Tesselated", ".dat");
   for (size_t i=0;i<List->ListOfMolecules.size();i++) {
         delete(LCList[i]);
         delete(TesselStruct[i]);
+  }
-  Log() << Verbose(0) << "End of FillBoxWithMolecule" << endl;
   return Filling;
 };
 …
  * \param RADIUS radius of the virtual sphere
  * \param *filename filename prefix for output of vertex data
+ */
+void FindNonConvexBorder(const molecule* const mol, Tesselation *&TesselStruct, const LinkedCell *&LCList, const double RADIUS, const char *filename = NULL)
+ * \return true - tesselation successful, false - tesselation failed
+ */
+bool FindNonConvexBorder(const molecule* const mol, Tesselation *&TesselStruct, const LinkedCell *&LCList, const double RADIUS, const char *filename = NULL)
+{
+        Info FunctionInfo(__func__);
   bool freeLC = false;
+  LineMap::iterator baseline;
+  bool status = false;
+  CandidateForTesselation *baseline;
   LineMap::iterator testline;
   bool OneLoopWithoutSuccessFlag = false;  // marks whether we went once through all baselines without finding any without two triangles
+  bool OneLoopWithoutSuccessFlag = true;  // marks whether we went once through all baselines without finding any without two triangles
   bool TesselationFailFlag = false;
+  Log() << Verbose(1) << "Entering search for non convex hull. " << endl;
+  BoundaryTriangleSet *T = NULL;
   if (TesselStruct == NULL) {
     Log() << Verbose(1) << "Allocating Tesselation struct ..." << endl;
 …
+  }
-  Log() << Verbose(0) << "Begin of FindNonConvexBorder\n";
   // initialise Linked Cell
   if (LCList == NULL) {
 …
   // 2. expand from there
+  baseline = TesselStruct->LinesOnBoundary.begin();
+  baseline++; // skip first line
+  while ((baseline != TesselStruct->LinesOnBoundary.end()) || (OneLoopWithoutSuccessFlag)) {
+    if (baseline->second->triangles.size() == 1) {
+      CheckListOfBaselines(TesselStruct);
+      // 3. find next triangle
+      TesselationFailFlag = TesselStruct->FindNextSuitableTriangle(*(baseline->second), *(((baseline->second->triangles.begin()))->second), RADIUS, LCList); //the line is there, so there is a triangle, but only one.
+      OneLoopWithoutSuccessFlag = OneLoopWithoutSuccessFlag || TesselationFailFlag;
+      if (!TesselationFailFlag)
+        eLog() << Verbose(2) << "FindNextSuitableTriangle failed." << endl;
+      // write temporary envelope
+      if (filename != NULL) {
+        if ((DoSingleStepOutput && ((TesselStruct->TrianglesOnBoundary.size() % SingleStepWidth == 0)))) { // if we have a new triangle and want to output each new triangle configuration
+          TesselStruct->Output(filename, mol);
+        }
+  while ((!TesselStruct->OpenLines.empty()) && (OneLoopWithoutSuccessFlag)) {
+    // 2a. fill all new OpenLines
+    Log() << Verbose(1) << "There are " << TesselStruct->OpenLines.size() << " open lines to scan for candidates:" << endl;
+    for (CandidateMap::iterator Runner = TesselStruct->OpenLines.begin(); Runner != TesselStruct->OpenLines.end(); Runner++)
+      Log() << Verbose(2) << *(Runner->second) << endl;
+    for (CandidateMap::iterator Runner = TesselStruct->OpenLines.begin(); Runner != TesselStruct->OpenLines.end(); Runner++) {
+      baseline = Runner->second;
+      if (baseline->pointlist.empty()) {
+        T = (((baseline->BaseLine->triangles.begin()))->second);
+        Log() << Verbose(1) << "Finding best candidate for open line " << *baseline->BaseLine << " of triangle " << *T << endl;
+        TesselationFailFlag = TesselStruct->FindNextSuitableTriangle(*baseline, *T, RADIUS, LCList); //the line is there, so there is a triangle, but only one.
+      }
+      if (TesselationFailFlag) {
+        baseline = TesselStruct->LinesOnBoundary.begin();
+        OneLoopWithoutSuccessFlag = false;
+        Log() << Verbose(2) << "Baseline set to begin." << endl;
+    }
+    // 2b. search for smallest ShortestAngle among all candidates
+    double ShortestAngle = 4.*M_PI;
+    Log() << Verbose(1) << "There are " << TesselStruct->OpenLines.size() << " open lines to scan for the best candidates:" << endl;
+    for (CandidateMap::iterator Runner = TesselStruct->OpenLines.begin(); Runner != TesselStruct->OpenLines.end(); Runner++)
+      Log() << Verbose(2) << *(Runner->second) << endl;
+    for (CandidateMap::iterator Runner = TesselStruct->OpenLines.begin(); Runner != TesselStruct->OpenLines.end(); Runner++) {
+      if (Runner->second->ShortestAngle < ShortestAngle) {
+        baseline = Runner->second;
+        ShortestAngle = baseline->ShortestAngle;
+        //Log() << Verbose(1) << "New best candidate is " << *baseline->BaseLine << " with point " << *baseline->point << " and angle " << baseline->ShortestAngle << endl;
+      }
+    } else {
+      //Log() << Verbose(1) << "Line " << *baseline->second << " has " << baseline->second->triangles.size() << " triangles adjacent" << endl;
+      if (baseline->second->triangles.size() != 2) {
+        eLog() << Verbose(0) << "TESSELATION FINISHED WITH INVALID TRIANGLE COUNT!" << endl;
+        performCriticalExit();
+    }
+    if ((ShortestAngle == 4.*M_PI) || (baseline->pointlist.empty()))
+      OneLoopWithoutSuccessFlag = false;
+    else {
+      TesselStruct->AddCandidateTriangle(*baseline);
+    }
+    // write temporary envelope
+    if (filename != NULL) {
+      if ((DoSingleStepOutput && ((TesselStruct->TrianglesOnBoundary.size() % SingleStepWidth == 0)))) { // if we have a new triangle and want to output each new triangle configuration
+        TesselStruct->Output(filename, mol);
+      }
+    }
+    if ((baseline == TesselStruct->LinesOnBoundary.end()) && (OneLoopWithoutSuccessFlag)) {
+      baseline = TesselStruct->LinesOnBoundary.begin();   // restart if we reach end due to newly inserted lines
+      OneLoopWithoutSuccessFlag = false;
+    }
+    baseline++;
+  }
+  // check envelope for consistency
+  CheckListOfBaselines(TesselStruct);
+  // look whether all points are inside of the convex envelope, otherwise add them via degenerated triangles
+  //->InsertStraddlingPoints(mol, LCList);
+  }
+//  // check envelope for consistency
+//  status = CheckListOfBaselines(TesselStruct);
+//
+//  // look whether all points are inside of the convex envelope, otherwise add them via degenerated triangles
+//  //->InsertStraddlingPoints(mol, LCList);
 //  mol->GoToFirst();
 //  class TesselPoint *Runner = NULL;
 …
 //  }
   // Purges surplus triangles.
   TesselStruct->RemoveDegeneratedTriangles();
+//  // Purges surplus triangles.
+//  TesselStruct->RemoveDegeneratedTriangles();
   // check envelope for consistency
+  CheckListOfBaselines(TesselStruct);
+  status = CheckListOfBaselines(TesselStruct);
+  // store before correction
+  StoreTrianglesinFile(mol, (const Tesselation *&)TesselStruct, filename, "");
+  // correct degenerated polygons
+  TesselStruct->CorrectAllDegeneratedPolygons();
+  // check envelope for consistency
+  status = CheckListOfBaselines(TesselStruct);
   // write final envelope
 …
   if (freeLC)
     delete(LCList);
+  Log() << Verbose(0) << "End of FindNonConvexBorder\n";
+  return status;
 };
 …
 Vector* FindEmbeddingHole(MoleculeListClass *mols, molecule *srcmol)
+{
+        Info FunctionInfo(__func__);
   Vector *Center = new Vector;
   Center->Zero();

TabularUnified src/boundary.hpp ¶

-              r9fe36b
+              rb8d1aeb
 #define DEBUG 1
 #define DoSingleStepOutput 1
 #define SingleStepWidth 1
+#define DoSingleStepOutput 0
+#define SingleStepWidth 10
 #define DistancePair pair < double, atom* >
 …
 double ConvexizeNonconvexEnvelope(class Tesselation *&TesselStruct, const molecule * const mol, const char * const filename);
 molecule * FillBoxWithMolecule(MoleculeListClass *List, molecule *filler, config &configuration, double distance[NDIM], double RandAtomDisplacement, double RandMolDisplacement, bool DoRandomRotation);
+molecule * FillBoxWithMolecule(MoleculeListClass *List, molecule *filler, config &configuration, const double distance[NDIM], const double boundary, const double RandomAtomDisplacement, const double RandomMolDisplacement, const bool DoRandomRotation);
 void FindConvexBorder(const molecule* const mol, Tesselation *&TesselStruct, const LinkedCell *LCList, const char *filename);
 Vector* FindEmbeddingHole(MoleculeListClass *mols, molecule *srcmol);
 void FindNextSuitablePoint(class BoundaryTriangleSet *BaseTriangle, class BoundaryLineSet *BaseLine, atom*& OptCandidate, Vector *OptCandidateCenter, double *ShortestAngle, const double RADIUS, LinkedCell *LC);
 void FindNonConvexBorder(const molecule* const mol, Tesselation *&TesselStruct, const LinkedCell *&LC, const double RADIUS, const char *tempbasename);
+bool FindNonConvexBorder(const molecule* const mol, Tesselation *&TesselStruct, const LinkedCell *&LC, const double RADIUS, const char *tempbasename);
 Boundaries *GetBoundaryPoints(const molecule *mol, Tesselation *&TesselStruct);
 double * GetDiametersOfCluster(const Boundaries *BoundaryPtr, const molecule *mol, Tesselation *&TesselStruct, const bool IsAngstroem);
 void PrepareClustersinWater(config *configuration, molecule *mol, double ClusterVolume, double celldensity);
 bool RemoveAllBoundaryPoints(class Tesselation *&TesselStruct, const molecule * const mol, const char * const filename);
 void StoreTrianglesinFile(const molecule * const mol, const Tesselation *&TesselStruct, const char *filename, const char *extraSuffix);
+void StoreTrianglesinFile(const molecule * const mol, const Tesselation * const TesselStruct, const char *filename, const char *extraSuffix);
 double VolumeOfConvexEnvelope(class Tesselation *TesselStruct, class config *configuration);

TabularUnified src/builder.cpp ¶

-              r9fe36b
+              rb8d1aeb
 using namespace std;
+#include <cstring>
 #include "analysis_correlation.hpp"
 #include "atom.hpp"
 …
 #include "Actions/MethodAction.hpp"
 #include "Actions/small_actions.hpp"
+#include "version.h"
+/********************************************* Subsubmenu routine ************************************/
+#if 0
+/** Submenu for adding atoms to the molecule.
+ * \param *periode periodentafel
+ * \param *molecule molecules with atoms
+ */
+static void AddAtoms(periodentafel *periode, molecule *mol)
+{
+  atom *first, *second, *third, *fourth;
+  Vector **atoms;
+  Vector x,y,z,n;  // coordinates for absolute point in cell volume
+  double a,b,c;
+  char choice;  // menu choice char
+  bool valid;
+  Log() << Verbose(0) << "===========ADD ATOM============================" << endl;
+  Log() << Verbose(0) << " a - state absolute coordinates of atom" << endl;
+  Log() << Verbose(0) << " b - state relative coordinates of atom wrt to reference point" << endl;
+  Log() << Verbose(0) << " c - state relative coordinates of atom wrt to already placed atom" << endl;
+  Log() << Verbose(0) << " d - state two atoms, two angles and a distance" << endl;
+  Log() << Verbose(0) << " e - least square distance position to a set of atoms" << endl;
+  Log() << Verbose(0) << "all else - go back" << endl;
+  Log() << Verbose(0) << "===============================================" << endl;
+  Log() << Verbose(0) << "Note: Specifiy angles in degrees not multiples of Pi!" << endl;
+  Log() << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+      eLog() << Verbose(2) << "Not a valid choice." << endl;
+      break;
+      case 'a': // absolute coordinates of atom
+        Log() << Verbose(0) << "Enter absolute coordinates." << endl;
+        first = new atom;
+        first->x.AskPosition(mol->cell_size, false);
+        first->type = periode->AskElement();  // give type
+        mol->AddAtom(first);  // add to molecule
+        break;
+      case 'b': // relative coordinates of atom wrt to reference point
+        first = new atom;
+        valid = true;
+        do {
+          if (!valid) eLog() << Verbose(2) << "Resulting position out of cell." << endl;
+          Log() << Verbose(0) << "Enter reference coordinates." << endl;
+          x.AskPosition(mol->cell_size, true);
+          Log() << Verbose(0) << "Enter relative coordinates." << endl;
+          first->x.AskPosition(mol->cell_size, false);
+          first->x.AddVector((const Vector *)&x);
+          Log() << Verbose(0) << "\n";
+        } while (!(valid = mol->CheckBounds((const Vector *)&first->x)));
+        first->type = periode->AskElement();  // give type
+        mol->AddAtom(first);  // add to molecule
+        break;
+      case 'c': // relative coordinates of atom wrt to already placed atom
+        first = new atom;
+        valid = true;
+        do {
+          if (!valid) eLog() << Verbose(2) << "Resulting position out of cell." << endl;
+          second = mol->AskAtom("Enter atom number: ");
+          Log() << Verbose(0) << "Enter relative coordinates." << endl;
+          first->x.AskPosition(mol->cell_size, false);
+          for (int i=NDIM;i--;) {
+            first->x.x[i] += second->x.x[i];
+          }
+        } while (!(valid = mol->CheckBounds((const Vector *)&first->x)));
+        first->type = periode->AskElement();  // give type
+        mol->AddAtom(first);  // add to molecule
+        break;
+    case 'd': // two atoms, two angles and a distance
+        first = new atom;
+        valid = true;
+        do {
+          if (!valid) {
+            eLog() << Verbose(2) << "Resulting coordinates out of cell - " << first->x << endl;
+          }
+          Log() << Verbose(0) << "First, we need two atoms, the first atom is the central, while the second is the outer one." << endl;
+          second = mol->AskAtom("Enter central atom: ");
+          third = mol->AskAtom("Enter second atom (specifying the axis for first angle): ");
+          fourth = mol->AskAtom("Enter third atom (specifying a plane for second angle): ");
+          a = ask_value("Enter distance between central (first) and new atom: ");
+          b = ask_value("Enter angle between new, first and second atom (degrees): ");
+          b *= M_PI/180.;
+          bound(&b, 0., 2.*M_PI);
+          c = ask_value("Enter second angle between new and normal vector of plane defined by first, second and third atom (degrees): ");
+          c *= M_PI/180.;
+          bound(&c, -M_PI, M_PI);
+          Log() << Verbose(0) << "radius: " << a << "\t phi: " << b*180./M_PI << "\t theta: " << c*180./M_PI << endl;
+/*
+          second->Output(1,1,(ofstream *)&cout);
+          third->Output(1,2,(ofstream *)&cout);
+          fourth->Output(1,3,(ofstream *)&cout);
+          n.MakeNormalvector((const vector *)&second->x, (const vector *)&third->x, (const vector *)&fourth->x);
+          x.Copyvector(&second->x);
+          x.SubtractVector(&third->x);
+          x.Copyvector(&fourth->x);
+          x.SubtractVector(&third->x);
+          if (!z.SolveSystem(&x,&y,&n, b, c, a)) {
+            Log() << Verbose(0) << "Failure solving self-dependent linear system!" << endl;
+            continue;
+          }
+          Log() << Verbose(0) << "resulting relative coordinates: ";
+          z.Output();
+          Log() << Verbose(0) << endl;
+          */
+          // calc axis vector
+          x.CopyVector(&second->x);
+          x.SubtractVector(&third->x);
+          x.Normalize();
+          Log() << Verbose(0) << "x: ",
+          x.Output();
+          Log() << Verbose(0) << endl;
+          z.MakeNormalVector(&second->x,&third->x,&fourth->x);
+          Log() << Verbose(0) << "z: ",
+          z.Output();
+          Log() << Verbose(0) << endl;
+          y.MakeNormalVector(&x,&z);
+          Log() << Verbose(0) << "y: ",
+          y.Output();
+          Log() << Verbose(0) << endl;
+          // rotate vector around first angle
+          first->x.CopyVector(&x);
+          first->x.RotateVector(&z,b - M_PI);
+          Log() << Verbose(0) << "Rotated vector: ",
+          first->x.Output();
+          Log() << Verbose(0) << endl;
+          // remove the projection onto the rotation plane of the second angle
+          n.CopyVector(&y);
+          n.Scale(first->x.ScalarProduct(&y));
+          Log() << Verbose(0) << "N1: ",
+          n.Output();
+          Log() << Verbose(0) << endl;
+          first->x.SubtractVector(&n);
+          Log() << Verbose(0) << "Subtracted vector: ",
+          first->x.Output();
+          Log() << Verbose(0) << endl;
+          n.CopyVector(&z);
+          n.Scale(first->x.ScalarProduct(&z));
+          Log() << Verbose(0) << "N2: ",
+          n.Output();
+          Log() << Verbose(0) << endl;
+          first->x.SubtractVector(&n);
+          Log() << Verbose(0) << "2nd subtracted vector: ",
+          first->x.Output();
+          Log() << Verbose(0) << endl;
+          // rotate another vector around second angle
+          n.CopyVector(&y);
+          n.RotateVector(&x,c - M_PI);
+          Log() << Verbose(0) << "2nd Rotated vector: ",
+          n.Output();
+          Log() << Verbose(0) << endl;
+          // add the two linear independent vectors
+          first->x.AddVector(&n);
+          first->x.Normalize();
+          first->x.Scale(a);
+          first->x.AddVector(&second->x);
+          Log() << Verbose(0) << "resulting coordinates: ";
+          first->x.Output();
+          Log() << Verbose(0) << endl;
+        } while (!(valid = mol->CheckBounds((const Vector *)&first->x)));
+        first->type = periode->AskElement();  // give type
+        mol->AddAtom(first);  // add to molecule
+        break;
+      case 'e': // least square distance position to a set of atoms
+        first = new atom;
+        atoms = new (Vector*[128]);
+        valid = true;
+        for(int i=128;i--;)
+          atoms[i] = NULL;
+        int i=0, j=0;
+        Log() << Verbose(0) << "Now we need at least three molecules.\n";
+        do {
+          Log() << Verbose(0) << "Enter " << i+1 << "th atom: ";
+          cin >> j;
+          if (j != -1) {
+            second = mol->FindAtom(j);
+            atoms[i++] = &(second->x);
+          }
+        } while ((j != -1) && (i<128));
+        if (i >= 2) {
+          first->x.LSQdistance((const Vector **)atoms, i);
+          first->x.Output();
+          first->type = periode->AskElement();  // give type
+          mol->AddAtom(first);  // add to molecule
+        } else {
+          delete first;
+          Log() << Verbose(0) << "Please enter at least two vectors!\n";
+        }
+        break;
+  };
+};
+/** Submenu for centering the atoms in the molecule.
+ * \param *mol molecule with all the atoms
+ */
+static void CenterAtoms(molecule *mol)
+{
+  Vector x, y, helper;
+  char choice;  // menu choice char
+  Log() << Verbose(0) << "===========CENTER ATOMS=========================" << endl;
+  Log() << Verbose(0) << " a - on origin" << endl;
+  Log() << Verbose(0) << " b - on center of gravity" << endl;
+  Log() << Verbose(0) << " c - within box with additional boundary" << endl;
+  Log() << Verbose(0) << " d - within given simulation box" << endl;
+  Log() << Verbose(0) << "all else - go back" << endl;
+  Log() << Verbose(0) << "===============================================" << endl;
+  Log() << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+      Log() << Verbose(0) << "Not a valid choice." << endl;
+      break;
+    case 'a':
+      Log() << Verbose(0) << "Centering atoms in config file on origin." << endl;
+      mol->CenterOrigin();
+      break;
+    case 'b':
+      Log() << Verbose(0) << "Centering atoms in config file on center of gravity." << endl;
+      mol->CenterPeriodic();
+      break;
+    case 'c':
+      Log() << Verbose(0) << "Centering atoms in config file within given additional boundary." << endl;
+      for (int i=0;i<NDIM;i++) {
+        Log() << Verbose(0) << "Enter axis " << i << " boundary: ";
+        cin >> y.x[i];
+      }
+      mol->CenterEdge(&x);  // make every coordinate positive
+      mol->Center.AddVector(&y); // translate by boundary
+      helper.CopyVector(&y);
+      helper.Scale(2.);
+      helper.AddVector(&x);
+      mol->SetBoxDimension(&helper);  // update Box of atoms by boundary
+      break;
+    case 'd':
+      Log() << Verbose(1) << "Centering atoms in config file within given simulation box." << endl;
+      for (int i=0;i<NDIM;i++) {
+        Log() << Verbose(0) << "Enter axis " << i << " boundary: ";
+        cin >> x.x[i];
+      }
+      // update Box of atoms by boundary
+      mol->SetBoxDimension(&x);
+      // center
+      mol->CenterInBox();
+      break;
+  }
+};
+/** Submenu for aligning the atoms in the molecule.
+ * \param *periode periodentafel
+ * \param *mol molecule with all the atoms
+ */
+static void AlignAtoms(periodentafel *periode, molecule *mol)
+{
+  atom *first, *second, *third;
+  Vector x,n;
+  char choice;  // menu choice char
+  Log() << Verbose(0) << "===========ALIGN ATOMS=========================" << endl;
+  Log() << Verbose(0) << " a - state three atoms defining align plane" << endl;
+  Log() << Verbose(0) << " b - state alignment vector" << endl;
+  Log() << Verbose(0) << " c - state two atoms in alignment direction" << endl;
+  Log() << Verbose(0) << " d - align automatically by least square fit" << endl;
+  Log() << Verbose(0) << "all else - go back" << endl;
+  Log() << Verbose(0) << "===============================================" << endl;
+  Log() << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+    case 'a': // three atoms defining mirror plane
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter second atom: ");
+      third = mol->AskAtom("Enter third atom: ");
+      n.MakeNormalVector((const Vector *)&first->x,(const Vector *)&second->x,(const Vector *)&third->x);
+      break;
+    case 'b': // normal vector of mirror plane
+      Log() << Verbose(0) << "Enter normal vector of mirror plane." << endl;
+      n.AskPosition(mol->cell_size,0);
+      n.Normalize();
+      break;
+    case 'c': // three atoms defining mirror plane
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter second atom: ");
+      n.CopyVector((const Vector *)&first->x);
+      n.SubtractVector((const Vector *)&second->x);
+      n.Normalize();
+      break;
+    case 'd':
+      char shorthand[4];
+      Vector a;
+      struct lsq_params param;
+      do {
+        fprintf(stdout, "Enter the element of atoms to be chosen: ");
+        fscanf(stdin, "%3s", shorthand);
+      } while ((param.type = periode->FindElement(shorthand)) == NULL);
+      Log() << Verbose(0) << "Element is " << param.type->name << endl;
+      mol->GetAlignvector(&param);
+      for (int i=NDIM;i--;) {
+        x.x[i] = gsl_vector_get(param.x,i);
+        n.x[i] = gsl_vector_get(param.x,i+NDIM);
+      }
+      gsl_vector_free(param.x);
+      Log() << Verbose(0) << "Offset vector: ";
+      x.Output();
+      Log() << Verbose(0) << endl;
+      n.Normalize();
+      break;
+  };
+  Log() << Verbose(0) << "Alignment vector: ";
+  n.Output();
+  Log() << Verbose(0) << endl;
+  mol->Align(&n);
+};
+/** Submenu for mirroring the atoms in the molecule.
+ * \param *mol molecule with all the atoms
+ */
+static void MirrorAtoms(molecule *mol)
+{
+  atom *first, *second, *third;
+  Vector n;
+  char choice;  // menu choice char
+  Log() << Verbose(0) << "===========MIRROR ATOMS=========================" << endl;
+  Log() << Verbose(0) << " a - state three atoms defining mirror plane" << endl;
+  Log() << Verbose(0) << " b - state normal vector of mirror plane" << endl;
+  Log() << Verbose(0) << " c - state two atoms in normal direction" << endl;
+  Log() << Verbose(0) << "all else - go back" << endl;
+  Log() << Verbose(0) << "===============================================" << endl;
+  Log() << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+    case 'a': // three atoms defining mirror plane
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter second atom: ");
+      third = mol->AskAtom("Enter third atom: ");
+      n.MakeNormalVector((const Vector *)&first->x,(const Vector *)&second->x,(const Vector *)&third->x);
+      break;
+    case 'b': // normal vector of mirror plane
+      Log() << Verbose(0) << "Enter normal vector of mirror plane." << endl;
+      n.AskPosition(mol->cell_size,0);
+      n.Normalize();
+      break;
+    case 'c': // three atoms defining mirror plane
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter second atom: ");
+      n.CopyVector((const Vector *)&first->x);
+      n.SubtractVector((const Vector *)&second->x);
+      n.Normalize();
+      break;
+  };
+  Log() << Verbose(0) << "Normal vector: ";
+  n.Output();
+  Log() << Verbose(0) << endl;
+  mol->Mirror((const Vector *)&n);
+};
+>>>>>>> MenuRefactoring:molecuilder/src/builder.cpp
+/** Submenu for removing the atoms from the molecule.
+ * \param *mol molecule with all the atoms
+ */
+static void RemoveAtoms(molecule *mol)
+{
+  atom *first, *second;
+  int axis;
+  double tmp1, tmp2;
+  char choice;  // menu choice char
+  Log() << Verbose(0) << "===========REMOVE ATOMS=========================" << endl;
+  Log() << Verbose(0) << " a - state atom for removal by number" << endl;
+  Log() << Verbose(0) << " b - keep only in radius around atom" << endl;
+  Log() << Verbose(0) << " c - remove this with one axis greater value" << endl;
+  Log() << Verbose(0) << "all else - go back" << endl;
+  Log() << Verbose(0) << "===============================================" << endl;
+  Log() << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+    case 'a':
+      if (mol->RemoveAtom(mol->AskAtom("Enter number of atom within molecule: ")))
+        Log() << Verbose(1) << "Atom removed." << endl;
+      else
+        Log() << Verbose(1) << "Atom not found." << endl;
+      break;
+    case 'b':
+      second = mol->AskAtom("Enter number of atom as reference point: ");
+      Log() << Verbose(0) << "Enter radius: ";
+      cin >> tmp1;
+      first = mol->start;
+      second = first->next;
+      while(second != mol->end) {
+        first = second;
+        second = first->next;
+        if (first->x.DistanceSquared((const Vector *)&second->x) > tmp1*tmp1) // distance to first above radius ...
+          mol->RemoveAtom(first);
+      }
+      break;
+    case 'c':
+      Log() << Verbose(0) << "Which axis is it: ";
+      cin >> axis;
+      Log() << Verbose(0) << "Lower boundary: ";
+      cin >> tmp1;
+      Log() << Verbose(0) << "Upper boundary: ";
+      cin >> tmp2;
+      first = mol->start;
+      second = first->next;
+      while(second != mol->end) {
+        first = second;
+        second = first->next;
+        if ((first->x.x[axis] < tmp1) || (first->x.x[axis] > tmp2)) {// out of boundary ...
+          //Log() << Verbose(0) << "Atom " << *first << " with " << first->x.x[axis] << " on axis " << axis << " is out of bounds [" << tmp1 << "," << tmp2 << "]." << endl;
+          mol->RemoveAtom(first);
+        }
+      }
+      break;
+  };
+  //mol->Output();
+  choice = 'r';
+};
+/** Submenu for measuring out the atoms in the molecule.
+ * \param *periode periodentafel
+ * \param *mol molecule with all the atoms
+ */
+static void MeasureAtoms(periodentafel *periode, molecule *mol, config *configuration)
+{
+  atom *first, *second, *third;
+  Vector x,y;
+  double min[256], tmp1, tmp2, tmp3;
+  int Z;
+  char choice;  // menu choice char
+  Log() << Verbose(0) << "===========MEASURE ATOMS=========================" << endl;
+  Log() << Verbose(0) << " a - calculate bond length between one atom and all others" << endl;
+  Log() << Verbose(0) << " b - calculate bond length between two atoms" << endl;
+  Log() << Verbose(0) << " c - calculate bond angle" << endl;
+  Log() << Verbose(0) << " d - calculate principal axis of the system" << endl;
+  Log() << Verbose(0) << " e - calculate volume of the convex envelope" << endl;
+  Log() << Verbose(0) << " f - calculate temperature from current velocity" << endl;
+  Log() << Verbose(0) << " g - output all temperatures per step from velocities" << endl;
+  Log() << Verbose(0) << "all else - go back" << endl;
+  Log() << Verbose(0) << "===============================================" << endl;
+  Log() << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch(choice) {
+    default:
+      Log() << Verbose(1) << "Not a valid choice." << endl;
+      break;
+    case 'a':
+      first = mol->AskAtom("Enter first atom: ");
+      for (int i=MAX_ELEMENTS;i--;)
+        min[i] = 0.;
+      second = mol->start;
+      while ((second->next != mol->end)) {
+        second = second->next; // advance
+        Z = second->type->Z;
+        tmp1 = 0.;
+        if (first != second) {
+          x.CopyVector((const Vector *)&first->x);
+          x.SubtractVector((const Vector *)&second->x);
+          tmp1 = x.Norm();
+        }
+        if ((tmp1 != 0.) && ((min[Z] == 0.) || (tmp1 < min[Z]))) min[Z] = tmp1;
+        //Log() << Verbose(0) << "Bond length between Atom " << first->nr << " and " << second->nr << ": " << tmp1 << " a.u." << endl;
+      }
+      for (int i=MAX_ELEMENTS;i--;)
+        if (min[i] != 0.) Log() << Verbose(0) << "Minimum Bond length between " << first->type->name << " Atom " << first->nr << " and next Ion of type " << (periode->FindElement(i))->name << ": " << min[i] << " a.u." << endl;
+      break;
+    case 'b':
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter second atom: ");
+      for (int i=NDIM;i--;)
+        min[i] = 0.;
+      x.CopyVector((const Vector *)&first->x);
+      x.SubtractVector((const Vector *)&second->x);
+      tmp1 = x.Norm();
+      Log() << Verbose(1) << "Distance vector is ";
+      x.Output();
+      Log() << Verbose(0) << "." << endl << "Norm of distance is " << tmp1 << "." << endl;
+      break;
+    case 'c':
+      Log() << Verbose(0) << "Evaluating bond angle between three - first, central, last - atoms." << endl;
+      first = mol->AskAtom("Enter first atom: ");
+      second = mol->AskAtom("Enter central atom: ");
+      third  = mol->AskAtom("Enter last atom: ");
+      tmp1 = tmp2 = tmp3 = 0.;
+      x.CopyVector((const Vector *)&first->x);
+      x.SubtractVector((const Vector *)&second->x);
+      y.CopyVector((const Vector *)&third->x);
+      y.SubtractVector((const Vector *)&second->x);
+      Log() << Verbose(0) << "Bond angle between first atom Nr." << first->nr << ", central atom Nr." << second->nr << " and last atom Nr." << third->nr << ": ";
+      Log() << Verbose(0) << (acos(x.ScalarProduct((const Vector *)&y)/(y.Norm()*x.Norm()))/M_PI*180.) << " degrees" << endl;
+      break;
+    case 'd':
+      Log() << Verbose(0) << "Evaluating prinicipal axis." << endl;
+      Log() << Verbose(0) << "Shall we rotate? [0/1]: ";
+      cin >> Z;
+      if ((Z >=0) && (Z <=1))
+        mol->PrincipalAxisSystem((bool)Z);
+      else
+        mol->PrincipalAxisSystem(false);
+      break;
+    case 'e':
+      {
+        Log() << Verbose(0) << "Evaluating volume of the convex envelope.";
+        class Tesselation *TesselStruct = NULL;
+        const LinkedCell *LCList = NULL;
+        LCList = new LinkedCell(mol, 10.);
+        FindConvexBorder(mol, TesselStruct, LCList, NULL);
+        double clustervolume = VolumeOfConvexEnvelope(TesselStruct, configuration);
+        Log() << Verbose(0) << "The tesselated surface area is " << clustervolume << "." << endl;\
+        delete(LCList);
+        delete(TesselStruct);
+      }
+      break;
+    case 'f':
+      mol->OutputTemperatureFromTrajectories((ofstream *)&cout, mol->MDSteps-1, mol->MDSteps);
+      break;
+    case 'g':
+      {
+        char filename[255];
+        Log() << Verbose(0) << "Please enter filename: " << endl;
+        cin >> filename;
+        Log() << Verbose(1) << "Storing temperatures in " << filename << "." << endl;
+        ofstream *output = new ofstream(filename, ios::trunc);
+        if (!mol->OutputTemperatureFromTrajectories(output, 0, mol->MDSteps))
+          Log() << Verbose(2) << "File could not be written." << endl;
+        else
+          Log() << Verbose(2) << "File stored." << endl;
+        output->close();
+        delete(output);
+      }
+      break;
+  }
+};
+/** Submenu for measuring out the atoms in the molecule.
+ * \param *mol molecule with all the atoms
+ * \param *configuration configuration structure for the to be written config files of all fragments
+ */
+static void FragmentAtoms(molecule *mol, config *configuration)
+{
+  int Order1;
+  clock_t start, end;
+  Log() << Verbose(0) << "Fragmenting molecule with current connection matrix ..." << endl;
+  Log() << Verbose(0) << "What's the desired bond order: ";
+  cin >> Order1;
+  if (mol->first->next != mol->last) {  // there are bonds
+    start = clock();
+    mol->FragmentMolecule(Order1, configuration);
+    end = clock();
+    Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
+  } else
+    Log() << Verbose(0) << "Connection matrix has not yet been generated!" << endl;
+};
+/********************************************** Submenu routine **************************************/
+/** Submenu for manipulating atoms.
+ * \param *periode periodentafel
+ * \param *molecules list of molecules whose atoms are to be manipulated
+ */
+static void ManipulateAtoms(periodentafel *periode, MoleculeListClass *molecules, config *configuration)
+{
+  atom *first, *second;
+  molecule *mol = NULL;
+  Vector x,y,z,n; // coordinates for absolute point in cell volume
+  double *factor; // unit factor if desired
+  double bond, minBond;
+  char choice;  // menu choice char
+  bool valid;
+  Log() << Verbose(0) << "=========MANIPULATE ATOMS======================" << endl;
+  Log() << Verbose(0) << "a - add an atom" << endl;
+  Log() << Verbose(0) << "r - remove an atom" << endl;
+  Log() << Verbose(0) << "b - scale a bond between atoms" << endl;
+  Log() << Verbose(0) << "u - change an atoms element" << endl;
+  Log() << Verbose(0) << "l - measure lengths, angles, ... for an atom" << endl;
+  Log() << Verbose(0) << "all else - go back" << endl;
+  Log() << Verbose(0) << "===============================================" << endl;
+  if (molecules->NumberOfActiveMolecules() > 1)
+    eLog() << Verbose(2) << "There is more than one molecule active! Atoms will be added to each." << endl;
+  Log() << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+      Log() << Verbose(0) << "Not a valid choice." << endl;
+      break;
+    case 'a': // add atom
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        AddAtoms(periode, mol);
+      }
+      break;
+    case 'b': // scale a bond
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        Log() << Verbose(0) << "Scaling bond length between two atoms." << endl;
+        first = mol->AskAtom("Enter first (fixed) atom: ");
+        second = mol->AskAtom("Enter second (shifting) atom: ");
+        minBond = 0.;
+        for (int i=NDIM;i--;)
+          minBond += (first->x.x[i]-second->x.x[i])*(first->x.x[i] - second->x.x[i]);
+        minBond = sqrt(minBond);
+        Log() << Verbose(0) << "Current Bond length between " << first->type->name << " Atom " << first->nr << " and " << second->type->name << " Atom " << second->nr << ": " << minBond << " a.u." << endl;
+        Log() << Verbose(0) << "Enter new bond length [a.u.]: ";
+        cin >> bond;
+        for (int i=NDIM;i--;) {
+          second->x.x[i] -= (second->x.x[i]-first->x.x[i])/minBond*(minBond-bond);
+        }
+        //Log() << Verbose(0) << "New coordinates of Atom " << second->nr << " are: ";
+        //second->Output(second->type->No, 1);
+      }
+      break;
+    case 'c': // unit scaling of the metric
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+       Log() << Verbose(0) << "Angstroem -> Bohrradius: 1.8897261\t\tBohrradius -> Angstroem: 0.52917721" << endl;
+       Log() << Verbose(0) << "Enter three factors: ";
+       factor = new double[NDIM];
+       cin >> factor[0];
+       cin >> factor[1];
+       cin >> factor[2];
+       valid = true;
+       mol->Scale((const double ** const)&factor);
+       delete[](factor);
+      }
+     break;
+    case 'l': // measure distances or angles
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        MeasureAtoms(periode, mol, configuration);
+      }
+      break;
+    case 'r': // remove atom
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        RemoveAtoms(mol);
+      }
+      break;
+    case 'u': // change an atom's element
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        int Z;
+        mol = *ListRunner;
+        Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        first = NULL;
+        do {
+          Log() << Verbose(0) << "Change the element of which atom: ";
+          cin >> Z;
+        } while ((first = mol->FindAtom(Z)) == NULL);
+        Log() << Verbose(0) << "New element by atomic number Z: ";
+        cin >> Z;
+        first->type = periode->FindElement(Z);
+        Log() << Verbose(0) << "Atom " << first->nr << "'s element is " << first->type->name << "." << endl;
+      }
+      break;
+  }
+};
+/** Submenu for manipulating molecules.
+ * \param *periode periodentafel
+ * \param *molecules list of molecule to manipulate
+ */
+static void ManipulateMolecules(periodentafel *periode, MoleculeListClass *molecules, config *configuration)
+{
+  atom *first = NULL;
+  Vector x,y,z,n; // coordinates for absolute point in cell volume
+  int j, axis, count, faktor;
+  char choice;  // menu choice char
+  molecule *mol = NULL;
+  element **Elements;
+  Vector **vectors;
+  MoleculeLeafClass *Subgraphs = NULL;
+  Log() << Verbose(0) << "=========MANIPULATE GLOBALLY===================" << endl;
+  Log() << Verbose(0) << "c - scale by unit transformation" << endl;
+  Log() << Verbose(0) << "d - duplicate molecule/periodic cell" << endl;
+  Log() << Verbose(0) << "f - fragment molecule many-body bond order style" << endl;
+  Log() << Verbose(0) << "g - center atoms in box" << endl;
+  Log() << Verbose(0) << "i - realign molecule" << endl;
+  Log() << Verbose(0) << "m - mirror all molecules" << endl;
+  Log() << Verbose(0) << "o - create connection matrix" << endl;
+  Log() << Verbose(0) << "t - translate molecule by vector" << endl;
+  Log() << Verbose(0) << "all else - go back" << endl;
+  Log() << Verbose(0) << "===============================================" << endl;
+  if (molecules->NumberOfActiveMolecules() > 1)
+    eLog() << Verbose(2) << "There is more than one molecule active! Atoms will be added to each." << endl;
+  Log() << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+      Log() << Verbose(0) << "Not a valid choice." << endl;
+      break;
+    case 'd': // duplicate the periodic cell along a given axis, given times
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        Log() << Verbose(0) << "State the axis [(+-)123]: ";
+        cin >> axis;
+        Log() << Verbose(0) << "State the factor: ";
+        cin >> faktor;
+        mol->CountAtoms(); // recount atoms
+        if (mol->AtomCount != 0) {  // if there is more than none
+          count = mol->AtomCount;  // is changed becausing of adding, thus has to be stored away beforehand
+          Elements = new element *[count];
+          vectors = new Vector *[count];
+          j = 0;
+          first = mol->start;
+          while (first->next != mol->end) { // make a list of all atoms with coordinates and element
+            first = first->next;
+            Elements[j] = first->type;
+            vectors[j] = &first->x;
+            j++;
+          }
+          if (count != j)
+            eLog() << Verbose(1) << "AtomCount " << count << " is not equal to number of atoms in molecule " << j << "!" << endl;
+          x.Zero();
+          y.Zero();
+          y.x[abs(axis)-1] = mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] * abs(axis)/axis; // last term is for sign, first is for magnitude
+          for (int i=1;i<faktor;i++) {  // then add this list with respective translation factor times
+            x.AddVector(&y); // per factor one cell width further
+            for (int k=count;k--;) { // go through every atom of the original cell
+              first = new atom(); // create a new body
+              first->x.CopyVector(vectors[k]);  // use coordinate of original atom
+              first->x.AddVector(&x);     // translate the coordinates
+              first->type = Elements[k];  // insert original element
+              mol->AddAtom(first);        // and add to the molecule (which increments ElementsInMolecule, AtomCount, ...)
+            }
+          }
+          if (mol->first->next != mol->last) // if connect matrix is present already, redo it
+            mol->CreateAdjacencyList(mol->BondDistance, configuration->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
+          // free memory
+          delete[](Elements);
+          delete[](vectors);
+          // correct cell size
+          if (axis < 0) { // if sign was negative, we have to translate everything
+            x.Zero();
+            x.AddVector(&y);
+            x.Scale(-(faktor-1));
+            mol->Translate(&x);
+          }
+          mol->cell_size[(abs(axis) == 2) ? 2 : ((abs(axis) == 3) ? 5 : 0)] *= faktor;
+        }
+      }
+      break;
+    case 'f':
+      FragmentAtoms(mol, configuration);
+      break;
+    case 'g': // center the atoms
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        CenterAtoms(mol);
+      }
+      break;
+    case 'i': // align all atoms
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        AlignAtoms(periode, mol);
+      }
+      break;
+    case 'm': // mirror atoms along a given axis
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        MirrorAtoms(mol);
+      }
+      break;
+    case 'o': // create the connection matrix
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+          mol = *ListRunner;
+          double bonddistance;
+          clock_t start,end;
+          Log() << Verbose(0) << "What's the maximum bond distance: ";
+          cin >> bonddistance;
+          start = clock();
+          mol->CreateAdjacencyList(bonddistance, configuration->GetIsAngstroem(), &BondGraph::CovalentMinMaxDistance, NULL);
+          end = clock();
+          Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
+        }
+      break;
+    case 't': // translate all atoms
+      for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if ((*ListRunner)->ActiveFlag) {
+        mol = *ListRunner;
+        Log() << Verbose(0) << "Current molecule is: " << mol->IndexNr << "\t" << mol->name << endl;
+        Log() << Verbose(0) << "Enter translation vector." << endl;
+        x.AskPosition(mol->cell_size,0);
+        mol->Center.AddVector((const Vector *)&x);
+     }
+     break;
+  }
+  // Free all
+  if (Subgraphs != NULL) {  // free disconnected subgraph list of DFS analysis was performed
+    while (Subgraphs->next != NULL) {
+      Subgraphs = Subgraphs->next;
+      delete(Subgraphs->previous);
+    }
+    delete(Subgraphs);
+  }
+};
+/** Submenu for creating new molecules.
+ * \param *periode periodentafel
+ * \param *molecules list of molecules to add to
+ */
+static void EditMolecules(periodentafel *periode, MoleculeListClass *molecules)
+{
+  char choice;  // menu choice char
+  Vector center;
+  int nr, count;
+  molecule *mol = NULL;
+  Log() << Verbose(0) << "==========EDIT MOLECULES=====================" << endl;
+  Log() << Verbose(0) << "c - create new molecule" << endl;
+  Log() << Verbose(0) << "l - load molecule from xyz file" << endl;
+  Log() << Verbose(0) << "n - change molecule's name" << endl;
+  Log() << Verbose(0) << "N - give molecules filename" << endl;
+  Log() << Verbose(0) << "p - parse atoms in xyz file into molecule" << endl;
+  Log() << Verbose(0) << "r - remove a molecule" << endl;
+  Log() << Verbose(0) << "all else - go back" << endl;
+  Log() << Verbose(0) << "===============================================" << endl;
+  Log() << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+      Log() << Verbose(0) << "Not a valid choice." << endl;
+      break;
+    case 'c':
+      mol = new molecule(periode);
+      molecules->insert(mol);
+      break;
+    case 'l': // load from XYZ file
+      {
+        char filename[MAXSTRINGSIZE];
+        Log() << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
+        mol = new molecule(periode);
+        do {
+          Log() << Verbose(0) << "Enter file name: ";
+          cin >> filename;
+        } while (!mol->AddXYZFile(filename));
+        mol->SetNameFromFilename(filename);
+        // center at set box dimensions
+        mol->CenterEdge(&center);
+        mol->cell_size[0] = center.x[0];
+        mol->cell_size[1] = 0;
+        mol->cell_size[2] = center.x[1];
+        mol->cell_size[3] = 0;
+        mol->cell_size[4] = 0;
+        mol->cell_size[5] = center.x[2];
+        molecules->insert(mol);
+      }
+      break;
+    case 'n':
+      {
+        char filename[MAXSTRINGSIZE];
+        do {
+          Log() << Verbose(0) << "Enter index of molecule: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while (mol == NULL);
+        Log() << Verbose(0) << "Enter name: ";
+        cin >> filename;
+        strcpy(mol->name, filename);
+      }
+      break;
+    case 'N':
+      {
+        char filename[MAXSTRINGSIZE];
+        do {
+          Log() << Verbose(0) << "Enter index of molecule: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while (mol == NULL);
+        Log() << Verbose(0) << "Enter name: ";
+        cin >> filename;
+        mol->SetNameFromFilename(filename);
+      }
+      break;
+    case 'p': // parse XYZ file
+      {
+        char filename[MAXSTRINGSIZE];
+        mol = NULL;
+        do {
+          Log() << Verbose(0) << "Enter index of molecule: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while (mol == NULL);
+        Log() << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
+        do {
+          Log() << Verbose(0) << "Enter file name: ";
+          cin >> filename;
+        } while (!mol->AddXYZFile(filename));
+        mol->SetNameFromFilename(filename);
+      }
+      break;
+    case 'r':
+      Log() << Verbose(0) << "Enter index of molecule: ";
+      cin >> nr;
+      count = 1;
+      for(MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+        if (nr == (*ListRunner)->IndexNr) {
+          mol = *ListRunner;
+          molecules->ListOfMolecules.erase(ListRunner);
+          delete(mol);
+          break;
+        }
+      break;
+  }
+};
+/** Submenu for merging molecules.
+ * \param *periode periodentafel
+ * \param *molecules list of molecules to add to
+ */
+static void MergeMolecules(periodentafel *periode, MoleculeListClass *molecules)
+{
+  char choice;  // menu choice char
+  Log() << Verbose(0) << "===========MERGE MOLECULES=====================" << endl;
+  Log() << Verbose(0) << "a - simple add of one molecule to another" << endl;
+  Log() << Verbose(0) << "e - embedding merge of two molecules" << endl;
+  Log() << Verbose(0) << "m - multi-merge of all molecules" << endl;
+  Log() << Verbose(0) << "s - scatter merge of two molecules" << endl;
+  Log() << Verbose(0) << "t - simple merge of two molecules" << endl;
+  Log() << Verbose(0) << "all else - go back" << endl;
+  Log() << Verbose(0) << "===============================================" << endl;
+  Log() << Verbose(0) << "INPUT: ";
+  cin >> choice;
+  switch (choice) {
+    default:
+      Log() << Verbose(0) << "Not a valid choice." << endl;
+      break;
+    case 'a':
+      {
+        int src, dest;
+        molecule *srcmol = NULL, *destmol = NULL;
+        {
+          do {
+            Log() << Verbose(0) << "Enter index of destination molecule: ";
+            cin >> dest;
+            destmol = molecules->ReturnIndex(dest);
+          } while ((destmol == NULL) && (dest != -1));
+          do {
+            Log() << Verbose(0) << "Enter index of source molecule to add from: ";
+            cin >> src;
+            srcmol = molecules->ReturnIndex(src);
+          } while ((srcmol == NULL) && (src != -1));
+          if ((src != -1) && (dest != -1))
+            molecules->SimpleAdd(srcmol, destmol);
+        }
+      }
+      break;
+    case 'e':
+      {
+        int src, dest;
+        molecule *srcmol = NULL, *destmol = NULL;
+        do {
+          Log() << Verbose(0) << "Enter index of matrix molecule (the variable one): ";
+          cin >> src;
+          srcmol = molecules->ReturnIndex(src);
+        } while ((srcmol == NULL) && (src != -1));
+        do {
+          Log() << Verbose(0) << "Enter index of molecule to merge into (the fixed one): ";
+          cin >> dest;
+          destmol = molecules->ReturnIndex(dest);
+        } while ((destmol == NULL) && (dest != -1));
+        if ((src != -1) && (dest != -1))
+          molecules->EmbedMerge(destmol, srcmol);
+      }
+      break;
+    case 'm':
+      {
+        int nr;
+        molecule *mol = NULL;
+        do {
+          Log() << Verbose(0) << "Enter index of molecule to merge into: ";
+          cin >> nr;
+          mol = molecules->ReturnIndex(nr);
+        } while ((mol == NULL) && (nr != -1));
+        if (nr != -1) {
+          int N = molecules->ListOfMolecules.size()-1;
+          int *src = new int(N);
+          for(MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+            if ((*ListRunner)->IndexNr != nr)
+              src[N++] = (*ListRunner)->IndexNr;
+          molecules->SimpleMultiMerge(mol, src, N);
+          delete[](src);
+        }
+      }
+      break;
+    case 's':
+      Log() << Verbose(0) << "Not implemented yet." << endl;
+      break;
+    case 't':
+      {
+        int src, dest;
+        molecule *srcmol = NULL, *destmol = NULL;
+        {
+          do {
+            Log() << Verbose(0) << "Enter index of destination molecule: ";
+            cin >> dest;
+            destmol = molecules->ReturnIndex(dest);
+          } while ((destmol == NULL) && (dest != -1));
+          do {
+            Log() << Verbose(0) << "Enter index of source molecule to merge into: ";
+            cin >> src;
+            srcmol = molecules->ReturnIndex(src);
+          } while ((srcmol == NULL) && (src != -1));
+          if ((src != -1) && (dest != -1))
+            molecules->SimpleMerge(srcmol, destmol);
+        }
+      }
+      break;
+  }
+};
+/********************************************** Test routine **************************************/
+/** Is called always as option 'T' in the menu.
+ * \param *molecules list of molecules
+ */
+static void testroutine(MoleculeListClass *molecules)
+{
+  // the current test routine checks the functionality of the KeySet&Graph concept:
+  // We want to have a multiindex (the KeySet) describing a unique subgraph
+  int i, comp, counter=0;
+  // create a clone
+  molecule *mol = NULL;
+  if (molecules->ListOfMolecules.size() != 0) // clone
+    mol = (molecules->ListOfMolecules.front())->CopyMolecule();
+  else {
+    eLog() << Verbose(0) << "I don't have anything to test on ... ";
+    performCriticalExit();
+    return;
+  }
+  atom *Walker = mol->start;
+  // generate some KeySets
+  Log() << Verbose(0) << "Generating KeySets." << endl;
+  KeySet TestSets[mol->AtomCount+1];
+  i=1;
+  while (Walker->next != mol->end) {
+    Walker = Walker->next;
+    for (int j=0;j<i;j++) {
+      TestSets[j].insert(Walker->nr);
+    }
+    i++;
+  }
+  Log() << Verbose(0) << "Testing insertion of already present item in KeySets." << endl;
+  KeySetTestPair test;
+  test = TestSets[mol->AtomCount-1].insert(Walker->nr);
+  if (test.second) {
+    Log() << Verbose(1) << "Insertion worked?!" << endl;
+  } else {
+    Log() << Verbose(1) << "Insertion rejected: Present object is " << (*test.first) << "." << endl;
+  }
+  TestSets[mol->AtomCount].insert(mol->end->previous->nr);
+  TestSets[mol->AtomCount].insert(mol->end->previous->previous->previous->nr);
+  // constructing Graph structure
+  Log() << Verbose(0) << "Generating Subgraph class." << endl;
+  Graph Subgraphs;
+  // insert KeySets into Subgraphs
+  Log() << Verbose(0) << "Inserting KeySets into Subgraph class." << endl;
+  for (int j=0;j<mol->AtomCount;j++) {
+    Subgraphs.insert(GraphPair (TestSets[j],pair<int, double>(counter++, 1.)));
+  }
+  Log() << Verbose(0) << "Testing insertion of already present item in Subgraph." << endl;
+  GraphTestPair test2;
+  test2 = Subgraphs.insert(GraphPair (TestSets[mol->AtomCount],pair<int, double>(counter++, 1.)));
+  if (test2.second) {
+    Log() << Verbose(1) << "Insertion worked?!" << endl;
+  } else {
+    Log() << Verbose(1) << "Insertion rejected: Present object is " << (*(test2.first)).second.first << "." << endl;
+  }
+  // show graphs
+  Log() << Verbose(0) << "Showing Subgraph's contents, checking that it's sorted." << endl;
+  Graph::iterator A = Subgraphs.begin();
+  while (A !=  Subgraphs.end()) {
+    Log() << Verbose(0) << (*A).second.first << ": ";
+    KeySet::iterator key = (*A).first.begin();
+    comp = -1;
+    while (key != (*A).first.end()) {
+      if ((*key) > comp)
+        Log() << Verbose(0) << (*key) << " ";
+      else
+        Log() << Verbose(0) << (*key) << "! ";
+      comp = (*key);
+      key++;
+    }
+    Log() << Verbose(0) << endl;
+    A++;
+  }
+  delete(mol);
+};
+#endif
 /** Parses the command line options.
 …
   int argptr;
   molecule *mol = NULL;
   string BondGraphFileName("");
+  string BondGraphFileName("\n");
   int verbosity = 0;
   strncpy(configuration.databasepath, LocalPath, MAXSTRINGSIZE-1);
 …
             Log() << Verbose(0) << "\t-B xx xy xz yy yz zz\tBound atoms by domain with given symmetric matrix of (xx,xy,xz,yy,yz,zz)." << endl;
             Log() << Verbose(0) << "\t-c x1 x2 x3\tCenter atoms in domain with a minimum distance to boundary of (x1,x2,x3)." << endl;
             Log() << Verbose(0) << "\t-C\tPair Correlation analysis." << endl;
+            Log() << Verbose(0) << "\t-C <Z> <output> <bin output>\tPair Correlation analysis." << endl;
             Log() << Verbose(0) << "\t-d x1 x2 x3\tDuplicate cell along each axis by given factor." << endl;
             Log() << Verbose(0) << "\t-D <bond distance>\tDepth-First-Search Analysis of the molecule, giving cycles and tree/back edges." << endl;
             Log() << Verbose(0) << "\t-e <file>\tSets the databases path to be parsed (default: ./)." << endl;
             Log() << Verbose(0) << "\t-E <id> <Z>\tChange atom <id>'s element to <Z>, <id> begins at 0." << endl;
+            Log() << Verbose(0) << "\t-f/F <dist> <order>\tFragments the molecule in BOSSANOVA manner (with/out rings compressed) and stores config files in same dir as config (return code 0 - fragmented, 2 - no fragmentation necessary)." << endl;
+            Log() << Verbose(0) << "\t-f <dist> <order>\tFragments the molecule in BOSSANOVA manner (with/out rings compressed) and stores config files in same dir as config (return code 0 - fragmented, 2 - no fragmentation necessary)." << endl;
+            Log() << Verbose(0) << "\t-F <dist_x> <dist_y> <dist_z> <epsilon> <randatom> <randmol> <DoRotate>\tFilling Box with water molecules." << endl;
             Log() << Verbose(0) << "\t-g <file>\tParses a bond length table from the given file." << endl;
             Log() << Verbose(0) << "\t-h/-H/-?\tGive this help screen." << endl;
+            Log() << Verbose(0) << "\t-I\t Dissect current system of molecules into a set of disconnected (subgraphs of) molecules." << endl;
             Log() << Verbose(0) << "\t-L <step0> <step1> <prefix>\tStore a linear interpolation between two configurations <step0> and <step1> into single config files with prefix <prefix> and as Trajectories into the current config file." << endl;
             Log() << Verbose(0) << "\t-m <0/1>\tCalculate (0)/ Align in(1) PAS with greatest EV along z axis." << endl;
 …
        mol = new molecule(periode);
        mol->ActiveFlag = true;
+       if (ConfigFileName != NULL)
+         mol->SetNameFromFilename(ConfigFileName);
        molecules->insert(mol);
+     }
+     if (configuration.BG == NULL) {
+       configuration.BG = new BondGraph(configuration.GetIsAngstroem());
+       if ((!BondGraphFileName.empty()) && (configuration.BG->LoadBondLengthTable(BondGraphFileName))) {
+         Log() << Verbose(0) << "Bond length table loaded successfully." << endl;
+       } else {
+         eLog() << Verbose(1) << "Bond length table loading failed." << endl;
+       }
+     }
 …
               //argptr+=1;
               break;
+            case 'I':
+              Log() << Verbose(1) << "Dissecting molecular system into a set of disconnected subgraphs ... " << endl;
+              // @TODO rather do the dissection afterwards
+              molecules->DissectMoleculeIntoConnectedSubgraphs(periode, &configuration);
+              mol = NULL;
+              if (molecules->ListOfMolecules.size() != 0) {
+                for (MoleculeList::iterator ListRunner = molecules->ListOfMolecules.begin(); ListRunner != molecules->ListOfMolecules.end(); ListRunner++)
+                  if ((*ListRunner)->ActiveFlag) {
+                    mol = *ListRunner;
+                    break;
+                  }
+              }
+              if (mol == NULL) {
+                mol = *(molecules->ListOfMolecules.begin());
+                mol->ActiveFlag = true;
+              }
+              break;
             case 'C':
               if (ExitFlag == 0) ExitFlag = 1;
 …
                 performCriticalExit();
               } else {
-                SaveFlag = false;
                 ofstream output(argv[argptr+1]);
                 ofstream binoutput(argv[argptr+2]);
 …
                 counter = 0;
                 for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++) {
                   Actives[counter] = (*BigFinder)->ActiveFlag;
+                  Actives[counter++] = (*BigFinder)->ActiveFlag;
                   (*BigFinder)->ActiveFlag = (*BigFinder == Boundary) ? false : true;
+                }
 …
                 int ranges[NDIM] = {1,1,1};
                 CorrelationToSurfaceMap *surfacemap = PeriodicCorrelationToSurface( molecules, elemental, TesselStruct, LCList, ranges );
+                //OutputCorrelationToSurface(&output, surfacemap);
                 BinPairMap *binmap = BinData( surfacemap, 0.5, 0., 0. );
                 OutputCorrelation ( &binoutput, binmap );
 …
                 binoutput.close();
                 for (MoleculeList::iterator BigFinder = molecules->ListOfMolecules.begin(); BigFinder != molecules->ListOfMolecules.end(); BigFinder++)
                   (*BigFinder)->ActiveFlag = Actives[counter];
+                  (*BigFinder)->ActiveFlag = Actives[counter++];
                 Free(&Actives);
                 delete(LCList);
 …
             case 'F':
               if (ExitFlag == 0) ExitFlag = 1;
               if (argptr+5 >=argc) {
+              if (argptr+6 >=argc) {
                 ExitFlag = 255;
                 eLog() << Verbose(0) << "Not enough or invalid arguments given for filling box with water: -F <dist_x> <dist_y> <dist_z> <randatom> <randmol> <DoRotate>" << endl;
+                eLog() << Verbose(0) << "Not enough or invalid arguments given for filling box with water: -F <dist_x> <dist_y> <dist_z> <boundary> <randatom> <randmol> <DoRotate>" << endl;
                 performCriticalExit();
               } else {
 …
                 Log() << Verbose(1) << "Filling Box with water molecules." << endl;
                 // construct water molecule
                 molecule *filler = new molecule(periode);;
+                molecule *filler = new molecule(periode);
                 molecule *Filling = NULL;
                 atom *second = NULL, *third = NULL;
+//                first = new atom();
+//                first->type = periode->FindElement(5);
+//                first->x.Zero();
+//                filler->AddAtom(first);
                 first = new atom();
                 first->type = periode->FindElement(1);
 …
                 for (int i=0;i<NDIM;i++)
                   distance[i] = atof(argv[argptr+i]);
                 Filling = FillBoxWithMolecule(molecules, filler, configuration, distance, atof(argv[argptr+3]), atof(argv[argptr+4]), atoi(argv[argptr+5]));
+                Filling = FillBoxWithMolecule(molecules, filler, configuration, distance, atof(argv[argptr+3]), atof(argv[argptr+4]), atof(argv[argptr+5]), atoi(argv[argptr+6]));
                 if (Filling != NULL) {
+                  Filling->ActiveFlag = false;
                   molecules->insert(Filling);
+                }
 …
                 start = clock();
                 LCList = new LinkedCell(Boundary, atof(argv[argptr])*2.);
+                FindNonConvexBorder(Boundary, T, LCList, atof(argv[argptr]), argv[argptr+1]);
+                if (!FindNonConvexBorder(Boundary, T, LCList, atof(argv[argptr]), argv[argptr+1]))
+                  ExitFlag = 255;
                 //FindDistributionOfEllipsoids(T, &LCList, N, number, filename.c_str());
                 end = clock();
                 Log() << Verbose(0) << "Clocks for this operation: " << (end-start) << ", time: " << ((double)(end-start)/CLOCKS_PER_SEC) << "s." << endl;
                 delete(LCList);
+                delete(T);
                 argptr+=2;
+              }
 …
                 if (volume != -1)
                   ExitFlag = 255;
                   eLog() << Verbose(0) << "Not enough arguments given for suspension: -u <density>" << endl;
+                  eLog() << Verbose(0) << "Not enough or invalid arguments given for suspension: -u <density>" << endl;
                   performCriticalExit();
               } else {
 …
   Action *eraseMoleculeAction = new MethodAction("eraseMoleculeAction",boost::bind(&MoleculeListClass::eraseMolecule,molecules));
   new ActionMenuItem('r',"remove a molecule",editMoleculesMenu,eraseMoleculeAction);
+}
 …
+    {
+      cout << ESPACKVersion << endl;
+      setVerbosity(0);
       menuPopulaters populaters;
       populaters.MakeEditMoleculesMenu = populateEditMoleculesMenu;
 …
       MainWindow *mainWindow = UIFactory::get()->makeMainWindow(populaters,molecules, configuration, periode, ConfigFileName);
       mainWindow->display();
       delete mainWindow;
+    }

TabularUnified src/config.cpp ¶

-              r9fe36b
+              rb8d1aeb
 #include <stdio.h>
+#include <cstring>
 #include "atom.hpp"
 …
     char number1[8];
     char number2[8];
     char *dummy1, *dummy2;
+    const char *dummy1, *dummy2;
     //Log() << Verbose(0) << s1 << "  " << s2 << endl;
     dummy1 = strchr(s1, '_')+sizeof(char)*5;  // go just after "Ion_Type"
 …
 void ConfigFileBuffer::MapIonTypesInBuffer(const int NoAtoms)
+{
   map<const char *, int, IonTypeCompare> LineList;
+  map<const char *, int, IonTypeCompare> IonTypeLineMap;
   if (LineMapping == NULL) {
     eLog() << Verbose(0) << "map pointer is NULL: " << LineMapping << endl;
 …
   // put all into hashed map
   for (int i=0; i<NoAtoms; ++i) {
     LineList.insert(pair<const char *, int> (buffer[CurrentLine+i], CurrentLine+i));
+    IonTypeLineMap.insert(pair<const char *, int> (buffer[CurrentLine+i], CurrentLine+i));
+  }
   // fill map
   int nr=0;
   for (map<const char *, int, IonTypeCompare>::iterator runner = LineList.begin(); runner != LineList.end(); ++runner) {
+  for (map<const char *, int, IonTypeCompare>::iterator runner = IonTypeLineMap.begin(); runner != IonTypeLineMap.end(); ++runner) {
     if (CurrentLine+nr < NoLines)
       LineMapping[CurrentLine+(nr++)] = runner->second;
 …
   // 2. parse the bond graph file if given
+  BG = new BondGraph(IsAngstroem);
+  if (BG->LoadBondLengthTable(BondGraphFileName)) {
+    Log() << Verbose(0) << "Bond length table loaded successfully." << endl;
+  } else {
+    eLog() << Verbose(1) << "Bond length table loading failed." << endl;
+  if (BG == NULL) {
+    BG = new BondGraph(IsAngstroem);
+    if (BG->LoadBondLengthTable(BondGraphFileName)) {
+      Log() << Verbose(0) << "Bond length table loaded successfully." << endl;
+    } else {
+      eLog() << Verbose(1) << "Bond length table loading failed." << endl;
+    }
+  }
   // 3. parse the molecule in
   LoadMolecule(mol, FileBuffer, periode, FastParsing);
+  mol->SetNameFromFilename(filename);
   mol->ActiveFlag = true;
+  MolList->insert(mol);
   // 4. dissect the molecule into connected subgraphs
+  MolList->DissectMoleculeIntoConnectedSubgraphs(mol,this);
+  delete(mol);
+  // don't do this here ...
+  //MolList->DissectMoleculeIntoConnectedSubgraphs(mol,this);
+  //delete(mol);
   delete(FileBuffer);
 };
 …
   ofstream output;
   molecule *mol = new molecule(periode);
+  mol->SetNameFromFilename(ConfigFileName);
   if (!strcmp(configpath, GetDefaultPath())) {
 …
   if (ConfigFileName != NULL)
     strcpy(filename, ConfigFileName);
   else
+  if (output == NULL)
     strcpy(filename,"main_pcp_linux");
   Log() << Verbose(0) << "Saving as pdb input ";
 …
   if (ConfigFileName != NULL)
     strcpy(filename, ConfigFileName);
   else
+  if (output == NULL)
     strcpy(filename,"main_pcp_linux");
   Log() << Verbose(0) << "Saving as tremolo data input ";
 …
     output.open(filename, ios::trunc);
+  }
   else {
+  if (output == NULL) {
     strcpy(filename,"main_pcp_linux");
     strcat(filename, ".xyz");
 …
   if (ConfigFileName != NULL)
     strcpy(filename, ConfigFileName);
   else
+  if (output == NULL)
     strcpy(filename,"main_pcp_linux");
   Log() << Verbose(0) << "Saving as mpqc input ";
 …
+              }
               line++;
             } while (dummy1 != NULL && (dummy1[0] == '#') || (dummy1[0] == '\n'));
+            } while ((dummy1 != NULL) && ((dummy1[0] == '#') || (dummy1[0] == '\n')));
             dummy = dummy1;
           } else { // simple int, strings or doubles start in the same line

TabularUnified src/helpers.hpp ¶

-              r9fe36b
+              rb8d1aeb
   x = y;
   y = tmp;
+};
+/** returns greater of the two values.
+ * \param x first value
+ * \param y second value
+ * \return greater of the two (by operator>())
+ */
+template <typename T> T Max(T x, T y)
+{
+  if (x > y)
+    return x;
+  else return y;
+};
+/** returns smaller of the two values.
+ * \param x first value
+ * \param y second value
+ * \return smaller of the two (by operator<())
+ */
+template <typename T> T Min(T x, T y)
+{
+  if (x < y)
+    return x;
+  else return y;
 };

TabularUnified src/joiner.cpp ¶

r9fe36b	rb8d1aeb
7	7
8	8	//============================ INCLUDES ===========================
	9
	10	#include <cstring>
9	11
10	12	#include "datacreator.hpp"

TabularUnified src/memoryallocator.hpp ¶

r9fe36b	rb8d1aeb
16	16	#endif
17	17
	18	#include <cstdlib>
18	19	#include <iostream>
19	20	#include <iomanip>

TabularUnified src/memoryusageobserver.cpp ¶

r9fe36b	rb8d1aeb
4	4	* This class represents a Singleton for observing memory usage.
5	5	*/
	6
	7	#include <cstdlib>
6	8
7	9	#include "log.hpp"

TabularUnified src/molecule.cpp ¶

-              r9fe36b
+              rb8d1aeb
+ *
  */
+#include <cstring>
 #include "atom.hpp"
 …
   else
     molname = filename; // contains no slashes
   char *endname = strchr(molname, '.');
+  const char *endname = strchr(molname, '.');
   if ((endname == NULL) || (endname < molname))
     length = strlen(molname);

TabularUnified src/molecule.hpp ¶

-              r9fe36b
+              rb8d1aeb
   // re-definition of virtual functions from PointCloud
+  const char * const GetName() const;
   Vector *GetCenter() const ;
   TesselPoint *GetPoint() const ;
   TesselPoint *GetTerminalPoint() const ;
+  int GetMaxId() const;
   void GoToNext() const ;
   void GoToPrevious() const ;
 …
   void Enumerate(ofstream *out);
   void Output(ofstream *out);
   void DissectMoleculeIntoConnectedSubgraphs(molecule * const mol, config * const configuration);
+  void DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration);
   int CountAllAtoms() const;

TabularUnified src/molecule_dynamics.cpp ¶

-              r9fe36b
+              rb8d1aeb
   // argument minimise the constrained potential in this injective PermutationMap
   Log() << Verbose(1) << "Argument minimising the PermutationMap, at current potential " << OldPotential << " ... " << endl;
+  Log() << Verbose(1) << "Argument minimising the PermutationMap." << endl;
   OldPotential = 1e+10;
   round = 0;
   do {
     Log() << Verbose(2) << "Starting round " << ++round << " ... " << endl;
+    Log() << Verbose(2) << "Starting round " << ++round << ", at current potential " << OldPotential << " ... " << endl;
     OlderPotential = OldPotential;
     do {

TabularUnified src/molecule_fragmentation.cpp ¶

r9fe36b	rb8d1aeb
5	5	* Author: heber
6	6	*/
	7
	8	#include <cstring>
7	9
8	10	#include "atom.hpp"

TabularUnified src/molecule_geometry.cpp ¶

-              r9fe36b
+              rb8d1aeb
+{
   int Num = 0;
   atom *ptr = start->next;  // start at first in list
+  atom *ptr = start;  // start at first in list
   Center.Zero();
   if (ptr != end) {   //list not empty?
+  if (ptr->next != end) {   //list not empty?
     while (ptr->next != end) {  // continue with second if present
       ptr = ptr->next;

TabularUnified src/molecule_graph.cpp ¶

-              r9fe36b
+              rb8d1aeb
   bool status = true;
   if (ReferenceStack->IsEmpty()) {
+    eLog() << Verbose(0) << "ReferenceStack is empty!" << endl;
+    performCriticalExit();
+    Log() << Verbose(1) << "ReferenceStack is empty!" << endl;
     return false;
+  }

TabularUnified src/molecule_pointcloud.cpp ¶

-              r9fe36b
+              rb8d1aeb
 /************************************* Functions for class molecule *********************************/
+/** Returns a name for this point cloud, here the molecule's name.
+ * \return name of point cloud
+ */
+const char * const molecule::GetName() const
+{
+  return name;
+};
 /** Determine center of all atoms.
 …
+{
   return end;
+};
+/** Return the greatest index of all atoms in the list.
+ * \return greatest index
+ */
+int molecule::GetMaxId() const
+{
+  return last_atom;
 };

TabularUnified src/moleculelist.cpp ¶

-              r9fe36b
+              rb8d1aeb
+ *
  */
+#include <cstring>
 #include "atom.hpp"
 …
   input.open(line.c_str());
   if (input == NULL) {
+    eLog() << Verbose(0) << endl << "Unable to open " << line << ", is the directory correct?" << endl;
+    performCriticalExit();
+    Log() << Verbose(1) << endl << "Unable to open " << line << ", is the directory correct?" << endl;
     return false;
+  }
 …
 /** Dissects given \a *mol into connected subgraphs and inserts them as new molecules but with old atoms into \a this.
  * \param *out output stream for debugging
  * \param *mol molecule with atoms to dissect
+ * \param *periode periodentafel
  * \param *configuration config with BondGraph
  */
+void MoleculeListClass::DissectMoleculeIntoConnectedSubgraphs(molecule * const mol, config * const configuration)
+{
+void MoleculeListClass::DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration)
+{
+  molecule *mol = new molecule(periode);
+  atom *Walker = NULL;
+  atom *Advancer = NULL;
+  bond *Binder = NULL;
+  bond *Stepper = NULL;
+  // 0. gather all atoms into single molecule
+  for (MoleculeList::iterator MolRunner = ListOfMolecules.begin(); !ListOfMolecules.empty(); MolRunner = ListOfMolecules.begin()) {
+    // shift all atoms to new molecule
+    Advancer = (*MolRunner)->start->next;
+    while (Advancer != (*MolRunner)->end) {
+      Walker = Advancer;
+      Advancer = Advancer->next;
+      Log() << Verbose(3) << "Re-linking " << *Walker << "..." << endl;
+      unlink(Walker);
+      Walker->father = Walker;
+      mol->AddAtom(Walker);    // counting starts at 1
+    }
+    // remove all bonds
+    Stepper = (*MolRunner)->first->next;
+    while (Stepper != (*MolRunner)->last) {
+      Binder = Stepper;
+      Stepper = Stepper->next;
+      delete(Binder);
+    }
+    // remove the molecule
+    delete(*MolRunner);
+    ListOfMolecules.erase(MolRunner);
+  }
   // 1. dissect the molecule into connected subgraphs
   configuration->BG->ConstructBondGraph(mol);
 …
   // 4a. create array of molecules to fill
   const int MolCount = Subgraphs->next->Count();
+  char number[MAXSTRINGSIZE];
   molecule **molecules = Malloc<molecule *>(MolCount, "config::Load() - **molecules");
   for (int i=0;i<MolCount;i++) {
     molecules[i] = (molecule*) new molecule(mol->elemente);
     molecules[i]->ActiveFlag = true;
+    strncpy(molecules[i]->name, mol->name, MAXSTRINGSIZE);
+    if (MolCount > 1) {
+      sprintf(number, "-%d", i+1);
+      strncat(molecules[i]->name, number, MAXSTRINGSIZE - strlen(mol->name) - 1);
+    }
+    cout << "MolName is " << molecules[i]->name << endl;
     insert(molecules[i]);
+  }
 …
   int *MolMap = Calloc<int>(mol->AtomCount, "config::Load() - *MolMap");
   MoleculeLeafClass *MolecularWalker = Subgraphs;
   atom *Walker = NULL;
+  Walker = NULL;
   while (MolecularWalker->next != NULL) {
     MolecularWalker = MolecularWalker->next;
 …
+    }
+  }
   // 4d. we don't need to redo bonds, as they are connected subgraphs and still maintained their ListOfBonds, but we have to remove them from first..last list
   bond *Binder = mol->first;
+  // 4d. we don't need to redo bonds, as they are connected subgraphs and still maintain their ListOfBonds, but we have to remove them from first..last list
+  Binder = mol->first;
   while (mol->first->next != mol->last) {
     Binder = mol->first->next;

TabularUnified src/parser.cpp ¶

-              r9fe36b
+              rb8d1aeb
 // ======================================= INCLUDES ==========================================
+#include <cstring>
 #include "helpers.hpp"
 …
   input.open(name, ios::in);
   //Log() << Verbose(0) << "Opening " << name << " ... "  << input << endl;
+  //Log() << Verbose(1) << "Opening " << name << " ... "  << input << endl;
   if (input == NULL) {
     eLog() << Verbose(0) << endl << "Unable to open " << name << ", is the directory correct?" << endl;
     performCriticalExit();
+    eLog() << Verbose(1) << endl << "Unable to open " << name << ", is the directory correct?" << endl;
+    //performCriticalExit();
     return false;
+  }
 …
+  }
   //Log() << Verbose(0) << line.str() << endl;
   //Log() << Verbose(0) << "ColumnCounter[" << MatrixNr << "]: " << ColumnCounter[MatrixNr] << "." << endl;
+  //Log() << Verbose(1) << "ColumnCounter[" << MatrixNr << "]: " << ColumnCounter[MatrixNr] << "." << endl;
   if (ColumnCounter[MatrixNr] == 0) {
     eLog() << Verbose(0) << "ColumnCounter[" << MatrixNr << "]: " << ColumnCounter[MatrixNr] << " from file " << name << ", this is probably an error!" << endl;
 …
+    }
+  }
   //Log() << Verbose(0) << "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from file " << name << "." << endl;
+  //Log() << Verbose(1) << "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from file " << name << "." << endl;
   if (RowCounter[MatrixNr] == 0) {
     eLog() << Verbose(0) << "RowCounter[" << MatrixNr << "]: " << RowCounter[MatrixNr] << " from file " << name << ", this is probably an error!" << endl;
 …
       input.getline(filename, 1023);
       stringstream lines(filename);
       //Log() << Verbose(0) << "Matrix at level " << j << ":";// << filename << endl;
+      //Log() << Verbose(2) << "Matrix at level " << j << ":";// << filename << endl;
       for(int k=skipcolumns;k--;)
         lines >> filename;
       for(int k=0;(k<ColumnCounter[MatrixNr]) && (!lines.eof());k++) {
         lines >> Matrix[MatrixNr][j][k];
         //Log() << Verbose(0) << " " << setprecision(2) << Matrix[MatrixNr][j][k];;
+        //Log() << Verbose(1) << " " << setprecision(2) << Matrix[MatrixNr][j][k] << endl;
+      }
-      //Log() << Verbose(0) << endl;
       Matrix[MatrixNr][ RowCounter[MatrixNr] ] = Malloc<double>(ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[RowCounter[MatrixNr]][]");
       for(int j=ColumnCounter[MatrixNr];j--;)

TabularUnified src/periodentafel.cpp ¶

r9fe36b	rb8d1aeb
9	9	#include <iomanip>
10	10	#include <fstream>
	11	#include <cstring>
11	12
12	13	#include "element.hpp"

TabularUnified src/tesselation.cpp ¶

-              r9fe36b
+              rb8d1aeb
 #include "helpers.hpp"
+#include "info.hpp"
 #include "linkedcell.hpp"
 #include "log.hpp"
 …
 /** Constructor of BoundaryPointSet.
  */
+BoundaryPointSet::BoundaryPointSet()
+{
+  LinesCount = 0;
+  Nr = -1;
+  value = 0.;
+BoundaryPointSet::BoundaryPointSet() :
+    LinesCount(0),
+    value(0.),
+    Nr(-1)
+{
+        Info FunctionInfo(__func__);
+        Log() << Verbose(1) << "Adding noname." << endl;
 };
 …
  * \param *Walker TesselPoint this boundary point represents
  */
+BoundaryPointSet::BoundaryPointSet(TesselPoint * Walker)
+{
+  node = Walker;
+  LinesCount = 0;
+  Nr = Walker->nr;
+  value = 0.;
+BoundaryPointSet::BoundaryPointSet(TesselPoint * const Walker) :
+  LinesCount(0),
+  node(Walker),
+  value(0.),
+  Nr(Walker->nr)
+{
+        Info FunctionInfo(__func__);
+  Log() << Verbose(1) << "Adding Node " << *Walker << endl;
 };
 …
 BoundaryPointSet::~BoundaryPointSet()
+{
+  //Log() << Verbose(5) << "Erasing point nr. " << Nr << "." << endl;
+        Info FunctionInfo(__func__);
+  //Log() << Verbose(0) << "Erasing point nr. " << Nr << "." << endl;
   if (!lines.empty())
     eLog() << Verbose(2) << "Memory Leak! I " << *this << " am still connected to some lines." << endl;
 …
  * \param *line line to add
  */
+void BoundaryPointSet::AddLine(class BoundaryLineSet *line)
+{
+  Log() << Verbose(6) << "Adding " << *this << " to line " << *line << "."
+void BoundaryPointSet::AddLine(BoundaryLineSet * const line)
+{
+        Info FunctionInfo(__func__);
+  Log() << Verbose(1) << "Adding " << *this << " to line " << *line << "."
       << endl;
   if (line->endpoints[0] == this)
 …
 /** Constructor of BoundaryLineSet.
  */
+BoundaryLineSet::BoundaryLineSet()
+{
+BoundaryLineSet::BoundaryLineSet() :
+    Nr(-1)
+{
+        Info FunctionInfo(__func__);
   for (int i = 0; i < 2; i++)
     endpoints[i] = NULL;
-  Nr = -1;
 };
 …
  * \param number number of the list
  */
+BoundaryLineSet::BoundaryLineSet(class BoundaryPointSet *Point[2], const int number)
+{
+BoundaryLineSet::BoundaryLineSet(BoundaryPointSet * const Point[2], const int number)
+{
+        Info FunctionInfo(__func__);
   // set number
   Nr = number;
 …
   Point[0]->AddLine(this); //Taken out, to check whether we can avoid unwanted double adding.
   Point[1]->AddLine(this); //
+  // set skipped to false
+  skipped = false;
   // clear triangles list
+  Log() << Verbose(5) << "New Line with endpoints " << *this << "." << endl;
+  Log() << Verbose(0) << "New Line with endpoints " << *this << "." << endl;
+};
+/** Constructor of BoundaryLineSet with two endpoints.
+ * Adds line automatically to each endpoints' LineMap
+ * \param *Point1 first boundary point
+ * \param *Point2 second boundary point
+ * \param number number of the list
+ */
+BoundaryLineSet::BoundaryLineSet(BoundaryPointSet * const Point1, BoundaryPointSet * const Point2, const int number)
+{
+  Info FunctionInfo(__func__);
+  // set number
+  Nr = number;
+  // set endpoints in ascending order
+  SetEndpointsOrdered(endpoints, Point1, Point2);
+  // add this line to the hash maps of both endpoints
+  Point1->AddLine(this); //Taken out, to check whether we can avoid unwanted double adding.
+  Point2->AddLine(this); //
+  // set skipped to false
+  skipped = false;
+  // clear triangles list
+  Log() << Verbose(0) << "New Line with endpoints " << *this << "." << endl;
 };
 …
 BoundaryLineSet::~BoundaryLineSet()
+{
+        Info FunctionInfo(__func__);
   int Numbers[2];
 …
         for (LineMap::iterator Runner = erasor.first; Runner != erasor.second; Runner++)
           if ((*Runner).second == this) {
             //Log() << Verbose(5) << "Removing Line Nr. " << Nr << " in boundary point " << *endpoints[i] << "." << endl;
+            //Log() << Verbose(0) << "Removing Line Nr. " << Nr << " in boundary point " << *endpoints[i] << "." << endl;
             endpoints[i]->lines.erase(Runner);
             break;
 …
       } else { // there's just a single line left
         if (endpoints[i]->lines.erase(Nr)) {
           //Log() << Verbose(5) << "Removing Line Nr. " << Nr << " in boundary point " << *endpoints[i] << "." << endl;
+          //Log() << Verbose(0) << "Removing Line Nr. " << Nr << " in boundary point " << *endpoints[i] << "." << endl;
+        }
+      }
       if (endpoints[i]->lines.empty()) {
         //Log() << Verbose(5) << *endpoints[i] << " has no more lines it's attached to, erasing." << endl;
+        //Log() << Verbose(0) << *endpoints[i] << " has no more lines it's attached to, erasing." << endl;
         if (endpoints[i] != NULL) {
           delete(endpoints[i]);
 …
  * \param *triangle to add
  */
+void BoundaryLineSet::AddTriangle(class BoundaryTriangleSet *triangle)
+{
+  Log() << Verbose(6) << "Add " << triangle->Nr << " to line " << *this << "." << endl;
+void BoundaryLineSet::AddTriangle(BoundaryTriangleSet * const triangle)
+{
+        Info FunctionInfo(__func__);
+  Log() << Verbose(0) << "Add " << triangle->Nr << " to line " << *this << "." << endl;
   triangles.insert(TrianglePair(triangle->Nr, triangle));
 };
 …
  * \return true - common endpoint present, false - not connected
  */
+bool BoundaryLineSet::IsConnectedTo(class BoundaryLineSet *line)
+{
+bool BoundaryLineSet::IsConnectedTo(const BoundaryLineSet * const line) const
+{
+        Info FunctionInfo(__func__);
   if ((endpoints[0] == line->endpoints[0]) || (endpoints[1] == line->endpoints[0]) || (endpoints[0] == line->endpoints[1]) || (endpoints[1] == line->endpoints[1]))
     return true;
 …
  * \return true - triangles are convex, false - concave or less than two triangles connected
  */
+bool BoundaryLineSet::CheckConvexityCriterion()
+{
+bool BoundaryLineSet::CheckConvexityCriterion() const
+{
+        Info FunctionInfo(__func__);
   Vector BaseLineCenter, BaseLineNormal, BaseLine, helper[2], NormalCheck;
   // get the two triangles
   if (triangles.size() != 2) {
     eLog() << Verbose(1) << "Baseline " << *this << " is connected to less than two triangles, Tesselation incomplete!" << endl;
+    eLog() << Verbose(0) << "Baseline " << *this << " is connected to less than two triangles, Tesselation incomplete!" << endl;
     return true;
+  }
   // check normal vectors
   // have a normal vector on the base line pointing outwards
   //Log() << Verbose(3) << "INFO: " << *this << " has vectors at " << *(endpoints[0]->node->node) << " and at " << *(endpoints[1]->node->node) << "." << endl;
+  //Log() << Verbose(0) << "INFO: " << *this << " has vectors at " << *(endpoints[0]->node->node) << " and at " << *(endpoints[1]->node->node) << "." << endl;
   BaseLineCenter.CopyVector(endpoints[0]->node->node);
   BaseLineCenter.AddVector(endpoints[1]->node->node);
 …
   BaseLine.CopyVector(endpoints[0]->node->node);
   BaseLine.SubtractVector(endpoints[1]->node->node);
   //Log() << Verbose(3) << "INFO: Baseline is " << BaseLine << " and its center is at " << BaseLineCenter << "." << endl;
+  //Log() << Verbose(0) << "INFO: Baseline is " << BaseLine << " and its center is at " << BaseLineCenter << "." << endl;
   BaseLineNormal.Zero();
 …
   int i=0;
   class BoundaryPointSet *node = NULL;
   for(TriangleMap::iterator runner = triangles.begin(); runner != triangles.end(); runner++) {
     //Log() << Verbose(3) << "INFO: NormalVector of " << *(runner->second) << " is " << runner->second->NormalVector << "." << endl;
+  for(TriangleMap::const_iterator runner = triangles.begin(); runner != triangles.end(); runner++) {
+    //Log() << Verbose(0) << "INFO: NormalVector of " << *(runner->second) << " is " << runner->second->NormalVector << "." << endl;
     NormalCheck.AddVector(&runner->second->NormalVector);
     NormalCheck.Scale(sign);
 …
       BaseLineNormal.CopyVector(&runner->second->NormalVector);   // yes, copy second on top of first
     else {
+      Log() << Verbose(1) << "CRITICAL: Triangle " << *runner->second << " has zero normal vector!" << endl;
+      exit(255);
+      eLog() << Verbose(0) << "Triangle " << *runner->second << " has zero normal vector!" << endl;
+    }
     node = runner->second->GetThirdEndpoint(this);
     if (node != NULL) {
       //Log() << Verbose(3) << "INFO: Third node for triangle " << *(runner->second) << " is " << *node << " at " << *(node->node->node) << "." << endl;
+      //Log() << Verbose(0) << "INFO: Third node for triangle " << *(runner->second) << " is " << *node << " at " << *(node->node->node) << "." << endl;
       helper[i].CopyVector(node->node->node);
       helper[i].SubtractVector(&BaseLineCenter);
       helper[i].MakeNormalVector(&BaseLine);  // we want to compare the triangle's heights' angles!
       //Log() << Verbose(4) << "INFO: Height vector with respect to baseline is " << helper[i] << "." << endl;
+      //Log() << Verbose(0) << "INFO: Height vector with respect to baseline is " << helper[i] << "." << endl;
       i++;
     } else {
       //eLog() << Verbose(1) << "I cannot find third node in triangle, something's wrong." << endl;
+      eLog() << Verbose(1) << "I cannot find third node in triangle, something's wrong." << endl;
       return true;
+    }
+  }
   //Log() << Verbose(3) << "INFO: BaselineNormal is " << BaseLineNormal << "." << endl;
+  //Log() << Verbose(0) << "INFO: BaselineNormal is " << BaseLineNormal << "." << endl;
   if (NormalCheck.NormSquared() < MYEPSILON) {
     Log() << Verbose(3) << "ACCEPT: Normalvectors of both triangles are the same: convex." << endl;
+    Log() << Verbose(0) << "ACCEPT: Normalvectors of both triangles are the same: convex." << endl;
     return true;
+  }
 …
   double angle = GetAngle(helper[0], helper[1], BaseLineNormal);
   if ((angle - M_PI) > -MYEPSILON) {
     Log() << Verbose(3) << "ACCEPT: Angle is greater than pi: convex." << endl;
+    Log() << Verbose(0) << "ACCEPT: Angle is greater than pi: convex." << endl;
     return true;
   } else {
     Log() << Verbose(3) << "REJECT: Angle is less than pi: concave." << endl;
+    Log() << Verbose(0) << "REJECT: Angle is less than pi: concave." << endl;
     return false;
+  }
 …
  * \return true - point is of the line, false - is not
  */
+bool BoundaryLineSet::ContainsBoundaryPoint(class BoundaryPointSet *point)
+{
+bool BoundaryLineSet::ContainsBoundaryPoint(const BoundaryPointSet * const point) const
+{
+        Info FunctionInfo(__func__);
   for(int i=0;i<2;i++)
     if (point == endpoints[i])
 …
  * \return NULL - if endpoint not contained in BoundaryLineSet, or pointer to BoundaryPointSet otherwise
  */
+class BoundaryPointSet *BoundaryLineSet::GetOtherEndpoint(class BoundaryPointSet *point)
+{
+class BoundaryPointSet *BoundaryLineSet::GetOtherEndpoint(const BoundaryPointSet * const point) const
+{
+        Info FunctionInfo(__func__);
   if (endpoints[0] == point)
     return endpoints[1];
 …
 /** Constructor for BoundaryTriangleSet.
  */
+BoundaryTriangleSet::BoundaryTriangleSet()
+{
+BoundaryTriangleSet::BoundaryTriangleSet() :
+  Nr(-1)
+{
+        Info FunctionInfo(__func__);
   for (int i = 0; i < 3; i++)
+    {
 …
       lines[i] = NULL;
+    }
-  Nr = -1;
 };
 …
  * \param number number of triangle
  */
+BoundaryTriangleSet::BoundaryTriangleSet(class BoundaryLineSet *line[3], int number)
+{
+BoundaryTriangleSet::BoundaryTriangleSet(class BoundaryLineSet * const line[3], const int number) :
+  Nr(number)
+{
+        Info FunctionInfo(__func__);
   // set number
-  Nr = number;
   // set lines
+  Log() << 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;
+  PointMap 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
+      }
+    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;
+  Log() << Verbose(6) << " with end points ";
+  for (map<int, class BoundaryPointSet *>::iterator runner = OrderMap.begin(); runner
+      != OrderMap.end(); runner++)
+    {
+      endpoints[Counter] = runner->second;
+      Log() << Verbose(0) << " " << *endpoints[Counter];
+      Counter++;
+    }
+  if (Counter < 3)
+    {
+      eLog() << Verbose(0) << "ERROR! We have a triangle with only two distinct endpoints!" << endl;
+      performCriticalExit();
+    }
+  Log() << Verbose(0) << "." << endl;
+  Log() << Verbose(0) << "New triangle " << Nr << " with end points: " << endl;
+  for (PointMap::iterator runner = OrderMap.begin(); runner != OrderMap.end(); runner++) {
+    endpoints[Counter] = runner->second;
+    Log() << Verbose(0) << " " << *endpoints[Counter] << endl;
+    Counter++;
+  }
+  if (Counter < 3) {
+    eLog() << Verbose(0) << "We have a triangle with only two distinct endpoints!" << endl;
+    performCriticalExit();
+  }
 };
 …
 BoundaryTriangleSet::~BoundaryTriangleSet()
+{
+        Info FunctionInfo(__func__);
   for (int i = 0; i < 3; i++) {
     if (lines[i] != NULL) {
       if (lines[i]->triangles.erase(Nr)) {
         //Log() << Verbose(5) << "Triangle Nr." << Nr << " erased in line " << *lines[i] << "." << endl;
+        //Log() << Verbose(0) << "Triangle Nr." << Nr << " erased in line " << *lines[i] << "." << endl;
+      }
       if (lines[i]->triangles.empty()) {
           //Log() << Verbose(5) << *lines[i] << " is no more attached to any triangle, erasing." << endl;
+          //Log() << Verbose(0) << *lines[i] << " is no more attached to any triangle, erasing." << endl;
           delete (lines[i]);
           lines[i] = NULL;
 …
+    }
+  }
   //Log() << Verbose(5) << "Erasing triangle Nr." << Nr << " itself." << endl;
+  //Log() << Verbose(0) << "Erasing triangle Nr." << Nr << " itself." << endl;
 };
 …
  * \param &OtherVector direction vector to make normal vector unique.
  */
+void BoundaryTriangleSet::GetNormalVector(Vector &OtherVector)
+{
+void BoundaryTriangleSet::GetNormalVector(const Vector &OtherVector)
+{
+        Info FunctionInfo(__func__);
   // get normal vector
   NormalVector.MakeNormalVector(endpoints[0]->node->node, endpoints[1]->node->node, endpoints[2]->node->node);
 …
   if (NormalVector.ScalarProduct(&OtherVector) > 0.)
     NormalVector.Scale(-1.);
+};
+/** Finds the point on the triangle \a *BTS the line defined by \a *MolCenter and \a *x crosses through.
+  Log() << Verbose(1) << "Normal Vector is " << NormalVector << "." << endl;
+};
+/** Finds the point on the triangle \a *BTS through which the line defined by \a *MolCenter and \a *x crosses.
  * We call Vector::GetIntersectionWithPlane() to receive the intersection point with the plane
  * This we test if it's really on the plane and whether it's inside the triangle on the plane or not.
+ * Thus we test if it's really on the plane and whether it's inside the triangle on the plane or not.
  * The latter is done as follows: We calculate the cross point of one of the triangle's baseline with the line
  * given by the intersection and the third basepoint. Then, we check whether it's on the baseline (i.e. between
 …
  * \return true - \a *Intersection contains intersection on plane defined by triangle, false - zero vector if outside of triangle.
  */
+bool BoundaryTriangleSet::GetIntersectionInsideTriangle(Vector *MolCenter, Vector *x, Vector *Intersection)
+{
+bool BoundaryTriangleSet::GetIntersectionInsideTriangle(const Vector * const MolCenter, const Vector * const x, Vector * const Intersection) const
+{
+  Info FunctionInfo(__func__);
   Vector CrossPoint;
   Vector helper;
   if (!Intersection->GetIntersectionWithPlane(&NormalVector, endpoints[0]->node->node, MolCenter, x)) {
     Log() << Verbose(1) << "Alas! Intersection with plane failed - at least numerically - the intersection is not on the plane!" << endl;
+    eLog() << Verbose(1) << "Alas! Intersection with plane failed - at least numerically - the intersection is not on the plane!" << endl;
     return false;
+  }
+  Log() << Verbose(1) << "INFO: Triangle is " << *this << "." << endl;
+  Log() << Verbose(1) << "INFO: Line is from " << *MolCenter << " to " << *x << "." << endl;
+  Log() << Verbose(1) << "INFO: Intersection is " << *Intersection << "." << endl;
+  if (Intersection->DistanceSquared(endpoints[0]->node->node) < MYEPSILON) {
+    Log() << Verbose(1) << "Intersection coindices with first endpoint." << endl;
+    return true;
+  }   else if (Intersection->DistanceSquared(endpoints[1]->node->node) < MYEPSILON) {
+    Log() << Verbose(1) << "Intersection coindices with second endpoint." << endl;
+    return true;
+  }   else if (Intersection->DistanceSquared(endpoints[2]->node->node) < MYEPSILON) {
+    Log() << Verbose(1) << "Intersection coindices with third endpoint." << endl;
+    return true;
+  }
   // Calculate cross point between one baseline and the line from the third endpoint to intersection
   int i=0;
 …
       helper.CopyVector(endpoints[(i+1)%3]->node->node);
       helper.SubtractVector(endpoints[i%3]->node->node);
+      CrossPoint.SubtractVector(endpoints[i%3]->node->node);  // cross point was returned as absolute vector
+      const double s = CrossPoint.ScalarProduct(&helper)/helper.NormSquared();
+      Log() << Verbose(1) << "INFO: Factor s is " << s << "." << endl;
+      if ((s < -MYEPSILON) || ((s-1.) > MYEPSILON)) {
+        Log() << Verbose(1) << "INFO: Crosspoint " << CrossPoint << "outside of triangle." << endl;
+        i=4;
+        break;
+      }
+      i++;
     } else
-      i++;
-    if (i>2)
       break;
   } while (CrossPoint.NormSquared() < MYEPSILON);
+  } while (i<3);
   if (i==3) {
+    eLog() << Verbose(1) << "Could not find any cross points, something's utterly wrong here!" << endl;
+    exit(255);
+  }
+  CrossPoint.SubtractVector(endpoints[i%3]->node->node);  // cross point was returned as absolute vector
+  // check whether intersection is inside or not by comparing length of intersection and length of cross point
+  if ((CrossPoint.NormSquared() - helper.NormSquared()) < MYEPSILON) { // inside
+    Log() << Verbose(1) << "INFO: Crosspoint " << CrossPoint << " inside of triangle." << endl;
     return true;
   } else { // outside!
     Intersection->Zero();
+  } else {
+    Log() << Verbose(1) << "INFO: Crosspoint " << CrossPoint << " outside of triangle." << endl;
     return false;
+  }
+};
+/** Finds the point on the triangle \a *BTS through which the line defined by \a *MolCenter and \a *x crosses.
+ * We call Vector::GetIntersectionWithPlane() to receive the intersection point with the plane
+ * Thus we test if it's really on the plane and whether it's inside the triangle on the plane or not.
+ * The latter is done as follows: We calculate the cross point of one of the triangle's baseline with the line
+ * given by the intersection and the third basepoint. Then, we check whether it's on the baseline (i.e. between
+ * the first two basepoints) or not.
+ * \param *x point
+ * \param *ClosestPoint desired closest point inside triangle to \a *x, is absolute vector
+ * \return Distance squared between \a *x and closest point inside triangle
+ */
+double BoundaryTriangleSet::GetClosestPointInsideTriangle(const Vector * const x, Vector * const ClosestPoint) const
+{
+  Info FunctionInfo(__func__);
+  Vector Direction;
+  // 1. get intersection with plane
+  Log() << Verbose(1) << "INFO: Looking for closest point of triangle " << *this << " to " << *x << "." << endl;
+  GetCenter(&Direction);
+  if (!ClosestPoint->GetIntersectionWithPlane(&NormalVector, endpoints[0]->node->node, x, &Direction)) {
+    ClosestPoint->CopyVector(x);
+  }
+  // 2. Calculate in plane part of line (x, intersection)
+  Vector InPlane;
+  InPlane.CopyVector(x);
+  InPlane.SubtractVector(ClosestPoint);  // points from plane intersection to straight-down point
+  InPlane.ProjectOntoPlane(&NormalVector);
+  InPlane.AddVector(ClosestPoint);
+  Log() << Verbose(2) << "INFO: Triangle is " << *this << "." << endl;
+  Log() << Verbose(2) << "INFO: Line is from " << Direction << " to " << *x << "." << endl;
+  Log() << Verbose(2) << "INFO: In-plane part is " << InPlane << "." << endl;
+  // Calculate cross point between one baseline and the desired point such that distance is shortest
+  double ShortestDistance = -1.;
+  bool InsideFlag = false;
+  Vector CrossDirection[3];
+  Vector CrossPoint[3];
+  Vector helper;
+  for (int i=0;i<3;i++) {
+    // treat direction of line as normal of a (cut)plane and the desired point x as the plane offset, the intersect line with point
+    Direction.CopyVector(endpoints[(i+1)%3]->node->node);
+    Direction.SubtractVector(endpoints[i%3]->node->node);
+    // calculate intersection, line can never be parallel to Direction (is the same vector as PlaneNormal);
+    CrossPoint[i].GetIntersectionWithPlane(&Direction, &InPlane, endpoints[i%3]->node->node, endpoints[(i+1)%3]->node->node);
+    CrossDirection[i].CopyVector(&CrossPoint[i]);
+    CrossDirection[i].SubtractVector(&InPlane);
+    CrossPoint[i].SubtractVector(endpoints[i%3]->node->node);  // cross point was returned as absolute vector
+    const double s = CrossPoint[i].ScalarProduct(&Direction)/Direction.NormSquared();
+    Log() << Verbose(2) << "INFO: Factor s is " << s << "." << endl;
+    if ((s >= -MYEPSILON) && ((s-1.) <= MYEPSILON)) {
+      CrossPoint[i].AddVector(endpoints[i%3]->node->node);  // make cross point absolute again
+      Log() << Verbose(2) << "INFO: Crosspoint is " << CrossPoint[i] << ", intersecting BoundaryLine between " << *endpoints[i%3]->node->node << " and " << *endpoints[(i+1)%3]->node->node << "." << endl;
+      const double distance = CrossPoint[i].DistanceSquared(x);
+      if ((ShortestDistance < 0.) || (ShortestDistance > distance)) {
+        ShortestDistance = distance;
+        ClosestPoint->CopyVector(&CrossPoint[i]);
+      }
+    } else
+      CrossPoint[i].Zero();
+  }
+  InsideFlag = true;
+  for (int i=0;i<3;i++) {
+    const double sign = CrossDirection[i].ScalarProduct(&CrossDirection[(i+1)%3]);
+    const double othersign = CrossDirection[i].ScalarProduct(&CrossDirection[(i+2)%3]);;
+    if ((sign > -MYEPSILON) && (othersign > -MYEPSILON))  // have different sign
+      InsideFlag = false;
+  }
+  if (InsideFlag) {
+    ClosestPoint->CopyVector(&InPlane);
+    ShortestDistance = InPlane.DistanceSquared(x);
+  } else {  // also check endnodes
+    for (int i=0;i<3;i++) {
+      const double distance = x->DistanceSquared(endpoints[i]->node->node);
+      if ((ShortestDistance < 0.) || (ShortestDistance > distance)) {
+        ShortestDistance = distance;
+        ClosestPoint->CopyVector(endpoints[i]->node->node);
+      }
+    }
+  }
+  Log() << Verbose(1) << "INFO: Closest Point is " << *ClosestPoint << " with shortest squared distance is " << ShortestDistance << "." << endl;
+  return ShortestDistance;
 };
 …
  * \return true - line is of the triangle, false - is not
  */
+bool BoundaryTriangleSet::ContainsBoundaryLine(class BoundaryLineSet *line)
+{
+bool BoundaryTriangleSet::ContainsBoundaryLine(const BoundaryLineSet * const line) const
+{
+        Info FunctionInfo(__func__);
   for(int i=0;i<3;i++)
     if (line == lines[i])
 …
  * \return true - point is of the triangle, false - is not
  */
+bool BoundaryTriangleSet::ContainsBoundaryPoint(class BoundaryPointSet *point)
+{
+bool BoundaryTriangleSet::ContainsBoundaryPoint(const BoundaryPointSet * const point) const
+{
+        Info FunctionInfo(__func__);
   for(int i=0;i<3;i++)
     if (point == endpoints[i])
 …
  * \return true - point is of the triangle, false - is not
  */
+bool BoundaryTriangleSet::ContainsBoundaryPoint(class TesselPoint *point)
+{
+bool BoundaryTriangleSet::ContainsBoundaryPoint(const TesselPoint * const point) const
+{
+        Info FunctionInfo(__func__);
   for(int i=0;i<3;i++)
     if (point == endpoints[i]->node)
 …
  * \return true - is the very triangle, false - is not
  */
+bool BoundaryTriangleSet::IsPresentTupel(class BoundaryPointSet *Points[3])
+{
+bool BoundaryTriangleSet::IsPresentTupel(const BoundaryPointSet * const Points[3]) const
+{
+        Info FunctionInfo(__func__);
+        Log() << Verbose(1) << "INFO: Checking " << Points[0] << ","  << Points[1] << "," << Points[2] << " against " << endpoints[0] << "," << endpoints[1] << "," << endpoints[2] << "." << endl;
   return (((endpoints[0] == Points[0])
             || (endpoints[0] == Points[1])
 …
  * \return true - is the very triangle, false - is not
  */
+bool BoundaryTriangleSet::IsPresentTupel(class BoundaryTriangleSet *T)
+{
+bool BoundaryTriangleSet::IsPresentTupel(const BoundaryTriangleSet * const T) const
+{
+        Info FunctionInfo(__func__);
   return (((endpoints[0] == T->endpoints[0])
             || (endpoints[0] == T->endpoints[1])
 …
  * \return pointer third endpoint or NULL if line does not belong to triangle.
  */
+class BoundaryPointSet *BoundaryTriangleSet::GetThirdEndpoint(class BoundaryLineSet *line)
+{
+class BoundaryPointSet *BoundaryTriangleSet::GetThirdEndpoint(const BoundaryLineSet * const line) const
+{
+        Info FunctionInfo(__func__);
   // sanity check
   if (!ContainsBoundaryLine(line))
 …
  * \param *center central point on return.
  */
+void BoundaryTriangleSet::GetCenter(Vector *center)
+{
+void BoundaryTriangleSet::GetCenter(Vector * const center) const
+{
+        Info FunctionInfo(__func__);
   center->Zero();
   for(int i=0;i<3;i++)
     center->AddVector(endpoints[i]->node->node);
   center->Scale(1./3.);
+  Log() << Verbose(1) << "INFO: Center is at " << *center << "." << endl;
+}
 …
 ostream &operator <<(ostream &ost, const BoundaryTriangleSet &a)
+{
+  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << " at " << *a.endpoints[0]->node->node << ","
+      << a.endpoints[1]->node->Name << " at " << *a.endpoints[1]->node->node << "," << a.endpoints[2]->node->Name << " at " << *a.endpoints[2]->node->node << "]";
+  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << "," << a.endpoints[1]->node->Name << "," << a.endpoints[2]->node->Name << "]";
+//  ost << "[" << a.Nr << "|" << a.endpoints[0]->node->Name << " at " << *a.endpoints[0]->node->node << ","
+//      << a.endpoints[1]->node->Name << " at " << *a.endpoints[1]->node->node << "," << a.endpoints[2]->node->Name << " at " << *a.endpoints[2]->node->node << "]";
   return ost;
 };
+// ======================================== Polygons on Boundary =================================
+/** Constructor for BoundaryPolygonSet.
+ */
+BoundaryPolygonSet::BoundaryPolygonSet() :
+  Nr(-1)
+{
+  Info FunctionInfo(__func__);
+};
+/** Destructor of BoundaryPolygonSet.
+ * Just clears endpoints.
+ * \note When removing triangles from a class Tesselation, use RemoveTesselationTriangle()
+ */
+BoundaryPolygonSet::~BoundaryPolygonSet()
+{
+  Info FunctionInfo(__func__);
+  endpoints.clear();
+  Log() << Verbose(1) << "Erasing polygon Nr." << Nr << " itself." << endl;
+};
+/** Calculates the normal vector for this triangle.
+ * Is made unique by comparison with \a OtherVector to point in the other direction.
+ * \param &OtherVector direction vector to make normal vector unique.
+ * \return allocated vector in normal direction
+ */
+Vector * BoundaryPolygonSet::GetNormalVector(const Vector &OtherVector) const
+{
+  Info FunctionInfo(__func__);
+  // get normal vector
+  Vector TemporaryNormal;
+  Vector *TotalNormal = new Vector;
+  PointSet::const_iterator Runner[3];
+  for (int i=0;i<3; i++) {
+    Runner[i] = endpoints.begin();
+    for (int j = 0; j<i; j++) { // go as much further
+      Runner[i]++;
+      if (Runner[i] == endpoints.end()) {
+        eLog() << Verbose(0) << "There are less than three endpoints in the polygon!" << endl;
+        performCriticalExit();
+      }
+    }
+  }
+  TotalNormal->Zero();
+  int counter=0;
+  for (; Runner[2] != endpoints.end(); ) {
+    TemporaryNormal.MakeNormalVector((*Runner[0])->node->node, (*Runner[1])->node->node, (*Runner[2])->node->node);
+    for (int i=0;i<3;i++) // increase each of them
+      Runner[i]++;
+    TotalNormal->AddVector(&TemporaryNormal);
+  }
+  TotalNormal->Scale(1./(double)counter);
+  // make it always point inward (any offset vector onto plane projected onto normal vector suffices)
+  if (TotalNormal->ScalarProduct(&OtherVector) > 0.)
+    TotalNormal->Scale(-1.);
+  Log() << Verbose(1) << "Normal Vector is " << *TotalNormal << "." << endl;
+  return TotalNormal;
+};
+/** Calculates the center point of the triangle.
+ * Is third of the sum of all endpoints.
+ * \param *center central point on return.
+ */
+void BoundaryPolygonSet::GetCenter(Vector * const center) const
+{
+  Info FunctionInfo(__func__);
+  center->Zero();
+  int counter = 0;
+  for(PointSet::const_iterator Runner = endpoints.begin(); Runner != endpoints.end(); Runner++) {
+    center->AddVector((*Runner)->node->node);
+    counter++;
+  }
+  center->Scale(1./(double)counter);
+  Log() << Verbose(1) << "Center is at " << *center << "." << endl;
+}
+/** Checks whether the polygons contains all three endpoints of the triangle.
+ * \param *triangle triangle to test
+ * \return true - triangle is contained polygon, false - is not
+ */
+bool BoundaryPolygonSet::ContainsBoundaryTriangle(const BoundaryTriangleSet * const triangle) const
+{
+  Info FunctionInfo(__func__);
+  return ContainsPresentTupel(triangle->endpoints, 3);
+};
+/** Checks whether the polygons contains both endpoints of the line.
+ * \param *line line to test
+ * \return true - line is of the triangle, false - is not
+ */
+bool BoundaryPolygonSet::ContainsBoundaryLine(const BoundaryLineSet * const line) const
+{
+  Info FunctionInfo(__func__);
+  return ContainsPresentTupel(line->endpoints, 2);
+};
+/** Checks whether point is any of the three endpoints this triangle contains.
+ * \param *point point to test
+ * \return true - point is of the triangle, false - is not
+ */
+bool BoundaryPolygonSet::ContainsBoundaryPoint(const BoundaryPointSet * const point) const
+{
+  Info FunctionInfo(__func__);
+  for(PointSet::const_iterator Runner = endpoints.begin(); Runner != endpoints.end(); Runner++) {
+    Log() << Verbose(0) << "Checking against " << **Runner << endl;
+    if (point == (*Runner)) {
+      Log() << Verbose(0) << " Contained." << endl;
+      return true;
+    }
+  }
+  Log() << Verbose(0) << " Not contained." << endl;
+  return false;
+};
+/** Checks whether point is any of the three endpoints this triangle contains.
+ * \param *point TesselPoint to test
+ * \return true - point is of the triangle, false - is not
+ */
+bool BoundaryPolygonSet::ContainsBoundaryPoint(const TesselPoint * const point) const
+{
+  Info FunctionInfo(__func__);
+  for(PointSet::const_iterator Runner = endpoints.begin(); Runner != endpoints.end(); Runner++)
+    if (point == (*Runner)->node) {
+      Log() << Verbose(0) << " Contained." << endl;
+      return true;
+    }
+  Log() << Verbose(0) << " Not contained." << endl;
+  return false;
+};
+/** Checks whether given array of \a *Points coincide with polygons's endpoints.
+ * \param **Points pointer to an array of BoundaryPointSet
+ * \param dim dimension of array
+ * \return true - set of points is contained in polygon, false - is not
+ */
+bool BoundaryPolygonSet::ContainsPresentTupel(const BoundaryPointSet * const * Points, const int dim) const
+{
+  Info FunctionInfo(__func__);
+  int counter = 0;
+  Log() << Verbose(1) << "Polygon is " << *this << endl;
+  for(int i=0;i<dim;i++) {
+    Log() << Verbose(1) << " Testing endpoint " << *Points[i] << endl;
+    if (ContainsBoundaryPoint(Points[i])) {
+      counter++;
+    }
+  }
+  if (counter == dim)
+    return true;
+  else
+    return false;
+};
+/** Checks whether given PointList coincide with polygons's endpoints.
+ * \param &endpoints PointList
+ * \return true - set of points is contained in polygon, false - is not
+ */
+bool BoundaryPolygonSet::ContainsPresentTupel(const PointSet &endpoints) const
+{
+  Info FunctionInfo(__func__);
+  size_t counter = 0;
+  Log() << Verbose(1) << "Polygon is " << *this << endl;
+  for(PointSet::const_iterator Runner = endpoints.begin(); Runner != endpoints.end(); Runner++) {
+    Log() << Verbose(1) << " Testing endpoint " << **Runner << endl;
+    if (ContainsBoundaryPoint(*Runner))
+      counter++;
+  }
+  if (counter == endpoints.size())
+    return true;
+  else
+    return false;
+};
+/** Checks whether given set of \a *Points coincide with polygons's endpoints.
+ * \param *P pointer to BoundaryPolygonSet
+ * \return true - is the very triangle, false - is not
+ */
+bool BoundaryPolygonSet::ContainsPresentTupel(const BoundaryPolygonSet * const P) const
+{
+  return ContainsPresentTupel((const PointSet)P->endpoints);
+};
+/** Gathers all the endpoints' triangles in a unique set.
+ * \return set of all triangles
+ */
+TriangleSet * BoundaryPolygonSet::GetAllContainedTrianglesFromEndpoints() const
+{
+  Info FunctionInfo(__func__);
+  pair <TriangleSet::iterator, bool> Tester;
+  TriangleSet *triangles = new TriangleSet;
+  for(PointSet::const_iterator Runner = endpoints.begin(); Runner != endpoints.end(); Runner++)
+    for(LineMap::const_iterator Walker = (*Runner)->lines.begin(); Walker != (*Runner)->lines.end(); Walker++)
+      for(TriangleMap::const_iterator Sprinter = (Walker->second)->triangles.begin(); Sprinter != (Walker->second)->triangles.end(); Sprinter++) {
+        //Log() << Verbose(0) << " Testing triangle " << *(Sprinter->second) << endl;
+        if (ContainsBoundaryTriangle(Sprinter->second)) {
+          Tester = triangles->insert(Sprinter->second);
+          if (Tester.second)
+            Log() << Verbose(0) << "Adding triangle " << *(Sprinter->second) << endl;
+        }
+      }
+  Log() << Verbose(1) << "The Polygon of " << endpoints.size() << " endpoints has " << triangles->size() << " unique triangles in total." << endl;
+  return triangles;
+};
+/** Fills the endpoints of this polygon from the triangles attached to \a *line.
+ * \param *line lines with triangles attached
+ * \return true - polygon contains endpoints, false - line was NULL
+ */
+bool BoundaryPolygonSet::FillPolygonFromTrianglesOfLine(const BoundaryLineSet * const line)
+{
+  Info FunctionInfo(__func__);
+  pair <PointSet::iterator, bool> Tester;
+  if (line == NULL)
+    return false;
+  Log() << Verbose(1) << "Filling polygon from line " << *line << endl;
+  for(TriangleMap::const_iterator Runner = line->triangles.begin(); Runner != line->triangles.end(); Runner++) {
+    for (int i=0;i<3;i++) {
+      Tester = endpoints.insert((Runner->second)->endpoints[i]);
+      if (Tester.second)
+        Log() << Verbose(1) << "  Inserting endpoint " << *((Runner->second)->endpoints[i]) << endl;
+    }
+  }
+  return true;
+};
+/** output operator for BoundaryPolygonSet.
+ * \param &ost output stream
+ * \param &a boundary polygon
+ */
+ostream &operator <<(ostream &ost, const BoundaryPolygonSet &a)
+{
+  ost << "[" << a.Nr << "|";
+  for(PointSet::const_iterator Runner = a.endpoints.begin(); Runner != a.endpoints.end();) {
+   ost << (*Runner)->node->Name;
+   Runner++;
+   if (Runner != a.endpoints.end())
+     ost << ",";
+  }
+  ost<< "]";
+  return ost;
+};
 // =========================================================== class TESSELPOINT ===========================================
 …
 TesselPoint::TesselPoint()
+{
+  //Info FunctionInfo(__func__);
   node = NULL;
   nr = -1;
 …
 TesselPoint::~TesselPoint()
+{
+  //Info FunctionInfo(__func__);
 };
 …
 ostream & TesselPoint::operator << (ostream &ost)
+{
+  ost << "[" << (Name) << "|" << this << "]";
+        Info FunctionInfo(__func__);
+  ost << "[" << (nr) << "|" << this << "]";
   return ost;
 };
 …
 PointCloud::PointCloud()
+{
+        //Info FunctionInfo(__func__);
 };
 …
 PointCloud::~PointCloud()
+{
+        //Info FunctionInfo(__func__);
 };
 …
 /** Constructor of class CandidateForTesselation.
  */
+CandidateForTesselation::CandidateForTesselation(TesselPoint *candidate, BoundaryLineSet* line, Vector OptCandidateCenter, Vector OtherOptCandidateCenter) {
+  point = candidate;
+  BaseLine = line;
+CandidateForTesselation::CandidateForTesselation (BoundaryLineSet* line) :
+  BaseLine(line),
+  ShortestAngle(2.*M_PI),
+  OtherShortestAngle(2.*M_PI)
+{
+        Info FunctionInfo(__func__);
+};
+/** Constructor of class CandidateForTesselation.
+ */
+CandidateForTesselation::CandidateForTesselation (TesselPoint *candidate, BoundaryLineSet* line, Vector OptCandidateCenter, Vector OtherOptCandidateCenter) :
+    BaseLine(line),
+    ShortestAngle(2.*M_PI),
+    OtherShortestAngle(2.*M_PI)
+{
+        Info FunctionInfo(__func__);
   OptCenter.CopyVector(&OptCandidateCenter);
   OtherOptCenter.CopyVector(&OtherOptCandidateCenter);
 …
  */
 CandidateForTesselation::~CandidateForTesselation() {
-  point = NULL;
   BaseLine = NULL;
 };
+/** output operator for CandidateForTesselation.
+ * \param &ost output stream
+ * \param &a boundary line
+ */
+ostream & operator <<(ostream &ost, const  CandidateForTesselation &a)
+{
+  ost << "[" << a.BaseLine->Nr << "|" << a.BaseLine->endpoints[0]->node->Name << "," << a.BaseLine->endpoints[1]->node->Name << "] with ";
+  if (a.pointlist.empty())
+    ost << "no candidate.";
+  else {
+    ost << "candidate";
+    if (a.pointlist.size() != 1)
+      ost << "s ";
+    else
+      ost << " ";
+    for (TesselPointList::const_iterator Runner = a.pointlist.begin(); Runner != a.pointlist.end(); Runner++)
+      ost << *(*Runner) << " ";
+    ost << " at angle " << (a.ShortestAngle)<< ".";
+  }
+  return ost;
+};
 // =========================================================== class TESSELATION ===========================================
 /** Constructor of class Tesselation.
  */
+Tesselation::Tesselation()
+{
+  PointsOnBoundaryCount = 0;
+  LinesOnBoundaryCount = 0;
+  TrianglesOnBoundaryCount = 0;
+  InternalPointer = PointsOnBoundary.begin();
+  LastTriangle = NULL;
+  TriangleFilesWritten = 0;
+Tesselation::Tesselation() :
+  PointsOnBoundaryCount(0),
+  LinesOnBoundaryCount(0),
+  TrianglesOnBoundaryCount(0),
+  LastTriangle(NULL),
+  TriangleFilesWritten(0),
+  InternalPointer(PointsOnBoundary.begin())
+{
+        Info FunctionInfo(__func__);
+}
+;
 …
 Tesselation::~Tesselation()
+{
+  Log() << Verbose(1) << "Free'ing TesselStruct ... " << endl;
+        Info FunctionInfo(__func__);
+  Log() << Verbose(0) << "Free'ing TesselStruct ... " << endl;
   for (TriangleMap::iterator runner = TrianglesOnBoundary.begin(); runner != TrianglesOnBoundary.end(); runner++) {
     if (runner->second != NULL) {
 …
       eLog() << Verbose(1) << "The triangle " << runner->first << " has already been free'd." << endl;
+  }
   Log() << Verbose(1) << "This envelope was written to file " << TriangleFilesWritten << " times(s)." << endl;
+  Log() << Verbose(0) << "This envelope was written to file " << TriangleFilesWritten << " times(s)." << endl;
+}
+;
 …
 Vector * Tesselation::GetCenter(ofstream *out) const
+{
+        Info FunctionInfo(__func__);
   Vector *Center = new Vector(0.,0.,0.);
   int num=0;
 …
 TesselPoint * Tesselation::GetPoint() const
+{
+        Info FunctionInfo(__func__);
   return (InternalPointer->second->node);
 };
 …
 TesselPoint * Tesselation::GetTerminalPoint() const
+{
+        Info FunctionInfo(__func__);
   PointMap::const_iterator Runner = PointsOnBoundary.end();
   Runner--;
 …
 void Tesselation::GoToNext() const
+{
+        Info FunctionInfo(__func__);
   if (InternalPointer != PointsOnBoundary.end())
     InternalPointer++;
 …
 void Tesselation::GoToPrevious() const
+{
+        Info FunctionInfo(__func__);
   if (InternalPointer != PointsOnBoundary.begin())
     InternalPointer--;
 …
 void Tesselation::GoToFirst() const
+{
+        Info FunctionInfo(__func__);
   InternalPointer = PointsOnBoundary.begin();
 };
 …
 void Tesselation::GoToLast() const
+{
+        Info FunctionInfo(__func__);
   InternalPointer = PointsOnBoundary.end();
   InternalPointer--;
 …
 bool Tesselation::IsEmpty() const
+{
+        Info FunctionInfo(__func__);
   return (PointsOnBoundary.empty());
 };
 …
 bool Tesselation::IsEnd() const
+{
+        Info FunctionInfo(__func__);
   return (InternalPointer == PointsOnBoundary.end());
 };
 …
  * \param PointsOnBoundary set of boundary points defining the convex envelope of the cluster
  */
 void
+Tesselation::GuessStartingTriangle()
+{
+void Tesselation::GuessStartingTriangle()
+{
+        Info FunctionInfo(__func__);
   // 4b. create a starting triangle
   // 4b1. create all distances
 …
           baseline->second.first->second->node->node,
           baseline->second.second->second->node->node);
+      Log() << Verbose(2) << "Plane vector of candidate triangle is ";
+      PlaneVector.Output();
+      Log() << Verbose(0) << endl;
+      Log() << Verbose(2) << "Plane vector of candidate triangle is " << PlaneVector << endl;
       // 4. loop over all points
       double sign = 0.;
 …
           if (fabs(distance) < 1e-4) // we need to have a small epsilon around 0 which is still ok
             continue;
+          Log() << Verbose(3) << "Projection of " << checker->second->node->Name
+              << " yields distance of " << distance << "." << endl;
+          Log() << Verbose(2) << "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 (checker == PointsOnBoundary.end())
+        {
           Log() << Verbose(0) << "Looks like we have a candidate!" << endl;
+          Log() << Verbose(2) << "Looks like we have a candidate!" << endl;
           break;
+        }
 …
   else
+    {
+      Log() << Verbose(1) << "No starting triangle found." << endl;
+      exit(255);
+      eLog() << Verbose(0) << "No starting triangle found." << endl;
+    }
+}
 …
 void Tesselation::TesselateOnBoundary(const PointCloud * const cloud)
+{
+        Info FunctionInfo(__func__);
   bool flag;
   PointMap::iterator winner;
 …
         // get peak point with respect to this base line's only triangle
         BTS = baseline->second->triangles.begin()->second; // there is only one triangle so far
         Log() << Verbose(2) << "Current baseline is between " << *(baseline->second) << "." << endl;
+        Log() << Verbose(0) << "Current baseline is between " << *(baseline->second) << "." << endl;
         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];
         Log() << Verbose(3) << " and has peak " << *peak << "." << endl;
+        Log() << Verbose(1) << " and has peak " << *peak << "." << endl;
         // prepare some auxiliary vectors
 …
           CenterVector.AddVector(BTS->endpoints[i]->node->node);
         CenterVector.Scale(1. / 3.);
         Log() << Verbose(4) << "CenterVector of base triangle is " << CenterVector << endl;
+        Log() << Verbose(2) << "CenterVector of base triangle is " << CenterVector << endl;
         // normal vector of triangle
 …
         BTS->GetNormalVector(NormalVector);
         NormalVector.CopyVector(&BTS->NormalVector);
         Log() << Verbose(4) << "NormalVector of base triangle is " << NormalVector << endl;
+        Log() << Verbose(2) << "NormalVector of base triangle is " << NormalVector << endl;
         // vector in propagation direction (out of triangle)
 …
         TempVector.CopyVector(&CenterVector);
         TempVector.SubtractVector(baseline->second->endpoints[0]->node->node); // TempVector is vector on triangle plane pointing from one baseline egde towards center!
         //Log() << Verbose(2) << "Projection of propagation onto temp: " << PropagationVector.Projection(&TempVector) << "." << endl;
+        //Log() << Verbose(0) << "Projection of propagation onto temp: " << PropagationVector.Projection(&TempVector) << "." << endl;
         if (PropagationVector.ScalarProduct(&TempVector) > 0) // make sure normal propagation vector points outward from baseline
           PropagationVector.Scale(-1.);
         Log() << Verbose(4) << "PropagationVector of base triangle is " << PropagationVector << endl;
+        Log() << Verbose(2) << "PropagationVector of base triangle is " << PropagationVector << 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
             Log() << Verbose(3) << "Target point is " << *(target->second) << ":" << endl;
+            Log() << Verbose(1) << "Target point is " << *(target->second) << ":" << endl;
             // first check direction, so that triangles don't intersect
 …
             VirtualNormalVector.ProjectOntoPlane(&NormalVector);
             TempAngle = VirtualNormalVector.Angle(&PropagationVector);
             Log() << Verbose(4) << "VirtualNormalVector is " << VirtualNormalVector << " and PropagationVector is " << PropagationVector << "." << endl;
+            Log() << Verbose(2) << "VirtualNormalVector is " << VirtualNormalVector << " and PropagationVector is " << PropagationVector << "." << endl;
             if (TempAngle > (M_PI/2.)) { // no bends bigger than Pi/2 (90 degrees)
               Log() << Verbose(4) << "Angle on triangle plane between propagation direction and base line to " << *(target->second) << " is " << TempAngle << ", bad direction!" << endl;
+              Log() << Verbose(2) << "Angle on triangle plane between propagation direction and base line to " << *(target->second) << " is " << TempAngle << ", bad direction!" << endl;
               continue;
             } else
               Log() << Verbose(4) << "Angle on triangle plane between propagation direction and base line to " << *(target->second) << " is " << TempAngle << ", good direction!" << endl;
+              Log() << Verbose(2) << "Angle on triangle plane between propagation direction and base line to " << *(target->second) << " is " << TempAngle << ", good direction!" << endl;
             // check first and second endpoint (if any connecting line goes to target has at least not more than 1 triangle)
 …
             LineChecker[1] = baseline->second->endpoints[1]->lines.find(target->first);
             if (((LineChecker[0] != baseline->second->endpoints[0]->lines.end()) && (LineChecker[0]->second->triangles.size() == 2))) {
               Log() << Verbose(4) << *(baseline->second->endpoints[0]) << " has line " << *(LineChecker[0]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[0]->second->triangles.size() << " triangles." << endl;
+              Log() << Verbose(2) << *(baseline->second->endpoints[0]) << " has line " << *(LineChecker[0]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[0]->second->triangles.size() << " triangles." << endl;
               continue;
+            }
             if (((LineChecker[1] != baseline->second->endpoints[1]->lines.end()) && (LineChecker[1]->second->triangles.size() == 2))) {
               Log() << Verbose(4) << *(baseline->second->endpoints[1]) << " has line " << *(LineChecker[1]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[1]->second->triangles.size() << " triangles." << endl;
+              Log() << Verbose(2) << *(baseline->second->endpoints[1]) << " has line " << *(LineChecker[1]->second) << " to " << *(target->second) << " as endpoint with " << LineChecker[1]->second->triangles.size() << " triangles." << endl;
               continue;
+            }
 …
             helper.ProjectOntoPlane(&TempVector);
             if (fabs(helper.NormSquared()) < MYEPSILON) {
               Log() << Verbose(4) << "Chosen set of vectors is linear dependent." << endl;
+              Log() << Verbose(2) << "Chosen set of vectors is linear dependent." << endl;
               continue;
+            }
 …
             // calculate angle
             TempAngle = NormalVector.Angle(&VirtualNormalVector);
             Log() << Verbose(4) << "NormalVector is " << VirtualNormalVector << " and the angle is " << TempAngle << "." << endl;
+            Log() << Verbose(2) << "NormalVector is " << VirtualNormalVector << " and the angle is " << TempAngle << "." << endl;
             if ((SmallestAngle - TempAngle) > MYEPSILON) { // set to new possible winner
               SmallestAngle = TempAngle;
               winner = target;
               Log() << Verbose(4) << "New winner " << *winner->second->node << " due to smaller angle between normal vectors." << endl;
+              Log() << Verbose(2) << "New winner " << *winner->second->node << " due to smaller angle between normal vectors." << endl;
             } else if (fabs(SmallestAngle - TempAngle) < MYEPSILON) { // check the angle to propagation, both possible targets are in one plane! (their normals have same angle)
               // hence, check the angles to some normal direction from our base line but in this common plane of both targets...
 …
                 SmallestAngle = TempAngle;
                 winner = target;
                 Log() << Verbose(4) << "New winner " << *winner->second->node << " due to smaller angle " << TempAngle << " to propagation direction." << endl;
+                Log() << Verbose(2) << "New winner " << *winner->second->node << " due to smaller angle " << TempAngle << " to propagation direction." << endl;
               } else
                 Log() << Verbose(4) << "Keeping old winner " << *winner->second->node << " due to smaller angle to propagation direction." << endl;
+                Log() << Verbose(2) << "Keeping old winner " << *winner->second->node << " due to smaller angle to propagation direction." << endl;
             } else
               Log() << Verbose(4) << "Keeping old winner " << *winner->second->node << " due to smaller angle between normal vectors." << endl;
+              Log() << Verbose(2) << "Keeping old winner " << *winner->second->node << " due to smaller angle between normal vectors." << endl;
+          }
         } // end of loop over all boundary points
 …
         // 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()) {
           Log() << Verbose(2) << "Winning target point is " << *(winner->second) << " with angle " << SmallestAngle << "." << endl;
+          Log() << Verbose(0) << "Winning target point is " << *(winner->second) << " with angle " << SmallestAngle << "." << endl;
           // create the lins of not yet present
           BLS[0] = baseline->second;
 …
           TrianglesOnBoundaryCount++;
         } else {
           Log() << Verbose(1) << "I could not determine a winner for this baseline " << *(baseline->second) << "." << endl;
+          eLog() << Verbose(2) << "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
         Log() << Verbose(2) << "Baseline candidate " << *(baseline->second) << " has a triangle count of " << baseline->second->triangles.size() << "." << endl;
+        Log() << Verbose(0) << "Baseline candidate " << *(baseline->second) << " has a triangle count of " << baseline->second->triangles.size() << "." << endl;
   } while (flag);
 …
 bool Tesselation::InsertStraddlingPoints(const PointCloud *cloud, const LinkedCell *LC)
+{
+        Info FunctionInfo(__func__);
   Vector Intersection, Normal;
   TesselPoint *Walker = NULL;
   Vector *Center = cloud->GetCenter();
   list<BoundaryTriangleSet*> *triangles = NULL;
+  TriangleList *triangles = NULL;
   bool AddFlag = false;
   LinkedCell *BoundaryPoints = NULL;
-  Log() << Verbose(1) << "Begin of InsertStraddlingPoints" << endl;
   cloud->GoToFirst();
 …
+    }
     Walker = cloud->GetPoint();
     Log() << Verbose(2) << "Current point is " << *Walker << "." << endl;
+    Log() << Verbose(0) << "Current point is " << *Walker << "." << endl;
     // get the next triangle
     triangles = FindClosestTrianglesToPoint(Walker->node, BoundaryPoints);
+    triangles = FindClosestTrianglesToVector(Walker->node, BoundaryPoints);
     BTS = triangles->front();
     if ((triangles == NULL) || (BTS->ContainsBoundaryPoint(Walker))) {
       Log() << Verbose(2) << "No triangles found, probably a tesselation point itself." << endl;
+      Log() << Verbose(0) << "No triangles found, probably a tesselation point itself." << endl;
       cloud->GoToNext();
       continue;
     } else {
+    }
     Log() << Verbose(2) << "Closest triangle is " << *BTS << "." << endl;
+    Log() << Verbose(0) << "Closest triangle is " << *BTS << "." << endl;
     // get the intersection point
     if (BTS->GetIntersectionInsideTriangle(Center, Walker->node, &Intersection)) {
       Log() << Verbose(2) << "We have an intersection at " << Intersection << "." << endl;
+      Log() << Verbose(0) << "We have an intersection at " << Intersection << "." << endl;
       // we have the intersection, check whether in- or outside of boundary
       if ((Center->DistanceSquared(Walker->node) - Center->DistanceSquared(&Intersection)) < -MYEPSILON) {
         // inside, next!
         Log() << Verbose(2) << *Walker << " is inside wrt triangle " << *BTS << "." << endl;
+        Log() << Verbose(0) << *Walker << " is inside wrt triangle " << *BTS << "." << endl;
       } else {
         // outside!
         Log() << Verbose(2) << *Walker << " is outside wrt triangle " << *BTS << "." << endl;
+        Log() << Verbose(0) << *Walker << " is outside wrt triangle " << *BTS << "." << endl;
         class BoundaryLineSet *OldLines[3], *NewLines[3];
         class BoundaryPointSet *OldPoints[3], *NewPoint;
 …
         Normal.CopyVector(&BTS->NormalVector);
         // add Walker to boundary points
         Log() << Verbose(2) << "Adding " << *Walker << " to BoundaryPoints." << endl;
+        Log() << Verbose(0) << "Adding " << *Walker << " to BoundaryPoints." << endl;
         AddFlag = true;
         if (AddBoundaryPoint(Walker,0))
 …
           continue;
         // remove triangle
         Log() << Verbose(2) << "Erasing triangle " << *BTS << "." << endl;
+        Log() << Verbose(0) << "Erasing triangle " << *BTS << "." << endl;
         TrianglesOnBoundary.erase(BTS->Nr);
         delete(BTS);
 …
           BPS[1] = OldPoints[i];
           NewLines[i] = new class BoundaryLineSet(BPS, LinesOnBoundaryCount);
           Log() << Verbose(3) << "Creating new line " << *NewLines[i] << "." << endl;
+          Log() << Verbose(1) << "Creating new line " << *NewLines[i] << "." << endl;
           LinesOnBoundary.insert(LinePair(LinesOnBoundaryCount, NewLines[i])); // no need for check for unique insertion as BPS[0] is definitely a new one
           LinesOnBoundaryCount++;
 …
             if (NewLines[j]->IsConnectedTo(BLS[0])) {
               if (n>2) {
                 Log() << Verbose(1) << BLS[0] << " connects to all of the new lines?!" << endl;
+                eLog() << Verbose(2) << BLS[0] << " connects to all of the new lines?!" << endl;
                 return false;
               } else
 …
           BTS->GetNormalVector(Normal);
           Normal.Scale(-1.);
           Log() << Verbose(2) << "Created new triangle " << *BTS << "." << endl;
+          Log() << Verbose(0) << "Created new triangle " << *BTS << "." << endl;
           TrianglesOnBoundary.insert(TrianglePair(TrianglesOnBoundaryCount, BTS));
           TrianglesOnBoundaryCount++;
 …
   // exit
   delete(Center);
-  Log() << Verbose(1) << "End of InsertStraddlingPoints" << endl;
   return true;
 };
 …
 bool Tesselation::AddBoundaryPoint(TesselPoint * Walker, const int n)
+{
+        Info FunctionInfo(__func__);
   PointTestPair InsertUnique;
   BPS[n] = new class BoundaryPointSet(Walker);
 …
 void Tesselation::AddTesselationPoint(TesselPoint* Candidate, const int n)
+{
+        Info FunctionInfo(__func__);
   PointTestPair InsertUnique;
   TPS[n] = new class BoundaryPointSet(Candidate);
 …
   } else {
     delete TPS[n];
     Log() << Verbose(4) << "Node " << *((InsertUnique.first)->second->node) << " is already present in PointsOnBoundary." << endl;
+    Log() << Verbose(0) << "Node " << *((InsertUnique.first)->second->node) << " is already present in PointsOnBoundary." << endl;
     TPS[n] = (InsertUnique.first)->second;
+  }
 …
 void Tesselation::SetTesselationPoint(TesselPoint* Candidate, const int n) const
+{
+        Info FunctionInfo(__func__);
   PointMap::const_iterator FindPoint = PointsOnBoundary.find(Candidate->nr);
   if (FindPoint != PointsOnBoundary.end())
 …
   bool insertNewLine = true;
+  if (a->lines.find(b->node->nr) != a->lines.end()) {
+    LineMap::iterator FindLine = a->lines.find(b->node->nr);
+  LineMap::iterator FindLine = a->lines.find(b->node->nr);
+  if (FindLine != a->lines.end()) {
+    Log() << Verbose(1) << "INFO: There is at least one line between " << *a << " and " << *b << ": " << *(FindLine->second) << "." << endl;
     pair<LineMap::iterator,LineMap::iterator> FindPair;
     FindPair = a->lines.equal_range(b->node->nr);
-    Log() << Verbose(5) << "INFO: There is at least one line between " << *a << " and " << *b << ": " << *(FindLine->second) << "." << endl;
     for (FindLine = FindPair.first; FindLine != FindPair.second; FindLine++) {
 …
       if (FindLine->second->triangles.size() < 2) {
         insertNewLine = false;
         Log() << Verbose(4) << "Using existing line " << *FindLine->second << endl;
+        Log() << Verbose(0) << "Using existing line " << *FindLine->second << endl;
         BPS[0] = FindLine->second->endpoints[0];
         BPS[1] = FindLine->second->endpoints[1];
         BLS[n] = FindLine->second;
+        // remove existing line from OpenLines
+        CandidateMap::iterator CandidateLine = OpenLines.find(BLS[n]);
+        if (CandidateLine != OpenLines.end()) {
+          Log() << Verbose(1) << " Removing line from OpenLines." << endl;
+          delete(CandidateLine->second);
+          OpenLines.erase(CandidateLine);
+        } else {
+          eLog() << Verbose(1) << "Line exists and is attached to less than two triangles, but not in OpenLines!" << endl;
+        }
         break;
 …
 void Tesselation::AlwaysAddTesselationTriangleLine(class BoundaryPointSet *a, class BoundaryPointSet *b, const int n)
+{
+  Log() << Verbose(4) << "Adding line [" << LinesOnBoundaryCount << "|" << *(a->node) << " and " << *(b->node) << "." << endl;
+        Info FunctionInfo(__func__);
+  Log() << Verbose(0) << "Adding open line [" << LinesOnBoundaryCount << "|" << *(a->node) << " and " << *(b->node) << "." << endl;
   BPS[0] = a;
   BPS[1] = b;
 …
   // increase counter
   LinesOnBoundaryCount++;
+  // also add to open lines
+  CandidateForTesselation *CFT = new CandidateForTesselation(BLS[n]);
+  OpenLines.insert(pair< BoundaryLineSet *, CandidateForTesselation *> (BLS[n], CFT));
 };
 …
 void Tesselation::AddTesselationTriangle()
+{
+        Info FunctionInfo(__func__);
   Log() << Verbose(1) << "Adding triangle to global TrianglesOnBoundary map." << endl;
 …
 void Tesselation::AddTesselationTriangle(const int nr)
+{
+  Log() << Verbose(1) << "Adding triangle to global TrianglesOnBoundary map." << endl;
+        Info FunctionInfo(__func__);
+  Log() << Verbose(0) << "Adding triangle to global TrianglesOnBoundary map." << endl;
   // add triangle to global map
 …
 void Tesselation::RemoveTesselationTriangle(class BoundaryTriangleSet *triangle)
+{
+        Info FunctionInfo(__func__);
   if (triangle == NULL)
     return;
   for (int i = 0; i < 3; i++) {
     if (triangle->lines[i] != NULL) {
       Log() << Verbose(5) << "Removing triangle Nr." << triangle->Nr << " in line " << *triangle->lines[i] << "." << endl;
+      Log() << Verbose(0) << "Removing triangle Nr." << triangle->Nr << " in line " << *triangle->lines[i] << "." << endl;
       triangle->lines[i]->triangles.erase(triangle->Nr);
       if (triangle->lines[i]->triangles.empty()) {
           Log() << Verbose(5) << *triangle->lines[i] << " is no more attached to any triangle, erasing." << endl;
+          Log() << Verbose(0) << *triangle->lines[i] << " is no more attached to any triangle, erasing." << endl;
           RemoveTesselationLine(triangle->lines[i]);
       } else {
+        Log() << Verbose(5) << *triangle->lines[i] << " is still attached to another triangle: ";
+        Log() << Verbose(0) << *triangle->lines[i] << " is still attached to another triangle: ";
+        OpenLines.insert(pair< BoundaryLineSet *, CandidateForTesselation *> (triangle->lines[i], NULL));
         for(TriangleMap::iterator TriangleRunner = triangle->lines[i]->triangles.begin(); TriangleRunner != triangle->lines[i]->triangles.end(); TriangleRunner++)
           Log() << Verbose(0) << "[" << (TriangleRunner->second)->Nr << "|" << *((TriangleRunner->second)->endpoints[0]) << ", " << *((TriangleRunner->second)->endpoints[1]) << ", " << *((TriangleRunner->second)->endpoints[2]) << "] \t";
         Log() << Verbose(0) << endl;
 //        for (int j=0;j<2;j++) {
 //          Log() << Verbose(5) << "Lines of endpoint " << *(triangle->lines[i]->endpoints[j]) << ": ";
+//          Log() << Verbose(0) << "Lines of endpoint " << *(triangle->lines[i]->endpoints[j]) << ": ";
 //          for(LineMap::iterator LineRunner = triangle->lines[i]->endpoints[j]->lines.begin(); LineRunner != triangle->lines[i]->endpoints[j]->lines.end(); LineRunner++)
 //            Log() << Verbose(0) << "[" << *(LineRunner->second) << "] \t";
 …
   if (TrianglesOnBoundary.erase(triangle->Nr))
     Log() << Verbose(5) << "Removing triangle Nr. " << triangle->Nr << "." << endl;
+    Log() << Verbose(0) << "Removing triangle Nr. " << triangle->Nr << "." << endl;
   delete(triangle);
 };
 …
 void Tesselation::RemoveTesselationLine(class BoundaryLineSet *line)
+{
+        Info FunctionInfo(__func__);
   int Numbers[2];
 …
         for (LineMap::iterator Runner = erasor.first; Runner != erasor.second; Runner++)
           if ((*Runner).second == line) {
             Log() << Verbose(5) << "Removing Line Nr. " << line->Nr << " in boundary point " << *line->endpoints[i] << "." << endl;
+            Log() << Verbose(0) << "Removing Line Nr. " << line->Nr << " in boundary point " << *line->endpoints[i] << "." << endl;
             line->endpoints[i]->lines.erase(Runner);
             break;
 …
       } else { // there's just a single line left
         if (line->endpoints[i]->lines.erase(line->Nr))
           Log() << Verbose(5) << "Removing Line Nr. " << line->Nr << " in boundary point " << *line->endpoints[i] << "." << endl;
+          Log() << Verbose(0) << "Removing Line Nr. " << line->Nr << " in boundary point " << *line->endpoints[i] << "." << endl;
+      }
       if (line->endpoints[i]->lines.empty()) {
         Log() << Verbose(5) << *line->endpoints[i] << " has no more lines it's attached to, erasing." << endl;
+        Log() << Verbose(0) << *line->endpoints[i] << " has no more lines it's attached to, erasing." << endl;
         RemoveTesselationPoint(line->endpoints[i]);
       } else {
         Log() << Verbose(5) << *line->endpoints[i] << " has still lines it's attached to: ";
+        Log() << Verbose(0) << *line->endpoints[i] << " has still lines it's attached to: ";
         for(LineMap::iterator LineRunner = line->endpoints[i]->lines.begin(); LineRunner != line->endpoints[i]->lines.end(); LineRunner++)
           Log() << Verbose(0) << "[" << *(LineRunner->second) << "] \t";
 …
   if (LinesOnBoundary.erase(line->Nr))
     Log() << Verbose(5) << "Removing line Nr. " << line->Nr << "." << endl;
+    Log() << Verbose(0) << "Removing line Nr. " << line->Nr << "." << endl;
   delete(line);
 };
 …
 void Tesselation::RemoveTesselationPoint(class BoundaryPointSet *point)
+{
+        Info FunctionInfo(__func__);
   if (point == NULL)
     return;
   if (PointsOnBoundary.erase(point->Nr))
     Log() << Verbose(5) << "Removing point Nr. " << point->Nr << "." << endl;
+    Log() << Verbose(0) << "Removing point Nr. " << point->Nr << "." << endl;
   delete(point);
 };
 …
 int Tesselation::CheckPresenceOfTriangle(TesselPoint *Candidates[3]) const
+{
+        Info FunctionInfo(__func__);
   int adjacentTriangleCount = 0;
   class BoundaryPointSet *Points[3];
-  Log() << Verbose(2) << "Begin of CheckPresenceOfTriangle" << endl;
   // builds a triangle point set (Points) of the end points
   for (int i = 0; i < 3; i++) {
 …
           for (; (FindLine != Points[i]->lines.end()) && (FindLine->first == Points[j]->node->nr); FindLine++) {
             TriangleMap *triangles = &FindLine->second->triangles;
             Log() << Verbose(3) << "Current line is " << FindLine->first << ": " << *(FindLine->second) << " with triangles " << triangles << "." << endl;
+            Log() << Verbose(1) << "Current line is " << FindLine->first << ": " << *(FindLine->second) << " with triangles " << triangles << "." << endl;
             for (TriangleMap::const_iterator FindTriangle = triangles->begin(); FindTriangle != triangles->end(); FindTriangle++) {
               if (FindTriangle->second->IsPresentTupel(Points)) {
 …
+              }
+            }
             Log() << Verbose(3) << "end." << endl;
+            Log() << Verbose(1) << "end." << endl;
+          }
           // Only one of the triangle lines must be considered for the triangle count.
           //Log() << Verbose(2) << "Found " << adjacentTriangleCount << " adjacent triangles for the point set." << endl;
+          //Log() << Verbose(0) << "Found " << adjacentTriangleCount << " adjacent triangles for the point set." << endl;
           //return adjacentTriangleCount;
+        }
 …
+  }
+  Log() << Verbose(2) << "Found " << adjacentTriangleCount << " adjacent triangles for the point set." << endl;
+  Log() << Verbose(2) << "End of CheckPresenceOfTriangle" << endl;
+  Log() << Verbose(0) << "Found " << adjacentTriangleCount << " adjacent triangles for the point set." << endl;
   return adjacentTriangleCount;
 };
 …
 class BoundaryTriangleSet * Tesselation::GetPresentTriangle(TesselPoint *Candidates[3])
+{
+        Info FunctionInfo(__func__);
   class BoundaryTriangleSet *triangle = NULL;
   class BoundaryPointSet *Points[3];
 …
+          }
           // Only one of the triangle lines must be considered for the triangle count.
           //Log() << Verbose(2) << "Found " << adjacentTriangleCount << " adjacent triangles for the point set." << endl;
+          //Log() << Verbose(0) << "Found " << adjacentTriangleCount << " adjacent triangles for the point set." << endl;
           //return adjacentTriangleCount;
+        }
 …
 void Tesselation::FindStartingTriangle(const double RADIUS, const LinkedCell *LC)
+{
   Log() << Verbose(1) << "Begin of FindStartingTriangle\n";
+        Info FunctionInfo(__func__);
   int i = 0;
-  TesselPoint* FirstPoint = NULL;
-  TesselPoint* SecondPoint = NULL;
   TesselPoint* MaxPoint[NDIM];
+  TesselPoint* Temporary;
   double maxCoordinate[NDIM];
   Vector Oben;
+  BoundaryLineSet BaseLine;
   Vector helper;
   Vector Chord;
   Vector SearchDirection;
+  Oben.Zero();
+  Vector CircleCenter;  // center of the circle, i.e. of the band of sphere's centers
+  Vector CirclePlaneNormal; // normal vector defining the plane this circle lives in
+  Vector SphereCenter;
+  Vector NormalVector;
+  NormalVector.Zero();
   for (i = 0; i < 3; i++) {
 …
       for (LC->n[(i+2)%NDIM]=0;LC->n[(i+2)%NDIM]<LC->N[(i+2)%NDIM];LC->n[(i+2)%NDIM]++) {
         const LinkedNodes *List = LC->GetCurrentCell();
         //Log() << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+        //Log() << Verbose(1) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
         if (List != NULL) {
           for (LinkedNodes::const_iterator Runner = List->begin();Runner != List->end();Runner++) {
             if ((*Runner)->node->x[i] > maxCoordinate[i]) {
               Log() << Verbose(2) << "New maximal for axis " << i << " node is " << *(*Runner) << " at " << *(*Runner)->node << "." << endl;
+              Log() << Verbose(1) << "New maximal for axis " << i << " node is " << *(*Runner) << " at " << *(*Runner)->node << "." << endl;
               maxCoordinate[i] = (*Runner)->node->x[i];
               MaxPoint[i] = (*Runner);
 …
+  }
   Log() << Verbose(2) << "Found maximum coordinates: ";
+  Log() << Verbose(1) << "Found maximum coordinates: ";
   for (int i=0;i<NDIM;i++)
     Log() << Verbose(0) << i << ": " << *MaxPoint[i] << "\t";
 …
   BTS = NULL;
-  CandidateList *OptCandidates = new CandidateList();
   for (int k=0;k<NDIM;k++) {
     Oben.Zero();
     Oben.x[k] = 1.;
     FirstPoint = MaxPoint[k];
     Log() << Verbose(1) << "Coordinates of start node at " << *FirstPoint->node << "." << endl;
+    NormalVector.Zero();
+    NormalVector.x[k] = 1.;
+    BaseLine.endpoints[0] = new BoundaryPointSet(MaxPoint[k]);
+    Log() << Verbose(0) << "Coordinates of start node at " << *BaseLine.endpoints[0]->node << "." << endl;
     double ShortestAngle;
-    TesselPoint* OptCandidate = NULL;
     ShortestAngle = 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.
+    FindSecondPointForTesselation(FirstPoint, Oben, OptCandidate, &ShortestAngle, RADIUS, LC); // we give same point as next candidate as its bonds are looked into in find_second_...
+    SecondPoint = OptCandidate;
+    if (SecondPoint == NULL)  // have we found a second point?
+    FindSecondPointForTesselation(BaseLine.endpoints[0]->node, NormalVector, Temporary, &ShortestAngle, RADIUS, LC); // we give same point as next candidate as its bonds are looked into in find_second_...
+    if (Temporary == NULL)  // have we found a second point?
       continue;
+    helper.CopyVector(FirstPoint->node);
+    helper.SubtractVector(SecondPoint->node);
+    helper.Normalize();
+    Oben.ProjectOntoPlane(&helper);
+    Oben.Normalize();
+    helper.VectorProduct(&Oben);
+    BaseLine.endpoints[1] = new BoundaryPointSet(Temporary);
+    // construct center of circle
+    CircleCenter.CopyVector(BaseLine.endpoints[0]->node->node);
+    CircleCenter.AddVector(BaseLine.endpoints[1]->node->node);
+    CircleCenter.Scale(0.5);
+    // construct normal vector of circle
+    CirclePlaneNormal.CopyVector(BaseLine.endpoints[0]->node->node);
+    CirclePlaneNormal.SubtractVector(BaseLine.endpoints[1]->node->node);
+    double radius = CirclePlaneNormal.NormSquared();
+    double CircleRadius = sqrt(RADIUS*RADIUS - radius/4.);
+    NormalVector.ProjectOntoPlane(&CirclePlaneNormal);
+    NormalVector.Normalize();
     ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
+    Chord.CopyVector(FirstPoint->node); // bring into calling function
+    Chord.SubtractVector(SecondPoint->node);
+    double radius = Chord.ScalarProduct(&Chord);
+    double CircleRadius = sqrt(RADIUS*RADIUS - radius/4.);
+    helper.CopyVector(&Oben);
+    helper.Scale(CircleRadius);
+    // Now, oben and helper are two orthonormalized vectors in the plane defined by Chord (not normalized)
+    SphereCenter.CopyVector(&NormalVector);
+    SphereCenter.Scale(CircleRadius);
+    SphereCenter.AddVector(&CircleCenter);
+    // Now, NormalVector and SphereCenter are two orthonormalized vectors in the plane defined by CirclePlaneNormal (not normalized)
     // look in one direction of baseline for initial candidate
     SearchDirection.MakeNormalVector(&Chord, &Oben);  // whether we look "left" first or "right" first is not important ...
+    SearchDirection.MakeNormalVector(&CirclePlaneNormal, &NormalVector);  // whether we look "left" first or "right" first is not important ...
     // adding point 1 and point 2 and add the line between them
+    Log() << Verbose(1) << "Coordinates of start node at " << *FirstPoint->node << "." << endl;
+    AddTesselationPoint(FirstPoint, 0);
+    Log() << Verbose(1) << "Found second point is at " << *SecondPoint->node << ".\n";
+    AddTesselationPoint(SecondPoint, 1);
+    AddTesselationLine(TPS[0], TPS[1], 0);
+    //Log() << Verbose(2) << "INFO: OldSphereCenter is at " << helper << ".\n";
+    FindThirdPointForTesselation(Oben, SearchDirection, helper, BLS[0], NULL, *&OptCandidates, &ShortestAngle, RADIUS, LC);
+    Log() << Verbose(1) << "List of third Points is ";
+    for (CandidateList::iterator it = OptCandidates->begin(); it != OptCandidates->end(); ++it) {
+        Log() << Verbose(0) << " " << *(*it)->point;
+    }
+    Log() << Verbose(0) << endl;
+    for (CandidateList::iterator it = OptCandidates->begin(); it != OptCandidates->end(); ++it) {
+      // add third triangle point
+      AddTesselationPoint((*it)->point, 2);
+      // add the second and third line
+      AddTesselationLine(TPS[1], TPS[2], 1);
+      AddTesselationLine(TPS[0], TPS[2], 2);
+      // ... and triangles to the Maps of the Tesselation class
+      BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+      AddTesselationTriangle();
+      // ... and calculate its normal vector (with correct orientation)
+      (*it)->OptCenter.Scale(-1.);
+      Log() << Verbose(2) << "Anti-Oben is currently " << (*it)->OptCenter << "." << endl;
+      BTS->GetNormalVector((*it)->OptCenter);  // vector to compare with should point inwards
+      Log() << Verbose(0) << "==> Found starting triangle consists of " << *FirstPoint << ", " << *SecondPoint << " and "
+      << *(*it)->point << " with normal vector " << BTS->NormalVector << ".\n";
+      // if we do not reach the end with the next step of iteration, we need to setup a new first line
+      if (it != OptCandidates->end()--) {
+        FirstPoint = (*it)->BaseLine->endpoints[0]->node;
+        SecondPoint = (*it)->point;
+        // adding point 1 and point 2 and the line between them
+        AddTesselationPoint(FirstPoint, 0);
+        AddTesselationPoint(SecondPoint, 1);
+        AddTesselationLine(TPS[0], TPS[1], 0);
+      }
+      Log() << Verbose(2) << "Projection is " << BTS->NormalVector.ScalarProduct(&Oben) << "." << endl;
+    }
+    Log() << Verbose(0) << "Coordinates of start node at " << *BaseLine.endpoints[0]->node << "." << endl;
+    Log() << Verbose(0) << "Found second point is at " << *BaseLine.endpoints[1]->node << ".\n";
+    //Log() << Verbose(1) << "INFO: OldSphereCenter is at " << helper << ".\n";
+    CandidateForTesselation OptCandidates(&BaseLine);
+    FindThirdPointForTesselation(NormalVector, SearchDirection, SphereCenter, OptCandidates, NULL, RADIUS, LC);
+    Log() << Verbose(0) << "List of third Points is:" << endl;
+    for (TesselPointList::iterator it = OptCandidates.pointlist.begin(); it != OptCandidates.pointlist.end(); it++) {
+        Log() << Verbose(0) << " " << *(*it) << endl;
+    }
+    BTS = NULL;
+    AddCandidateTriangle(OptCandidates);
+//    delete(BaseLine.endpoints[0]);
+//    delete(BaseLine.endpoints[1]);
     if (BTS != NULL) // we have created one starting triangle
       break;
     else {
       // remove all candidates from the list and then the list itself
+      class CandidateForTesselation *remover = NULL;
+      for (CandidateList::iterator it = OptCandidates->begin(); it != OptCandidates->end(); ++it) {
+        remover = *it;
+        delete(remover);
+      }
+      OptCandidates->clear();
+    }
+  }
+  // remove all candidates from the list and then the list itself
+  class CandidateForTesselation *remover = NULL;
+  for (CandidateList::iterator it = OptCandidates->begin(); it != OptCandidates->end(); ++it) {
+    remover = *it;
+    delete(remover);
+  }
+  delete(OptCandidates);
+  Log() << Verbose(1) << "End of FindStartingTriangle\n";
+      OptCandidates.pointlist.clear();
+    }
+  }
 };
 /** Checks for a given baseline and a third point candidate whether baselines of the found triangle don't have even better candidates.
  * This is supposed to prevent early closing of the tesselation.
  * \param *BaseRay baseline, i.e. not \a *OptCandidate
+ * \param CandidateLine CandidateForTesselation with baseline and shortestangle , i.e. not \a *OptCandidate
  * \param *ThirdNode third point in triangle, not in BoundaryLineSet::endpoints
- * \param ShortestAngle path length on this circle band for the current \a *ThirdNode
  * \param RADIUS radius of sphere
  * \param *LC LinkedCell structure
  * \return true - there is a better candidate (smaller angle than \a ShortestAngle), false - no better TesselPoint candidate found
  */
+bool Tesselation::HasOtherBaselineBetterCandidate(const BoundaryLineSet * const BaseRay, const TesselPoint * const ThirdNode, double ShortestAngle, double RADIUS, const LinkedCell * const LC) const
+{
+  bool result = false;
+  Vector CircleCenter;
+  Vector CirclePlaneNormal;
+  Vector OldSphereCenter;
+  Vector SearchDirection;
+  Vector helper;
+  TesselPoint *OtherOptCandidate = NULL;
+  double OtherShortestAngle = 2.*M_PI; // This will indicate the quadrant.
+  double radius, CircleRadius;
+  BoundaryLineSet *Line = NULL;
+  BoundaryTriangleSet *T = NULL;
+  Log() << Verbose(1) << "Begin of HasOtherBaselineBetterCandidate" << endl;
+  // check both other lines
+  PointMap::const_iterator FindPoint = PointsOnBoundary.find(ThirdNode->nr);
+  if (FindPoint != PointsOnBoundary.end()) {
+    for (int i=0;i<2;i++) {
+      LineMap::const_iterator FindLine = (FindPoint->second)->lines.find(BaseRay->endpoints[0]->node->nr);
+      if (FindLine != (FindPoint->second)->lines.end()) {
+        Line = FindLine->second;
+        Log() << Verbose(1) << "Found line " << *Line << "." << endl;
+        if (Line->triangles.size() == 1) {
+          T = Line->triangles.begin()->second;
+          // construct center of circle
+          CircleCenter.CopyVector(Line->endpoints[0]->node->node);
+          CircleCenter.AddVector(Line->endpoints[1]->node->node);
+          CircleCenter.Scale(0.5);
+          // construct normal vector of circle
+          CirclePlaneNormal.CopyVector(Line->endpoints[0]->node->node);
+          CirclePlaneNormal.SubtractVector(Line->endpoints[1]->node->node);
+          // calculate squared radius of circle
+          radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
+          if (radius/4. < RADIUS*RADIUS) {
+            CircleRadius = RADIUS*RADIUS - radius/4.;
+            CirclePlaneNormal.Normalize();
+            //Log() << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+            // construct old center
+            GetCenterofCircumcircle(&OldSphereCenter, *T->endpoints[0]->node->node, *T->endpoints[1]->node->node, *T->endpoints[2]->node->node);
+            helper.CopyVector(&T->NormalVector);  // normal vector ensures that this is correct center of the two possible ones
+            radius = Line->endpoints[0]->node->node->DistanceSquared(&OldSphereCenter);
+            helper.Scale(sqrt(RADIUS*RADIUS - radius));
+            OldSphereCenter.AddVector(&helper);
+            OldSphereCenter.SubtractVector(&CircleCenter);
+            //Log() << Verbose(2) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
+            // construct SearchDirection
+            SearchDirection.MakeNormalVector(&T->NormalVector, &CirclePlaneNormal);
+            helper.CopyVector(Line->endpoints[0]->node->node);
+            helper.SubtractVector(ThirdNode->node);
+            if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)// ohoh, SearchDirection points inwards!
+              SearchDirection.Scale(-1.);
+            SearchDirection.ProjectOntoPlane(&OldSphereCenter);
+            SearchDirection.Normalize();
+            Log() << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+            if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {
+              // rotated the wrong way!
+              eLog() << Verbose(1) << "SearchDirection and RelativeOldSphereCenter are still not orthogonal!" << endl;
+            }
+            // add third point
+            CandidateList *OptCandidates = new CandidateList();
+            FindThirdPointForTesselation(T->NormalVector, SearchDirection, OldSphereCenter, Line, ThirdNode, OptCandidates, &OtherShortestAngle, RADIUS, LC);
+            for (CandidateList::iterator it = OptCandidates->begin(); it != OptCandidates->end(); ++it) {
+              if (((*it)->point == BaseRay->endpoints[0]->node) || ((*it)->point == BaseRay->endpoints[1]->node)) // skip if it's the same triangle than suggested
+                continue;
+              Log() << Verbose(1) << " Third point candidate is " << *(*it)->point
+              << " with circumsphere's center at " << (*it)->OptCenter << "." << endl;
+              Log() << Verbose(1) << " Baseline is " << *BaseRay << endl;
+              // check whether all edges of the new triangle still have space for one more triangle (i.e. TriangleCount <2)
+              TesselPoint *PointCandidates[3];
+              PointCandidates[0] = (*it)->point;
+              PointCandidates[1] = BaseRay->endpoints[0]->node;
+              PointCandidates[2] = BaseRay->endpoints[1]->node;
+              bool check=false;
+              int existentTrianglesCount = CheckPresenceOfTriangle(PointCandidates);
+              // If there is no triangle, add it regularly.
+              if (existentTrianglesCount == 0) {
+                SetTesselationPoint((*it)->point, 0);
+                SetTesselationPoint(BaseRay->endpoints[0]->node, 1);
+                SetTesselationPoint(BaseRay->endpoints[1]->node, 2);
+                if (CheckLineCriteriaForDegeneratedTriangle((const BoundaryPointSet ** const )TPS)) {
+                  OtherOptCandidate = (*it)->point;
+                  check = true;
+                }
+              } else if ((existentTrianglesCount >= 1) && (existentTrianglesCount <= 3)) { // If there is a planar region within the structure, we need this triangle a second time.
+                SetTesselationPoint((*it)->point, 0);
+                SetTesselationPoint(BaseRay->endpoints[0]->node, 1);
+                SetTesselationPoint(BaseRay->endpoints[1]->node, 2);
+                // We demand that at most one new degenerate line is created and that this line also already exists (which has to be the case due to existentTrianglesCount == 1)
+                // i.e. at least one of the three lines must be present with TriangleCount <= 1
+                if (CheckLineCriteriaForDegeneratedTriangle((const BoundaryPointSet ** const)TPS)) {
+                  OtherOptCandidate = (*it)->point;
+                  check = true;
+                }
+              }
+              if (check) {
+                if (ShortestAngle > OtherShortestAngle) {
+                  Log() << Verbose(1) << "There is a better candidate than " << *ThirdNode << " with " << ShortestAngle << " from baseline " << *Line << ": " << *OtherOptCandidate << " with " << OtherShortestAngle << "." << endl;
+                  result = true;
+                  break;
+                }
+              }
+            }
+            delete(OptCandidates);
+            if (result)
+              break;
+          } else {
+            Log() << Verbose(1) << "Circumcircle for base line " << *Line << " and base triangle " << T << " is too big!" << endl;
+          }
+        } else {
+          eLog() << Verbose(2) << "Baseline is connected to two triangles already?" << endl;
+        }
+      } else {
+        Log() << Verbose(2) << "No present baseline between " << BaseRay->endpoints[0] << " and candidate " << *ThirdNode << "." << endl;
+      }
+    }
+  } else {
+    eLog() << Verbose(1) << "Could not find the TesselPoint " << *ThirdNode << "." << endl;
+  }
+  Log() << Verbose(1) << "End of HasOtherBaselineBetterCandidate" << endl;
+  return result;
+};
+//bool Tesselation::HasOtherBaselineBetterCandidate(CandidateForTesselation &CandidateLine, const TesselPoint * const ThirdNode, double RADIUS, const LinkedCell * const LC) const
+//{
+//      Info FunctionInfo(__func__);
+//  bool result = false;
+//  Vector CircleCenter;
+//  Vector CirclePlaneNormal;
+//  Vector OldSphereCenter;
+//  Vector SearchDirection;
+//  Vector helper;
+//  TesselPoint *OtherOptCandidate = NULL;
+//  double OtherShortestAngle = 2.*M_PI; // This will indicate the quadrant.
+//  double radius, CircleRadius;
+//  BoundaryLineSet *Line = NULL;
+//  BoundaryTriangleSet *T = NULL;
+//
+//  // check both other lines
+//  PointMap::const_iterator FindPoint = PointsOnBoundary.find(ThirdNode->nr);
+//  if (FindPoint != PointsOnBoundary.end()) {
+//    for (int i=0;i<2;i++) {
+//      LineMap::const_iterator FindLine = (FindPoint->second)->lines.find(BaseRay->endpoints[0]->node->nr);
+//      if (FindLine != (FindPoint->second)->lines.end()) {
+//        Line = FindLine->second;
+//        Log() << Verbose(0) << "Found line " << *Line << "." << endl;
+//        if (Line->triangles.size() == 1) {
+//          T = Line->triangles.begin()->second;
+//          // construct center of circle
+//          CircleCenter.CopyVector(Line->endpoints[0]->node->node);
+//          CircleCenter.AddVector(Line->endpoints[1]->node->node);
+//          CircleCenter.Scale(0.5);
+//
+//          // construct normal vector of circle
+//          CirclePlaneNormal.CopyVector(Line->endpoints[0]->node->node);
+//          CirclePlaneNormal.SubtractVector(Line->endpoints[1]->node->node);
+//
+//          // calculate squared radius of circle
+//          radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
+//          if (radius/4. < RADIUS*RADIUS) {
+//            CircleRadius = RADIUS*RADIUS - radius/4.;
+//            CirclePlaneNormal.Normalize();
+//            //Log() << Verbose(1) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+//
+//            // construct old center
+//            GetCenterofCircumcircle(&OldSphereCenter, *T->endpoints[0]->node->node, *T->endpoints[1]->node->node, *T->endpoints[2]->node->node);
+//            helper.CopyVector(&T->NormalVector);  // normal vector ensures that this is correct center of the two possible ones
+//            radius = Line->endpoints[0]->node->node->DistanceSquared(&OldSphereCenter);
+//            helper.Scale(sqrt(RADIUS*RADIUS - radius));
+//            OldSphereCenter.AddVector(&helper);
+//            OldSphereCenter.SubtractVector(&CircleCenter);
+//            //Log() << Verbose(1) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
+//
+//            // construct SearchDirection
+//            SearchDirection.MakeNormalVector(&T->NormalVector, &CirclePlaneNormal);
+//            helper.CopyVector(Line->endpoints[0]->node->node);
+//            helper.SubtractVector(ThirdNode->node);
+//            if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)// ohoh, SearchDirection points inwards!
+//              SearchDirection.Scale(-1.);
+//            SearchDirection.ProjectOntoPlane(&OldSphereCenter);
+//            SearchDirection.Normalize();
+//            Log() << Verbose(1) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+//            if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {
+//              // rotated the wrong way!
+//              eLog() << Verbose(1) << "SearchDirection and RelativeOldSphereCenter are still not orthogonal!" << endl;
+//            }
+//
+//            // add third point
+//            FindThirdPointForTesselation(T->NormalVector, SearchDirection, OldSphereCenter, OptCandidates, ThirdNode, RADIUS, LC);
+//            for (TesselPointList::iterator it = OptCandidates.pointlist.begin(); it != OptCandidates.pointlist.end(); ++it) {
+//              if (((*it) == BaseRay->endpoints[0]->node) || ((*it) == BaseRay->endpoints[1]->node)) // skip if it's the same triangle than suggested
+//                continue;
+//              Log() << Verbose(0) << " Third point candidate is " << (*it)
+//              << " with circumsphere's center at " << (*it)->OptCenter << "." << endl;
+//              Log() << Verbose(0) << " Baseline is " << *BaseRay << endl;
+//
+//              // check whether all edges of the new triangle still have space for one more triangle (i.e. TriangleCount <2)
+//              TesselPoint *PointCandidates[3];
+//              PointCandidates[0] = (*it);
+//              PointCandidates[1] = BaseRay->endpoints[0]->node;
+//              PointCandidates[2] = BaseRay->endpoints[1]->node;
+//              bool check=false;
+//              int existentTrianglesCount = CheckPresenceOfTriangle(PointCandidates);
+//              // If there is no triangle, add it regularly.
+//              if (existentTrianglesCount == 0) {
+//                SetTesselationPoint((*it), 0);
+//                SetTesselationPoint(BaseRay->endpoints[0]->node, 1);
+//                SetTesselationPoint(BaseRay->endpoints[1]->node, 2);
+//
+//                if (CheckLineCriteriaForDegeneratedTriangle((const BoundaryPointSet ** const )TPS)) {
+//                  OtherOptCandidate = (*it);
+//                  check = true;
+//                }
+//              } else if ((existentTrianglesCount >= 1) && (existentTrianglesCount <= 3)) { // If there is a planar region within the structure, we need this triangle a second time.
+//                SetTesselationPoint((*it), 0);
+//                SetTesselationPoint(BaseRay->endpoints[0]->node, 1);
+//                SetTesselationPoint(BaseRay->endpoints[1]->node, 2);
+//
+//                // We demand that at most one new degenerate line is created and that this line also already exists (which has to be the case due to existentTrianglesCount == 1)
+//                // i.e. at least one of the three lines must be present with TriangleCount <= 1
+//                if (CheckLineCriteriaForDegeneratedTriangle((const BoundaryPointSet ** const)TPS)) {
+//                  OtherOptCandidate = (*it);
+//                  check = true;
+//                }
+//              }
+//
+//              if (check) {
+//                if (ShortestAngle > OtherShortestAngle) {
+//                  Log() << Verbose(0) << "There is a better candidate than " << *ThirdNode << " with " << ShortestAngle << " from baseline " << *Line << ": " << *OtherOptCandidate << " with " << OtherShortestAngle << "." << endl;
+//                  result = true;
+//                  break;
+//                }
+//              }
+//            }
+//            delete(OptCandidates);
+//            if (result)
+//              break;
+//          } else {
+//            Log() << Verbose(0) << "Circumcircle for base line " << *Line << " and base triangle " << T << " is too big!" << endl;
+//          }
+//        } else {
+//          eLog() << Verbose(2) << "Baseline is connected to two triangles already?" << endl;
+//        }
+//      } else {
+//        Log() << Verbose(1) << "No present baseline between " << BaseRay->endpoints[0] << " and candidate " << *ThirdNode << "." << endl;
+//      }
+//    }
+//  } else {
+//    eLog() << Verbose(1) << "Could not find the TesselPoint " << *ThirdNode << "." << endl;
+//  }
+//
+//  return result;
+//};
 /** This function finds a triangle to a line, adjacent to an existing one.
  * @param out output stream for debugging
  * @param Line current baseline to search from
+ * @param CandidateLine current cadndiate baseline to search from
  * @param T current triangle which \a Line is edge of
  * @param RADIUS radius of the rolling ball
 …
  * @param *LC LinkedCell structure with neighbouring points
  */
 bool Tesselation::FindNextSuitableTriangle(BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, const LinkedCell *LC)
+{
   Log() << Verbose(0) << "Begin of FindNextSuitableTriangle\n";
+bool Tesselation::FindNextSuitableTriangle(CandidateForTesselation &CandidateLine, BoundaryTriangleSet &T, const double& RADIUS, const LinkedCell *LC)
+{
+        Info FunctionInfo(__func__);
   bool result = true;
-  CandidateList *OptCandidates = new CandidateList();
   Vector CircleCenter;
   Vector CirclePlaneNormal;
   Vector OldSphereCenter;
+  Vector RelativeSphereCenter;
   Vector SearchDirection;
   Vector helper;
   TesselPoint *ThirdNode = NULL;
   LineMap::iterator testline;
-  double ShortestAngle = 2.*M_PI; // This will indicate the quadrant.
   double radius, CircleRadius;
-  Log() << Verbose(1) << "Current baseline is " << Line << " of triangle " << T << "." << endl;
   for (int i=0;i<3;i++)
     if ((T.endpoints[i]->node != Line.endpoints[0]->node) && (T.endpoints[i]->node != Line.endpoints[1]->node))
+    if ((T.endpoints[i]->node != CandidateLine.BaseLine->endpoints[0]->node) && (T.endpoints[i]->node != CandidateLine.BaseLine->endpoints[1]->node)) {
       ThirdNode = T.endpoints[i]->node;
+      break;
+    }
+  Log() << Verbose(0) << "Current baseline is " << *CandidateLine.BaseLine << " with ThirdNode " << *ThirdNode << " of triangle " << T << "." << endl;
   // construct center of circle
   CircleCenter.CopyVector(Line.endpoints[0]->node->node);
   CircleCenter.AddVector(Line.endpoints[1]->node->node);
+  CircleCenter.CopyVector(CandidateLine.BaseLine->endpoints[0]->node->node);
+  CircleCenter.AddVector(CandidateLine.BaseLine->endpoints[1]->node->node);
   CircleCenter.Scale(0.5);
   // construct normal vector of circle
   CirclePlaneNormal.CopyVector(Line.endpoints[0]->node->node);
   CirclePlaneNormal.SubtractVector(Line.endpoints[1]->node->node);
+  CirclePlaneNormal.CopyVector(CandidateLine.BaseLine->endpoints[0]->node->node);
+  CirclePlaneNormal.SubtractVector(CandidateLine.BaseLine->endpoints[1]->node->node);
   // calculate squared radius of circle
   radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
   if (radius/4. < RADIUS*RADIUS) {
+    // construct relative sphere center with now known CircleCenter
+    RelativeSphereCenter.CopyVector(&T.SphereCenter);
+    RelativeSphereCenter.SubtractVector(&CircleCenter);
     CircleRadius = RADIUS*RADIUS - radius/4.;
     CirclePlaneNormal.Normalize();
+    //Log() << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+    // construct old center
+    GetCenterofCircumcircle(&OldSphereCenter, *T.endpoints[0]->node->node, *T.endpoints[1]->node->node, *T.endpoints[2]->node->node);
+    helper.CopyVector(&T.NormalVector);  // normal vector ensures that this is correct center of the two possible ones
+    radius = Line.endpoints[0]->node->node->DistanceSquared(&OldSphereCenter);
+    helper.Scale(sqrt(RADIUS*RADIUS - radius));
+    OldSphereCenter.AddVector(&helper);
+    OldSphereCenter.SubtractVector(&CircleCenter);
+    //Log() << Verbose(2) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
+    // construct SearchDirection
+    SearchDirection.MakeNormalVector(&T.NormalVector, &CirclePlaneNormal);
+    helper.CopyVector(Line.endpoints[0]->node->node);
+    Log() << Verbose(1) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+    Log() << Verbose(1) << "INFO: OldSphereCenter is at " << T.SphereCenter << "." << endl;
+    // construct SearchDirection and an "outward pointer"
+    SearchDirection.MakeNormalVector(&RelativeSphereCenter, &CirclePlaneNormal);
+    helper.CopyVector(&CircleCenter);
     helper.SubtractVector(ThirdNode->node);
     if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)// ohoh, SearchDirection points inwards!
       SearchDirection.Scale(-1.);
+    SearchDirection.ProjectOntoPlane(&OldSphereCenter);
+    SearchDirection.Normalize();
+    Log() << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+    if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {
+    Log() << Verbose(1) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+    if (fabs(RelativeSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {
       // rotated the wrong way!
       eLog() << Verbose(1) << "SearchDirection and RelativeOldSphereCenter are still not orthogonal!" << endl;
 …
     // add third point
     FindThirdPointForTesselation(T.NormalVector, SearchDirection, OldSphereCenter, &Line, ThirdNode, OptCandidates, &ShortestAngle, RADIUS, LC);
+    FindThirdPointForTesselation(T.NormalVector, SearchDirection, T.SphereCenter, CandidateLine, ThirdNode, RADIUS, LC);
   } else {
     Log() << Verbose(1) << "Circumcircle for base line " << Line << " and base triangle " << T << " is too big!" << endl;
+  }
   if (OptCandidates->begin() == OptCandidates->end()) {
+    Log() << Verbose(0) << "Circumcircle for base line " << *CandidateLine.BaseLine << " and base triangle " << T << " is too big!" << endl;
+  }
+  if (CandidateLine.pointlist.empty()) {
     eLog() << Verbose(2) << "Could not find a suitable candidate." << endl;
     return false;
+  }
+  Log() << Verbose(1) << "Third Points are ";
+  for (CandidateList::iterator it = OptCandidates->begin(); it != OptCandidates->end(); ++it) {
+    Log() << Verbose(1) << " " << *(*it)->point << endl;
+  }
+  BoundaryLineSet *BaseRay = &Line;
+  for (CandidateList::iterator it = OptCandidates->begin(); it != OptCandidates->end(); ++it) {
+    Log() << Verbose(1) << " Third point candidate is " << *(*it)->point
+    << " with circumsphere's center at " << (*it)->OptCenter << "." << endl;
+    Log() << Verbose(1) << " Baseline is " << *BaseRay << endl;
+    // check whether all edges of the new triangle still have space for one more triangle (i.e. TriangleCount <2)
+    TesselPoint *PointCandidates[3];
+    PointCandidates[0] = (*it)->point;
+    PointCandidates[1] = BaseRay->endpoints[0]->node;
+    PointCandidates[2] = BaseRay->endpoints[1]->node;
+    int existentTrianglesCount = CheckPresenceOfTriangle(PointCandidates);
+    BTS = NULL;
+    // check for present edges and whether we reach better candidates from them
+    if (HasOtherBaselineBetterCandidate(BaseRay, (*it)->point, ShortestAngle, RADIUS, LC) ) {
+      result = false;
+      break;
+    } else {
+      // If there is no triangle, add it regularly.
+      if (existentTrianglesCount == 0) {
+        AddTesselationPoint((*it)->point, 0);
+        AddTesselationPoint(BaseRay->endpoints[0]->node, 1);
+        AddTesselationPoint(BaseRay->endpoints[1]->node, 2);
+        if (CheckLineCriteriaForDegeneratedTriangle((const BoundaryPointSet ** const )TPS)) {
+          AddTesselationLine(TPS[0], TPS[1], 0);
+          AddTesselationLine(TPS[0], TPS[2], 1);
+          AddTesselationLine(TPS[1], TPS[2], 2);
+          BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+          AddTesselationTriangle();
+          (*it)->OptCenter.Scale(-1.);
+          BTS->GetNormalVector((*it)->OptCenter);
+          (*it)->OptCenter.Scale(-1.);
+          Log() << Verbose(0) << "--> New triangle with " << *BTS << " and normal vector " << BTS->NormalVector
+            << " for this triangle ... " << endl;
+        //Log() << Verbose(1) << "We have "<< TrianglesOnBoundaryCount << " for line " << *BaseRay << "." << endl;
+        } else {
+          eLog() << Verbose(2) << "This triangle consisting of ";
+          Log() << Verbose(0) << *(*it)->point << ", ";
+          Log() << Verbose(0) << *BaseRay->endpoints[0]->node << " and ";
+          Log() << Verbose(0) << *BaseRay->endpoints[1]->node << " ";
+          Log() << Verbose(0) << "exists and is not added, as it does not seem helpful!" << endl;
+          result = false;
+        }
+      } else if ((existentTrianglesCount >= 1) && (existentTrianglesCount <= 3)) { // If there is a planar region within the structure, we need this triangle a second time.
+          AddTesselationPoint((*it)->point, 0);
+          AddTesselationPoint(BaseRay->endpoints[0]->node, 1);
+          AddTesselationPoint(BaseRay->endpoints[1]->node, 2);
+          // We demand that at most one new degenerate line is created and that this line also already exists (which has to be the case due to existentTrianglesCount == 1)
+          // i.e. at least one of the three lines must be present with TriangleCount <= 1
+          if (CheckLineCriteriaForDegeneratedTriangle((const BoundaryPointSet ** const)TPS)) {
+            AddTesselationLine(TPS[0], TPS[1], 0);
+            AddTesselationLine(TPS[0], TPS[2], 1);
+            AddTesselationLine(TPS[1], TPS[2], 2);
+            BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+            AddTesselationTriangle();  // add to global map
+            (*it)->OtherOptCenter.Scale(-1.);
+            BTS->GetNormalVector((*it)->OtherOptCenter);
+            (*it)->OtherOptCenter.Scale(-1.);
+            eLog() << Verbose(2) << "--> WARNING: Special new triangle with " << *BTS << " and normal vector " << BTS->NormalVector << " for this triangle ... " << endl;
+            Log() << Verbose(1) << "We have "<< BaseRay->triangles.size() << " for line " << BaseRay << "." << endl;
+          } else {
+            eLog() << Verbose(2) << "This triangle consisting of " << *(*it)->point << ", " << *BaseRay->endpoints[0]->node << " and " << *BaseRay->endpoints[1]->node << " " << "exists and is not added, as it does not seem helpful!" << endl;
+            result = false;
+          }
+      } else {
+        Log() << Verbose(1) << "This triangle consisting of ";
+        Log() << Verbose(0) << *(*it)->point << ", ";
+        Log() << Verbose(0) << *BaseRay->endpoints[0]->node << " and ";
+        Log() << Verbose(0) << *BaseRay->endpoints[1]->node << " ";
+        Log() << Verbose(0) << "is invalid!" << endl;
+        result = false;
+      }
+    }
+    // set baseline to new ray from ref point (here endpoints[0]->node) to current candidate (here (*it)->point))
+    BaseRay = BLS[0];
+    if ((BTS != NULL) && (BTS->NormalVector.NormSquared() < MYEPSILON)) {
+      eLog() << Verbose(1) << "Triangle " << *BTS << " has zero normal vector!" << endl;
+      exit(255);
+    }
+  }
+  // remove all candidates from the list and then the list itself
+  class CandidateForTesselation *remover = NULL;
+  for (CandidateList::iterator it = OptCandidates->begin(); it != OptCandidates->end(); ++it) {
+    remover = *it;
+    delete(remover);
+  }
+  delete(OptCandidates);
+  Log() << Verbose(0) << "End of FindNextSuitableTriangle\n";
+  Log() << Verbose(0) << "Third Points are: " << endl;
+  for (TesselPointList::iterator it = CandidateLine.pointlist.begin(); it != CandidateLine.pointlist.end(); ++it) {
+    Log() << Verbose(0) << " " << *(*it) << endl;
+  }
+  return true;
+//  BoundaryLineSet *BaseRay = CandidateLine.BaseLine;
+//  for (CandidateList::iterator it = OptCandidates->begin(); it != OptCandidates->end(); ++it) {
+//    Log() << Verbose(0) << "Third point candidate is " << *(*it)->point
+//    << " with circumsphere's center at " << (*it)->OptCenter << "." << endl;
+//    Log() << Verbose(0) << "Baseline is " << *BaseRay << endl;
+//
+//    // check whether all edges of the new triangle still have space for one more triangle (i.e. TriangleCount <2)
+//    TesselPoint *PointCandidates[3];
+//    PointCandidates[0] = (*it)->point;
+//    PointCandidates[1] = BaseRay->endpoints[0]->node;
+//    PointCandidates[2] = BaseRay->endpoints[1]->node;
+//    int existentTrianglesCount = CheckPresenceOfTriangle(PointCandidates);
+//
+//    BTS = NULL;
+//    // check for present edges and whether we reach better candidates from them
+//    //if (HasOtherBaselineBetterCandidate(BaseRay, (*it)->point, ShortestAngle, RADIUS, LC) ) {
+//    if (0) {
+//      result = false;
+//      break;
+//    } else {
+//      // If there is no triangle, add it regularly.
+//      if (existentTrianglesCount == 0) {
+//        AddTesselationPoint((*it)->point, 0);
+//        AddTesselationPoint(BaseRay->endpoints[0]->node, 1);
+//        AddTesselationPoint(BaseRay->endpoints[1]->node, 2);
+//
+//        if (CheckLineCriteriaForDegeneratedTriangle((const BoundaryPointSet ** const )TPS)) {
+//          CandidateLine.point = (*it)->point;
+//          CandidateLine.OptCenter.CopyVector(&((*it)->OptCenter));
+//          CandidateLine.OtherOptCenter.CopyVector(&((*it)->OtherOptCenter));
+//          CandidateLine.ShortestAngle = ShortestAngle;
+//        } else {
+////          eLog() << Verbose(1) << "This triangle consisting of ";
+////          Log() << Verbose(0) << *(*it)->point << ", ";
+////          Log() << Verbose(0) << *BaseRay->endpoints[0]->node << " and ";
+////          Log() << Verbose(0) << *BaseRay->endpoints[1]->node << " ";
+////          Log() << Verbose(0) << "exists and is not added, as it 0x80000000006fc150(does not seem helpful!" << endl;
+//          result = false;
+//        }
+//      } else if ((existentTrianglesCount >= 1) && (existentTrianglesCount <= 3)) { // If there is a planar region within the structure, we need this triangle a second time.
+//          AddTesselationPoint((*it)->point, 0);
+//          AddTesselationPoint(BaseRay->endpoints[0]->node, 1);
+//          AddTesselationPoint(BaseRay->endpoints[1]->node, 2);
+//
+//          // We demand that at most one new degenerate line is created and that this line also already exists (which has to be the case due to existentTrianglesCount == 1)
+//          // i.e. at least one of the three lines must be present with TriangleCount <= 1
+//          if (CheckLineCriteriaForDegeneratedTriangle((const BoundaryPointSet ** const)TPS) || CandidateLine.BaseLine->skipped) {
+//            CandidateLine.point = (*it)->point;
+//            CandidateLine.OptCenter.CopyVector(&(*it)->OptCenter);
+//            CandidateLine.OtherOptCenter.CopyVector(&(*it)->OtherOptCenter);
+//            CandidateLine.ShortestAngle = ShortestAngle+2.*M_PI;
+//
+//          } else {
+////            eLog() << Verbose(1) << "This triangle consisting of " << *(*it)->point << ", " << *BaseRay->endpoints[0]->node << " and " << *BaseRay->endpoints[1]->node << " " << "exists and is not added, as it does not seem helpful!" << endl;
+//            result = false;
+//          }
+//      } else {
+////        Log() << Verbose(1) << "This triangle consisting of ";
+////        Log() << Verbose(0) << *(*it)->point << ", ";
+////        Log() << Verbose(0) << *BaseRay->endpoints[0]->node << " and ";
+////        Log() << Verbose(0) << *BaseRay->endpoints[1]->node << " ";
+////        Log() << Verbose(0) << "is invalid!" << endl;
+//        result = false;
+//      }
+//    }
+//
+//    // set baseline to new ray from ref point (here endpoints[0]->node) to current candidate (here (*it)->point))
+//    BaseRay = BLS[0];
+//    if ((BTS != NULL) && (BTS->NormalVector.NormSquared() < MYEPSILON)) {
+//      eLog() << Verbose(1) << "Triangle " << *BTS << " has zero normal vector!" << endl;
+//      exit(255);
+//    }
+//
+//  }
+//
+//  // remove all candidates from the list and then the list itself
+//  class CandidateForTesselation *remover = NULL;
+//  for (CandidateList::iterator it = OptCandidates->begin(); it != OptCandidates->end(); ++it) {
+//    remover = *it;
+//    delete(remover);
+//  }
+//  delete(OptCandidates);
   return result;
+};
+/** Adds the present line and candidate point from \a &CandidateLine to the Tesselation.
+ * \param CandidateLine triangle to add
+ * \NOTE we need the copy operator here as the original CandidateForTesselation is removed in AddTesselationLine()
+ */
+void Tesselation::AddCandidateTriangle(CandidateForTesselation CandidateLine)
+{
+        Info FunctionInfo(__func__);
+  Vector Center;
+  TesselPoint * const TurningPoint = CandidateLine.BaseLine->endpoints[0]->node;
+  // fill the set of neighbours
+  TesselPointSet SetOfNeighbours;
+  SetOfNeighbours.insert(CandidateLine.BaseLine->endpoints[1]->node);
+  for (TesselPointList::iterator Runner = CandidateLine.pointlist.begin(); Runner != CandidateLine.pointlist.end(); Runner++)
+    SetOfNeighbours.insert(*Runner);
+  TesselPointList *connectedClosestPoints = GetCircleOfSetOfPoints(&SetOfNeighbours, TurningPoint, CandidateLine.BaseLine->endpoints[1]->node->node);
+  // go through all angle-sorted candidates (in degenerate n-nodes case we may have to add multiple triangles)
+  Log() << Verbose(0) << "List of Candidates for Turning Point: " << *TurningPoint << "." << endl;
+  for (TesselPointList::iterator TesselRunner = connectedClosestPoints->begin(); TesselRunner != connectedClosestPoints->end(); ++TesselRunner)
+    Log() << Verbose(0) << **TesselRunner << endl;
+  TesselPointList::iterator Runner = connectedClosestPoints->begin();
+  TesselPointList::iterator Sprinter = Runner;
+  Sprinter++;
+  while(Sprinter != connectedClosestPoints->end()) {
+    // add the points
+    AddTesselationPoint(TurningPoint, 0);
+    AddTesselationPoint((*Runner), 1);
+    AddTesselationPoint((*Sprinter), 2);
+    // add the lines
+    AddTesselationLine(TPS[0], TPS[1], 0);
+    AddTesselationLine(TPS[0], TPS[2], 1);
+    AddTesselationLine(TPS[1], TPS[2], 2);
+    // add the triangles
+    BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
+    AddTesselationTriangle();
+    BTS->GetCenter(&Center);
+    Center.SubtractVector(&CandidateLine.OptCenter);
+    BTS->SphereCenter.CopyVector(&CandidateLine.OptCenter);
+    BTS->GetNormalVector(Center);
+    Log() << Verbose(0) << "--> New triangle with " << *BTS << " and normal vector " << BTS->NormalVector << "." << endl;
+    Runner = Sprinter;
+    Sprinter++;
+    Log() << Verbose(0) << "Current Runner is " << **Runner << "." << endl;
+    if (Sprinter != connectedClosestPoints->end())
+      Log() << Verbose(0) << " There are still more triangles to add." << endl;
+  }
+  delete(connectedClosestPoints);
 };
 …
 class BoundaryPointSet *Tesselation::IsConvexRectangle(class BoundaryLineSet *Base)
+{
+        Info FunctionInfo(__func__);
   class BoundaryPointSet *Spot = NULL;
   class BoundaryLineSet *OtherBase;
 …
   OtherBase = new class BoundaryLineSet(BPS,-1);
   Log() << Verbose(3) << "INFO: Current base line is " << *Base << "." << endl;
   Log() << Verbose(3) << "INFO: Other base line is " << *OtherBase << "." << endl;
+  Log() << Verbose(1) << "INFO: Current base line is " << *Base << "." << endl;
+  Log() << Verbose(1) << "INFO: Other base line is " << *OtherBase << "." << endl;
   // get the closest point on each line to the other line
 …
   delete(ClosestPoint);
   if ((distance[0] * distance[1]) > 0)  { // have same sign?
     Log() << Verbose(3) << "REJECT: Both SKPs have same sign: " << distance[0] << " and " << distance[1]  << ". " << *Base << "' rectangle is concave." << endl;
+    Log() << Verbose(1) << "REJECT: Both SKPs have same sign: " << distance[0] << " and " << distance[1]  << ". " << *Base << "' rectangle is concave." << endl;
     if (distance[0] < distance[1]) {
       Spot = Base->endpoints[0];
 …
     return Spot;
   } else {  // different sign, i.e. we are in between
     Log() << Verbose(3) << "ACCEPT: Rectangle of triangles of base line " << *Base << " is convex." << endl;
+    Log() << Verbose(0) << "ACCEPT: Rectangle of triangles of base line " << *Base << " is convex." << endl;
     return NULL;
+  }
 …
 void Tesselation::PrintAllBoundaryPoints(ofstream *out) const
+{
+        Info FunctionInfo(__func__);
   // print all lines
   Log() << Verbose(1) << "Printing all boundary points for debugging:" << endl;
+  Log() << Verbose(0) << "Printing all boundary points for debugging:" << endl;
   for (PointMap::const_iterator PointRunner = PointsOnBoundary.begin();PointRunner != PointsOnBoundary.end(); PointRunner++)
     Log() << Verbose(2) << *(PointRunner->second) << endl;
+    Log() << Verbose(0) << *(PointRunner->second) << endl;
 };
 void Tesselation::PrintAllBoundaryLines(ofstream *out) const
+{
+        Info FunctionInfo(__func__);
   // print all lines
   Log() << Verbose(1) << "Printing all boundary lines for debugging:" << endl;
+  Log() << Verbose(0) << "Printing all boundary lines for debugging:" << endl;
   for (LineMap::const_iterator LineRunner = LinesOnBoundary.begin(); LineRunner != LinesOnBoundary.end(); LineRunner++)
     Log() << Verbose(2) << *(LineRunner->second) << endl;
+    Log() << Verbose(0) << *(LineRunner->second) << endl;
 };
 void Tesselation::PrintAllBoundaryTriangles(ofstream *out) const
+{
+        Info FunctionInfo(__func__);
   // print all triangles
   Log() << Verbose(1) << "Printing all boundary triangles for debugging:" << endl;
+  Log() << Verbose(0) << "Printing all boundary triangles for debugging:" << endl;
   for (TriangleMap::const_iterator TriangleRunner = TrianglesOnBoundary.begin(); TriangleRunner != TrianglesOnBoundary.end(); TriangleRunner++)
     Log() << Verbose(2) << *(TriangleRunner->second) << endl;
+    Log() << Verbose(0) << *(TriangleRunner->second) << endl;
 };
 …
 double Tesselation::PickFarthestofTwoBaselines(class BoundaryLineSet *Base)
+{
+        Info FunctionInfo(__func__);
   class BoundaryLineSet *OtherBase;
   Vector *ClosestPoint[2];
 …
   OtherBase = new class BoundaryLineSet(BPS,-1);
   Log() << Verbose(3) << "INFO: Current base line is " << *Base << "." << endl;
   Log() << Verbose(3) << "INFO: Other base line is " << *OtherBase << "." << endl;
+  Log() << Verbose(0) << "INFO: Current base line is " << *Base << "." << endl;
+  Log() << Verbose(0) << "INFO: Other base line is " << *OtherBase << "." << endl;
   // get the closest point on each line to the other line
 …
   if (Distance.NormSquared() < MYEPSILON) { // check for intersection
     Log() << Verbose(3) << "REJECT: Both lines have an intersection: Nothing to do." << endl;
+    Log() << Verbose(0) << "REJECT: Both lines have an intersection: Nothing to do." << endl;
     return false;
   } else { // check for sign against BaseLineNormal
 …
+    }
     for (TriangleMap::iterator runner = Base->triangles.begin(); runner != Base->triangles.end(); runner++) {
       Log() << Verbose(4) << "INFO: Adding NormalVector " << runner->second->NormalVector << " of triangle " << *(runner->second) << "." << endl;
+      Log() << Verbose(1) << "INFO: Adding NormalVector " << runner->second->NormalVector << " of triangle " << *(runner->second) << "." << endl;
       BaseLineNormal.AddVector(&(runner->second->NormalVector));
+    }
 …
     if (Distance.ScalarProduct(&BaseLineNormal) > MYEPSILON) { // Distance points outwards, hence OtherBase higher than Base -> flip
       Log() << Verbose(2) << "ACCEPT: Other base line would be higher: Flipping baseline." << endl;
+      Log() << Verbose(0) << "ACCEPT: Other base line would be higher: Flipping baseline." << endl;
       // calculate volume summand as a general tetraeder
       return volume;
     } else {  // Base higher than OtherBase -> do nothing
       Log() << Verbose(2) << "REJECT: Base line is higher: Nothing to do." << endl;
+      Log() << Verbose(0) << "REJECT: Base line is higher: Nothing to do." << endl;
       return 0.;
+    }
 …
 class BoundaryLineSet * Tesselation::FlipBaseline(class BoundaryLineSet *Base)
+{
+        Info FunctionInfo(__func__);
   class BoundaryLineSet *OldLines[4], *NewLine;
   class BoundaryPointSet *OldPoints[2];
 …
   int i,m;
-  Log() << Verbose(1) << "Begin of FlipBaseline" << endl;
   // calculate NormalVector for later use
   BaseLineNormal.Zero();
 …
+  }
   for (TriangleMap::iterator runner = Base->triangles.begin(); runner != Base->triangles.end(); runner++) {
     Log() << Verbose(4) << "INFO: Adding NormalVector " << runner->second->NormalVector << " of triangle " << *(runner->second) << "." << endl;
+    Log() << Verbose(1) << "INFO: Adding NormalVector " << runner->second->NormalVector << " of triangle " << *(runner->second) << "." << endl;
     BaseLineNormal.AddVector(&(runner->second->NormalVector));
+  }
 …
   i=0;
   m=0;
   Log() << Verbose(3) << "The four old lines are: ";
+  Log() << Verbose(0) << "The four old lines are: ";
   for(TriangleMap::iterator runner = Base->triangles.begin(); runner != Base->triangles.end(); runner++)
     for (int j=0;j<3;j++) // all of their endpoints and baselines
 …
+      }
   Log() << Verbose(0) << endl;
   Log() << Verbose(3) << "The two old points are: ";
+  Log() << Verbose(0) << "The two old points are: ";
   for(TriangleMap::iterator runner = Base->triangles.begin(); runner != Base->triangles.end(); runner++)
     for (int j=0;j<3;j++) // all of their endpoints and baselines
 …
   // remove triangles and baseline removes itself
   Log() << Verbose(3) << "INFO: Deleting baseline " << *Base << " from global list." << endl;
+  Log() << Verbose(0) << "INFO: Deleting baseline " << *Base << " from global list." << endl;
   OldBaseLineNr = Base->Nr;
   m=0;
   for(TriangleMap::iterator runner = Base->triangles.begin(); runner != Base->triangles.end(); runner++) {
     Log() << Verbose(3) << "INFO: Deleting triangle " << *(runner->second) << "." << endl;
+    Log() << Verbose(0) << "INFO: Deleting triangle " << *(runner->second) << "." << endl;
     OldTriangleNrs[m++] = runner->second->Nr;
     RemoveTesselationTriangle(runner->second);
 …
   NewLine = new class BoundaryLineSet(BPS, OldBaseLineNr);
   LinesOnBoundary.insert(LinePair(OldBaseLineNr, NewLine)); // no need for check for unique insertion as NewLine is definitely a new one
   Log() << Verbose(3) << "INFO: Created new baseline " << *NewLine << "." << endl;
+  Log() << Verbose(0) << "INFO: Created new baseline " << *NewLine << "." << endl;
   // construct new triangles with flipped baseline
 …
     BTS->GetNormalVector(BaseLineNormal);
     AddTesselationTriangle(OldTriangleNrs[0]);
     Log() << Verbose(3) << "INFO: Created new triangle " << *BTS << "." << endl;
+    Log() << Verbose(0) << "INFO: Created new triangle " << *BTS << "." << endl;
     BLS[0] = (i==2 ? OldLines[3] : OldLines[2]);
 …
     BTS->GetNormalVector(BaseLineNormal);
     AddTesselationTriangle(OldTriangleNrs[1]);
     Log() << Verbose(3) << "INFO: Created new triangle " << *BTS << "." << endl;
+    Log() << Verbose(0) << "INFO: Created new triangle " << *BTS << "." << endl;
   } else {
     Log() << Verbose(1) << "The four old lines do not connect, something's utterly wrong here!" << endl;
+    eLog() << Verbose(0) << "The four old lines do not connect, something's utterly wrong here!" << endl;
     return NULL;
+  }
-  Log() << Verbose(1) << "End of FlipBaseline" << endl;
   return NewLine;
 };
 …
 void Tesselation::FindSecondPointForTesselation(TesselPoint* a, Vector Oben, TesselPoint*& OptCandidate, double Storage[3], double RADIUS, const LinkedCell *LC)
+{
   Log() << Verbose(2) << "Begin of FindSecondPointForTesselation" << endl;
+        Info FunctionInfo(__func__);
   Vector AngleCheck;
   class TesselPoint* Candidate = NULL;
 …
     Nupper[i] = ((N[i]+1) < LC->N[i]) ? N[i]+1 : LC->N[i]-1;
+  }
   Log() << Verbose(3) << "LC Intervals from [" << N[0] << "<->" << LC->N[0] << ", " << N[1] << "<->" << LC->N[1] << ", " << N[2] << "<->" << LC->N[2] << "] :"
+  Log() << Verbose(0) << "LC Intervals from [" << N[0] << "<->" << LC->N[0] << ", " << N[1] << "<->" << LC->N[1] << ", " << N[2] << "<->" << LC->N[2] << "] :"
     << " [" << Nlower[0] << "," << Nupper[0] << "], " << " [" << Nlower[1] << "," << Nupper[1] << "], " << " [" << Nlower[2] << "," << Nupper[2] << "], " << endl;
 …
       for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
         const LinkedNodes *List = LC->GetCurrentCell();
         //Log() << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+        //Log() << Verbose(1) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
         if (List != NULL) {
           for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
 …
                 angle = AngleCheck.Angle(&Oben);
                 if (angle < Storage[0]) {
                   //Log() << Verbose(3) << "Old values of Storage: %lf %lf \n", Storage[0], Storage[1]);
                   Log() << Verbose(3) << "Current candidate is " << *Candidate << ": Is a better candidate with distance " << norm << " and angle " << angle << " to oben " << Oben << ".\n";
+                  //Log() << Verbose(1) << "Old values of Storage: %lf %lf \n", Storage[0], Storage[1]);
+                  Log() << Verbose(1) << "Current candidate is " << *Candidate << ": Is a better candidate with distance " << norm << " and angle " << angle << " to oben " << Oben << ".\n";
                   OptCandidate = Candidate;
                   Storage[0] = angle;
                   //Log() << Verbose(3) << "Changing something in Storage: %lf %lf. \n", Storage[0], Storage[2]);
+                  //Log() << Verbose(1) << "Changing something in Storage: %lf %lf. \n", Storage[0], Storage[2]);
                 } else {
                   //Log() << Verbose(3) << "Current candidate is " << *Candidate << ": Looses with angle " << angle << " to a better candidate " << *OptCandidate << endl;
+                  //Log() << Verbose(1) << "Current candidate is " << *Candidate << ": Looses with angle " << angle << " to a better candidate " << *OptCandidate << endl;
+                }
               } else {
                 //Log() << Verbose(3) << "Current candidate is " << *Candidate << ": Refused due to Radius " << norm << endl;
+                //Log() << Verbose(1) << "Current candidate is " << *Candidate << ": Refused due to Radius " << norm << endl;
+              }
             } else {
               //Log() << Verbose(3) << "Current candidate is " << *Candidate << ": Candidate is equal to first endpoint." << *a << "." << endl;
+              //Log() << Verbose(1) << "Current candidate is " << *Candidate << ": Candidate is equal to first endpoint." << *a << "." << endl;
+            }
+          }
         } else {
           Log() << Verbose(3) << "Linked cell list is empty." << endl;
+          Log() << Verbose(0) << "Linked cell list is empty." << endl;
+        }
+      }
-  Log() << Verbose(2) << "End of FindSecondPointForTesselation" << endl;
 };
 …
  * @param SearchDirection general direction where to search for the next point, relative to center of BaseLine
  * @param OldSphereCenter center of sphere for base triangle, relative to center of BaseLine, giving null angle for the parameter circle
  * @param BaseLine BoundaryLineSet with the current base line
+ * @param CandidateLine CandidateForTesselation with the current base line and list of candidates and ShortestAngle
  * @param ThirdNode third point to avoid in search
- * @param candidates list of equally good candidates to return
- * @param ShortestAngle the current path length on this circle band for the current OptCandidate
  * @param RADIUS radius of sphere
  * @param *LC LinkedCell structure with neighbouring points
  */
+void Tesselation::FindThirdPointForTesselation(Vector &NormalVector, Vector &SearchDirection, Vector &OldSphereCenter, class BoundaryLineSet *BaseLine, const class TesselPoint  * const ThirdNode, CandidateList* &candidates, double *ShortestAngle, const double RADIUS, const LinkedCell *LC) const
+{
+void Tesselation::FindThirdPointForTesselation(Vector &NormalVector, Vector &SearchDirection, Vector &OldSphereCenter, CandidateForTesselation &CandidateLine, const class TesselPoint  * const ThirdNode, const double RADIUS, const LinkedCell *LC) const
+{
+        Info FunctionInfo(__func__);
   Vector CircleCenter;  // center of the circle, i.e. of the band of sphere's centers
   Vector CirclePlaneNormal; // normal vector defining the plane this circle lives in
 …
   Vector NewNormalVector;   // normal vector of the Candidate's triangle
   Vector helper, OptCandidateCenter, OtherOptCandidateCenter;
+  Vector RelativeOldSphereCenter;
+  Vector NewPlaneCenter;
   double CircleRadius; // radius of this circle
   double radius;
+  double otherradius;
   double alpha, Otheralpha; // angles (i.e. parameter for the circle).
   int N[NDIM], Nlower[NDIM], Nupper[NDIM];
   TesselPoint *Candidate = NULL;
+  CandidateForTesselation *optCandidate = NULL;
+  Log() << Verbose(1) << "Begin of FindThirdPointForTesselation" << endl;
+  Log() << Verbose(2) << "INFO: NormalVector of BaseTriangle is " << NormalVector << "." << endl;
+  Log() << Verbose(1) << "INFO: NormalVector of BaseTriangle is " << NormalVector << "." << endl;
   // construct center of circle
   CircleCenter.CopyVector(BaseLine->endpoints[0]->node->node);
   CircleCenter.AddVector(BaseLine->endpoints[1]->node->node);
+  CircleCenter.CopyVector(CandidateLine.BaseLine->endpoints[0]->node->node);
+  CircleCenter.AddVector(CandidateLine.BaseLine->endpoints[1]->node->node);
   CircleCenter.Scale(0.5);
   // construct normal vector of circle
+  CirclePlaneNormal.CopyVector(BaseLine->endpoints[0]->node->node);
+  CirclePlaneNormal.SubtractVector(BaseLine->endpoints[1]->node->node);
+  CirclePlaneNormal.CopyVector(CandidateLine.BaseLine->endpoints[0]->node->node);
+  CirclePlaneNormal.SubtractVector(CandidateLine.BaseLine->endpoints[1]->node->node);
+  RelativeOldSphereCenter.CopyVector(&OldSphereCenter);
+  RelativeOldSphereCenter.SubtractVector(&CircleCenter);
   // calculate squared radius TesselPoint *ThirdNode,f circle
   radius = CirclePlaneNormal.ScalarProduct(&CirclePlaneNormal);
   if (radius/4. < RADIUS*RADIUS) {
     CircleRadius = RADIUS*RADIUS - radius/4.;
+  radius = CirclePlaneNormal.NormSquared()/4.;
+  if (radius < RADIUS*RADIUS) {
+    CircleRadius = RADIUS*RADIUS - radius;
     CirclePlaneNormal.Normalize();
     //Log() << Verbose(2) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+    Log() << Verbose(1) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
     // test whether old center is on the band's plane
     if (fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
       eLog() << Verbose(1) << "Something's very wrong here: OldSphereCenter is not on the band's plane as desired by " << fabs(OldSphereCenter.ScalarProduct(&CirclePlaneNormal)) << "!" << endl;
       OldSphereCenter.ProjectOntoPlane(&CirclePlaneNormal);
+    }
     radius = OldSphereCenter.ScalarProduct(&OldSphereCenter);
+    if (fabs(RelativeOldSphereCenter.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
+      eLog() << Verbose(1) << "Something's very wrong here: RelativeOldSphereCenter is not on the band's plane as desired by " << fabs(RelativeOldSphereCenter.ScalarProduct(&CirclePlaneNormal)) << "!" << endl;
+      RelativeOldSphereCenter.ProjectOntoPlane(&CirclePlaneNormal);
+    }
+    radius = RelativeOldSphereCenter.NormSquared();
     if (fabs(radius - CircleRadius) < HULLEPSILON) {
       //Log() << Verbose(2) << "INFO: OldSphereCenter is at " << OldSphereCenter << "." << endl;
+      Log() << Verbose(1) << "INFO: RelativeOldSphereCenter is at " << RelativeOldSphereCenter << "." << endl;
       // check SearchDirection
       //Log() << Verbose(2) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
       if (fabs(OldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {  // rotated the wrong way!
+      Log() << Verbose(1) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+      if (fabs(RelativeOldSphereCenter.ScalarProduct(&SearchDirection)) > HULLEPSILON) {  // rotated the wrong way!
         eLog() << Verbose(1) << "SearchDirection and RelativeOldSphereCenter are not orthogonal!" << endl;
+      }
 …
         for(int i=0;i<NDIM;i++) // store indices of this cell
         N[i] = LC->n[i];
         //Log() << Verbose(2) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
+        //Log() << Verbose(1) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
       } else {
         eLog() << Verbose(1) << "Vector " << CircleCenter << " is outside of LinkedCell's bounding box." << endl;
 …
+      }
       // then go through the current and all neighbouring cells and check the contained points for possible candidates
       //Log() << Verbose(2) << "LC Intervals:";
+      //Log() << Verbose(1) << "LC Intervals:";
       for (int i=0;i<NDIM;i++) {
         Nlower[i] = ((N[i]-1) >= 0) ? N[i]-1 : 0;
 …
           for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
             const LinkedNodes *List = LC->GetCurrentCell();
             //Log() << Verbose(2) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
+            //Log() << Verbose(1) << "Current cell is " << LC->n[0] << ", " << LC->n[1] << ", " << LC->n[2] << " with No. " << LC->index << "." << endl;
             if (List != NULL) {
               for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
 …
                 // check for three unique points
                 //Log() << Verbose(2) << "INFO: Current Candidate is " << *Candidate << " at " << Candidate->node << "." << endl;
                 if ((Candidate != BaseLine->endpoints[0]->node) && (Candidate != BaseLine->endpoints[1]->node) ){
                   // construct both new centers
                   GetCenterofCircumcircle(&NewSphereCenter, *BaseLine->endpoints[0]->node->node, *BaseLine->endpoints[1]->node->node, *Candidate->node);
                   OtherNewSphereCenter.CopyVector(&NewSphereCenter);
                   if ((NewNormalVector.MakeNormalVector(BaseLine->endpoints[0]->node->node, BaseLine->endpoints[1]->node->node, Candidate->node))
                   && (fabs(NewNormalVector.ScalarProduct(&NewNormalVector)) > HULLEPSILON)
+                Log() << Verbose(2) << "INFO: Current Candidate is " << *Candidate << " for BaseLine " << *CandidateLine.BaseLine << " with OldSphereCenter " << OldSphereCenter << "." << endl;
+                if ((Candidate != CandidateLine.BaseLine->endpoints[0]->node) && (Candidate != CandidateLine.BaseLine->endpoints[1]->node) ){
+                  // find center on the plane
+                  GetCenterofCircumcircle(&NewPlaneCenter, *CandidateLine.BaseLine->endpoints[0]->node->node, *CandidateLine.BaseLine->endpoints[1]->node->node, *Candidate->node);
+                  Log() << Verbose(1) << "INFO: NewPlaneCenter is " << NewPlaneCenter << "." << endl;
+                  if (NewNormalVector.MakeNormalVector(CandidateLine.BaseLine->endpoints[0]->node->node, CandidateLine.BaseLine->endpoints[1]->node->node, Candidate->node)
+                  && (fabs(NewNormalVector.NormSquared()) > HULLEPSILON)
                   ) {
+                    helper.CopyVector(&NewNormalVector);
+                    //Log() << Verbose(2) << "INFO: NewNormalVector is " << NewNormalVector << "." << endl;
+                    radius = BaseLine->endpoints[0]->node->node->DistanceSquared(&NewSphereCenter);
+                    Log() << Verbose(1) << "INFO: NewNormalVector is " << NewNormalVector << "." << endl;
+                    radius = CandidateLine.BaseLine->endpoints[0]->node->node->DistanceSquared(&NewPlaneCenter);
+                    Log() << Verbose(1) << "INFO: CircleCenter is at " << CircleCenter << ", CirclePlaneNormal is " << CirclePlaneNormal << " with circle radius " << sqrt(CircleRadius) << "." << endl;
+                    Log() << Verbose(1) << "INFO: SearchDirection is " << SearchDirection << "." << endl;
+                    Log() << Verbose(1) << "INFO: Radius of CircumCenterCircle is " << radius << "." << endl;
                     if (radius < RADIUS*RADIUS) {
+                      otherradius = CandidateLine.BaseLine->endpoints[1]->node->node->DistanceSquared(&NewPlaneCenter);
+                      if (fabs(radius - otherradius) > HULLEPSILON) {
+                        eLog() << Verbose(1) << "Distance to center of circumcircle is not the same from each corner of the triangle: " << fabs(radius-otherradius) << endl;
+                      }
+                      // construct both new centers
+                      NewSphereCenter.CopyVector(&NewPlaneCenter);
+                      OtherNewSphereCenter.CopyVector(&NewPlaneCenter);
+                      helper.CopyVector(&NewNormalVector);
                       helper.Scale(sqrt(RADIUS*RADIUS - radius));
                       //Log() << Verbose(2) << "INFO: Distance of NewCircleCenter to NewSphereCenter is " << helper.Norm() << " with sphere radius " << RADIUS << "." << endl;
+                      Log() << Verbose(2) << "INFO: Distance of NewPlaneCenter " << NewPlaneCenter << " to either NewSphereCenter is " << helper.Norm() << " of vector " << helper << " with sphere radius " << RADIUS << "." << endl;
                       NewSphereCenter.AddVector(&helper);
+                      NewSphereCenter.SubtractVector(&CircleCenter);
+                      //Log() << Verbose(2) << "INFO: NewSphereCenter is at " << NewSphereCenter << "." << endl;
+                      Log() << Verbose(2) << "INFO: NewSphereCenter is at " << NewSphereCenter << "." << endl;
                       // OtherNewSphereCenter is created by the same vector just in the other direction
                       helper.Scale(-1.);
                       OtherNewSphereCenter.AddVector(&helper);
+                      OtherNewSphereCenter.SubtractVector(&CircleCenter);
+                      //Log() << Verbose(2) << "INFO: OtherNewSphereCenter is at " << OtherNewSphereCenter << "." << endl;
+                      Log() << Verbose(2) << "INFO: OtherNewSphereCenter is at " << OtherNewSphereCenter << "." << endl;
                       alpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, NewSphereCenter, OldSphereCenter, NormalVector, SearchDirection);
                       Otheralpha = GetPathLengthonCircumCircle(CircleCenter, CirclePlaneNormal, CircleRadius, OtherNewSphereCenter, OldSphereCenter, NormalVector, SearchDirection);
                       alpha = min(alpha, Otheralpha);
                       // if there is a better candidate, drop the current list and add the new candidate
                       // otherwise ignore the new candidate and keep the list
+                      if (*ShortestAngle > (alpha - HULLEPSILON)) {
+                        optCandidate = new CandidateForTesselation(Candidate, BaseLine, OptCandidateCenter, OtherOptCandidateCenter);
+                      if (CandidateLine.ShortestAngle > (alpha - HULLEPSILON)) {
                         if (fabs(alpha - Otheralpha) > MYEPSILON) {
                           optCandidate->OptCenter.CopyVector(&NewSphereCenter);
                           optCandidate->OtherOptCenter.CopyVector(&OtherNewSphereCenter);
+                          CandidateLine.OptCenter.CopyVector(&NewSphereCenter);
+                          CandidateLine.OtherOptCenter.CopyVector(&OtherNewSphereCenter);
                         } else {
                           optCandidate->OptCenter.CopyVector(&OtherNewSphereCenter);
                           optCandidate->OtherOptCenter.CopyVector(&NewSphereCenter);
+                          CandidateLine.OptCenter.CopyVector(&OtherNewSphereCenter);
+                          CandidateLine.OtherOptCenter.CopyVector(&NewSphereCenter);
+                        }
                         // if there is an equal candidate, add it to the list without clearing the list
                         if ((*ShortestAngle - HULLEPSILON) < alpha) {
                           candidates->push_back(optCandidate);
                           Log() << Verbose(2) << "ACCEPT: We have found an equally good candidate: " << *(optCandidate->point) << " with "
                             << alpha << " and circumsphere's center at " << optCandidate->OptCenter << "." << endl;
+                        if ((CandidateLine.ShortestAngle - HULLEPSILON) < alpha) {
+                          CandidateLine.pointlist.push_back(Candidate);
+                          Log() << Verbose(0) << "ACCEPT: We have found an equally good candidate: " << *(Candidate) << " with "
+                            << alpha << " and circumsphere's center at " << CandidateLine.OptCenter << "." << endl;
                         } else {
                           // remove all candidates from the list and then the list itself
+                          class CandidateForTesselation *remover = NULL;
+                          for (CandidateList::iterator it = candidates->begin(); it != candidates->end(); ++it) {
+                            remover = *it;
+                            delete(remover);
+                          }
+                          candidates->clear();
+                          candidates->push_back(optCandidate);
+                          Log() << Verbose(2) << "ACCEPT: We have found a better candidate: " << *(optCandidate->point) << " with "
+                            << alpha << " and circumsphere's center at " << optCandidate->OptCenter << "." << endl;
+                          CandidateLine.pointlist.clear();
+                          CandidateLine.pointlist.push_back(Candidate);
+                          Log() << Verbose(0) << "ACCEPT: We have found a better candidate: " << *(Candidate) << " with "
+                            << alpha << " and circumsphere's center at " << CandidateLine.OptCenter << "." << endl;
+                        }
                         *ShortestAngle = alpha;
                         //Log() << Verbose(2) << "INFO: There are " << candidates->size() << " candidates in the list now." << endl;
+                        CandidateLine.ShortestAngle = alpha;
+                        Log() << Verbose(0) << "INFO: There are " << CandidateLine.pointlist.size() << " candidates in the list now." << endl;
                       } else {
                         if ((optCandidate != NULL) && (optCandidate->point != NULL)) {
                           //Log() << Verbose(2) << "REJECT: Old candidate " << *(optCandidate->point) << " with " << *ShortestAngle << " is better than new one " << *Candidate << " with " << alpha << " ." << endl;
+                        if ((Candidate != NULL) && (CandidateLine.pointlist.begin() != CandidateLine.pointlist.end())) {
+                          Log() << Verbose(1) << "REJECT: Old candidate " << *(Candidate) << " with " << CandidateLine.ShortestAngle << " is better than new one " << *Candidate << " with " << alpha << " ." << endl;
                         } else {
                           //Log() << Verbose(2) << "REJECT: Candidate " << *Candidate << " with " << alpha << " was rejected." << endl;
+                          Log() << Verbose(1) << "REJECT: Candidate " << *Candidate << " with " << alpha << " was rejected." << endl;
+                        }
+                      }
                     } else {
                       //Log() << Verbose(2) << "REJECT: NewSphereCenter " << NewSphereCenter << " for " << *Candidate << " is too far away: " << radius << "." << endl;
+                      Log() << Verbose(1) << "REJECT: NewSphereCenter " << NewSphereCenter << " for " << *Candidate << " is too far away: " << radius << "." << endl;
+                    }
                   } else {
                     //Log() << Verbose(2) << "REJECT: Three points from " << *BaseLine << " and Candidate " << *Candidate << " are linear-dependent." << endl;
+                    Log() << Verbose(1) << "REJECT: Three points from " << *CandidateLine.BaseLine << " and Candidate " << *Candidate << " are linear-dependent." << endl;
+                  }
                 } else {
                   if (ThirdNode != NULL) {
                     //Log() << Verbose(2) << "REJECT: Base triangle " << *BaseLine << " and " << *ThirdNode << " contains Candidate " << *Candidate << "." << endl;
+                    Log() << Verbose(1) << "REJECT: Base triangle " << *CandidateLine.BaseLine << " and " << *ThirdNode << " contains Candidate " << *Candidate << "." << endl;
                   } else {
                     //Log() << Verbose(2) << "REJECT: Base triangle " << *BaseLine << " contains Candidate " << *Candidate << "." << endl;
+                    Log() << Verbose(1) << "REJECT: Base triangle " << *CandidateLine.BaseLine << " contains Candidate " << *Candidate << "." << endl;
+                  }
+                }
 …
   } else {
     if (ThirdNode != NULL)
       Log() << Verbose(2) << "Circumcircle for base line " << *BaseLine << " and third node " << *ThirdNode << " is too big!" << endl;
+      Log() << Verbose(1) << "Circumcircle for base line " << *CandidateLine.BaseLine << " and third node " << *ThirdNode << " is too big!" << endl;
     else
+      Log() << Verbose(2) << "Circumcircle for base line " << *BaseLine << " is too big!" << endl;
+  }
+  //Log() << Verbose(2) << "INFO: Sorting candidate list ..." << endl;
+  if (candidates->size() > 1) {
+    candidates->unique();
+    candidates->sort(SortCandidates);
+  }
+  Log() << Verbose(1) << "End of FindThirdPointForTesselation" << endl;
+      Log() << Verbose(1) << "Circumcircle for base line " << *CandidateLine.BaseLine << " is too big!" << endl;
+  }
+  Log() << Verbose(1) << "INFO: Sorting candidate list ..." << endl;
+  if (CandidateLine.pointlist.size() > 1) {
+    CandidateLine.pointlist.unique();
+    CandidateLine.pointlist.sort(); //SortCandidates);
+  }
 };
 …
 class BoundaryPointSet *Tesselation::GetCommonEndpoint(const BoundaryLineSet * line1, const BoundaryLineSet * line2) const
+{
+        Info FunctionInfo(__func__);
   const BoundaryLineSet * lines[2] = { line1, line2 };
   class BoundaryPointSet *node = NULL;
   map<int, class BoundaryPointSet *> OrderMap;
   pair<map<int, class BoundaryPointSet *>::iterator, bool> OrderTest;
+  PointMap OrderMap;
+  PointTestPair OrderTest;
   for (int i = 0; i < 2; i++)
     // for both lines
 …
           { // if insertion fails, we have common endpoint
             node = OrderTest.first->second;
             Log() << Verbose(5) << "Common endpoint of lines " << *line1
+            Log() << Verbose(1) << "Common endpoint of lines " << *line1
                 << " and " << *line2 << " is: " << *node << "." << endl;
             j = 2;
 …
 };
+/** Finds the boundary points that are closest to a given Vector \a *x.
+ * \param *out output stream for debugging
+ * \param *x Vector to look from
+ * \return map of BoundaryPointSet of closest points sorted by squared distance or NULL.
+ */
+DistanceToPointMap * Tesselation::FindClosestBoundaryPointsToVector(const Vector *x, const LinkedCell* LC) const
+{
+  Info FunctionInfo(__func__);
+  PointMap::const_iterator FindPoint;
+  int N[NDIM], Nlower[NDIM], Nupper[NDIM];
+  if (LinesOnBoundary.empty()) {
+    eLog() << Verbose(1) << "There is no tesselation structure to compare the point with, please create one first." << endl;
+    return NULL;
+  }
+  // gather all points close to the desired one
+  LC->SetIndexToVector(x); // ignore status as we calculate bounds below sensibly
+  for(int i=0;i<NDIM;i++) // store indices of this cell
+    N[i] = LC->n[i];
+  Log() << Verbose(1) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
+  DistanceToPointMap * points = new DistanceToPointMap;
+  LC->GetNeighbourBounds(Nlower, Nupper);
+  //Log() << Verbose(1) << endl;
+  for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
+    for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
+      for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
+        const LinkedNodes *List = LC->GetCurrentCell();
+        //Log() << Verbose(1) << "The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << endl;
+        if (List != NULL) {
+          for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
+            FindPoint = PointsOnBoundary.find((*Runner)->nr);
+            if (FindPoint != PointsOnBoundary.end()) {
+              points->insert(DistanceToPointPair (FindPoint->second->node->node->DistanceSquared(x), FindPoint->second) );
+              Log() << Verbose(1) << "INFO: Putting " << *FindPoint->second << " into the list." << endl;
+            }
+          }
+        } else {
+          eLog() << Verbose(1) << "The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << " is invalid!" << endl;
+        }
+      }
+  // check whether we found some points
+  if (points->empty()) {
+    eLog() << Verbose(1) << "There is no nearest point: too far away from the surface." << endl;
+    delete(points);
+    return NULL;
+  }
+  return points;
+};
+/** Finds the boundary line that is closest to a given Vector \a *x.
+ * \param *out output stream for debugging
+ * \param *x Vector to look from
+ * \return closest BoundaryLineSet or NULL in degenerate case.
+ */
+BoundaryLineSet * Tesselation::FindClosestBoundaryLineToVector(const Vector *x, const LinkedCell* LC) const
+{
+  Info FunctionInfo(__func__);
+  // get closest points
+  DistanceToPointMap * points = FindClosestBoundaryPointsToVector(x,LC);
+  if (points == NULL) {
+    eLog() << Verbose(1) << "There is no nearest point: too far away from the surface." << endl;
+    return NULL;
+  }
+  // for each point, check its lines, remember closest
+  Log() << Verbose(1) << "Finding closest BoundaryLine to " << *x << " ... " << endl;
+  BoundaryLineSet *ClosestLine = NULL;
+  double MinDistance = -1.;
+  Vector helper;
+  Vector Center;
+  Vector BaseLine;
+  for (DistanceToPointMap::iterator Runner = points->begin(); Runner != points->end(); Runner++) {
+    for (LineMap::iterator LineRunner = Runner->second->lines.begin(); LineRunner != Runner->second->lines.end(); LineRunner++) {
+      // calculate closest point on line to desired point
+      helper.CopyVector((LineRunner->second)->endpoints[0]->node->node);
+      helper.AddVector((LineRunner->second)->endpoints[1]->node->node);
+      helper.Scale(0.5);
+      Center.CopyVector(x);
+      Center.SubtractVector(&helper);
+      BaseLine.CopyVector((LineRunner->second)->endpoints[0]->node->node);
+      BaseLine.SubtractVector((LineRunner->second)->endpoints[1]->node->node);
+      Center.ProjectOntoPlane(&BaseLine);
+      const double distance = Center.NormSquared();
+      if ((ClosestLine == NULL) || (distance < MinDistance)) {
+        // additionally calculate intersection on line (whether it's on the line section or not)
+        helper.CopyVector(x);
+        helper.SubtractVector((LineRunner->second)->endpoints[0]->node->node);
+        helper.SubtractVector(&Center);
+        const double lengthA = helper.ScalarProduct(&BaseLine);
+        helper.CopyVector(x);
+        helper.SubtractVector((LineRunner->second)->endpoints[1]->node->node);
+        helper.SubtractVector(&Center);
+        const double lengthB = helper.ScalarProduct(&BaseLine);
+        if (lengthB*lengthA < 0) {  // if have different sign
+          ClosestLine = LineRunner->second;
+          MinDistance = distance;
+          Log() << Verbose(1) << "ACCEPT: New closest line is " << *ClosestLine << " with projected distance " << MinDistance << "." << endl;
+        } else {
+          Log() << Verbose(1) << "REJECT: Intersection is outside of the line section: " << lengthA << " and " << lengthB << "." << endl;
+        }
+      } else {
+        Log() << Verbose(1) << "REJECT: Point is too further away than present line: " << distance << " >> " << MinDistance << "." << endl;
+      }
+    }
+  }
+  delete(points);
+  // check whether closest line is "too close" :), then it's inside
+  if (ClosestLine == NULL) {
+    Log() << Verbose(0) << "Is the only point, no one else is closeby." << endl;
+    return NULL;
+  }
+  return ClosestLine;
+};
 /** Finds the triangle that is closest to a given Vector \a *x.
  * \param *out output stream for debugging
  * \param *x Vector to look from
  * \return list of BoundaryTriangleSet of nearest triangles or NULL in degenerate case.
  */
 list<BoundaryTriangleSet*> * Tesselation::FindClosestTrianglesToPoint(const Vector *x, const LinkedCell* LC) const
+{
   TesselPoint *trianglePoints[3];
+  TesselPoint *SecondPoint = NULL;
+  list<BoundaryTriangleSet*> *triangles = NULL;
   if (LinesOnBoundary.empty()) {
     Log() << Verbose(0) << "Error: There is no tesselation structure to compare the point with, please create one first.";
+ * \return BoundaryTriangleSet of nearest triangle or NULL.
+ */
+TriangleList * Tesselation::FindClosestTrianglesToVector(const Vector *x, const LinkedCell* LC) const
+{
+        Info FunctionInfo(__func__);
+        // get closest points
+        DistanceToPointMap * points = FindClosestBoundaryPointsToVector(x,LC);
+  if (points == NULL) {
+    eLog() << Verbose(1) << "There is no nearest point: too far away from the surface." << endl;
     return NULL;
+  }
+  Log() << Verbose(1) << "Finding closest Tesselpoint to " << *x << " ... " << endl;
+  trianglePoints[0] = FindClosestPoint(x, SecondPoint, LC);
+  // check whether closest point is "too close" :), then it's inside
+  if (trianglePoints[0] == NULL) {
+    Log() << Verbose(2) << "Is the only point, no one else is closeby." << endl;
+  // for each point, check its lines, remember closest
+  Log() << Verbose(1) << "Finding closest BoundaryTriangle to " << *x << " ... " << endl;
+  LineSet ClosestLines;
+  double MinDistance = 1e+16;
+  Vector BaseLineIntersection;
+  Vector Center;
+  Vector BaseLine;
+  Vector BaseLineCenter;
+  for (DistanceToPointMap::iterator Runner = points->begin(); Runner != points->end(); Runner++) {
+    for (LineMap::iterator LineRunner = Runner->second->lines.begin(); LineRunner != Runner->second->lines.end(); LineRunner++) {
+      BaseLine.CopyVector((LineRunner->second)->endpoints[0]->node->node);
+      BaseLine.SubtractVector((LineRunner->second)->endpoints[1]->node->node);
+      const double lengthBase = BaseLine.NormSquared();
+      BaseLineIntersection.CopyVector(x);
+      BaseLineIntersection.SubtractVector((LineRunner->second)->endpoints[0]->node->node);
+      const double lengthEndA = BaseLineIntersection.NormSquared();
+      BaseLineIntersection.CopyVector(x);
+      BaseLineIntersection.SubtractVector((LineRunner->second)->endpoints[1]->node->node);
+      const double lengthEndB = BaseLineIntersection.NormSquared();
+      if ((lengthEndA > lengthBase) || (lengthEndB > lengthBase) || ((lengthEndA < MYEPSILON) || (lengthEndB < MYEPSILON))) {  // intersection would be outside, take closer endpoint
+        const double lengthEnd = Min(lengthEndA, lengthEndB);
+        if (lengthEnd - MinDistance < -MYEPSILON) { // new best line
+          ClosestLines.clear();
+          ClosestLines.insert(LineRunner->second);
+          MinDistance = lengthEnd;
+          Log() << Verbose(1) << "ACCEPT: Line " << *LineRunner->second << " to endpoint " << *LineRunner->second->endpoints[0]->node << " is closer with " << lengthEnd << "." << endl;
+        } else if  (fabs(lengthEnd - MinDistance) < MYEPSILON) { // additional best candidate
+          ClosestLines.insert(LineRunner->second);
+          Log() << Verbose(1) << "ACCEPT: Line " << *LineRunner->second << " to endpoint " << *LineRunner->second->endpoints[1]->node << " is equally good with " << lengthEnd << "." << endl;
+        } else { // line is worse
+          Log() << Verbose(1) << "REJECT: Line " << *LineRunner->second << " to either endpoints is further away than present closest line candidate: " << lengthEndA << ", " << lengthEndB << ", and distance is longer than baseline:" << lengthBase << "." << endl;
+        }
+      } else { // intersection is closer, calculate
+        // calculate closest point on line to desired point
+        BaseLineIntersection.CopyVector(x);
+        BaseLineIntersection.SubtractVector((LineRunner->second)->endpoints[1]->node->node);
+        Center.CopyVector(&BaseLineIntersection);
+        Center.ProjectOntoPlane(&BaseLine);
+        BaseLineIntersection.SubtractVector(&Center);
+        const double distance = BaseLineIntersection.NormSquared();
+        if (Center.NormSquared() > BaseLine.NormSquared()) {
+          eLog() << Verbose(0) << "Algorithmic error: In second case we have intersection outside of baseline!" << endl;
+        }
+        if ((ClosestLines.empty()) || (distance < MinDistance)) {
+          ClosestLines.insert(LineRunner->second);
+          MinDistance = distance;
+          Log() << Verbose(1) << "ACCEPT: Intersection in between endpoints, new closest line " << *LineRunner->second << " is " << *ClosestLines.begin() << " with projected distance " << MinDistance << "." << endl;
+        } else {
+          Log() << Verbose(2) << "REJECT: Point is further away from line " << *LineRunner->second << " than present closest line: " << distance << " >> " << MinDistance << "." << endl;
+        }
+      }
+    }
+  }
+  delete(points);
+  // check whether closest line is "too close" :), then it's inside
+  if (ClosestLines.empty()) {
+    Log() << Verbose(0) << "Is the only point, no one else is closeby." << endl;
     return NULL;
+  }
+  if (trianglePoints[0]->node->DistanceSquared(x) < MYEPSILON) {
+    Log() << Verbose(3) << "Point is right on a tesselation point, no nearest triangle." << endl;
+    PointMap::const_iterator PointRunner = PointsOnBoundary.find(trianglePoints[0]->nr);
+    triangles = new list<BoundaryTriangleSet*>;
+    if (PointRunner != PointsOnBoundary.end()) {
+      for(LineMap::iterator LineRunner = PointRunner->second->lines.begin(); LineRunner != PointRunner->second->lines.end(); LineRunner++)
+        for(TriangleMap::iterator TriangleRunner = LineRunner->second->triangles.begin(); TriangleRunner != LineRunner->second->triangles.end(); TriangleRunner++)
+          triangles->push_back(TriangleRunner->second);
+      triangles->sort();
+      triangles->unique();
+    } else {
+      PointRunner = PointsOnBoundary.find(SecondPoint->nr);
+      trianglePoints[0] = SecondPoint;
+      if (PointRunner != PointsOnBoundary.end()) {
+        for(LineMap::iterator LineRunner = PointRunner->second->lines.begin(); LineRunner != PointRunner->second->lines.end(); LineRunner++)
+          for(TriangleMap::iterator TriangleRunner = LineRunner->second->triangles.begin(); TriangleRunner != LineRunner->second->triangles.end(); TriangleRunner++)
+            triangles->push_back(TriangleRunner->second);
+        triangles->sort();
+        triangles->unique();
+      } else {
+        eLog() << Verbose(1) << "I cannot find a boundary point to the tessel point " << *trianglePoints[0] << "." << endl;
+        return NULL;
+      }
+    }
+  } else {
+    list<TesselPoint*> *connectedClosestPoints = GetCircleOfConnectedPoints(trianglePoints[0], x);
+    if (connectedClosestPoints != NULL) {
+      trianglePoints[1] = connectedClosestPoints->front();
+      trianglePoints[2] = connectedClosestPoints->back();
+      for (int i=0;i<3;i++) {
+        if (trianglePoints[i] == NULL) {
+          eLog() << Verbose(1) << "IsInnerPoint encounters serious error, point " << i << " not found." << endl;
+        }
+        //Log() << Verbose(2) << "List of triangle points:" << endl;
+        //Log() << Verbose(3) << *trianglePoints[i] << endl;
+      }
+      triangles = FindTriangles(trianglePoints);
+      Log() << Verbose(2) << "List of possible triangles:" << endl;
+      for(list<BoundaryTriangleSet*>::iterator Runner = triangles->begin(); Runner != triangles->end(); Runner++)
+        Log() << Verbose(3) << **Runner << endl;
+      delete(connectedClosestPoints);
+    } else {
+      triangles = NULL;
+      Log() << Verbose(1) << "There is no circle of connected points!" << endl;
+    }
+  }
+  if ((triangles == NULL) || (triangles->empty())) {
+    eLog() << Verbose(1) << "There is no nearest triangle. Please check the tesselation structure.";
+    delete(triangles);
+    return NULL;
+  } else
+    return triangles;
+  TriangleList * candidates = new TriangleList;
+  for (LineSet::iterator LineRunner = ClosestLines.begin(); LineRunner != ClosestLines.end(); LineRunner++)
+    for (TriangleMap::iterator Runner = (*LineRunner)->triangles.begin(); Runner != (*LineRunner)->triangles.end(); Runner++) {
+    candidates->push_back(Runner->second);
+  }
+  return candidates;
 };
 …
  * \return list of BoundaryTriangleSet of nearest triangles or NULL.
  */
+class BoundaryTriangleSet * Tesselation::FindClosestTriangleToPoint(const Vector *x, const LinkedCell* LC) const
+{
+class BoundaryTriangleSet * Tesselation::FindClosestTriangleToVector(const Vector *x, const LinkedCell* LC) const
+{
+        Info FunctionInfo(__func__);
   class BoundaryTriangleSet *result = NULL;
+  list<BoundaryTriangleSet*> *triangles = FindClosestTrianglesToPoint(x, LC);
+  TriangleList *triangles = FindClosestTrianglesToVector(x, LC);
+  TriangleList candidates;
   Vector Center;
+  if (triangles == NULL)
+  Vector helper;
+  if ((triangles == NULL) || (triangles->empty()))
     return NULL;
+  if (triangles->size() == 1) { // there is no degenerate case
+    result = triangles->front();
+    Log() << Verbose(2) << "Normal Vector of this triangle is " << result->NormalVector << "." << endl;
+  } else {
+    result = triangles->front();
+    result->GetCenter(&Center);
+    Center.SubtractVector(x);
+    Log() << Verbose(2) << "Normal Vector of this front side is " << result->NormalVector << "." << endl;
+    if (Center.ScalarProduct(&result->NormalVector) < 0) {
+      result = triangles->back();
+      Log() << Verbose(2) << "Normal Vector of this back side is " << result->NormalVector << "." << endl;
+      if (Center.ScalarProduct(&result->NormalVector) < 0) {
+        eLog() << Verbose(1) << "Front and back side yield NormalVector in wrong direction!" << endl;
+      }
+  // go through all and pick the one with the best alignment to x
+  double MinAlignment = 2.*M_PI;
+  for (TriangleList::iterator Runner = triangles->begin(); Runner != triangles->end(); Runner++) {
+    (*Runner)->GetCenter(&Center);
+    helper.CopyVector(x);
+    helper.SubtractVector(&Center);
+    const double Alignment = helper.Angle(&(*Runner)->NormalVector);
+    if (Alignment < MinAlignment) {
+      result = *Runner;
+      MinAlignment = Alignment;
+      Log() << Verbose(1) << "ACCEPT: Triangle " << *result << " is better aligned with " << MinAlignment << "." << endl;
+    } else {
+      Log() << Verbose(1) << "REJECT: Triangle " << *result << " is worse aligned with " << MinAlignment << "." << endl;
+    }
+  }
   delete(triangles);
   return result;
 };
+/** Checks whether the provided Vector is within the tesselation structure.
+/** Checks whether the provided Vector is within the Tesselation structure.
+ * Basically calls Tesselation::GetDistanceToSurface() and checks the sign of the return value.
+ * @param point of which to check the position
+ * @param *LC LinkedCell structure
+ *
+ * @return true if the point is inside the Tesselation structure, false otherwise
+ */
+bool Tesselation::IsInnerPoint(const Vector &Point, const LinkedCell* const LC) const
+{
+  return (GetDistanceSquaredToSurface(Point, LC) < MYEPSILON);
+}
+/** Returns the distance to the surface given by the tesselation.
+ * Calls FindClosestTriangleToVector() and checks whether the resulting triangle's BoundaryTriangleSet#NormalVector points
+ * towards or away from the given \a &Point. Additionally, we check whether it's normal to the normal vector, i.e. on the
+ * closest triangle's plane. Then, we have to check whether \a Point is inside the triangle or not to determine whether it's
+ * an inside or outside point. This is done by calling BoundaryTriangleSet::GetIntersectionInsideTriangle().
+ * In the end we additionally find the point on the triangle who was smallest distance to \a Point:
+ *  -# Separate distance from point to center in vector in NormalDirection and on the triangle plane.
+ *  -# Check whether vector on triangle plane points inside the triangle or crosses triangle bounds.
+ *  -# If inside, take it to calculate closest distance
+ *  -# If not, take intersection with BoundaryLine as distance
+ *
+ * @note distance is squared despite it still contains a sign to determine in-/outside!
+ *
  * @param point of which to check the position
  * @param *LC LinkedCell structure
+ *
  * @return true if the point is inside the tesselation structure, false otherwise
  */
 bool Tesselation::IsInnerPoint(const Vector &Point, const LinkedCell* const LC) const
+{
   class BoundaryTriangleSet *result = FindClosestTriangleToPoint(&Point, LC);
+ * @return >0 if outside, ==0 if on surface, <0 if inside
+ */
+double Tesselation::GetDistanceSquaredToTriangle(const Vector &Point, const BoundaryTriangleSet* const triangle) const
+{
+  Info FunctionInfo(__func__);
   Vector Center;
+  if (result == NULL) {// is boundary point or only point in point cloud?
+    Log() << Verbose(1) << Point << " is the only point in vicinity." << endl;
+    return false;
+  }
+  result->GetCenter(&Center);
+  Log() << Verbose(3) << "INFO: Central point of the triangle is " << Center << "." << endl;
+  Center.SubtractVector(&Point);
+  Log() << Verbose(3) << "INFO: Vector from center to point to test is " << Center << "." << endl;
+  if (Center.ScalarProduct(&result->NormalVector) > -MYEPSILON) {
+    Log() << Verbose(1) << Point << " is an inner point." << endl;
+    return true;
+  Vector helper;
+  Vector DistanceToCenter;
+  Vector Intersection;
+  double distance = 0.;
+  if (triangle == NULL) {// is boundary point or only point in point cloud?
+    Log() << Verbose(1) << "No triangle given!" << endl;
+    return -1.;
   } else {
+    Log() << Verbose(1) << Point << " is NOT an inner point." << endl;
+    return false;
+  }
+}
+/** Checks whether the provided TesselPoint is within the tesselation structure.
+ *
+ * @param *Point of which to check the position
+ * @param *LC Linked Cell structure
+ *
+ * @return true if the point is inside the tesselation structure, false otherwise
+ */
+bool Tesselation::IsInnerPoint(const TesselPoint * const Point, const LinkedCell* const LC) const
+{
+  return IsInnerPoint(*(Point->node), LC);
+}
+    Log() << Verbose(1) << "INFO: Closest triangle found is " << *triangle << " with normal vector " << triangle->NormalVector << "." << endl;
+  }
+  triangle->GetCenter(&Center);
+  Log() << Verbose(2) << "INFO: Central point of the triangle is " << Center << "." << endl;
+  DistanceToCenter.CopyVector(&Center);
+  DistanceToCenter.SubtractVector(&Point);
+  Log() << Verbose(2) << "INFO: Vector from point to test to center is " << DistanceToCenter << "." << endl;
+  // check whether we are on boundary
+  if (fabs(DistanceToCenter.ScalarProduct(&triangle->NormalVector)) < MYEPSILON) {
+    // calculate whether inside of triangle
+    DistanceToCenter.CopyVector(&Point);
+    Center.CopyVector(&Point);
+    Center.SubtractVector(&triangle->NormalVector); // points towards MolCenter
+    DistanceToCenter.AddVector(&triangle->NormalVector); // points outside
+    Log() << Verbose(1) << "INFO: Calling Intersection with " << Center << " and " << DistanceToCenter << "." << endl;
+    if (triangle->GetIntersectionInsideTriangle(&Center, &DistanceToCenter, &Intersection)) {
+      Log() << Verbose(1) << Point << " is inner point: sufficiently close to boundary, " << Intersection << "." << endl;
+      return 0.;
+    } else {
+      Log() << Verbose(1) << Point << " is NOT an inner point: on triangle plane but outside of triangle bounds." << endl;
+      return false;
+    }
+  } else {
+    // calculate smallest distance
+    distance = triangle->GetClosestPointInsideTriangle(&Point, &Intersection);
+    Log() << Verbose(1) << "Closest point on triangle is " << Intersection << "." << endl;
+    // then check direction to boundary
+    if (DistanceToCenter.ScalarProduct(&triangle->NormalVector) > MYEPSILON) {
+      Log() << Verbose(1) << Point << " is an inner point, " << distance << " below surface." << endl;
+      return -distance;
+    } else {
+      Log() << Verbose(1) << Point << " is NOT an inner point, " << distance << " above surface." << endl;
+      return +distance;
+    }
+  }
+};
+/** Calculates distance to a tesselated surface.
+ * Combines \sa FindClosestTrianglesToVector() and \sa GetDistanceSquaredToTriangle().
+ * \param &Point point to calculate distance from
+ * \param *LC needed for finding closest points fast
+ * \return distance squared to closest point on surface
+ */
+double Tesselation::GetDistanceSquaredToSurface(const Vector &Point, const LinkedCell* const LC) const
+{
+  BoundaryTriangleSet *triangle = FindClosestTriangleToVector(&Point, LC);
+  const double distance = GetDistanceSquaredToTriangle(Point, triangle);
+  return Min(distance, LC->RADIUS);
+};
 /** Gets all points connected to the provided point by triangulation lines.
 …
  * @return set of the all points linked to the provided one
  */
+set<TesselPoint*> * Tesselation::GetAllConnectedPoints(const TesselPoint* const Point) const
+{
+  set<TesselPoint*> *connectedPoints = new set<TesselPoint*>;
+TesselPointSet * Tesselation::GetAllConnectedPoints(const TesselPoint* const Point) const
+{
+        Info FunctionInfo(__func__);
+        TesselPointSet *connectedPoints = new TesselPointSet;
   class BoundaryPointSet *ReferencePoint = NULL;
   TesselPoint* current;
   bool takePoint = false;
-  Log() << Verbose(3) << "Begin of GetAllConnectedPoints" << endl;
   // find the respective boundary point
 …
     ReferencePoint = PointRunner->second;
   } else {
     Log() << Verbose(2) << "GetAllConnectedPoints() could not find the BoundaryPoint belonging to " << *Point << "." << endl;
+    eLog() << Verbose(2) << "GetAllConnectedPoints() could not find the BoundaryPoint belonging to " << *Point << "." << endl;
     ReferencePoint = NULL;
+  }
 …
    if (takePoint) {
      Log() << Verbose(5) << "INFO: Endpoint " << *current << " of line " << *(findLines->second) << " is enlisted." << endl;
+     Log() << Verbose(1) << "INFO: Endpoint " << *current << " of line " << *(findLines->second) << " is enlisted." << endl;
      connectedPoints->insert(current);
+   }
 …
+  }
   if (connectedPoints->size() == 0) { // if have not found any points
+  if (connectedPoints->empty()) { // if have not found any points
     eLog() << Verbose(1) << "We have not found any connected points to " << *Point<< "." << endl;
     return NULL;
+  }
-  Log() << Verbose(3) << "End of GetAllConnectedPoints" << endl;
   return connectedPoints;
 };
 …
+ *
  * @param *out output stream for debugging
+ * @param *SetOfNeighbours all points for which the angle should be calculated
  * @param *Point of which get all connected points
  * @param *Reference Reference vector for zero angle or NULL for no preference
  * @return list of the all points linked to the provided one
  */
+list<TesselPoint*> * Tesselation::GetCircleOfConnectedPoints(const TesselPoint* const Point, const Vector * const Reference) const
+{
+TesselPointList * Tesselation::GetCircleOfConnectedTriangles(TesselPointSet *SetOfNeighbours, const TesselPoint* const Point, const Vector * const Reference) const
+{
+        Info FunctionInfo(__func__);
   map<double, TesselPoint*> anglesOfPoints;
+  set<TesselPoint*> *connectedPoints = GetAllConnectedPoints(Point);
+  list<TesselPoint*> *connectedCircle = new list<TesselPoint*>;
+  TesselPointList *connectedCircle = new TesselPointList;
+  Vector PlaneNormal;
+  Vector AngleZero;
+  Vector OrthogonalVector;
+  Vector helper;
+  const TesselPoint * const TrianglePoints[3] = {Point, NULL, NULL};
+  TriangleList *triangles = NULL;
+  if (SetOfNeighbours == NULL) {
+    eLog() << Verbose(2) << "Could not find any connected points!" << endl;
+    delete(connectedCircle);
+    return NULL;
+  }
+  // calculate central point
+  triangles = FindTriangles(TrianglePoints);
+  if ((triangles != NULL) && (!triangles->empty())) {
+    for (TriangleList::iterator Runner = triangles->begin(); Runner != triangles->end(); Runner++)
+      PlaneNormal.AddVector(&(*Runner)->NormalVector);
+  } else {
+    eLog() << Verbose(0) << "Could not find any triangles for point " << *Point << "." << endl;
+    performCriticalExit();
+  }
+  PlaneNormal.Scale(1.0/triangles->size());
+  Log() << Verbose(1) << "INFO: Calculated PlaneNormal of all circle points is " << PlaneNormal << "." << endl;
+  PlaneNormal.Normalize();
+  // construct one orthogonal vector
+  if (Reference != NULL) {
+    AngleZero.CopyVector(Reference);
+    AngleZero.SubtractVector(Point->node);
+    AngleZero.ProjectOntoPlane(&PlaneNormal);
+  }
+  if ((Reference == NULL) || (AngleZero.NormSquared() < MYEPSILON )) {
+    Log() << Verbose(1) << "Using alternatively " << *(*SetOfNeighbours->begin())->node << " as angle 0 referencer." << endl;
+    AngleZero.CopyVector((*SetOfNeighbours->begin())->node);
+    AngleZero.SubtractVector(Point->node);
+    AngleZero.ProjectOntoPlane(&PlaneNormal);
+    if (AngleZero.NormSquared() < MYEPSILON) {
+      eLog() << Verbose(0) << "CRITIAL: AngleZero is 0 even with alternative reference. The algorithm has to be changed here!" << endl;
+      performCriticalExit();
+    }
+  }
+  Log() << Verbose(1) << "INFO: Reference vector on this plane representing angle 0 is " << AngleZero << "." << endl;
+  if (AngleZero.NormSquared() > MYEPSILON)
+    OrthogonalVector.MakeNormalVector(&PlaneNormal, &AngleZero);
+  else
+    OrthogonalVector.MakeNormalVector(&PlaneNormal);
+  Log() << Verbose(1) << "INFO: OrthogonalVector on plane is " << OrthogonalVector << "." << endl;
+  // go through all connected points and calculate angle
+  for (TesselPointSet::iterator listRunner = SetOfNeighbours->begin(); listRunner != SetOfNeighbours->end(); listRunner++) {
+    helper.CopyVector((*listRunner)->node);
+    helper.SubtractVector(Point->node);
+    helper.ProjectOntoPlane(&PlaneNormal);
+    double angle = GetAngle(helper, AngleZero, OrthogonalVector);
+    Log() << Verbose(0) << "INFO: Calculated angle is " << angle << " for point " << **listRunner << "." << endl;
+    anglesOfPoints.insert(pair<double, TesselPoint*>(angle, (*listRunner)));
+  }
+  for(map<double, TesselPoint*>::iterator AngleRunner = anglesOfPoints.begin(); AngleRunner != anglesOfPoints.end(); AngleRunner++) {
+    connectedCircle->push_back(AngleRunner->second);
+  }
+  return connectedCircle;
+}
+/** Gets all points connected to the provided point by triangulation lines, ordered such that we have the circle round the point.
+ * Maps them down onto the plane designated by the axis \a *Point and \a *Reference. The center of all points
+ * connected in the tesselation to \a *Point is mapped to spherical coordinates with the zero angle being given
+ * by the mapped down \a *Reference. Hence, the biggest and the smallest angles are those of the two shanks of the
+ * triangle we are looking for.
+ *
+ * @param *SetOfNeighbours all points for which the angle should be calculated
+ * @param *Point of which get all connected points
+ * @param *Reference Reference vector for zero angle or NULL for no preference
+ * @return list of the all points linked to the provided one
+ */
+TesselPointList * Tesselation::GetCircleOfSetOfPoints(TesselPointSet *SetOfNeighbours, const TesselPoint* const Point, const Vector * const Reference) const
+{
+  Info FunctionInfo(__func__);
+  map<double, TesselPoint*> anglesOfPoints;
+  TesselPointList *connectedCircle = new TesselPointList;
   Vector center;
   Vector PlaneNormal;
 …
   Vector helper;
   if (connectedPoints == NULL) {
     Log() << Verbose(2) << "Could not find any connected points!" << endl;
+  if (SetOfNeighbours == NULL) {
+    eLog() << Verbose(2) << "Could not find any connected points!" << endl;
     delete(connectedCircle);
     return NULL;
+  }
+  Log() << Verbose(2) << "Begin of GetCircleOfConnectedPoints" << endl;
+  // check whether there's something to do
+  if (SetOfNeighbours->size() < 3) {
+    for (TesselPointSet::iterator TesselRunner = SetOfNeighbours->begin(); TesselRunner != SetOfNeighbours->end(); TesselRunner++)
+      connectedCircle->push_back(*TesselRunner);
+    return connectedCircle;
+  }
+  Log() << Verbose(1) << "INFO: Point is " << *Point << " and Reference is " << *Reference << "." << endl;
   // calculate central point
+  for (set<TesselPoint*>::const_iterator TesselRunner = connectedPoints->begin(); TesselRunner != connectedPoints->end(); TesselRunner++)
+    center.AddVector((*TesselRunner)->node);
+  TesselPointSet::const_iterator TesselA = SetOfNeighbours->begin();
+  TesselPointSet::const_iterator TesselB = SetOfNeighbours->begin();
+  TesselPointSet::const_iterator TesselC = SetOfNeighbours->begin();
+  TesselB++;
+  TesselC++;
+  TesselC++;
+  int counter = 0;
+  while (TesselC != SetOfNeighbours->end()) {
+    helper.MakeNormalVector((*TesselA)->node, (*TesselB)->node, (*TesselC)->node);
+    Log() << Verbose(0) << "Making normal vector out of " << *(*TesselA) << ", " << *(*TesselB) << " and " << *(*TesselC) << ":" << helper << endl;
+    counter++;
+    TesselA++;
+    TesselB++;
+    TesselC++;
+    PlaneNormal.AddVector(&helper);
+  }
   //Log() << Verbose(0) << "Summed vectors " << center << "; number of points " << connectedPoints.size()
   //  << "; scale factor " << 1.0/connectedPoints.size();
   center.Scale(1.0/connectedPoints->size());
   Log() << Verbose(4) << "INFO: Calculated center of all circle points is " << center << "." << endl;
   // projection plane of the circle is at the closes Point and normal is pointing away from center of all circle points
   PlaneNormal.CopyVector(Point->node);
   PlaneNormal.SubtractVector(&center);
   PlaneNormal.Normalize();
   Log() << Verbose(4) << "INFO: Calculated plane normal of circle is " << PlaneNormal << "." << endl;
+  //  << "; scale factor " << counter;
+  PlaneNormal.Scale(1.0/(double)counter);
+//  Log() << Verbose(1) << "INFO: Calculated center of all circle points is " << center << "." << endl;
+//
+//  // projection plane of the circle is at the closes Point and normal is pointing away from center of all circle points
+//  PlaneNormal.CopyVector(Point->node);
+//  PlaneNormal.SubtractVector(&center);
+//  PlaneNormal.Normalize();
+  Log() << Verbose(1) << "INFO: Calculated plane normal of circle is " << PlaneNormal << "." << endl;
   // construct one orthogonal vector
 …
+  }
   if ((Reference == NULL) || (AngleZero.NormSquared() < MYEPSILON )) {
     Log() << Verbose(4) << "Using alternatively " << *(*connectedPoints->begin())->node << " as angle 0 referencer." << endl;
     AngleZero.CopyVector((*connectedPoints->begin())->node);
+    Log() << Verbose(1) << "Using alternatively " << *(*SetOfNeighbours->begin())->node << " as angle 0 referencer." << endl;
+    AngleZero.CopyVector((*SetOfNeighbours->begin())->node);
     AngleZero.SubtractVector(Point->node);
     AngleZero.ProjectOntoPlane(&PlaneNormal);
 …
+    }
+  }
   Log() << Verbose(4) << "INFO: Reference vector on this plane representing angle 0 is " << AngleZero << "." << endl;
+  Log() << Verbose(1) << "INFO: Reference vector on this plane representing angle 0 is " << AngleZero << "." << endl;
   if (AngleZero.NormSquared() > MYEPSILON)
     OrthogonalVector.MakeNormalVector(&PlaneNormal, &AngleZero);
   else
     OrthogonalVector.MakeNormalVector(&PlaneNormal);
   Log() << Verbose(4) << "INFO: OrthogonalVector on plane is " << OrthogonalVector << "." << endl;
+  Log() << Verbose(1) << "INFO: OrthogonalVector on plane is " << OrthogonalVector << "." << endl;
   // go through all connected points and calculate angle
+  for (set<TesselPoint*>::iterator listRunner = connectedPoints->begin(); listRunner != connectedPoints->end(); listRunner++) {
+  pair <map<double, TesselPoint*>::iterator, bool > InserterTest;
+  for (TesselPointSet::iterator listRunner = SetOfNeighbours->begin(); listRunner != SetOfNeighbours->end(); listRunner++) {
     helper.CopyVector((*listRunner)->node);
     helper.SubtractVector(Point->node);
     helper.ProjectOntoPlane(&PlaneNormal);
     double angle = GetAngle(helper, AngleZero, OrthogonalVector);
+    Log() << Verbose(3) << "INFO: Calculated angle is " << angle << " for point " << **listRunner << "." << endl;
+    anglesOfPoints.insert(pair<double, TesselPoint*>(angle, (*listRunner)));
+    if (angle > M_PI) // the correction is of no use here (and not desired)
+      angle = 2.*M_PI - angle;
+    Log() << Verbose(0) << "INFO: Calculated angle between " << helper << " and " << AngleZero << " is " << angle << " for point " << **listRunner << "." << endl;
+    InserterTest = anglesOfPoints.insert(pair<double, TesselPoint*>(angle, (*listRunner)));
+    if (!InserterTest.second) {
+      eLog() << Verbose(0) << "GetCircleOfSetOfPoints() got two atoms with same angle: " << *((InserterTest.first)->second) << " and " << (*listRunner) << endl;
+      performCriticalExit();
+    }
+  }
 …
     connectedCircle->push_back(AngleRunner->second);
+  }
-  delete(connectedPoints);
-  Log() << Verbose(2) << "End of GetCircleOfConnectedPoints" << endl;
   return connectedCircle;
 …
  * @return list of the all points linked to the provided one
  */
+list<list<TesselPoint*> *> * Tesselation::GetPathsOfConnectedPoints(const TesselPoint* const Point) const
+{
+ListOfTesselPointList * Tesselation::GetPathsOfConnectedPoints(const TesselPoint* const Point) const
+{
+        Info FunctionInfo(__func__);
   map<double, TesselPoint*> anglesOfPoints;
   list<list<TesselPoint*> *> *ListOfPaths = new list<list<TesselPoint*> *>;
   list<TesselPoint*> *connectedPath = NULL;
+  list< TesselPointList *> *ListOfPaths = new list< TesselPointList *>;
+  TesselPointList *connectedPath = NULL;
   Vector center;
   Vector PlaneNormal;
 …
       } else if (!LineRunner->second) {
         LineRunner->second = true;
         connectedPath = new list<TesselPoint*>;
+        connectedPath = new TesselPointList;
         triangle = NULL;
         CurrentLine = runner->second;
         StartLine = CurrentLine;
         CurrentPoint = CurrentLine->GetOtherEndpoint(ReferencePoint);
         Log() << Verbose(3)<< "INFO: Beginning path retrieval at " << *CurrentPoint << " of line " << *CurrentLine << "." << endl;
+        Log() << Verbose(1)<< "INFO: Beginning path retrieval at " << *CurrentPoint << " of line " << *CurrentLine << "." << endl;
         do {
           // push current one
           Log() << Verbose(3) << "INFO: Putting " << *CurrentPoint << " at end of path." << endl;
+          Log() << Verbose(1) << "INFO: Putting " << *CurrentPoint << " at end of path." << endl;
           connectedPath->push_back(CurrentPoint->node);
           // find next triangle
           for (TriangleMap::iterator Runner = CurrentLine->triangles.begin(); Runner != CurrentLine->triangles.end(); Runner++) {
             Log() << Verbose(3) << "INFO: Inspecting triangle " << *Runner->second << "." << endl;
+            Log() << Verbose(1) << "INFO: Inspecting triangle " << *Runner->second << "." << endl;
             if ((Runner->second != triangle)) { // look for first triangle not equal to old one
               triangle = Runner->second;
 …
                 if (!TriangleRunner->second) {
                   TriangleRunner->second = true;
                   Log() << Verbose(3) << "INFO: Connecting triangle is " << *triangle << "." << endl;
+                  Log() << Verbose(1) << "INFO: Connecting triangle is " << *triangle << "." << endl;
                   break;
                 } else {
                   Log() << Verbose(3) << "INFO: Skipping " << *triangle << ", as we have already visited it." << endl;
+                  Log() << Verbose(1) << "INFO: Skipping " << *triangle << ", as we have already visited it." << endl;
                   triangle = NULL;
+                }
 …
             if ((triangle->lines[i] != CurrentLine) && (triangle->lines[i]->ContainsBoundaryPoint(ReferencePoint))) { // not the current line and still containing Point
               CurrentLine = triangle->lines[i];
               Log() << Verbose(3) << "INFO: Connecting line is " << *CurrentLine << "." << endl;
+              Log() << Verbose(1) << "INFO: Connecting line is " << *CurrentLine << "." << endl;
               break;
+            }
 …
         } while (CurrentLine != StartLine);
         // last point is missing, as it's on start line
         Log() << Verbose(3) << "INFO: Putting " << *CurrentPoint << " at end of path." << endl;
+        Log() << Verbose(1) << "INFO: Putting " << *CurrentPoint << " at end of path." << endl;
         if (StartLine->GetOtherEndpoint(ReferencePoint)->node != connectedPath->back())
           connectedPath->push_back(StartLine->GetOtherEndpoint(ReferencePoint)->node);
 …
         ListOfPaths->push_back(connectedPath);
       } else {
         Log() << Verbose(3) << "INFO: Skipping " << *runner->second << ", as we have already visited it." << endl;
+        Log() << Verbose(1) << "INFO: Skipping " << *runner->second << ", as we have already visited it." << endl;
+      }
+    }
 …
  * @return list of the closed paths
  */
+list<list<TesselPoint*> *> * Tesselation::GetClosedPathsOfConnectedPoints(const TesselPoint* const Point) const
+{
+  list<list<TesselPoint*> *> *ListofPaths = GetPathsOfConnectedPoints(Point);
+  list<list<TesselPoint*> *> *ListofClosedPaths = new list<list<TesselPoint*> *>;
+  list<TesselPoint*> *connectedPath = NULL;
+  list<TesselPoint*> *newPath = NULL;
+ListOfTesselPointList * Tesselation::GetClosedPathsOfConnectedPoints(const TesselPoint* const Point) const
+{
+        Info FunctionInfo(__func__);
+  list<TesselPointList *> *ListofPaths = GetPathsOfConnectedPoints(Point);
+  list<TesselPointList *> *ListofClosedPaths = new list<TesselPointList *>;
+  TesselPointList *connectedPath = NULL;
+  TesselPointList *newPath = NULL;
   int count = 0;
   list<TesselPoint*>::iterator CircleRunner;
   list<TesselPoint*>::iterator CircleStart;
   for(list<list<TesselPoint*> *>::iterator ListRunner = ListofPaths->begin(); ListRunner != ListofPaths->end(); ListRunner++) {
+  TesselPointList::iterator CircleRunner;
+  TesselPointList::iterator CircleStart;
+  for(list<TesselPointList *>::iterator ListRunner = ListofPaths->begin(); ListRunner != ListofPaths->end(); ListRunner++) {
     connectedPath = *ListRunner;
     Log() << Verbose(2) << "INFO: Current path is " << connectedPath << "." << endl;
+    Log() << Verbose(1) << "INFO: Current path is " << connectedPath << "." << endl;
     // go through list, look for reappearance of starting Point and count
 …
     // go through list, look for reappearance of starting Point and create list
     list<TesselPoint*>::iterator Marker = CircleStart;
+    TesselPointList::iterator Marker = CircleStart;
     for (CircleRunner = CircleStart; CircleRunner != connectedPath->end(); CircleRunner++) {
       if ((*CircleRunner == *CircleStart) && (CircleRunner != CircleStart)) { // is not the very first point
         // we have a closed circle from Marker to new Marker
         Log() << Verbose(3) << count+1 << ". closed path consists of: ";
         newPath = new list<TesselPoint*>;
         list<TesselPoint*>::iterator CircleSprinter = Marker;
+        Log() << Verbose(1) << count+1 << ". closed path consists of: ";
+        newPath = new TesselPointList;
+        TesselPointList::iterator CircleSprinter = Marker;
         for (; CircleSprinter != CircleRunner; CircleSprinter++) {
           newPath->push_back(*CircleSprinter);
 …
+    }
+  }
   Log() << Verbose(3) << "INFO: " << count << " closed additional path(s) have been created." << endl;
+  Log() << Verbose(1) << "INFO: " << count << " closed additional path(s) have been created." << endl;
   // delete list of paths
 …
  * \return pointer to allocated list of triangles
  */
+set<BoundaryTriangleSet*> *Tesselation::GetAllTriangles(const BoundaryPointSet * const Point) const
+{
+  set<BoundaryTriangleSet*> *connectedTriangles = new set<BoundaryTriangleSet*>;
+TriangleSet *Tesselation::GetAllTriangles(const BoundaryPointSet * const Point) const
+{
+        Info FunctionInfo(__func__);
+        TriangleSet *connectedTriangles = new TriangleSet;
   if (Point == NULL) {
 …
     return 0.;
   } else
     Log() << Verbose(2) << "Removing point " << *point << " from tesselated boundary ..." << endl;
+    Log() << Verbose(0) << "Removing point " << *point << " from tesselated boundary ..." << endl;
   // copy old location for the volume
 …
+  }
   list<list<TesselPoint*> *> *ListOfClosedPaths = GetClosedPathsOfConnectedPoints(point->node);
   list<TesselPoint*> *connectedPath = NULL;
+  list<TesselPointList *> *ListOfClosedPaths = GetClosedPathsOfConnectedPoints(point->node);
+  TesselPointList *connectedPath = NULL;
   // gather all triangles
   for (LineMap::iterator LineRunner = point->lines.begin(); LineRunner != point->lines.end(); LineRunner++)
     count+=LineRunner->second->triangles.size();
   map<class BoundaryTriangleSet *, int> Candidates;
+  TriangleMap Candidates;
   for (LineMap::iterator LineRunner = point->lines.begin(); LineRunner != point->lines.end(); LineRunner++) {
     line = LineRunner->second;
     for (TriangleMap::iterator TriangleRunner = line->triangles.begin(); TriangleRunner != line->triangles.end(); TriangleRunner++) {
       triangle = TriangleRunner->second;
       Candidates.insert( pair<class BoundaryTriangleSet *, int> (triangle, triangle->Nr) );
+      Candidates.insert( TrianglePair (triangle->Nr, triangle) );
+    }
+  }
 …
   count=0;
   NormalVector.Zero();
   for (map<class BoundaryTriangleSet *, int>::iterator Runner = Candidates.begin(); Runner != Candidates.end(); Runner++) {
     Log() << Verbose(3) << "INFO: Removing triangle " << *(Runner->first) << "." << endl;
     NormalVector.SubtractVector(&Runner->first->NormalVector); // has to point inward
     RemoveTesselationTriangle(Runner->first);
+  for (TriangleMap::iterator Runner = Candidates.begin(); Runner != Candidates.end(); Runner++) {
+    Log() << Verbose(1) << "INFO: Removing triangle " << *(Runner->second) << "." << endl;
+    NormalVector.SubtractVector(&Runner->second->NormalVector); // has to point inward
+    RemoveTesselationTriangle(Runner->second);
     count++;
+  }
   Log() << Verbose(1) << count << " triangles were removed." << endl;
   list<list<TesselPoint*> *>::iterator ListAdvance = ListOfClosedPaths->begin();
   list<list<TesselPoint*> *>::iterator ListRunner = ListAdvance;
   map<class BoundaryTriangleSet *, int>::iterator NumberRunner = Candidates.begin();
   list<TesselPoint*>::iterator StartNode, MiddleNode, EndNode;
+  list<TesselPointList *>::iterator ListAdvance = ListOfClosedPaths->begin();
+  list<TesselPointList *>::iterator ListRunner = ListAdvance;
+  TriangleMap::iterator NumberRunner = Candidates.begin();
+  TesselPointList::iterator StartNode, MiddleNode, EndNode;
   double angle;
   double smallestangle;
 …
       // re-create all triangles by going through connected points list
       list<class BoundaryLineSet *> NewLines;
+      LineList NewLines;
       for (;!connectedPath->empty();) {
         // search middle node with widest angle to next neighbours
 …
         smallestangle = 0.;
         for (MiddleNode = connectedPath->begin(); MiddleNode != connectedPath->end(); MiddleNode++) {
           Log() << Verbose(3) << "INFO: MiddleNode is " << **MiddleNode << "." << endl;
+          Log() << Verbose(1) << "INFO: MiddleNode is " << **MiddleNode << "." << endl;
           // construct vectors to next and previous neighbour
           StartNode = MiddleNode;
 …
         MiddleNode = EndNode;
         if (MiddleNode == connectedPath->end()) {
           Log() << Verbose(1) << "CRITICAL: Could not find a smallest angle!" << endl;
           exit(255);
+          eLog() << Verbose(0) << "CRITICAL: Could not find a smallest angle!" << endl;
+          performCriticalExit();
+        }
         StartNode = MiddleNode;
 …
         if (EndNode == connectedPath->end())
           EndNode = connectedPath->begin();
         Log() << Verbose(4) << "INFO: StartNode is " << **StartNode << "." << endl;
         Log() << Verbose(4) << "INFO: MiddleNode is " << **MiddleNode << "." << endl;
         Log() << Verbose(4) << "INFO: EndNode is " << **EndNode << "." << endl;
         Log() << Verbose(3) << "INFO: Attempting to create triangle " << (*StartNode)->Name << ", " << (*MiddleNode)->Name << " and " << (*EndNode)->Name << "." << endl;
+        Log() << Verbose(2) << "INFO: StartNode is " << **StartNode << "." << endl;
+        Log() << Verbose(2) << "INFO: MiddleNode is " << **MiddleNode << "." << endl;
+        Log() << Verbose(2) << "INFO: EndNode is " << **EndNode << "." << endl;
+        Log() << Verbose(1) << "INFO: Attempting to create triangle " << (*StartNode)->Name << ", " << (*MiddleNode)->Name << " and " << (*EndNode)->Name << "." << endl;
         TriangleCandidates[0] = *StartNode;
         TriangleCandidates[1] = *MiddleNode;
 …
         triangle = GetPresentTriangle(TriangleCandidates);
         if (triangle != NULL) {
           eLog() << Verbose(2) << "New triangle already present, skipping!" << endl;
+          eLog() << Verbose(0) << "New triangle already present, skipping!" << endl;
           StartNode++;
           MiddleNode++;
 …
           continue;
+        }
         Log() << Verbose(5) << "Adding new triangle points."<< endl;
+        Log() << Verbose(3) << "Adding new triangle points."<< endl;
         AddTesselationPoint(*StartNode, 0);
         AddTesselationPoint(*MiddleNode, 1);
         AddTesselationPoint(*EndNode, 2);
         Log() << Verbose(5) << "Adding new triangle lines."<< endl;
+        Log() << Verbose(3) << "Adding new triangle lines."<< endl;
         AddTesselationLine(TPS[0], TPS[1], 0);
         AddTesselationLine(TPS[0], TPS[2], 1);
 …
         // prepare nodes for next triangle
         StartNode = EndNode;
         Log() << Verbose(4) << "Removing " << **MiddleNode << " from closed path, remaining points: " << connectedPath->size() << "." << endl;
+        Log() << Verbose(2) << "Removing " << **MiddleNode << " from closed path, remaining points: " << connectedPath->size() << "." << endl;
         connectedPath->remove(*MiddleNode); // remove the middle node (it is surrounded by triangles)
         if (connectedPath->size() == 2) { // we are done
 …
           break;
         } else if (connectedPath->size() < 2) { // something's gone wrong!
           Log() << Verbose(1) << "CRITICAL: There are only two endpoints left!" << endl;
           exit(255);
+          eLog() << Verbose(0) << "CRITICAL: There are only two endpoints left!" << endl;
+          performCriticalExit();
         } else {
           MiddleNode = StartNode;
 …
       // maximize the inner lines (we preferentially created lines with a huge angle, which is for the tesselation not wanted though useful for the closing)
       if (NewLines.size() > 1) {
         list<class BoundaryLineSet *>::iterator Candidate;
+        LineList::iterator Candidate;
         class BoundaryLineSet *OtherBase = NULL;
         double tmp, maxgain;
         do {
           maxgain = 0;
           for(list<class BoundaryLineSet *>::iterator Runner = NewLines.begin(); Runner != NewLines.end(); Runner++) {
+          for(LineList::iterator Runner = NewLines.begin(); Runner != NewLines.end(); Runner++) {
             tmp = PickFarthestofTwoBaselines(*Runner);
             if (maxgain < tmp) {
 …
           if (maxgain != 0) {
             volume += maxgain;
             Log() << Verbose(3) << "Flipping baseline with highest volume" << **Candidate << "." << endl;
+            Log() << Verbose(1) << "Flipping baseline with highest volume" << **Candidate << "." << endl;
             OtherBase = FlipBaseline(*Candidate);
             NewLines.erase(Candidate);
 …
       delete(connectedPath);
+    }
     Log() << Verbose(1) << count << " triangles were created." << endl;
+    Log() << Verbose(0) << count << " triangles were created." << endl;
   } else {
     while (!ListOfClosedPaths->empty()) {
 …
       delete(connectedPath);
+    }
     Log() << Verbose(1) << "No need to create any triangles." << endl;
+    Log() << Verbose(0) << "No need to create any triangles." << endl;
+  }
   delete(ListOfClosedPaths);
   Log() << Verbose(1) << "Removed volume is " << volume << "." << endl;
+  Log() << Verbose(0) << "Removed volume is " << volume << "." << endl;
   return volume;
 …
  * Finds triangles belonging to the three provided points.
+ *
  * @param *Points[3] list, is expected to contain three points
+ * @param *Points[3] list, is expected to contain three points (NULL means wildcard)
+ *
  * @return triangles which belong to the provided points, will be empty if there are none,
  *         will usually be one, in case of degeneration, there will be two
  */
+list<BoundaryTriangleSet*> *Tesselation::FindTriangles(const TesselPoint* const Points[3]) const
+{
+  list<BoundaryTriangleSet*> *result = new list<BoundaryTriangleSet*>;
+TriangleList *Tesselation::FindTriangles(const TesselPoint* const Points[3]) const
+{
+        Info FunctionInfo(__func__);
+        TriangleList *result = new TriangleList;
   LineMap::const_iterator FindLine;
   TriangleMap::const_iterator FindTriangle;
   class BoundaryPointSet *TrianglePoints[3];
+  size_t NoOfWildcards = 0;
   for (int i = 0; i < 3; i++) {
     PointMap::const_iterator FindPoint = PointsOnBoundary.find(Points[i]->nr);
     if (FindPoint != PointsOnBoundary.end()) {
       TrianglePoints[i] = FindPoint->second;
+    if (Points[i] == NULL) {
+      NoOfWildcards++;
+      TrianglePoints[i] = NULL;
     } else {
+      TrianglePoints[i] = NULL;
+    }
+  }
+  // checks lines between the points in the Points for their adjacent triangles
+  for (int i = 0; i < 3; i++) {
+    if (TrianglePoints[i] != NULL) {
+      for (int j = i+1; j < 3; j++) {
+        if (TrianglePoints[j] != NULL) {
+          for (FindLine = TrianglePoints[i]->lines.find(TrianglePoints[j]->node->nr); // is a multimap!
+              (FindLine != TrianglePoints[i]->lines.end()) && (FindLine->first == TrianglePoints[j]->node->nr);
+              FindLine++) {
+            for (FindTriangle = FindLine->second->triangles.begin();
+                FindTriangle != FindLine->second->triangles.end();
+                FindTriangle++) {
+              if (FindTriangle->second->IsPresentTupel(TrianglePoints)) {
+                result->push_back(FindTriangle->second);
+      PointMap::const_iterator FindPoint = PointsOnBoundary.find(Points[i]->nr);
+      if (FindPoint != PointsOnBoundary.end()) {
+        TrianglePoints[i] = FindPoint->second;
+      } else {
+        TrianglePoints[i] = NULL;
+      }
+    }
+  }
+  switch (NoOfWildcards) {
+    case 0: // checks lines between the points in the Points for their adjacent triangles
+      for (int i = 0; i < 3; i++) {
+        if (TrianglePoints[i] != NULL) {
+          for (int j = i+1; j < 3; j++) {
+            if (TrianglePoints[j] != NULL) {
+              for (FindLine = TrianglePoints[i]->lines.find(TrianglePoints[j]->node->nr); // is a multimap!
+                  (FindLine != TrianglePoints[i]->lines.end()) && (FindLine->first == TrianglePoints[j]->node->nr);
+                  FindLine++) {
+                for (FindTriangle = FindLine->second->triangles.begin();
+                    FindTriangle != FindLine->second->triangles.end();
+                    FindTriangle++) {
+                  if (FindTriangle->second->IsPresentTupel(TrianglePoints)) {
+                    result->push_back(FindTriangle->second);
+                  }
+                }
+              }
+              // Is it sufficient to consider one of the triangle lines for this.
+              return result;
+            }
+          }
-          // Is it sufficient to consider one of the triangle lines for this.
-          return result;
+        }
+      }
+    }
+      break;
+    case 1: // copy all triangles of the respective line
+    {
+      int i=0;
+      for (; i < 3; i++)
+        if (TrianglePoints[i] == NULL)
+          break;
+      for (FindLine = TrianglePoints[(i+1)%3]->lines.find(TrianglePoints[(i+2)%3]->node->nr); // is a multimap!
+          (FindLine != TrianglePoints[(i+1)%3]->lines.end()) && (FindLine->first == TrianglePoints[(i+2)%3]->node->nr);
+          FindLine++) {
+        for (FindTriangle = FindLine->second->triangles.begin();
+            FindTriangle != FindLine->second->triangles.end();
+            FindTriangle++) {
+          if (FindTriangle->second->IsPresentTupel(TrianglePoints)) {
+            result->push_back(FindTriangle->second);
+          }
+        }
+      }
+      break;
+    }
+    case 2: // copy all triangles of the respective point
+    {
+      int i=0;
+      for (; i < 3; i++)
+        if (TrianglePoints[i] != NULL)
+          break;
+      for (LineMap::const_iterator line = TrianglePoints[i]->lines.begin(); line != TrianglePoints[i]->lines.end(); line++)
+        for (TriangleMap::const_iterator triangle = line->second->triangles.begin(); triangle != line->second->triangles.end(); triangle++)
+          result->push_back(triangle->second);
+      result->sort();
+      result->unique();
+      break;
+    }
+    case 3: // copy all triangles
+    {
+      for (TriangleMap::const_iterator triangle = TrianglesOnBoundary.begin(); triangle != TrianglesOnBoundary.end(); triangle++)
+        result->push_back(triangle->second);
+      break;
+    }
+    default:
+      eLog() << Verbose(0) << "Number of wildcards is greater than 3, cannot happen!" << endl;
+      performCriticalExit();
+      break;
+  }
   return result;
+}
+struct BoundaryLineSetCompare {
+  bool operator() (const BoundaryLineSet * const a, const BoundaryLineSet * const b) {
+    int lowerNra = -1;
+    int lowerNrb = -1;
+    if (a->endpoints[0] < a->endpoints[1])
+      lowerNra = 0;
+    else
+      lowerNra = 1;
+    if (b->endpoints[0] < b->endpoints[1])
+      lowerNrb = 0;
+    else
+      lowerNrb = 1;
+    if (a->endpoints[lowerNra] < b->endpoints[lowerNrb])
+      return true;
+    else if (a->endpoints[lowerNra] > b->endpoints[lowerNrb])
+      return false;
+    else {  // both lower-numbered endpoints are the same ...
+     if (a->endpoints[(lowerNra+1)%2] < b->endpoints[(lowerNrb+1)%2])
+       return true;
+     else if (a->endpoints[(lowerNra+1)%2] > b->endpoints[(lowerNrb+1)%2])
+       return false;
+    }
+    return false;
+  };
+};
+#define UniqueLines set < class BoundaryLineSet *, BoundaryLineSetCompare>
 /**
 …
  *         in the list, once as key and once as value
  */
+map<int, int> * Tesselation::FindAllDegeneratedLines()
+{
+  map<int, class BoundaryLineSet *> AllLines;
+  map<int, int> * DegeneratedLines = new map<int, int>;
+IndexToIndex * Tesselation::FindAllDegeneratedLines()
+{
+        Info FunctionInfo(__func__);
+        UniqueLines AllLines;
+  IndexToIndex * DegeneratedLines = new IndexToIndex;
   // sanity check
   if (LinesOnBoundary.empty()) {
     Log() << Verbose(1) << "Warning: FindAllDegeneratedTriangles() was called without any tesselation structure.";
+    eLog() << Verbose(2) << "FindAllDegeneratedTriangles() was called without any tesselation structure.";
     return DegeneratedLines;
+  }
   LineMap::iterator LineRunner1;
   pair<LineMap::iterator, bool> tester;
+  pair< UniqueLines::iterator, bool> tester;
   for (LineRunner1 = LinesOnBoundary.begin(); LineRunner1 != LinesOnBoundary.end(); ++LineRunner1) {
     tester = AllLines.insert( pair<int,BoundaryLineSet *> (LineRunner1->second->endpoints[0]->Nr, LineRunner1->second) );
     if ((!tester.second) && (tester.first->second->endpoints[1]->Nr == LineRunner1->second->endpoints[1]->Nr)) { // found degenerated line
       DegeneratedLines->insert ( pair<int, int> (LineRunner1->second->Nr, tester.first->second->Nr) );
       DegeneratedLines->insert ( pair<int, int> (tester.first->second->Nr, LineRunner1->second->Nr) );
+    tester = AllLines.insert( LineRunner1->second );
+    if (!tester.second) { // found degenerated line
+      DegeneratedLines->insert ( pair<int, int> (LineRunner1->second->Nr, (*tester.first)->Nr) );
+      DegeneratedLines->insert ( pair<int, int> ((*tester.first)->Nr, LineRunner1->second->Nr) );
+    }
+  }
 …
   AllLines.clear();
+  Log() << Verbose(1) << "FindAllDegeneratedLines() found " << DegeneratedLines->size() << " lines." << endl;
+  map<int,int>::iterator it;
+  for (it = DegeneratedLines->begin(); it != DegeneratedLines->end(); it++)
+      Log() << Verbose(2) << (*it).first << " => " << (*it).second << endl;
+  Log() << Verbose(0) << "FindAllDegeneratedLines() found " << DegeneratedLines->size() << " lines." << endl;
+  IndexToIndex::iterator it;
+  for (it = DegeneratedLines->begin(); it != DegeneratedLines->end(); it++) {
+    const LineMap::const_iterator Line1 = LinesOnBoundary.find((*it).first);
+    const LineMap::const_iterator Line2 = LinesOnBoundary.find((*it).second);
+    if (Line1 != LinesOnBoundary.end() && Line2 != LinesOnBoundary.end())
+      Log() << Verbose(0) << *Line1->second << " => " << *Line2->second << endl;
+    else
+      eLog() << Verbose(1) << "Either " << (*it).first << " or " << (*it).second << " are not in LinesOnBoundary!" << endl;
+  }
   return DegeneratedLines;
 …
  *         in the list, once as key and once as value
  */
+map<int, int> * Tesselation::FindAllDegeneratedTriangles()
+{
+  map<int, int> * DegeneratedLines = FindAllDegeneratedLines();
+  map<int, int> * DegeneratedTriangles = new map<int, int>;
+IndexToIndex * Tesselation::FindAllDegeneratedTriangles()
+{
+        Info FunctionInfo(__func__);
+  IndexToIndex * DegeneratedLines = FindAllDegeneratedLines();
+  IndexToIndex * DegeneratedTriangles = new IndexToIndex;
   TriangleMap::iterator TriangleRunner1, TriangleRunner2;
 …
   class BoundaryLineSet *line1 = NULL, *line2 = NULL;
   for (map<int, int>::iterator LineRunner = DegeneratedLines->begin(); LineRunner != DegeneratedLines->end(); ++LineRunner) {
+  for (IndexToIndex::iterator LineRunner = DegeneratedLines->begin(); LineRunner != DegeneratedLines->end(); ++LineRunner) {
     // run over both lines' triangles
     Liner = LinesOnBoundary.find(LineRunner->first);
 …
   delete(DegeneratedLines);
   Log() << Verbose(1) << "FindAllDegeneratedTriangles() found " << DegeneratedTriangles->size() << " triangles:" << endl;
   map<int,int>::iterator it;
+  Log() << Verbose(0) << "FindAllDegeneratedTriangles() found " << DegeneratedTriangles->size() << " triangles:" << endl;
+  IndexToIndex::iterator it;
   for (it = DegeneratedTriangles->begin(); it != DegeneratedTriangles->end(); it++)
       Log() << Verbose(2) << (*it).first << " => " << (*it).second << endl;
+      Log() << Verbose(0) << (*it).first << " => " << (*it).second << endl;
   return DegeneratedTriangles;
 …
 void Tesselation::RemoveDegeneratedTriangles()
+{
+  map<int, int> * DegeneratedTriangles = FindAllDegeneratedTriangles();
+        Info FunctionInfo(__func__);
+  IndexToIndex * DegeneratedTriangles = FindAllDegeneratedTriangles();
   TriangleMap::iterator finder;
   BoundaryTriangleSet *triangle = NULL, *partnerTriangle = NULL;
   int count  = 0;
+  Log() << Verbose(1) << "Begin of RemoveDegeneratedTriangles" << endl;
+  for (map<int, int>::iterator TriangleKeyRunner = DegeneratedTriangles->begin();
+  for (IndexToIndex::iterator TriangleKeyRunner = DegeneratedTriangles->begin();
     TriangleKeyRunner != DegeneratedTriangles->end(); ++TriangleKeyRunner
   ) {
 …
       // erase the pair
       count += (int) DegeneratedTriangles->erase(triangle->Nr);
       Log() << Verbose(1) << "RemoveDegeneratedTriangles() removes triangle " << *triangle << "." << endl;
+      Log() << Verbose(0) << "RemoveDegeneratedTriangles() removes triangle " << *triangle << "." << endl;
       RemoveTesselationTriangle(triangle);
       count += (int) DegeneratedTriangles->erase(partnerTriangle->Nr);
       Log() << Verbose(1) << "RemoveDegeneratedTriangles() removes triangle " << *partnerTriangle << "." << endl;
+      Log() << Verbose(0) << "RemoveDegeneratedTriangles() removes triangle " << *partnerTriangle << "." << endl;
       RemoveTesselationTriangle(partnerTriangle);
     } else {
       Log() << Verbose(1) << "RemoveDegeneratedTriangles() does not remove triangle " << *triangle
+      Log() << Verbose(0) << "RemoveDegeneratedTriangles() does not remove triangle " << *triangle
         << " and its partner " << *partnerTriangle << " because it is essential for at"
         << " least one of the endpoints to be kept in the tesselation structure." << endl;
 …
+  }
   delete(DegeneratedTriangles);
+  Log() << Verbose(1) << "RemoveDegeneratedTriangles() removed " << count << " triangles:" << endl;
+  Log() << Verbose(1) << "End of RemoveDegeneratedTriangles" << endl;
+  if (count > 0)
+    LastTriangle = NULL;
+  Log() << Verbose(0) << "RemoveDegeneratedTriangles() removed " << count << " triangles:" << endl;
+}
 …
 void Tesselation::AddBoundaryPointByDegeneratedTriangle(class TesselPoint *point, LinkedCell *LC)
+{
+  Log() << Verbose(2) << "Begin of AddBoundaryPointByDegeneratedTriangle" << endl;
+        Info FunctionInfo(__func__);
   // find nearest boundary point
   class TesselPoint *BackupPoint = NULL;
   class TesselPoint *NearestPoint = FindClosestPoint(point->node, BackupPoint, LC);
+  class TesselPoint *NearestPoint = FindClosestTesselPoint(point->node, BackupPoint, LC);
   class BoundaryPointSet *NearestBoundaryPoint = NULL;
   PointMap::iterator PointRunner;
 …
     return;
+  }
   Log() << Verbose(2) << "Nearest point on boundary is " << NearestPoint->Name << "." << endl;
+  Log() << Verbose(0) << "Nearest point on boundary is " << NearestPoint->Name << "." << endl;
   // go through its lines and find the best one to split
 …
   // create new triangle to connect point (connects automatically with the missing spot of the chosen line)
   Log() << Verbose(5) << "Adding new triangle points."<< endl;
+  Log() << Verbose(2) << "Adding new triangle points."<< endl;
   AddTesselationPoint((BestLine->endpoints[0]->node), 0);
   AddTesselationPoint((BestLine->endpoints[1]->node), 1);
   AddTesselationPoint(point, 2);
   Log() << Verbose(5) << "Adding new triangle lines."<< endl;
+  Log() << Verbose(2) << "Adding new triangle lines."<< endl;
   AddTesselationLine(TPS[0], TPS[1], 0);
   AddTesselationLine(TPS[0], TPS[2], 1);
 …
   BTS->GetNormalVector(TempTriangle->NormalVector);
   BTS->NormalVector.Scale(-1.);
   Log() << Verbose(3) << "INFO: NormalVector of new triangle is " << BTS->NormalVector << "." << endl;
+  Log() << Verbose(1) << "INFO: NormalVector of new triangle is " << BTS->NormalVector << "." << endl;
   AddTesselationTriangle();
   // create other side of this triangle and close both new sides of the first created triangle
   Log() << Verbose(5) << "Adding new triangle points."<< endl;
+  Log() << Verbose(2) << "Adding new triangle points."<< endl;
   AddTesselationPoint((BestLine->endpoints[0]->node), 0);
   AddTesselationPoint((BestLine->endpoints[1]->node), 1);
   AddTesselationPoint(point, 2);
   Log() << Verbose(5) << "Adding new triangle lines."<< endl;
+  Log() << Verbose(2) << "Adding new triangle lines."<< endl;
   AddTesselationLine(TPS[0], TPS[1], 0);
   AddTesselationLine(TPS[0], TPS[2], 1);
 …
   BTS = new class BoundaryTriangleSet(BLS, TrianglesOnBoundaryCount);
   BTS->GetNormalVector(TempTriangle->NormalVector);
   Log() << Verbose(3) << "INFO: NormalVector of other new triangle is " << BTS->NormalVector << "." << endl;
+  Log() << Verbose(1) << "INFO: NormalVector of other new triangle is " << BTS->NormalVector << "." << endl;
   AddTesselationTriangle();
 …
     if ((BTS->lines[i]->ContainsBoundaryPoint(BestLine->endpoints[0])) && (BTS->lines[i]->ContainsBoundaryPoint(BestLine->endpoints[1]))) {
       if (BestLine == BTS->lines[i]){
         Log() << Verbose(1) << "CRITICAL: BestLine is same as found line, something's wrong here!" << endl;
         exit(255);
+        eLog() << Verbose(0) << "BestLine is same as found line, something's wrong here!" << endl;
+        performCriticalExit();
+      }
       BTS->lines[i]->triangles.insert( pair<int, class BoundaryTriangleSet *> (TempTriangle->Nr, TempTriangle) );
 …
+    }
+  }
-  // exit
-  Log() << Verbose(2) << "End of AddBoundaryPointByDegeneratedTriangle" << endl;
 };
 …
 void Tesselation::Output(const char *filename, const PointCloud * const cloud)
+{
+        Info FunctionInfo(__func__);
   ofstream *tempstream = NULL;
   string NameofTempFile;
 …
       NameofTempFile.erase(npos, 1);
       NameofTempFile.append(TecplotSuffix);
       Log() << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
+      Log() << Verbose(0) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
       tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
       WriteTecplotFile(tempstream, this, cloud, TriangleFilesWritten);
 …
       NameofTempFile.erase(npos, 1);
       NameofTempFile.append(Raster3DSuffix);
       Log() << Verbose(1) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
+      Log() << Verbose(0) << "Writing temporary non convex hull to file " << NameofTempFile << ".\n";
       tempstream = new ofstream(NameofTempFile.c_str(), ios::trunc);
       WriteRaster3dFile(tempstream, this, cloud);
 …
     TriangleFilesWritten++;
 };
+struct BoundaryPolygonSetCompare {
+  bool operator()(const BoundaryPolygonSet * s1, const BoundaryPolygonSet * s2) const {
+    if (s1->endpoints.size() < s2->endpoints.size())
+      return true;
+    else if (s1->endpoints.size() > s2->endpoints.size())
+      return false;
+    else { // equality of number of endpoints
+      PointSet::const_iterator Walker1 = s1->endpoints.begin();
+      PointSet::const_iterator Walker2 = s2->endpoints.begin();
+      while ((Walker1 != s1->endpoints.end()) || (Walker2 != s2->endpoints.end())) {
+        if ((*Walker1)->Nr < (*Walker2)->Nr)
+          return true;
+        else if ((*Walker1)->Nr > (*Walker2)->Nr)
+          return false;
+        Walker1++;
+        Walker2++;
+      }
+      return false;
+    }
+  }
+};
+#define UniquePolygonSet set < BoundaryPolygonSet *, BoundaryPolygonSetCompare>
+/** Finds all degenerated polygons and calls ReTesselateDegeneratedPolygon()/
+ * \return number of polygons found
+ */
+int Tesselation::CorrectAllDegeneratedPolygons()
+{
+  Info FunctionInfo(__func__);
+  /// 2. Go through all BoundaryPointSet's, check their triangles' NormalVector
+  IndexToIndex *DegeneratedTriangles = FindAllDegeneratedTriangles();
+  set < BoundaryPointSet *> EndpointCandidateList;
+  pair < set < BoundaryPointSet *>::iterator, bool > InsertionTester;
+  pair < map < int, Vector *>::iterator, bool > TriangleInsertionTester;
+  for (PointMap::const_iterator Runner = PointsOnBoundary.begin(); Runner != PointsOnBoundary.end(); Runner++) {
+    Log() << Verbose(0) << "Current point is " << *Runner->second << "." << endl;
+    map < int, Vector *> TriangleVectors;
+    // gather all NormalVectors
+    Log() << Verbose(1) << "Gathering triangles ..." << endl;
+    for (LineMap::const_iterator LineRunner = (Runner->second)->lines.begin(); LineRunner != (Runner->second)->lines.end(); LineRunner++)
+      for (TriangleMap::const_iterator TriangleRunner = (LineRunner->second)->triangles.begin(); TriangleRunner != (LineRunner->second)->triangles.end(); TriangleRunner++) {
+        if (DegeneratedTriangles->find(TriangleRunner->second->Nr) == DegeneratedTriangles->end()) {
+          TriangleInsertionTester = TriangleVectors.insert( pair< int, Vector *> ((TriangleRunner->second)->Nr, &((TriangleRunner->second)->NormalVector)) );
+          if (TriangleInsertionTester.second)
+            Log() << Verbose(1) << " Adding triangle " << *(TriangleRunner->second) << " to triangles to check-list." << endl;
+        } else {
+          Log() << Verbose(1) << " NOT adding triangle " << *(TriangleRunner->second) << " as it's a simply degenerated one." << endl;
+        }
+      }
+    // check whether there are two that are parallel
+    Log() << Verbose(1) << "Finding two parallel triangles ..." << endl;
+    for (map < int, Vector *>::iterator VectorWalker = TriangleVectors.begin(); VectorWalker != TriangleVectors.end(); VectorWalker++)
+      for (map < int, Vector *>::iterator VectorRunner = VectorWalker; VectorRunner != TriangleVectors.end(); VectorRunner++)
+        if (VectorWalker != VectorRunner) { // skip equals
+          const double SCP = VectorWalker->second->ScalarProduct(VectorRunner->second);  // ScalarProduct should result in -1. for degenerated triangles
+          Log() << Verbose(1) << "Checking " << *VectorWalker->second<< " against " << *VectorRunner->second << ": " << SCP << endl;
+          if (fabs(SCP + 1.) < ParallelEpsilon) {
+            InsertionTester = EndpointCandidateList.insert((Runner->second));
+            if (InsertionTester.second)
+              Log() << Verbose(0) << " Adding " << *Runner->second << " to endpoint candidate list." << endl;
+            // and break out of both loops
+            VectorWalker = TriangleVectors.end();
+            VectorRunner = TriangleVectors.end();
+            break;
+          }
+        }
+  }
+  /// 3. Find connected endpoint candidates and put them into a polygon
+  UniquePolygonSet ListofDegeneratedPolygons;
+  BoundaryPointSet *Walker = NULL;
+  BoundaryPointSet *OtherWalker = NULL;
+  BoundaryPolygonSet *Current = NULL;
+  stack <BoundaryPointSet*> ToCheckConnecteds;
+  while (!EndpointCandidateList.empty()) {
+    Walker = *(EndpointCandidateList.begin());
+    if (Current == NULL) {  // create a new polygon with current candidate
+      Log() << Verbose(0) << "Starting new polygon set at point " << *Walker << endl;
+      Current = new BoundaryPolygonSet;
+      Current->endpoints.insert(Walker);
+      EndpointCandidateList.erase(Walker);
+      ToCheckConnecteds.push(Walker);
+    }
+    // go through to-check stack
+    while (!ToCheckConnecteds.empty()) {
+      Walker = ToCheckConnecteds.top(); // fetch ...
+      ToCheckConnecteds.pop(); // ... and remove
+      for (LineMap::const_iterator LineWalker = Walker->lines.begin(); LineWalker != Walker->lines.end(); LineWalker++) {
+        OtherWalker = (LineWalker->second)->GetOtherEndpoint(Walker);
+        Log() << Verbose(1) << "Checking " << *OtherWalker << endl;
+        set < BoundaryPointSet *>::iterator Finder = EndpointCandidateList.find(OtherWalker);
+        if (Finder != EndpointCandidateList.end()) {  // found a connected partner
+          Log() << Verbose(1) << " Adding to polygon." << endl;
+          Current->endpoints.insert(OtherWalker);
+          EndpointCandidateList.erase(Finder);  // remove from candidates
+          ToCheckConnecteds.push(OtherWalker);  // but check its partners too
+        } else {
+          Log() << Verbose(1) << " is not connected to " << *Walker << endl;
+        }
+      }
+    }
+    Log() << Verbose(0) << "Final polygon is " << *Current << endl;
+    ListofDegeneratedPolygons.insert(Current);
+    Current = NULL;
+  }
+  const int counter = ListofDegeneratedPolygons.size();
+  Log() << Verbose(0) << "The following " << counter << " degenerated polygons have been found: " << endl;
+  for (UniquePolygonSet::iterator PolygonRunner = ListofDegeneratedPolygons.begin(); PolygonRunner != ListofDegeneratedPolygons.end(); PolygonRunner++)
+    Log() << Verbose(0) << " " << **PolygonRunner << endl;
+  /// 4. Go through all these degenerated polygons
+  for (UniquePolygonSet::iterator PolygonRunner = ListofDegeneratedPolygons.begin(); PolygonRunner != ListofDegeneratedPolygons.end(); PolygonRunner++) {
+    stack <int> TriangleNrs;
+    Vector NormalVector;
+    /// 4a. Gather all triangles of this polygon
+    TriangleSet *T = (*PolygonRunner)->GetAllContainedTrianglesFromEndpoints();
+    // check whether number is bigger than 2, otherwise it's just a simply degenerated one and nothing to do.
+    if (T->size() == 2) {
+      Log() << Verbose(1) << " Skipping degenerated polygon, is just a (already simply degenerated) triangle." << endl;
+      delete(T);
+      continue;
+    }
+    // check whether number is even
+    // If this case occurs, we have to think about it!
+    // The Problem is probably due to two degenerated polygons being connected by a bridging, non-degenerated polygon, as somehow one node has
+    // connections to either polygon ...
+    if (T->size() % 2 != 0) {
+      eLog() << Verbose(0) << " degenerated polygon contains an odd number of triangles, probably contains bridging non-degenerated ones, too!" << endl;
+      performCriticalExit();
+    }
+    TriangleSet::iterator TriangleWalker = T->begin();  // is the inner iterator
+    /// 4a. Get NormalVector for one side (this is "front")
+    NormalVector.CopyVector(&(*TriangleWalker)->NormalVector);
+    Log() << Verbose(1) << "\"front\" defining triangle is " << **TriangleWalker << " and Normal vector of \"front\" side is " << NormalVector << endl;
+    TriangleWalker++;
+    TriangleSet::iterator TriangleSprinter = TriangleWalker; // is the inner advanced iterator
+    /// 4b. Remove all triangles whose NormalVector is in opposite direction (i.e. "back")
+    BoundaryTriangleSet *triangle = NULL;
+    while (TriangleSprinter != T->end()) {
+      TriangleWalker = TriangleSprinter;
+      triangle = *TriangleWalker;
+      TriangleSprinter++;
+      Log() << Verbose(1) << "Current triangle to test for removal: " << *triangle << endl;
+      if (triangle->NormalVector.ScalarProduct(&NormalVector) < 0) { // if from other side, then delete and remove from list
+        Log() << Verbose(1) << " Removing ... " << endl;
+        TriangleNrs.push(triangle->Nr);
+        T->erase(TriangleWalker);
+        RemoveTesselationTriangle(triangle);
+      } else
+        Log() << Verbose(1) << " Keeping ... " << endl;
+    }
+    /// 4c. Copy all "front" triangles but with inverse NormalVector
+    TriangleWalker = T->begin();
+    while (TriangleWalker != T->end()) {  // go through all front triangles
+      Log() << Verbose(1) << " Re-creating triangle " << **TriangleWalker << " with NormalVector " << (*TriangleWalker)->NormalVector << endl;
+      for (int i = 0; i < 3; i++)
+        AddTesselationPoint((*TriangleWalker)->endpoints[i]->node, i);
+      AddTesselationLine(TPS[0], TPS[1], 0);
+      AddTesselationLine(TPS[0], TPS[2], 1);
+      AddTesselationLine(TPS[1], TPS[2], 2);
+      if (TriangleNrs.empty())
+        eLog() << Verbose(0) << "No more free triangle numbers!" << endl;
+      BTS = new BoundaryTriangleSet(BLS, TriangleNrs.top()); // copy triangle ...
+      AddTesselationTriangle(); // ... and add
+      TriangleNrs.pop();
+      BTS->NormalVector.CopyVector(&(*TriangleWalker)->NormalVector);
+      BTS->NormalVector.Scale(-1.);
+      TriangleWalker++;
+    }
+    if (!TriangleNrs.empty()) {
+      eLog() << Verbose(0) << "There have been less triangles created than removed!" << endl;
+    }
+    delete(T);  // remove the triangleset
+  }
+  IndexToIndex * SimplyDegeneratedTriangles = FindAllDegeneratedTriangles();
+  Log() << Verbose(0) << "Final list of simply degenerated triangles found, containing " << SimplyDegeneratedTriangles->size() << " triangles:" << endl;
+  IndexToIndex::iterator it;
+  for (it = SimplyDegeneratedTriangles->begin(); it != SimplyDegeneratedTriangles->end(); it++)
+      Log() << Verbose(0) << (*it).first << " => " << (*it).second << endl;
+  delete(SimplyDegeneratedTriangles);
+  /// 5. exit
+  UniquePolygonSet::iterator PolygonRunner;
+  while (!ListofDegeneratedPolygons.empty()) {
+    PolygonRunner = ListofDegeneratedPolygons.begin();
+    delete(*PolygonRunner);
+    ListofDegeneratedPolygons.erase(PolygonRunner);
+  }
+  return counter;
+};

TabularUnified src/tesselation.hpp ¶

-              r9fe36b
+              rb8d1aeb
 #include <list>
 #include <set>
+#include <stack>
 #include "atom_particleinfo.hpp"
 …
 #define VRMLSUffix ".wrl"
+#define ParallelEpsilon 1e-3
 // ======================================================= some template functions =========================================
+#define IndexToIndex map <int, int>
 #define PointMap map < int, class BoundaryPointSet * >
+#define PointSet set < class BoundaryPointSet * >
+#define PointList list < class BoundaryPointSet * >
 #define PointPair pair < int, class BoundaryPointSet * >
 #define PointTestPair pair < PointMap::iterator, bool >
 #define CandidateList list <class CandidateForTesselation *>
+#define CandidateMap map <class BoundaryLineSet *, class CandidateForTesselation *>
 #define LineMap multimap < int, class BoundaryLineSet * >
+#define LineSet set < class BoundaryLineSet * >
+#define LineList list < class BoundaryLineSet * >
 #define LinePair pair < int, class BoundaryLineSet * >
 #define LineTestPair pair < LineMap::iterator, bool >
 #define TriangleMap map < int, class BoundaryTriangleSet * >
+#define TriangleSet set < class BoundaryTriangleSet * >
+#define TriangleList list < class BoundaryTriangleSet * >
 #define TrianglePair pair < int, class BoundaryTriangleSet * >
 #define TriangleTestPair pair < TrianglePair::iterator, bool >
+#define PolygonMap map < int, class BoundaryPolygonSet * >
+#define PolygonSet set < class BoundaryPolygonSet * >
+#define PolygonList list < class BoundaryPolygonSet * >
+#define DistanceToPointMap multimap <double, class BoundaryPointSet * >
+#define DistanceToPointPair pair <double, class BoundaryPointSet * >
 #define DistanceMultiMap multimap <double, pair < PointMap::iterator, PointMap::iterator> >
 #define DistanceMultiMapPair pair <double, pair < PointMap::iterator, PointMap::iterator> >
+#define TesselPointList list <TesselPoint *>
+#define TesselPointSet set <TesselPoint *>
+#define ListOfTesselPointList list<list <TesselPoint *> *>
 /********************************************** declarations *******************************/
 …
   public:
     BoundaryPointSet();
     BoundaryPointSet(TesselPoint * Walker);
+    BoundaryPointSet(TesselPoint * const Walker);
     ~BoundaryPointSet();
     void AddLine(class BoundaryLineSet *line);
+    void AddLine(BoundaryLineSet * const line);
     LineMap lines;
 …
   public:
     BoundaryLineSet();
+    BoundaryLineSet(class BoundaryPointSet *Point[2], const int number);
+    BoundaryLineSet(BoundaryPointSet * const Point[2], const int number);
+    BoundaryLineSet(BoundaryPointSet * const Point1, BoundaryPointSet * const Point2, const int number);
     ~BoundaryLineSet();
     void AddTriangle(class BoundaryTriangleSet *triangle);
     bool IsConnectedTo(class BoundaryLineSet *line);
     bool ContainsBoundaryPoint(class BoundaryPointSet *point);
     bool CheckConvexityCriterion();
     class BoundaryPointSet *GetOtherEndpoint(class BoundaryPointSet *);
+    void AddTriangle(BoundaryTriangleSet * const triangle);
+    bool IsConnectedTo(const BoundaryLineSet * const line) const;
+    bool ContainsBoundaryPoint(const BoundaryPointSet * const point) const;
+    bool CheckConvexityCriterion() const;
+    class BoundaryPointSet *GetOtherEndpoint(const BoundaryPointSet * const point) const;
     class BoundaryPointSet *endpoints[2];
     TriangleMap triangles;
     int Nr;
+    bool skipped;
 };
 …
   public:
     BoundaryTriangleSet();
     BoundaryTriangleSet(class BoundaryLineSet *line[3], int number);
+    BoundaryTriangleSet(class BoundaryLineSet * const line[3], const int number);
     ~BoundaryTriangleSet();
+    void GetNormalVector(Vector &NormalVector);
+    void GetCenter(Vector *center);
+    bool GetIntersectionInsideTriangle(Vector *MolCenter, Vector *x, Vector *Intersection);
+    bool ContainsBoundaryLine(class BoundaryLineSet *line);
+    bool ContainsBoundaryPoint(class BoundaryPointSet *point);
+    bool ContainsBoundaryPoint(class TesselPoint *point);
+    class BoundaryPointSet *GetThirdEndpoint(class BoundaryLineSet *line);
+    bool IsPresentTupel(class BoundaryPointSet *Points[3]);
+    bool IsPresentTupel(class BoundaryTriangleSet *T);
+    void GetNormalVector(const Vector &NormalVector);
+    void GetCenter(Vector * const center) const;
+    bool GetIntersectionInsideTriangle(const Vector * const MolCenter, const Vector * const x, Vector * const Intersection) const;
+    double GetClosestPointInsideTriangle(const Vector * const x, Vector * const ClosestPoint) const;
+    bool ContainsBoundaryLine(const BoundaryLineSet * const line) const;
+    bool ContainsBoundaryPoint(const BoundaryPointSet * const point) const;
+    bool ContainsBoundaryPoint(const TesselPoint * const point) const;
+    class BoundaryPointSet *GetThirdEndpoint(const BoundaryLineSet * const line) const;
+    bool IsPresentTupel(const BoundaryPointSet * const Points[3]) const;
+    bool IsPresentTupel(const BoundaryTriangleSet * const T) const;
     class BoundaryPointSet *endpoints[3];
     class BoundaryLineSet *lines[3];
     Vector NormalVector;
+    Vector SphereCenter;
     int Nr;
 };
 ostream & operator << (ostream &ost, const BoundaryTriangleSet &a);
+// ======================================================== class BoundaryTriangleSet =======================================
+/** Set of BoundaryPointSet.
+ * This is just meant as a container for a group of endpoints, extending the node, line, triangle concept. However, this has
+ * only marginally something to do with the tesselation. Hence, there is no incorporation into the bookkeeping of the Tesselation
+ * class (i.e. no allocation, no deletion).
+ * \note we assume that the set of endpoints reside (more or less) on a plane.
+ */
+class BoundaryPolygonSet {
+  public:
+    BoundaryPolygonSet();
+    ~BoundaryPolygonSet();
+    Vector * GetNormalVector(const Vector &NormalVector) const;
+    void GetCenter(Vector *center) const;
+    bool ContainsBoundaryLine(const BoundaryLineSet * const line) const;
+    bool ContainsBoundaryPoint(const BoundaryPointSet * const point) const;
+    bool ContainsBoundaryPoint(const TesselPoint * const point) const;
+    bool ContainsBoundaryTriangle(const BoundaryTriangleSet * const point) const;
+    bool ContainsPresentTupel(const BoundaryPointSet * const * Points, const int dim) const;
+    bool ContainsPresentTupel(const BoundaryPolygonSet * const P) const;
+    bool ContainsPresentTupel(const PointSet &endpoints) const;
+    TriangleSet * GetAllContainedTrianglesFromEndpoints() const;
+    bool FillPolygonFromTrianglesOfLine(const BoundaryLineSet * const line);
+    PointSet endpoints;
+    int Nr;
+};
+ostream & operator << (ostream &ost, const BoundaryPolygonSet &a);
 // =========================================================== class TESSELPOINT ===========================================
 …
   virtual ~PointCloud();
+  virtual const char * const GetName() const { return "unknown"; };
   virtual Vector *GetCenter() const { return NULL; };
   virtual TesselPoint *GetPoint() const { return NULL; };
   virtual TesselPoint *GetTerminalPoint() const { return NULL; };
+  virtual int GetMaxId() const { return 0; };
   virtual void GoToNext() const {};
   virtual void GoToPrevious() const {};
   virtual void GoToFirst() const {};
   virtual void GoToLast() const {};
   virtual bool IsEmpty() const { return false; };
   virtual bool IsEnd() const { return false; };
+  virtual bool IsEmpty() const { return true; };
+  virtual bool IsEnd() const { return true; };
 };
 …
 class CandidateForTesselation {
   public :
+  CandidateForTesselation(BoundaryLineSet* currentBaseLine);
   CandidateForTesselation(TesselPoint* candidate, BoundaryLineSet* currentBaseLine, Vector OptCandidateCenter, Vector OtherOptCandidateCenter);
   ~CandidateForTesselation();
   TesselPoint *point;
+  TesselPointList pointlist;
   BoundaryLineSet *BaseLine;
   Vector OptCenter;
   Vector OtherOptCenter;
+};
+  double ShortestAngle;
+  double OtherShortestAngle;
+};
+ostream & operator <<(ostream &ost, const  CandidateForTesselation &a);
 // =========================================================== class TESSELATION ===========================================
 …
     void AddTesselationTriangle();
     void AddTesselationTriangle(const int nr);
+    void AddCandidateTriangle(CandidateForTesselation CandidateLine);
     void RemoveTesselationTriangle(class BoundaryTriangleSet *triangle);
     void RemoveTesselationLine(class BoundaryLineSet *line);
 …
     void FindStartingTriangle(const double RADIUS, const LinkedCell *LC);
     void FindSecondPointForTesselation(class TesselPoint* a, Vector Oben, class TesselPoint*& OptCandidate, double Storage[3], double RADIUS, const LinkedCell *LC);
     void FindThirdPointForTesselation(Vector &NormalVector, Vector &SearchDirection, Vector &OldSphereCenter, class BoundaryLineSet *BaseLine, const class TesselPoint * const ThirdNode, CandidateList* &candidates, double *ShortestAngle, const double RADIUS, const LinkedCell *LC) const;
     bool FindNextSuitableTriangle(BoundaryLineSet &Line, BoundaryTriangleSet &T, const double& RADIUS, const LinkedCell *LC);
+    void FindThirdPointForTesselation(Vector &NormalVector, Vector &SearchDirection, Vector &OldSphereCenter, CandidateForTesselation &CandidateLine, const class TesselPoint  * const ThirdNode, const double RADIUS, const LinkedCell *LC) const;
+    bool FindNextSuitableTriangle(CandidateForTesselation &CandidateLine, BoundaryTriangleSet &T, const double& RADIUS, const LinkedCell *LC);
     int CheckPresenceOfTriangle(class TesselPoint *Candidates[3]) const;
     class BoundaryTriangleSet * GetPresentTriangle(TesselPoint *Candidates[3]);
 …
     double PickFarthestofTwoBaselines(class BoundaryLineSet *Base);
     class BoundaryPointSet *IsConvexRectangle(class BoundaryLineSet *Base);
     map<int, int> * FindAllDegeneratedTriangles();
     map<int, int> * FindAllDegeneratedLines();
+    IndexToIndex * FindAllDegeneratedTriangles();
+    IndexToIndex * FindAllDegeneratedLines();
     void RemoveDegeneratedTriangles();
     void AddBoundaryPointByDegeneratedTriangle(class TesselPoint *point, LinkedCell *LC);
+    set<TesselPoint*> * GetAllConnectedPoints(const TesselPoint* const Point) const;
+    set<BoundaryTriangleSet*> *GetAllTriangles(const BoundaryPointSet * const Point) const;
+    list<list<TesselPoint*> *> * GetPathsOfConnectedPoints(const TesselPoint* const Point) const;
+    list<list<TesselPoint*> *> * GetClosedPathsOfConnectedPoints(const TesselPoint* const Point) const;
+    list<TesselPoint*> * GetCircleOfConnectedPoints(const TesselPoint* const Point, const Vector * const Reference = NULL) const;
+    class BoundaryPointSet *GetCommonEndpoint(const BoundaryLineSet * line1, const BoundaryLineSet * line2) const;
+    list<BoundaryTriangleSet*> *FindTriangles(const TesselPoint* const Points[3]) const;
+    list<BoundaryTriangleSet*> * FindClosestTrianglesToPoint(const Vector *x, const LinkedCell* LC) const;
+    class BoundaryTriangleSet * FindClosestTriangleToPoint(const Vector *x, const LinkedCell* LC) const;
+    int CorrectAllDegeneratedPolygons();
+    TesselPointSet * GetAllConnectedPoints(const TesselPoint* const Point) const;
+    TriangleSet * GetAllTriangles(const BoundaryPointSet * const Point) const;
+    ListOfTesselPointList * GetPathsOfConnectedPoints(const TesselPoint* const Point) const;
+    ListOfTesselPointList * GetClosedPathsOfConnectedPoints(const TesselPoint* const Point) const;
+    TesselPointList * GetCircleOfSetOfPoints(TesselPointSet *SetOfNeighbours, const TesselPoint* const Point, const Vector * const Reference = NULL) const;
+    TesselPointList * GetCircleOfConnectedTriangles(TesselPointSet *SetOfNeighbours, const TesselPoint* const Point, const Vector * const Reference) const;
+    class BoundaryPointSet * GetCommonEndpoint(const BoundaryLineSet * line1, const BoundaryLineSet * line2) const;
+    TriangleList * FindTriangles(const TesselPoint* const Points[3]) const;
+    TriangleList * FindClosestTrianglesToVector(const Vector *x, const LinkedCell* LC) const;
+    BoundaryTriangleSet * FindClosestTriangleToVector(const Vector *x, const LinkedCell* LC) const;
     bool IsInnerPoint(const Vector &Point, const LinkedCell* const LC) const;
+    bool IsInnerPoint(const TesselPoint * const Point, const LinkedCell* const LC) const;
+    double GetDistanceSquaredToTriangle(const Vector &Point, const BoundaryTriangleSet* const triangle) const;
+    double GetDistanceSquaredToSurface(const Vector &Point, const LinkedCell* const LC) const;
     bool AddBoundaryPoint(TesselPoint * Walker, const int n);
+    DistanceToPointMap * FindClosestBoundaryPointsToVector(const Vector *x, const LinkedCell* LC) const;
+    BoundaryLineSet * FindClosestBoundaryLineToVector(const Vector *x, const LinkedCell* LC) const;
     // print for debugging
 …
     PointMap PointsOnBoundary;
     LineMap LinesOnBoundary;
+    CandidateMap OpenLines;
     TriangleMap TrianglesOnBoundary;
     int PointsOnBoundaryCount;
 …
     mutable PointMap::const_iterator InternalPointer;
     bool HasOtherBaselineBetterCandidate(const BoundaryLineSet * const BaseRay, const TesselPoint * const OptCandidate, double ShortestAngle, double RADIUS, const LinkedCell * const LC) const;
+    //bool HasOtherBaselineBetterCandidate(const BoundaryLineSet * const BaseRay, const TesselPoint * const OptCandidate, double ShortestAngle, double RADIUS, const LinkedCell * const LC) const;
 };

TabularUnified src/tesselationhelpers.cpp ¶

-              r9fe36b
+              rb8d1aeb
 #include <fstream>
+#include "info.hpp"
 #include "linkedcell.hpp"
 #include "log.hpp"
 …
 #include "verbose.hpp"
+double DetGet(gsl_matrix * const A, const int inPlace) {
+double DetGet(gsl_matrix * const A, const int inPlace)
+{
+        Info FunctionInfo(__func__);
   /*
   inPlace = 1 => A is replaced with the LU decomposed copy.
 …
 void GetSphere(Vector * const center, const Vector &a, const Vector &b, const Vector &c, const double RADIUS)
+{
+        Info FunctionInfo(__func__);
   gsl_matrix *A = gsl_matrix_calloc(3,3);
   double m11, m12, m13, m14;
 …
     const double HalfplaneIndicator, const double AlternativeIndicator, const double alpha, const double beta, const double gamma, const double RADIUS, const double Umkreisradius)
+{
+        Info FunctionInfo(__func__);
   Vector TempNormal, helper;
   double Restradius;
   Vector OtherCenter;
-  Log() << Verbose(3) << "Begin of GetCenterOfSphere.\n";
   Center->Zero();
   helper.CopyVector(&a);
 …
   Center->Scale(1./(sin(2.*alpha) + sin(2.*beta) + sin(2.*gamma)));
   NewUmkreismittelpunkt->CopyVector(Center);
   Log() << Verbose(4) << "Center of new circumference is " << *NewUmkreismittelpunkt << ".\n";
+  Log() << Verbose(1) << "Center of new circumference is " << *NewUmkreismittelpunkt << ".\n";
   // Here we calculated center of circumscribing circle, using barycentric coordinates
   Log() << Verbose(4) << "Center of circumference is " << *Center << " in direction " << *Direction << ".\n";
+  Log() << Verbose(1) << "Center of circumference is " << *Center << " in direction " << *Direction << ".\n";
   TempNormal.CopyVector(&a);
 …
   if (fabs(HalfplaneIndicator) < MYEPSILON)
+    {
       if ((TempNormal.ScalarProduct(AlternativeDirection) <0 and AlternativeIndicator >0) or (TempNormal.ScalarProduct(AlternativeDirection) >0 and AlternativeIndicator <0))
+      if ((TempNormal.ScalarProduct(AlternativeDirection) <0 && AlternativeIndicator >0) || (TempNormal.ScalarProduct(AlternativeDirection) >0 && AlternativeIndicator <0))
+        {
           TempNormal.Scale(-1);
 …
   else
+    {
       if (TempNormal.ScalarProduct(Direction)<0 && HalfplaneIndicator >0 || TempNormal.ScalarProduct(Direction)>0 && HalfplaneIndicator<0)
+      if (((TempNormal.ScalarProduct(Direction)<0) && (HalfplaneIndicator >0)) || ((TempNormal.ScalarProduct(Direction)>0) && (HalfplaneIndicator<0)))
+        {
           TempNormal.Scale(-1);
 …
   TempNormal.Normalize();
   Restradius = sqrt(RADIUS*RADIUS - Umkreisradius*Umkreisradius);
   Log() << Verbose(4) << "Height of center of circumference to center of sphere is " << Restradius << ".\n";
+  Log() << Verbose(1) << "Height of center of circumference to center of sphere is " << Restradius << ".\n";
   TempNormal.Scale(Restradius);
   Log() << Verbose(4) << "Shift vector to sphere of circumference is " << TempNormal << ".\n";
+  Log() << Verbose(1) << "Shift vector to sphere of circumference is " << TempNormal << ".\n";
   Center->AddVector(&TempNormal);
   Log() << Verbose(0) << "Center of sphere of circumference is " << *Center << ".\n";
+  Log() << Verbose(1) << "Center of sphere of circumference is " << *Center << ".\n";
   GetSphere(&OtherCenter, a, b, c, RADIUS);
+  Log() << Verbose(0) << "OtherCenter of sphere of circumference is " << OtherCenter << ".\n";
+  Log() << Verbose(3) << "End of GetCenterOfSphere.\n";
+  Log() << Verbose(1) << "OtherCenter of sphere of circumference is " << OtherCenter << ".\n";
 };
 …
 void GetCenterofCircumcircle(Vector * const Center, const Vector &a, const Vector &b, const Vector &c)
+{
+        Info FunctionInfo(__func__);
   Vector helper;
   double alpha, beta, gamma;
 …
   beta = M_PI - SideC.Angle(&SideA);
   gamma = M_PI - SideA.Angle(&SideB);
   //Log() << Verbose(3) << "INFO: alpha = " << alpha/M_PI*180. << ", beta = " << beta/M_PI*180. << ", gamma = " << gamma/M_PI*180. << "." << endl;
+  //Log() << Verbose(1) << "INFO: alpha = " << alpha/M_PI*180. << ", beta = " << beta/M_PI*180. << ", gamma = " << gamma/M_PI*180. << "." << endl;
   if (fabs(M_PI - alpha - beta - gamma) > HULLEPSILON) {
     eLog() << Verbose(1) << "GetCenterofCircumcircle: Sum of angles " << (alpha+beta+gamma)/M_PI*180. << " > 180 degrees by " << fabs(M_PI - alpha - beta - gamma)/M_PI*180. << "!" << endl;
 …
 double GetPathLengthonCircumCircle(const Vector &CircleCenter, const Vector &CirclePlaneNormal, const double CircleRadius, const Vector &NewSphereCenter, const Vector &OldSphereCenter, const Vector &NormalVector, const Vector &SearchDirection)
+{
+        Info FunctionInfo(__func__);
   Vector helper;
   double radius, alpha;
+  helper.CopyVector(&NewSphereCenter);
+  Vector RelativeOldSphereCenter;
+  Vector RelativeNewSphereCenter;
+  RelativeOldSphereCenter.CopyVector(&OldSphereCenter);
+  RelativeOldSphereCenter.SubtractVector(&CircleCenter);
+  RelativeNewSphereCenter.CopyVector(&NewSphereCenter);
+  RelativeNewSphereCenter.SubtractVector(&CircleCenter);
+  helper.CopyVector(&RelativeNewSphereCenter);
   // test whether new center is on the parameter circle's plane
   if (fabs(helper.ScalarProduct(&CirclePlaneNormal)) > HULLEPSILON) {
 …
     helper.ProjectOntoPlane(&CirclePlaneNormal);
+  }
   radius = helper.ScalarProduct(&helper);
+  radius = helper.NormSquared();
   // test whether the new center vector has length of CircleRadius
   if (fabs(radius - CircleRadius) > HULLEPSILON)
     eLog() << Verbose(1) << "The projected center of the new sphere has radius " << radius << " instead of " << CircleRadius << "." << endl;
   alpha = helper.Angle(&OldSphereCenter);
+  alpha = helper.Angle(&RelativeOldSphereCenter);
   // make the angle unique by checking the halfplanes/search direction
   if (helper.ScalarProduct(&SearchDirection) < -HULLEPSILON)  // acos is not unique on [0, 2.*M_PI), hence extra check to decide between two half intervals
     alpha = 2.*M_PI - alpha;
   //Log() << Verbose(2) << "INFO: RelativeNewSphereCenter is " << helper << ", RelativeOldSphereCenter is " << OldSphereCenter << " and resulting angle is " << alpha << "." << endl;
   radius = helper.Distance(&OldSphereCenter);
+  Log() << Verbose(1) << "INFO: RelativeNewSphereCenter is " << helper << ", RelativeOldSphereCenter is " << RelativeOldSphereCenter << " and resulting angle is " << alpha << "." << endl;
+  radius = helper.Distance(&RelativeOldSphereCenter);
   helper.ProjectOntoPlane(&NormalVector);
   // check whether new center is somewhat away or at least right over the current baseline to prevent intersecting triangles
   if ((radius > HULLEPSILON) || (helper.Norm() < HULLEPSILON)) {
     //Log() << Verbose(2) << "INFO: Distance between old and new center is " << radius << " and between new center and baseline center is " << helper.Norm() << "." << endl;
+    Log() << Verbose(1) << "INFO: Distance between old and new center is " << radius << " and between new center and baseline center is " << helper.Norm() << "." << endl;
     return alpha;
   } else {
     //Log() << Verbose(1) << "INFO: NewSphereCenter " << helper << " is too close to OldSphereCenter" << OldSphereCenter << "." << endl;
+    Log() << Verbose(1) << "INFO: NewSphereCenter " << RelativeNewSphereCenter << " is too close to RelativeOldSphereCenter" << RelativeOldSphereCenter << "." << endl;
     return 2.*M_PI;
+  }
 …
 double MinIntersectDistance(const gsl_vector * x, void *params)
+{
+        Info FunctionInfo(__func__);
   double retval = 0;
   struct Intersection *I = (struct Intersection *)params;
 …
   retval = HeightA.ScalarProduct(&HeightA) + HeightB.ScalarProduct(&HeightB);
   //Log() << Verbose(2) << "MinIntersectDistance called, result: " << retval << endl;
+  //Log() << Verbose(1) << "MinIntersectDistance called, result: " << retval << endl;
   return retval;
 …
 bool existsIntersection(const Vector &point1, const Vector &point2, const Vector &point3, const Vector &point4)
+{
+        Info FunctionInfo(__func__);
   bool result;
 …
         if (status == GSL_SUCCESS) {
           Log() << Verbose(2) << "converged to minimum" <<  endl;
+          Log() << Verbose(1) << "converged to minimum" <<  endl;
+        }
     } while (status == GSL_CONTINUE && iter < 100);
 …
   t2 = HeightB.ScalarProduct(&SideB)/SideB.ScalarProduct(&SideB);
   Log() << Verbose(2) << "Intersection " << intersection << " is at "
+  Log() << Verbose(1) << "Intersection " << intersection << " is at "
     << t1 << " for (" << point1 << "," << point2 << ") and at "
     << t2 << " for (" << point3 << "," << point4 << "): ";
   if (((t1 >= 0) && (t1 <= 1)) && ((t2 >= 0) && (t2 <= 1))) {
     Log() << Verbose(0) << "true intersection." << endl;
+    Log() << Verbose(1) << "true intersection." << endl;
     result = true;
   } else {
     Log() << Verbose(0) << "intersection out of region of interest." << endl;
+    Log() << Verbose(1) << "intersection out of region of interest." << endl;
     result = false;
+  }
 …
 double GetAngle(const Vector &point, const Vector &reference, const Vector &OrthogonalVector)
+{
+        Info FunctionInfo(__func__);
   if (reference.IsZero())
     return M_PI;
 …
+  }
   Log() << Verbose(4) << "INFO: " << point << " has angle " << phi << " with respect to reference " << reference << "." << endl;
+  Log() << Verbose(1) << "INFO: " << point << " has angle " << phi << " with respect to reference " << reference << "." << endl;
   return phi;
 …
 double CalculateVolumeofGeneralTetraeder(const Vector &a, const Vector &b, const Vector &c, const Vector &d)
+{
+        Info FunctionInfo(__func__);
   Vector Point, TetraederVector[3];
   double volume;
 …
 bool CheckLineCriteriaForDegeneratedTriangle(const BoundaryPointSet * const nodes[3])
+{
+        Info FunctionInfo(__func__);
   bool result = false;
   int counter = 0;
 …
+    }
   if ((!result) && (counter > 1)) {
     Log() << Verbose(2) << "INFO: Degenerate triangle is ok, at least two, here " << counter << ", existing lines are used." << endl;
+    Log() << Verbose(1) << "INFO: Degenerate triangle is ok, at least two, here " << counter << ", existing lines are used." << endl;
     result = true;
+  }
 …
+/** Sort function for the candidate list.
+ */
+bool SortCandidates(const CandidateForTesselation* candidate1, const CandidateForTesselation* candidate2)
+{
+  Vector BaseLineVector, OrthogonalVector, helper;
+  if (candidate1->BaseLine != candidate2->BaseLine) {  // sanity check
+    eLog() << Verbose(1) << "sortCandidates was called for two different baselines: " << candidate1->BaseLine << " and " << candidate2->BaseLine << "." << endl;
+    //return false;
+    exit(1);
+  }
+  // create baseline vector
+  BaseLineVector.CopyVector(candidate1->BaseLine->endpoints[1]->node->node);
+  BaseLineVector.SubtractVector(candidate1->BaseLine->endpoints[0]->node->node);
+  BaseLineVector.Normalize();
+  // create normal in-plane vector to cope with acos() non-uniqueness on [0,2pi] (note that is pointing in the "right" direction already, hence ">0" test!)
+  helper.CopyVector(candidate1->BaseLine->endpoints[0]->node->node);
+  helper.SubtractVector(candidate1->point->node);
+  OrthogonalVector.CopyVector(&helper);
+  helper.VectorProduct(&BaseLineVector);
+  OrthogonalVector.SubtractVector(&helper);
+  OrthogonalVector.Normalize();
+  // calculate both angles and correct with in-plane vector
+  helper.CopyVector(candidate1->point->node);
+  helper.SubtractVector(candidate1->BaseLine->endpoints[0]->node->node);
+  double phi = BaseLineVector.Angle(&helper);
+  if (OrthogonalVector.ScalarProduct(&helper) > 0) {
+    phi = 2.*M_PI - phi;
+  }
+  helper.CopyVector(candidate2->point->node);
+  helper.SubtractVector(candidate1->BaseLine->endpoints[0]->node->node);
+  double psi = BaseLineVector.Angle(&helper);
+  if (OrthogonalVector.ScalarProduct(&helper) > 0) {
+    psi = 2.*M_PI - psi;
+  }
+  Log() << Verbose(2) << *candidate1->point << " has angle " << phi << endl;
+  Log() << Verbose(2) << *candidate2->point << " has angle " << psi << endl;
+  // return comparison
+  return phi < psi;
+};
+///** Sort function for the candidate list.
+// */
+//bool SortCandidates(const CandidateForTesselation* candidate1, const CandidateForTesselation* candidate2)
+//{
+//      Info FunctionInfo(__func__);
+//  Vector BaseLineVector, OrthogonalVector, helper;
+//  if (candidate1->BaseLine != candidate2->BaseLine) {  // sanity check
+//    eLog() << Verbose(1) << "sortCandidates was called for two different baselines: " << candidate1->BaseLine << " and " << candidate2->BaseLine << "." << endl;
+//    //return false;
+//    exit(1);
+//  }
+//  // create baseline vector
+//  BaseLineVector.CopyVector(candidate1->BaseLine->endpoints[1]->node->node);
+//  BaseLineVector.SubtractVector(candidate1->BaseLine->endpoints[0]->node->node);
+//  BaseLineVector.Normalize();
+//
+//  // create normal in-plane vector to cope with acos() non-uniqueness on [0,2pi] (note that is pointing in the "right" direction already, hence ">0" test!)
+//  helper.CopyVector(candidate1->BaseLine->endpoints[0]->node->node);
+//  helper.SubtractVector(candidate1->point->node);
+//  OrthogonalVector.CopyVector(&helper);
+//  helper.VectorProduct(&BaseLineVector);
+//  OrthogonalVector.SubtractVector(&helper);
+//  OrthogonalVector.Normalize();
+//
+//  // calculate both angles and correct with in-plane vector
+//  helper.CopyVector(candidate1->point->node);
+//  helper.SubtractVector(candidate1->BaseLine->endpoints[0]->node->node);
+//  double phi = BaseLineVector.Angle(&helper);
+//  if (OrthogonalVector.ScalarProduct(&helper) > 0) {
+//    phi = 2.*M_PI - phi;
+//  }
+//  helper.CopyVector(candidate2->point->node);
+//  helper.SubtractVector(candidate1->BaseLine->endpoints[0]->node->node);
+//  double psi = BaseLineVector.Angle(&helper);
+//  if (OrthogonalVector.ScalarProduct(&helper) > 0) {
+//    psi = 2.*M_PI - psi;
+//  }
+//
+//  Log() << Verbose(1) << *candidate1->point << " has angle " << phi << endl;
+//  Log() << Verbose(1) << *candidate2->point << " has angle " << psi << endl;
+//
+//  // return comparison
+//  return phi < psi;
+//};
 /**
 …
  * @return point which is second closest to the provided one
  */
+TesselPoint* FindSecondClosestPoint(const Vector* Point, const LinkedCell* const LC)
+{
+TesselPoint* FindSecondClosestTesselPoint(const Vector* Point, const LinkedCell* const LC)
+{
+        Info FunctionInfo(__func__);
   TesselPoint* closestPoint = NULL;
   TesselPoint* secondClosestPoint = NULL;
 …
   for(int i=0;i<NDIM;i++) // store indices of this cell
     N[i] = LC->n[i];
   Log() << Verbose(2) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
+  Log() << Verbose(1) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
   LC->GetNeighbourBounds(Nlower, Nupper);
   //Log() << Verbose(0) << endl;
+  //Log() << Verbose(1) << endl;
   for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
     for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
       for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
         const LinkedNodes *List = LC->GetCurrentCell();
         //Log() << Verbose(3) << "The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << endl;
+        //Log() << Verbose(1) << "The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << endl;
         if (List != NULL) {
           for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
 …
  * @return point which is closest to the provided one, NULL if none found
  */
+TesselPoint* FindClosestPoint(const Vector* Point, TesselPoint *&SecondPoint, const LinkedCell* const LC)
+{
+TesselPoint* FindClosestTesselPoint(const Vector* Point, TesselPoint *&SecondPoint, const LinkedCell* const LC)
+{
+        Info FunctionInfo(__func__);
   TesselPoint* closestPoint = NULL;
   SecondPoint = NULL;
 …
   for(int i=0;i<NDIM;i++) // store indices of this cell
     N[i] = LC->n[i];
   Log() << Verbose(3) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
+  Log() << Verbose(1) << "INFO: Center cell is " << N[0] << ", " << N[1] << ", " << N[2] << " with No. " << LC->index << "." << endl;
   LC->GetNeighbourBounds(Nlower, Nupper);
   //Log() << Verbose(0) << endl;
+  //Log() << Verbose(1) << endl;
   for (LC->n[0] = Nlower[0]; LC->n[0] <= Nupper[0]; LC->n[0]++)
     for (LC->n[1] = Nlower[1]; LC->n[1] <= Nupper[1]; LC->n[1]++)
       for (LC->n[2] = Nlower[2]; LC->n[2] <= Nupper[2]; LC->n[2]++) {
         const LinkedNodes *List = LC->GetCurrentCell();
         //Log() << Verbose(3) << "The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << endl;
+        //Log() << Verbose(1) << "The current cell " << LC->n[0] << "," << LC->n[1] << "," << LC->n[2] << endl;
         if (List != NULL) {
           for (LinkedNodes::const_iterator Runner = List->begin(); Runner != List->end(); Runner++) {
             helper.CopyVector(Point);
             helper.SubtractVector((*Runner)->node);
             double currentNorm = helper. Norm();
+            double currentNorm = helper.NormSquared();
             if (currentNorm < distance) {
               secondDistance = distance;
 …
               distance = currentNorm;
               closestPoint = (*Runner);
               //Log() << Verbose(2) << "INFO: New Nearest Neighbour is " << *closestPoint << "." << endl;
+              //Log() << Verbose(1) << "INFO: New Nearest Neighbour is " << *closestPoint << "." << endl;
             } else if (currentNorm < secondDistance) {
               secondDistance = currentNorm;
               SecondPoint = (*Runner);
               //Log() << Verbose(2) << "INFO: New Second Nearest Neighbour is " << *SecondPoint << "." << endl;
+              //Log() << Verbose(1) << "INFO: New Second Nearest Neighbour is " << *SecondPoint << "." << endl;
+            }
+          }
 …
   // output
   if (closestPoint != NULL) {
     Log() << Verbose(2) << "Closest point is " << *closestPoint;
+    Log() << Verbose(1) << "Closest point is " << *closestPoint;
     if (SecondPoint != NULL)
       Log() << Verbose(0) << " and second closest is " << *SecondPoint;
 …
 Vector * GetClosestPointBetweenLine(const BoundaryLineSet * const Base, const BoundaryLineSet * const OtherBase)
+{
+        Info FunctionInfo(__func__);
   // construct the plane of the two baselines (i.e. take both their directional vectors)
   Vector Normal;
 …
   Normal.VectorProduct(&OtherBaseline);
   Normal.Normalize();
   Log() << Verbose(4) << "First direction is " << Baseline << ", second direction is " << OtherBaseline << ", normal of intersection plane is " << Normal << "." << endl;
+  Log() << Verbose(1) << "First direction is " << Baseline << ", second direction is " << OtherBaseline << ", normal of intersection plane is " << Normal << "." << endl;
   // project one offset point of OtherBase onto this plane (and add plane offset vector)
 …
   Normal.CopyVector(Intersection);
   Normal.SubtractVector(Base->endpoints[0]->node->node);
   Log() << Verbose(3) << "Found closest point on " << *Base << " at " << *Intersection << ", factor in line is " << fabs(Normal.ScalarProduct(&Baseline)/Baseline.NormSquared()) << "." << endl;
+  Log() << Verbose(1) << "Found closest point on " << *Base << " at " << *Intersection << ", factor in line is " << fabs(Normal.ScalarProduct(&Baseline)/Baseline.NormSquared()) << "." << endl;
   return Intersection;
 …
 double DistanceToTrianglePlane(const Vector *x, const BoundaryTriangleSet * const triangle)
+{
+        Info FunctionInfo(__func__);
   double distance = 0.;
   if (x == NULL) {
 …
 void WriteVrmlFile(ofstream * const vrmlfile, const Tesselation * const Tess, const PointCloud * const cloud)
+{
+        Info FunctionInfo(__func__);
   TesselPoint *Walker = NULL;
   int i;
 …
 void IncludeSphereinRaster3D(ofstream * const rasterfile, const Tesselation * const Tess, const PointCloud * const cloud)
+{
+        Info FunctionInfo(__func__);
   Vector helper;
+  // include the current position of the virtual sphere in the temporary raster3d file
+  Vector *center = cloud->GetCenter();
+  // make the circumsphere's center absolute again
+  helper.CopyVector(Tess->LastTriangle->endpoints[0]->node->node);
+  helper.AddVector(Tess->LastTriangle->endpoints[1]->node->node);
+  helper.AddVector(Tess->LastTriangle->endpoints[2]->node->node);
+  helper.Scale(1./3.);
+  helper.SubtractVector(center);
+  // and add to file plus translucency object
+  *rasterfile << "# current virtual sphere\n";
+  *rasterfile << "8\n  25.0    0.6     -1.0 -1.0 -1.0     0.2        0 0 0 0\n";
+  *rasterfile << "2\n  " << helper.x[0] << " " << helper.x[1] << " " << helper.x[2] << "\t" << 5. << "\t1 0 0\n";
+  *rasterfile << "9\n  terminating special property\n";
+  delete(center);
+  if (Tess->LastTriangle != NULL) {
+    // include the current position of the virtual sphere in the temporary raster3d file
+    Vector *center = cloud->GetCenter();
+    // make the circumsphere's center absolute again
+    helper.CopyVector(Tess->LastTriangle->endpoints[0]->node->node);
+    helper.AddVector(Tess->LastTriangle->endpoints[1]->node->node);
+    helper.AddVector(Tess->LastTriangle->endpoints[2]->node->node);
+    helper.Scale(1./3.);
+    helper.SubtractVector(center);
+    // and add to file plus translucency object
+    *rasterfile << "# current virtual sphere\n";
+    *rasterfile << "8\n  25.0    0.6     -1.0 -1.0 -1.0     0.2        0 0 0 0\n";
+    *rasterfile << "2\n  " << helper.x[0] << " " << helper.x[1] << " " << helper.x[2] << "\t" << 5. << "\t1 0 0\n";
+    *rasterfile << "9\n  terminating special property\n";
+    delete(center);
+  }
 };
 …
 void WriteRaster3dFile(ofstream * const rasterfile, const Tesselation * const Tess, const PointCloud * const cloud)
+{
+        Info FunctionInfo(__func__);
   TesselPoint *Walker = NULL;
   int i;
 …
 void WriteTecplotFile(ofstream * const tecplot, const Tesselation * const TesselStruct, const PointCloud * const cloud, const int N)
+{
+        Info FunctionInfo(__func__);
   if ((tecplot != NULL) && (TesselStruct != NULL)) {
     // write header
     *tecplot << "TITLE = \"3D CONVEX SHELL\"" << endl;
     *tecplot << "VARIABLES = \"X\" \"Y\" \"Z\" \"U\"" << endl;
+    *tecplot << "ZONE T=\"" << N << "-";
+    for (int i=0;i<3;i++)
+      *tecplot << (i==0 ? "" : "_") << TesselStruct->LastTriangle->endpoints[i]->node->Name;
+    *tecplot << "ZONE T=\"";
+    if (N < 0) {
+      *tecplot << cloud->GetName();
+    } else {
+      *tecplot << N << "-";
+      for (int i=0;i<3;i++)
+        *tecplot << (i==0 ? "" : "_") << TesselStruct->LastTriangle->endpoints[i]->node->Name;
+    }
     *tecplot << "\", N=" << TesselStruct->PointsOnBoundary.size() << ", E=" << TesselStruct->TrianglesOnBoundary.size() << ", DATAPACKING=POINT, ZONETYPE=FETRIANGLE" << endl;
+    int i=0;
+    for (cloud->GoToFirst(); !cloud->IsEnd(); cloud->GoToNext(), i++);
+    int i=cloud->GetMaxId();
     int *LookupList = new int[i];
     for (cloud->GoToFirst(), i=0; !cloud->IsEnd(); cloud->GoToNext(), i++)
 …
     // print atom coordinates
-    Log() << Verbose(2) << "The following triangles were created:";
     int Counter = 1;
     TesselPoint *Walker = NULL;
 …
     *tecplot << endl;
     // print connectivity
+    Log() << Verbose(1) << "The following triangles were created:" << endl;
     for (TriangleMap::const_iterator runner = TesselStruct->TrianglesOnBoundary.begin(); runner != TesselStruct->TrianglesOnBoundary.end(); runner++) {
       Log() << Verbose(0) << " " << runner->second->endpoints[0]->node->Name << "<->" << runner->second->endpoints[1]->node->Name << "<->" << runner->second->endpoints[2]->node->Name;
+      Log() << Verbose(1) << " " << runner->second->endpoints[0]->node->Name << "<->" << runner->second->endpoints[1]->node->Name << "<->" << runner->second->endpoints[2]->node->Name << endl;
       *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);
-    Log() << Verbose(0) << endl;
+  }
 };
 …
 void CalculateConcavityPerBoundaryPoint(const Tesselation * const TesselStruct)
+{
+        Info FunctionInfo(__func__);
   class BoundaryPointSet *point = NULL;
   class BoundaryLineSet *line = NULL;
-  //Log() << Verbose(2) << "Begin of CalculateConcavityPerBoundaryPoint" << endl;
   // calculate remaining concavity
   for (PointMap::const_iterator PointRunner = TesselStruct->PointsOnBoundary.begin(); PointRunner != TesselStruct->PointsOnBoundary.end(); PointRunner++) {
 …
     for (LineMap::iterator LineRunner = point->lines.begin(); LineRunner != point->lines.end(); LineRunner++) {
       line = LineRunner->second;
       //Log() << Verbose(2) << "INFO: Current line of point " << *point << " is " << *line << "." << endl;
+      //Log() << Verbose(1) << "INFO: Current line of point " << *point << " is " << *line << "." << endl;
       if (!line->CheckConvexityCriterion())
         point->value += 1;
+    }
+  }
-  //Log() << Verbose(2) << "End of CalculateConcavityPerBoundaryPoint" << endl;
 };
 …
 bool CheckListOfBaselines(const Tesselation * const TesselStruct)
+{
+        Info FunctionInfo(__func__);
   LineMap::const_iterator testline;
   bool result = false;
 …
   for (testline = TesselStruct->LinesOnBoundary.begin(); testline != TesselStruct->LinesOnBoundary.end(); testline++) {
     if (testline->second->triangles.size() != 2) {
       Log() << Verbose(1) << *testline->second << "\t" << testline->second->triangles.size() << endl;
+      Log() << Verbose(2) << *testline->second << "\t" << testline->second->triangles.size() << endl;
       counter++;
+    }
 …
+}
+/** Counts the number of triangle pairs that contain the given polygon.
+ * \param *P polygon with endpoints to look for
+ * \param *T set of triangles to create pairs from containing \a *P
+ */
+int CountTrianglePairContainingPolygon(const BoundaryPolygonSet * const P, const TriangleSet * const T)
+{
+  Info FunctionInfo(__func__);
+  // check number of endpoints in *P
+  if (P->endpoints.size() != 4) {
+    eLog() << Verbose(1) << "CountTrianglePairContainingPolygon works only on polygons with 4 nodes!" << endl;
+    return 0;
+  }
+  // check number of triangles in *T
+  if (T->size() < 2) {
+    eLog() << Verbose(1) << "Not enough triangles to have pairs!" << endl;
+    return 0;
+  }
+  Log() << Verbose(0) << "Polygon is " << *P << endl;
+  // create each pair, get the endpoints and check whether *P is contained.
+  int counter = 0;
+  PointSet Trianglenodes;
+  class BoundaryPolygonSet PairTrianglenodes;
+  for(TriangleSet::iterator Walker = T->begin(); Walker != T->end(); Walker++) {
+    for (int i=0;i<3;i++)
+      Trianglenodes.insert((*Walker)->endpoints[i]);
+    for(TriangleSet::iterator PairWalker = Walker; PairWalker != T->end(); PairWalker++) {
+      if (Walker != PairWalker) { // skip first
+        PairTrianglenodes.endpoints = Trianglenodes;
+        for (int i=0;i<3;i++)
+          PairTrianglenodes.endpoints.insert((*PairWalker)->endpoints[i]);
+        const int size = PairTrianglenodes.endpoints.size();
+        if (size == 4) {
+          Log() << Verbose(0) << " Current pair of triangles: " << **Walker << "," << **PairWalker << " with " << size << " distinct endpoints:" << PairTrianglenodes << endl;
+          // now check
+          if (PairTrianglenodes.ContainsPresentTupel(P)) {
+            counter++;
+            Log() << Verbose(0) << "  ACCEPT: Matches with " << *P << endl;
+          } else {
+            Log() << Verbose(0) << "  REJECT: No match with " << *P << endl;
+          }
+        } else {
+          Log() << Verbose(0) << "  REJECT: Less than four endpoints." << endl;
+        }
+      }
+    }
+    Trianglenodes.clear();
+  }
+  return counter;
+};
+/** Checks whether two give polygons have two or more points in common.
+ * \param *P1 first polygon
+ * \param *P2 second polygon
+ * \return true - are connected, false = are note
+ */
+bool ArePolygonsEdgeConnected(const BoundaryPolygonSet * const P1, const BoundaryPolygonSet * const P2)
+{
+  Info FunctionInfo(__func__);
+  int counter = 0;
+  for(PointSet::const_iterator Runner = P1->endpoints.begin(); Runner != P1->endpoints.end(); Runner++) {
+    if (P2->ContainsBoundaryPoint((*Runner))) {
+      counter++;
+      Log() << Verbose(1) << *(*Runner) << " of second polygon is found in the first one." << endl;
+      return true;
+    }
+  }
+  return false;
+};
+/** Combines second into the first and deletes the second.
+ * \param *P1 first polygon, contains all nodes on return
+ * \param *&P2 second polygon, is deleted.
+ */
+void CombinePolygons(BoundaryPolygonSet * const P1, BoundaryPolygonSet * &P2)
+{
+  Info FunctionInfo(__func__);
+  pair <PointSet::iterator, bool> Tester;
+  for(PointSet::iterator Runner = P2->endpoints.begin(); Runner != P2->endpoints.end(); Runner++) {
+    Tester = P1->endpoints.insert((*Runner));
+    if (Tester.second)
+      Log() << Verbose(0) << "Inserting endpoint " << *(*Runner) << " into first polygon." << endl;
+  }
+  P2->endpoints.clear();
+  delete(P2);
+};

TabularUnified src/tesselationhelpers.hpp ¶

-              r9fe36b
+              rb8d1aeb
 bool CheckLineCriteriaForDegeneratedTriangle(const BoundaryPointSet * const nodes[3]);
 bool SortCandidates(const CandidateForTesselation* candidate1, const CandidateForTesselation *candidate2);
 TesselPoint* FindClosestPoint(const Vector* Point, TesselPoint *&SecondPoint, const LinkedCell* const LC);
 TesselPoint* FindSecondClosestPoint(const Vector*, const LinkedCell* const LC);
+TesselPoint* FindClosestTesselPoint(const Vector* Point, TesselPoint *&SecondPoint, const LinkedCell* const LC);
+TesselPoint* FindSecondClosestTesselPoint(const Vector*, const LinkedCell* const LC);
 Vector * GetClosestPointBetweenLine(const BoundaryLineSet * const Base, const BoundaryLineSet * const OtherBase);
 …
 bool CheckListOfBaselines(const Tesselation * const TesselStruct);
+int CountTrianglePairContainingPolygon(const BoundaryPolygonSet * const P, const TriangleSet * const T);
+bool ArePolygonsEdgeConnected(const BoundaryPolygonSet * const P1, const BoundaryPolygonSet * const P2);
+void CombinePolygons(BoundaryPolygonSet * const P1, BoundaryPolygonSet * &P2);
 #endif /* TESSELATIONHELPERS_HPP_ */

TabularUnified src/unittests/AnalysisCorrelationToPointUnitTest.cpp ¶

r9fe36b	rb8d1aeb
11	11	#include <cppunit/extensions/TestFactoryRegistry.h>
12	12	#include <cppunit/ui/text/TestRunner.h>
	13
	14	#include <cstring>
13	15
14	16	#include "analysis_correlation.hpp"

TabularUnified src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp ¶

r9fe36b	rb8d1aeb
11	11	#include <cppunit/extensions/TestFactoryRegistry.h>
12	12	#include <cppunit/ui/text/TestRunner.h>
	13
	14	#include <cstring>
13	15
14	16	#include "analysis_correlation.hpp"

TabularUnified src/unittests/AnalysisPairCorrelationUnitTest.cpp ¶

r9fe36b	rb8d1aeb
11	11	#include <cppunit/extensions/TestFactoryRegistry.h>
12	12	#include <cppunit/ui/text/TestRunner.h>
	13
	14	#include <cstring>
13	15
14	16	#include "analysis_correlation.hpp"

TabularUnified src/unittests/Makefile.am ¶

-              r9fe36b
+              rb8d1aeb
 MENUTESTS = ActionSequenceTest
+TESTS = ActOnAllUnitTest AnalysisBondsUnitTests AnalysisCorrelationToPointUnitTest AnalysisCorrelationToSurfaceUnitTest AnalysisPairCorrelationUnitTest BondGraphUnitTest ListOfBondsUnitTest LogUnitTest MemoryUsageObserverUnitTest MemoryAllocatorUnitTest StackClassUnitTest VectorUnitTest ObserverTest $(MENUTESTS)
+TESTS = \
+  ActOnAllUnitTest \
+  AnalysisBondsUnitTests \
+  AnalysisCorrelationToPointUnitTest \
+  AnalysisCorrelationToSurfaceUnitTest \
+  AnalysisPairCorrelationUnitTest \
+  BondGraphUnitTest \
+  GSLMatrixSymmetricUnitTest \
+  GSLMatrixUnitTest \
+  GSLVectorUnitTest \
+  InfoUnitTest \
+  LinearSystemOfEquationsUnitTest \
+  ListOfBondsUnitTest \
+  LogUnitTest \
+  MemoryUsageObserverUnitTest \
+  MemoryAllocatorUnitTest \
+  StackClassUnitTest \
+  TesselationUnitTest \
+  Tesselation_BoundaryTriangleUnitTest \
+  Tesselation_InOutsideUnitTest \
+  VectorUnitTest \
+  ObserverTest \
+  ${MENUTESTS}
 check_PROGRAMS = $(TESTS)
 noinst_PROGRAMS = $(TESTS)
 ActOnAllUnitTest_SOURCES = ../test/ActOnAllTest.hpp ActOnAllUnitTest.cpp ActOnAllUnitTest.hpp
 ActOnAllUnitTest_LDADD = ../libmolecuilder.a
+ActOnAllUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
 AnalysisBondsUnitTests_SOURCES = analysisbondsunittest.cpp analysisbondsunittest.hpp
 AnalysisBondsUnitTests_LDADD = ../libmolecuilder.a
+AnalysisBondsUnitTests_LDADD = ../libmolecuilder.a ../libgslwrapper.a
 AnalysisCorrelationToPointUnitTest_SOURCES = analysis_correlation.hpp AnalysisCorrelationToPointUnitTest.cpp AnalysisCorrelationToPointUnitTest.hpp
 AnalysisCorrelationToPointUnitTest_LDADD = ../libmolecuilder.a
+AnalysisCorrelationToPointUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
 AnalysisCorrelationToSurfaceUnitTest_SOURCES = analysis_correlation.hpp AnalysisCorrelationToSurfaceUnitTest.cpp AnalysisCorrelationToSurfaceUnitTest.hpp
 AnalysisCorrelationToSurfaceUnitTest_LDADD = ../libmolecuilder.a
+AnalysisCorrelationToSurfaceUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
 AnalysisPairCorrelationUnitTest_SOURCES = analysis_correlation.hpp AnalysisPairCorrelationUnitTest.cpp AnalysisPairCorrelationUnitTest.hpp
 AnalysisPairCorrelationUnitTest_LDADD = ../libmolecuilder.a
+AnalysisPairCorrelationUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
 BondGraphUnitTest_SOURCES = bondgraphunittest.cpp bondgraphunittest.hpp
+BondGraphUnitTest_LDADD = ../libmolecuilder.a
+BondGraphUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+GSLMatrixSymmetricUnitTest_SOURCES = gslmatrixsymmetricunittest.cpp gslmatrixsymmetricunittest.hpp
+GSLMatrixSymmetricUnitTest_LDADD = ../libgslwrapper.a
+GSLMatrixUnitTest_SOURCES = gslmatrixunittest.cpp gslmatrixunittest.hpp
+GSLMatrixUnitTest_LDADD = ../libgslwrapper.a
+GSLVectorUnitTest_SOURCES = gslvectorunittest.cpp gslvectorunittest.hpp
+GSLVectorUnitTest_LDADD = ../libgslwrapper.a
+InfoUnitTest_SOURCES = infounittest.cpp infounittest.hpp
+InfoUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+LinearSystemOfEquationsUnitTest_SOURCES = linearsystemofequationsunittest.cpp linearsystemofequationsunittest.hpp
+LinearSystemOfEquationsUnitTest_LDADD = ../libgslwrapper.a ../libmolecuilder.a
 ListOfBondsUnitTest_SOURCES = listofbondsunittest.cpp listofbondsunittest.hpp
 ListOfBondsUnitTest_LDADD = ../libmolecuilder.a
+ListOfBondsUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
 LogUnitTest_SOURCES = logunittest.cpp logunittest.hpp
 LogUnitTest_LDADD = ../libmolecuilder.a
+LogUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
 MemoryAllocatorUnitTest_SOURCES = memoryallocatorunittest.cpp memoryallocatorunittest.hpp
 MemoryAllocatorUnitTest_LDADD = ../libmolecuilder.a
+MemoryAllocatorUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
 MemoryUsageObserverUnitTest_SOURCES = memoryusageobserverunittest.cpp memoryusageobserverunittest.hpp
 MemoryUsageObserverUnitTest_LDADD = ../libmolecuilder.a
+MemoryUsageObserverUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
 StackClassUnitTest_SOURCES = stackclassunittest.cpp stackclassunittest.hpp
+StackClassUnitTest_LDADD = ../libmolecuilder.a
+StackClassUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+TesselationUnitTest_SOURCES = tesselationunittest.cpp tesselationunittest.hpp
+TesselationUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+Tesselation_BoundaryTriangleUnitTest_SOURCES = tesselation_boundarytriangleunittest.cpp tesselation_boundarytriangleunittest.hpp
+Tesselation_BoundaryTriangleUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
+Tesselation_InOutsideUnitTest_SOURCES = tesselation_insideoutsideunittest.cpp tesselation_insideoutsideunittest.hpp
+Tesselation_InOutsideUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
 VectorUnitTest_SOURCES = vectorunittest.cpp vectorunittest.hpp
 VectorUnitTest_LDADD = ../libmolecuilder.a
+VectorUnitTest_LDADD = ../libmolecuilder.a ../libgslwrapper.a
 ActionSequenceTest_SOURCES = ActionSequenceTest.cpp ActionSequenceTest.hpp

TabularUnified src/unittests/analysisbondsunittest.cpp ¶

r9fe36b	rb8d1aeb
14	14	#include <iostream>
15	15	#include <stdio.h>
	16	#include <cstring>
16	17
17	18	#include "analysis_bonds.hpp"

TabularUnified src/unittests/bondgraphunittest.cpp ¶

r9fe36b	rb8d1aeb
14	14	#include <iostream>
15	15	#include <stdio.h>
	16	#include <cstring>
16	17
17	18	#include "atom.hpp"

TabularUnified src/unittests/listofbondsunittest.cpp ¶

r9fe36b	rb8d1aeb
11	11	#include <cppunit/extensions/TestFactoryRegistry.h>
12	12	#include <cppunit/ui/text/TestRunner.h>
	13
	14	#include <cstring>
13	15
14	16	#include "listofbondsunittest.hpp"

TabularUnified src/unittests/tesselationunittest.cpp ¶

-              r9fe36b
+              rb8d1aeb
 #include <cppunit/extensions/TestFactoryRegistry.h>
 #include <cppunit/ui/text/TestRunner.h>
+#include <cstring>
 #include "defs.hpp"
 …
   class TesselPoint *Walker;
   Walker = new TesselPoint;
   Walker->node = new Vector(1., 0., 0.);
   Walker->Name = new char[3];
+  Walker->node = new Vector(1., 0., -1.);
+  Walker->Name = Malloc<char>(3, "TesselationTest::setUp");
   strcpy(Walker->Name, "1");
   Walker->nr = 1;
   Corners.push_back(Walker);
   Walker = new TesselPoint;
   Walker->node = new Vector(-1., 1., 0.);
   Walker->Name = new char[3];
+  Walker->node = new Vector(-1., 1., -1.);
+  Walker->Name = Malloc<char>(3, "TesselationTest::setUp");
   strcpy(Walker->Name, "2");
   Walker->nr = 2;
   Corners.push_back(Walker);
   Walker = new TesselPoint;
   Walker->node = new Vector(-1., -1., 0.);
   Walker->Name = new char[3];
+  Walker->node = new Vector(-1., -1., -1.);
+  Walker->Name = Malloc<char>(3, "TesselationTest::setUp");
   strcpy(Walker->Name, "3");
   Walker->nr = 3;
 …
   Walker = new TesselPoint;
   Walker->node = new Vector(-1., 0., 1.);
   Walker->Name = new char[3];
+  Walker->Name = Malloc<char>(3, "TesselationTest::setUp");
   strcpy(Walker->Name, "4");
   Walker->nr = 4;
 …
   // create tesselation
   TesselStruct = new Tesselation;
   TesselStruct->PointsOnBoundary.clear();
   TesselStruct->LinesOnBoundary.clear();
   TesselStruct->TrianglesOnBoundary.clear();
+  CPPUNIT_ASSERT_EQUAL( true, TesselStruct->PointsOnBoundary.empty() );
+  CPPUNIT_ASSERT_EQUAL( true, TesselStruct->LinesOnBoundary.empty() );
+  CPPUNIT_ASSERT_EQUAL( true, TesselStruct->TrianglesOnBoundary.empty() );
   TesselStruct->FindStartingTriangle(SPHERERADIUS, LinkedList);
-  bool flag = false;
+  LineMap::iterator baseline = TesselStruct->LinesOnBoundary.begin();
+  while (baseline != TesselStruct->LinesOnBoundary.end()) {
+    if (baseline->second->triangles.size() == 1) {
+      flag = TesselStruct->FindNextSuitableTriangle(*(baseline->second), *(((baseline->second->triangles.begin()))->second), SPHERERADIUS, LinkedList); //the line is there, so there is a triangle, but only one.
+  CandidateForTesselation *baseline = NULL;
+  BoundaryTriangleSet *T = NULL;
+  bool OneLoopWithoutSuccessFlag = true;
+  bool TesselationFailFlag = false;
+  while ((!TesselStruct->OpenLines.empty()) && (OneLoopWithoutSuccessFlag)) {
+    // 2a. fill all new OpenLines
+    for (CandidateMap::iterator Runner = TesselStruct->OpenLines.begin(); Runner != TesselStruct->OpenLines.end(); Runner++) {
+      baseline = Runner->second;
+      if (baseline->pointlist.empty()) {
+        T = (((baseline->BaseLine->triangles.begin()))->second);
+        TesselationFailFlag = TesselStruct->FindNextSuitableTriangle(*baseline, *T, SPHERERADIUS, LinkedList); //the line is there, so there is a triangle, but only one.
+      }
+    }
+    baseline++;
+    if ((baseline == TesselStruct->LinesOnBoundary.end()) && (flag)) {
+      baseline = TesselStruct->LinesOnBoundary.begin();   // restart if we reach end due to newly inserted lines
+      flag = false;
+    // 2b. search for smallest ShortestAngle among all candidates
+    double ShortestAngle = 4.*M_PI;
+    for (CandidateMap::iterator Runner = TesselStruct->OpenLines.begin(); Runner != TesselStruct->OpenLines.end(); Runner++) {
+      if (Runner->second->ShortestAngle < ShortestAngle) {
+        baseline = Runner->second;
+        ShortestAngle = baseline->ShortestAngle;
+      }
+    }
+    if ((ShortestAngle == 4.*M_PI) || (baseline->pointlist.empty()))
+      OneLoopWithoutSuccessFlag = false;
+    else {
+      TesselStruct->AddCandidateTriangle(*baseline);
+    }
+  }
 …
   delete(TesselStruct);
   for (LinkedNodes::iterator Runner = Corners.begin(); Runner != Corners.end(); Runner++) {
-    delete[]((*Runner)->Name);
     delete((*Runner)->node);
     delete(*Runner);
+  }
   Corners.clear();
+};
+/** UnitTest for Tesselation::IsInnerPoint()
+ */
+void TesselationTest::IsInnerPointTest()
+{
+  // true inside points
+  CPPUNIT_ASSERT_EQUAL( true, TesselStruct->IsInnerPoint(Vector(0.,0.,0.), LinkedList) );
+  CPPUNIT_ASSERT_EQUAL( true, TesselStruct->IsInnerPoint(Vector(0.5,0.,0.), LinkedList) );
+  CPPUNIT_ASSERT_EQUAL( true, TesselStruct->IsInnerPoint(Vector(0.,0.5,0.), LinkedList) );
+  CPPUNIT_ASSERT_EQUAL( true, TesselStruct->IsInnerPoint(Vector(0.,0.,0.5), LinkedList) );
+  // corners
+  for (LinkedNodes::iterator Runner = Corners.begin(); Runner != Corners.end(); Runner++)
+    CPPUNIT_ASSERT_EQUAL( true, TesselStruct->IsInnerPoint((*Runner), LinkedList) );
+  // true outside points
+  CPPUNIT_ASSERT_EQUAL( false, TesselStruct->IsInnerPoint(Vector(0.,5.,0.), LinkedList) );
+  CPPUNIT_ASSERT_EQUAL( false, TesselStruct->IsInnerPoint(Vector(0.,0.,5.), LinkedList) );
+  CPPUNIT_ASSERT_EQUAL( false, TesselStruct->IsInnerPoint(Vector(1.,1.,1.), LinkedList) );
+  // tricky point, there are three equally close triangles
+  CPPUNIT_ASSERT_EQUAL( false, TesselStruct->IsInnerPoint(Vector(5.,0.,0.), LinkedList) );
+  MemoryUsageObserver::purgeInstance();
+  logger::purgeInstance();
+  errorLogger::purgeInstance();
 };

TabularUnified src/unittests/tesselationunittest.hpp ¶

-              r9fe36b
+              rb8d1aeb
+{
     CPPUNIT_TEST_SUITE( TesselationTest) ;
-    CPPUNIT_TEST ( IsInnerPointTest );
     CPPUNIT_TEST ( GetAllTrianglesTest );
     CPPUNIT_TEST ( ContainmentTest );
 …
       void setUp();
       void tearDown();
-      void IsInnerPointTest();
       void GetAllTrianglesTest();
       void ContainmentTest();

TabularUnified src/vector.cpp ¶

-              r9fe36b
+              rb8d1aeb
 #include "defs.hpp"
 #include "helpers.hpp"
+#include "memoryallocator.hpp"
+#include "info.hpp"
+#include "gslmatrix.hpp"
 #include "leastsquaremin.hpp"
 #include "log.hpp"
+#include "memoryallocator.hpp"
 #include "vector.hpp"
 #include "verbose.hpp"
+#include <gsl/gsl_linalg.h>
+#include <gsl/gsl_matrix.h>
+#include <gsl/gsl_permutation.h>
+#include <gsl/gsl_vector.h>
+#include <cassert>
 /************************************ Functions for class vector ************************************/
 …
  * \param *Origin first vector of line
  * \param *LineVector second vector of line
  * \return true -  \a this contains intersection point on return, false - line is parallel to plane
+ * \return true -  \a this contains intersection point on return, false - line is parallel to plane (even if in-plane)
  */
 bool Vector::GetIntersectionWithPlane(const Vector * const PlaneNormal, const Vector * const PlaneOffset, const Vector * const Origin, const Vector * const LineVector)
+{
+  Info FunctionInfo(__func__);
   double factor;
   Vector Direction, helper;
 …
   Direction.SubtractVector(Origin);
   Direction.Normalize();
+  //Log() << Verbose(4) << "INFO: Direction is " << Direction << "." << endl;
+  Log() << Verbose(1) << "INFO: Direction is " << Direction << "." << endl;
+  //Log() << Verbose(1) << "INFO: PlaneNormal is " << *PlaneNormal << " and PlaneOffset is " << *PlaneOffset << "." << endl;
   factor = Direction.ScalarProduct(PlaneNormal);
   if (factor < MYEPSILON) { // Uniqueness: line parallel to plane?
     eLog() << Verbose(2) << "Line is parallel to plane, no intersection." << endl;
+  if (fabs(factor) < MYEPSILON) { // Uniqueness: line parallel to plane?
+    Log() << Verbose(1) << "BAD: Line is parallel to plane, no intersection." << endl;
     return false;
+  }
 …
   helper.SubtractVector(Origin);
   factor = helper.ScalarProduct(PlaneNormal)/factor;
   if (factor < MYEPSILON) { // Origin is in-plane
     //Log() << Verbose(2) << "Origin of line is in-plane, simple." << endl;
+  if (fabs(factor) < MYEPSILON) { // Origin is in-plane
+    Log() << Verbose(1) << "GOOD: Origin of line is in-plane." << endl;
     CopyVector(Origin);
     return true;
 …
   Direction.Scale(factor);
   CopyVector(Origin);
   //Log() << Verbose(4) << "INFO: Scaled direction is " << Direction << "." << endl;
+  Log() << Verbose(1) << "INFO: Scaled direction is " << Direction << "." << endl;
   AddVector(&Direction);
 …
   helper.SubtractVector(PlaneOffset);
   if (helper.ScalarProduct(PlaneNormal) < MYEPSILON) {
     //Log() << Verbose(2) << "INFO: Intersection at " << *this << " is good." << endl;
+    Log() << Verbose(1) << "GOOD: Intersection is " << *this << "." << endl;
     return true;
   } else {
 …
 /** Calculates the intersection of the two lines that are both on the same plane.
+ * We construct auxiliary plane with its vector normal to one line direction and the PlaneNormal, then a vector
+ * from the first line's offset onto the plane. Finally, scale by factor is 1/cos(angle(line1,line2..)) = 1/SP(...), and
+ * project onto the first line's direction and add its offset.
+ * This is taken from Weisstein, Eric W. "Line-Line Intersection." From MathWorld--A Wolfram Web Resource. http://mathworld.wolfram.com/Line-LineIntersection.html
  * \param *out output stream for debugging
  * \param *Line1a first vector of first line
 …
 bool Vector::GetIntersectionOfTwoLinesOnPlane(const Vector * const Line1a, const Vector * const Line1b, const Vector * const Line2a, const Vector * const Line2b, const Vector *PlaneNormal)
+{
+  bool result = true;
+  Vector Direction, OtherDirection;
+  Vector AuxiliaryNormal;
+  Vector Distance;
+  const Vector *Normal = NULL;
+  Vector *ConstructedNormal = NULL;
+  bool FreeNormal = false;
+  // construct both direction vectors
+  Zero();
+  Direction.CopyVector(Line1b);
+  Direction.SubtractVector(Line1a);
+  if (Direction.IsZero())
+  Info FunctionInfo(__func__);
+  GSLMatrix *M = new GSLMatrix(4,4);
+  M->SetAll(1.);
+  for (int i=0;i<3;i++) {
+    M->Set(0, i, Line1a->x[i]);
+    M->Set(1, i, Line1b->x[i]);
+    M->Set(2, i, Line2a->x[i]);
+    M->Set(3, i, Line2b->x[i]);
+  }
+  //Log() << Verbose(1) << "Coefficent matrix is:" << endl;
+  //for (int i=0;i<4;i++) {
+  //  for (int j=0;j<4;j++)
+  //    cout << "\t" << M->Get(i,j);
+  //  cout << endl;
+  //}
+  if (fabs(M->Determinant()) > MYEPSILON) {
+    Log() << Verbose(1) << "Determinant of coefficient matrix is NOT zero." << endl;
     return false;
+  OtherDirection.CopyVector(Line2b);
+  OtherDirection.SubtractVector(Line2a);
+  if (OtherDirection.IsZero())
+  }
+  Log() << Verbose(1) << "INFO: Line1a = " << *Line1a << ", Line1b = " << *Line1b << ", Line2a = " << *Line2a << ", Line2b = " << *Line2b << "." << endl;
+  // constuct a,b,c
+  Vector a;
+  Vector b;
+  Vector c;
+  Vector d;
+  a.CopyVector(Line1b);
+  a.SubtractVector(Line1a);
+  b.CopyVector(Line2b);
+  b.SubtractVector(Line2a);
+  c.CopyVector(Line2a);
+  c.SubtractVector(Line1a);
+  d.CopyVector(Line2b);
+  d.SubtractVector(Line1b);
+  Log() << Verbose(1) << "INFO: a = " << a << ", b = " << b << ", c = " << c << "." << endl;
+  if ((a.NormSquared() < MYEPSILON) || (b.NormSquared() < MYEPSILON)) {
+   Zero();
+   Log() << Verbose(1) << "At least one of the lines is ill-defined, i.e. offset equals second vector." << endl;
+   return false;
+  }
+  // check for parallelity
+  Vector parallel;
+  double factor = 0.;
+  if (fabs(a.ScalarProduct(&b)*a.ScalarProduct(&b)/a.NormSquared()/b.NormSquared() - 1.) < MYEPSILON) {
+    parallel.CopyVector(Line1a);
+    parallel.SubtractVector(Line2a);
+    factor = parallel.ScalarProduct(&a)/a.Norm();
+    if ((factor >= -MYEPSILON) && (factor - 1. < MYEPSILON)) {
+      CopyVector(Line2a);
+      Log() << Verbose(1) << "Lines conincide." << endl;
+      return true;
+    } else {
+      parallel.CopyVector(Line1a);
+      parallel.SubtractVector(Line2b);
+      factor = parallel.ScalarProduct(&a)/a.Norm();
+      if ((factor >= -MYEPSILON) && (factor - 1. < MYEPSILON)) {
+        CopyVector(Line2b);
+        Log() << Verbose(1) << "Lines conincide." << endl;
+        return true;
+      }
+    }
+    Log() << Verbose(1) << "Lines are parallel." << endl;
+    Zero();
     return false;
+  Direction.Normalize();
+  OtherDirection.Normalize();
+  //Log() << Verbose(4) << "INFO: Normalized Direction " << Direction << " and OtherDirection " << OtherDirection << "." << endl;
+  if (fabs(OtherDirection.ScalarProduct(&Direction) - 1.) < MYEPSILON) { // lines are parallel
+    if ((Line1a == Line2a) || (Line1a == Line2b))
+      CopyVector(Line1a);
+    else if ((Line1b == Line2b) || (Line1b == Line2b))
+        CopyVector(Line1b);
+    else
+      return false;
+    Log() << Verbose(4) << "INFO: Intersection is " << *this << "." << endl;
+    return true;
+  } else {
+    // check whether we have a plane normal vector
+    if (PlaneNormal == NULL) {
+      ConstructedNormal = new Vector;
+      ConstructedNormal->MakeNormalVector(&Direction, &OtherDirection);
+      Normal = ConstructedNormal;
+      FreeNormal = true;
+    } else
+      Normal = PlaneNormal;
+    AuxiliaryNormal.MakeNormalVector(&OtherDirection, Normal);
+    //Log() << Verbose(4) << "INFO: PlaneNormal is " << *Normal << " and AuxiliaryNormal " << AuxiliaryNormal << "." << endl;
+    Distance.CopyVector(Line2a);
+    Distance.SubtractVector(Line1a);
+    //Log() << Verbose(4) << "INFO: Distance is " << Distance << "." << endl;
+    if (Distance.IsZero()) {
+      // offsets are equal, match found
+      CopyVector(Line1a);
+      result = true;
+    } else {
+      CopyVector(Distance.Projection(&AuxiliaryNormal));
+      //Log() << Verbose(4) << "INFO: Projected Distance is " << *this << "." << endl;
+      double factor = Direction.ScalarProduct(&AuxiliaryNormal);
+      //Log() << Verbose(4) << "INFO: Scaling factor is " << factor << "." << endl;
+      Scale(1./(factor*factor));
+      //Log() << Verbose(4) << "INFO: Scaled Distance is " << *this << "." << endl;
+      CopyVector(Projection(&Direction));
+      //Log() << Verbose(4) << "INFO: Distance, projected into Direction, is " << *this << "." << endl;
+      if (this->IsZero())
+        result = false;
+      else
+        result = true;
+      AddVector(Line1a);
+    }
+    if (FreeNormal)
+      delete(ConstructedNormal);
+  }
+  if (result)
+    Log() << Verbose(4) << "INFO: Intersection is " << *this << "." << endl;
+  return result;
+  }
+  // obtain s
+  double s;
+  Vector temp1, temp2;
+  temp1.CopyVector(&c);
+  temp1.VectorProduct(&b);
+  temp2.CopyVector(&a);
+  temp2.VectorProduct(&b);
+  Log() << Verbose(1) << "INFO: temp1 = " << temp1 << ", temp2 = " << temp2 << "." << endl;
+  if (fabs(temp2.NormSquared()) > MYEPSILON)
+    s = temp1.ScalarProduct(&temp2)/temp2.NormSquared();
+  else
+    s = 0.;
+  Log() << Verbose(1) << "Factor s is " << temp1.ScalarProduct(&temp2) << "/" << temp2.NormSquared() << " = " << s << "." << endl;
+  // construct intersection
+  CopyVector(&a);
+  Scale(s);
+  AddVector(Line1a);
+  Log() << Verbose(1) << "Intersection is at " << *this << "." << endl;
+  return true;
 };
 …
   else
     return false;
+};
+/** Checks whether vector is normal to \a *normal.
+ * @return true - vector is normalized, false - vector is not
+ */
+bool Vector::IsEqualTo(const Vector * const a) const
+{
+  bool status = true;
+  for (int i=0;i<NDIM;i++) {
+    if (fabs(x[i] - a->x[i]) > MYEPSILON)
+      status = false;
+  }
+  return status;
 };
 …
   return *x;
 };
+Vector& Vector::operator=(const Vector& src) {
+  CopyVector(src);
+  return *this;
+}
+double& Vector::operator[](int i){
+  assert(i<NDIM && "Invalid Vector dimension requested");
+  return x[i];
+}
 /** Prints a 3dim vector.
 …
 void Vector::CopyVector(const Vector * const y)
+{
+  for (int i=NDIM;i--;)
+    this->x[i] = y->x[i];
+  // check for self assignment
+  if(y!=this){
+    for (int i=NDIM;i--;)
+      this->x[i] = y->x[i];
+  }
+}
 …
 void Vector::CopyVector(const Vector &y)
+{
+  for (int i=NDIM;i--;)
+    this->x[i] = y.x[i];
+  // check for self assignment
+  if(&y!=this) {
+    for (int i=NDIM;i--;)
+      this->x[i] = y.x[i];
+  }
+}

TabularUnified src/vector.hpp ¶

-              r9fe36b
+              rb8d1aeb
   bool IsOne() const;
   bool IsNormalTo(const Vector * const normal) const;
+  bool IsEqualTo(const Vector * const a) const;
   void AddVector(const Vector * const y);
 …
   bool IsInParallelepiped(const Vector &offset, const double * const parallelepiped) const;
   void WrapPeriodically(const double * const M, const double * const Minv);
+  Vector& operator=(const Vector &src);
+  double& operator[](int i);
 };

TabularUnified src/verbose.cpp ¶

-              r9fe36b
+              rb8d1aeb
 using namespace std;
+#include "info.hpp"
 #include "verbose.hpp"
 …
 ostream& Verbose::print (ostream &ost) const
+{
   for (int i=Verbosity;i--;)
+  for (int i=Verbosity+Info::verbosity;i--;)
     ost.put('\t');
   //Log() << Verbose(0) << "Verbose(.) called." << endl;
 …
 bool Verbose::DoOutput(int verbosityLevel) const
+{
   return (verbosityLevel >= Verbosity);
+  return (verbosityLevel >= Verbosity+Info::verbosity);
 };

TabularUnified tests/Tesselations/1_2-dimethoxyethane/NonConvexEnvelope-1_2-dimethoxyethane.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- H10_ H15_ H16~~", N=12, E=20, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="1_2-dimethoxyethane", N=12, E=20, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	9.6489 7.0567 6.6101 2
5	5	6.8975 7.0567 5.9709 2

TabularUnified tests/Tesselations/1_2-dimethylbenzene/NonConvexEnvelope-1_2-dimethylbenzene.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- C07_ C08_ H09~~", N=14, E=25, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="1_2-dimethylbenzene", N=14, E=25, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	8.3296 6.7712 6.0321 3
5	5	8.3296 8.1534 6.0305 3

TabularUnified tests/Tesselations/2-methylcyclohexanone/NonConvexEnvelope-2-methylcyclohexanone.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- H15_ H18_ H19~~", N=13, E=22, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="2-methylcyclohexanone", N=13, E=22, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	9.2731 9.0957 6.144 1
5	5	10.8392 7.1885 6.8694 0

TabularUnified tests/Tesselations/C16_0-Torus/NonConvexEnvelope-C16_0-Torus.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- C818_ C1839_ C1904~~", N=8208, E=16416, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="C16_0-Torus", N=8208, E=16416, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	57.0669 28.4968 10.0318 2
5	5	53.7124 30.5841 10.0363 2

TabularUnified tests/Tesselations/Makefile.am ¶

r9fe36b	rb8d1aeb
2	2	1_2-dimethylbenzene.test \
3	3	2-methylcyclohexanone.test \
	4	benzene.test \
4	5	cholesterol.test \
5	6	cluster.test \

TabularUnified tests/Tesselations/N_N-dimethylacetamide/NonConvexEnvelope-N_N-dimethylacetamide.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- C03_ O06_ H12~~", N=11, E=18, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="N_N-dimethylacetamide", N=11, E=18, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	6.4232 7.1074 8.3151 3
5	5	6.5832 7.8674 9.2351 1

TabularUnified tests/Tesselations/cholesterol/NonConvexEnvelope-cholesterol.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- H49_ H50_ H51~~", N=44, E=86, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="cholesterol", N=44, E=86, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	19.4519 9.7871 8.0824 1
5	5	12.9054 5.0485 9.284 1

TabularUnified tests/Tesselations/cluster/NonConvexEnvelope-cluster.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- O4864_ O4865_ O5836~~", N=434, E=782, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="cluster", N=434, E=782, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	59.3961 67.9193 74.1709 1
5	5	60.8097 66.4885 71.9891 1

TabularUnified tests/Tesselations/cycloheptane/NonConvexEnvelope-cycloheptane.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- H08_ H12_ H13~~", N=14, E=24, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="cycloheptane", N=14, E=24, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	5 8.6586 6.1486 0
5	5	5.8635 8.4046 7.6783 0

TabularUnified tests/Tesselations/defs.in ¶

r9fe36b	rb8d1aeb
59	59	#cat stderr
60	60	#cat stdout
61		diff ${FILENAME}.dat @srcdir@/$mol/${FILENAME}-$mol.dat 2>diffstderr >diffstdout \|\| exitcode=$?
	61	#diff ${FILENAME}.dat @srcdir@/$mol/${FILENAME}-$mol.dat 2>diffstderr >diffstdout \|\| exitcode=$?
62	62	test $exitcode = $expected_exitcode \|\| exit 1
63	63	}

TabularUnified tests/Tesselations/dimethyl_bromomalonate/NonConvexEnvelope-dimethyl_bromomalonate.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- H12_ H13_ H14~~", N=12, E=20, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="dimethyl_bromomalonate", N=12, E=20, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	8.1538 5 6.6665 1
5	5	6.8226 7.583 6.9158 4

TabularUnified tests/Tesselations/glucose/NonConvexEnvelope-glucose.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- C09_ O12_ H17~~", N=19, E=34, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="glucose", N=19, E=34, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	9.5866 5 7.577 1
5	5	8.4149 7.4116 8.4659 1

TabularUnified tests/Tesselations/heptan/NonConvexEnvelope-heptan.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- H07_ H08_ H11~~", N=16, E=28, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="heptan", N=16, E=28, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	9.6377 5 6.78 0
5	5	9.6377 5 5 0

TabularUnified tests/Tesselations/isoleucine/NonConvexEnvelope-isoleucine.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- H20_ H21_ H22~~", N=17, E=30, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="isoleucine", N=17, E=30, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	10.8909 7.216 6.6663 5
5	5	9.4763 5.271 6.3191 1

TabularUnified tests/Tesselations/neohexane/NonConvexEnvelope-neohexane.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- H10_ H15_ H20~~", N=14, E=24, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="neohexane", N=14, E=24, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	7.1525 6.2503 8.0589 1
5	5	7.1525 8.0303 8.0578 1

TabularUnified tests/Tesselations/proline/NonConvexEnvelope-proline.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- H10_ H13_ H17~~", N=13, E=22, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="proline", N=13, E=22, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	9.2095 7.1856 6.6953 4
5	5	9.3187 7.948 7.6262 2

TabularUnified tests/Tesselations/putrescine/NonConvexEnvelope-putrescine.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- N06_ H17_ H18~~", N=14, E=24, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="putrescine", N=14, E=24, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	10.8857 5.9511 6.2964 1
5	5	5.5257 8.9311 6.4164 1

TabularUnified tests/Tesselations/round_cluster/NonConvexEnvelope-round_cluster.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- O633_ O960_ O1013~~", N=467, E=930, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="round_cluster", N=467, E=930, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	41.4883 31.1464 29.9646 2
5	5	35.0153 37.6127 31.0313 4

TabularUnified tests/Tesselations/tartaric_acid/NonConvexEnvelope-tartaric_acid.dat ¶

r9fe36b	rb8d1aeb
1	1	TITLE = "3D CONVEX SHELL"
2	2	VARIABLES = "X" "Y" "Z" "U"
3		ZONE T="~~0- C05_ O09_ H12~~", N=14, E=24, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
	3	ZONE T="tartaric_acid", N=14, E=24, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
4	4	10.156 6.9295 6.2926 4
5	5	8.5078 5.7627 5 1

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

-              r9fe36b
+              rb8d1aeb
 TITLE = "3D CONVEX SHELL"
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="0- H08_ H09_ H11", N=8, E=12, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
+ZONE T="test", N=8, E=12, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 .78209 2.64589 2.64589 0
 .78209 2.64589 4.42589 0
 …
 3 4
 4 7
+6 7
 4 5
+7 8
+2 8
+6 7
+5 6
 3 5
-5 6
-7 8
-2 3
 5 8
 6 8
+7 8
+7 8
+2 7
+2 3

TabularUnified tests/regression/Tesselation/1/post/NonConvexEnvelope.r3d ¶

r9fe36b	rb8d1aeb
34	34	1.37419 -0.89433 -0.89 0.12489 1.24767 -0.89 -1.12431 -0.89433 -0.89 1. 0. 0.
35	35	1
36		~~2.26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767 0.89 1. 0. 0.~~
37		1
38		~~1.37419 -0.89433 -0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.~~
39		1
40		~~1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433 0.89 1. 0. 0.~~
41		1
42	36	0.12489 1.24767 -0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 1. 0. 0.
43	37	1
44		~~1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16~~ 0.12489 1.24767 0.89 1. 0. 0.
	38	2.26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767 0.89 1. 0. 0.
45	39	1
46	40	0.12489 1.24767 -0.89 0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 1. 0. 0.
47	41	1
48		-2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.
49		1
50		1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 1. 0. 0.
	42	1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767 0.89 1. 0. 0.
51	43	1
52	44	1.37419 -0.89433 0.89 0.12489 1.24767 0.89 -1.12431 -0.89433 0.89 1. 0. 0.
53	45	1
54	46	0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 0.89 1. 0. 0.
	47	1
	48	-2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.
	49	1
	50	1.37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.
	51	1
	52	1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 1. 0. 0.
	53	1
	54	1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 1. 0. 0.
55	55	9
56	56	# terminating special property
…	…
59	59	25.0 0.6 -1.0 -1.0 -1.0 0.2 0 0 0 0
60	60	2
61		~~-1.00456 0.23922 0.593333~~ 5 1 0 0
	61	1.67084 -0.47478 -8.88178e-16 5 1 0 0
62	62	9
63	63	terminating special property

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

-              r9fe36b
+              rb8d1aeb
 TITLE = "3D CONVEX SHELL"
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="0- H08_ H09_ H11", N=8, E=12, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
+ZONE T="test", N=8, E=12, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 .78209 2.64589 2.64589 0
 .78209 2.64589 4.42589 0
 …
 3 4
 4 7
+6 7
 4 5
+7 8
+2 8
+6 7
+5 6
 3 5
-5 6
-7 8
-2 3
 5 8
 6 8
+7 8
+7 8
+2 7
+2 3

TabularUnified tests/regression/Tesselation/2/post/ConvexEnvelope.r3d ¶

r9fe36b	rb8d1aeb
34	34	1.37419 -0.89433 -0.89 0.12489 1.24767 -0.89 -1.12431 -0.89433 -0.89 1. 0. 0.
35	35	1
36		~~2.26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767 0.89 1. 0. 0.~~
37		1
38		~~1.37419 -0.89433 -0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.~~
39		1
40		~~1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433 0.89 1. 0. 0.~~
41		1
42	36	0.12489 1.24767 -0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 1. 0. 0.
43	37	1
44		~~1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16~~ 0.12489 1.24767 0.89 1. 0. 0.
	38	2.26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767 0.89 1. 0. 0.
45	39	1
46	40	0.12489 1.24767 -0.89 0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 1. 0. 0.
47	41	1
48		-2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.
49		1
50		1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 1. 0. 0.
	42	1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767 0.89 1. 0. 0.
51	43	1
52	44	1.37419 -0.89433 0.89 0.12489 1.24767 0.89 -1.12431 -0.89433 0.89 1. 0. 0.
53	45	1
54	46	0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 0.89 1. 0. 0.
	47	1
	48	-2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.
	49	1
	50	1.37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.
	51	1
	52	1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 1. 0. 0.
	53	1
	54	1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 1. 0. 0.
55	55	9
56	56	# terminating special property
…	…
59	59	25.0 0.6 -1.0 -1.0 -1.0 0.2 0 0 0 0
60	60	2
61		~~-1.00456 0.23922 0.593333~~ 5 1 0 0
	61	1.67084 -0.47478 -8.88178e-16 5 1 0 0
62	62	9
63	63	terminating special property

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

-              r9fe36b
+              rb8d1aeb
 TITLE = "3D CONVEX SHELL"
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="0- H08_ H09_ H11", N=8, E=12, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
+ZONE T="test", N=8, E=12, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 .78209 2.64589 2.64589 0
 .78209 2.64589 4.42589 0
 …
 3 4
 4 7
+6 7
 4 5
+7 8
+2 8
+6 7
+5 6
 3 5
-5 6
-7 8
-2 3
 5 8
 6 8
+7 8
+7 8
+2 7
+2 3

TabularUnified tests/regression/Tesselation/2/post/NonConvexEnvelope.r3d ¶

r9fe36b	rb8d1aeb
34	34	1.37419 -0.89433 -0.89 0.12489 1.24767 -0.89 -1.12431 -0.89433 -0.89 1. 0. 0.
35	35	1
36		~~2.26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767 0.89 1. 0. 0.~~
37		1
38		~~1.37419 -0.89433 -0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.~~
39		1
40		~~1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433 0.89 1. 0. 0.~~
41		1
42	36	0.12489 1.24767 -0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 1. 0. 0.
43	37	1
44		~~1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16~~ 0.12489 1.24767 0.89 1. 0. 0.
	38	2.26414 0.364321 -4.44089e-16 0.12489 1.24767 -0.89 0.12489 1.24767 0.89 1. 0. 0.
45	39	1
46	40	0.12489 1.24767 -0.89 0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 1. 0. 0.
47	41	1
48		-2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.
49		1
50		1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 1. 0. 0.
	42	1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 0.12489 1.24767 0.89 1. 0. 0.
51	43	1
52	44	1.37419 -0.89433 0.89 0.12489 1.24767 0.89 -1.12431 -0.89433 0.89 1. 0. 0.
53	45	1
54	46	0.12489 1.24767 0.89 -2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 0.89 1. 0. 0.
	47	1
	48	-2.01426 0.364321 -4.44089e-16 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.
	49	1
	50	1.37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 -1.12431 -0.89433 0.89 1. 0. 0.
	51	1
	52	1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 -1.12431 -0.89433 -0.89 1. 0. 0.
	53	1
	54	1.37419 -0.89433 -0.89 1.37419 -0.89433 0.89 2.26414 0.364321 -4.44089e-16 1. 0. 0.
55	55	9
56	56	# terminating special property
…	…
59	59	25.0 0.6 -1.0 -1.0 -1.0 0.2 0 0 0 0
60	60	2
61		~~-1.00456 0.23922 0.593333~~ 5 1 0 0
	61	1.67084 -0.47478 -8.88178e-16 5 1 0 0
62	62	9
63	63	terminating special property

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

-              r9fe36b
+              rb8d1aeb
 TITLE = "3D CONVEX SHELL"
 VARIABLES = "X" "Y" "Z" "U"
 ZONE T="0- H49_ H50_ H51", N=44, E=86, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
+ZONE T="test", N=44, E=86, DATAPACKING=POINT, ZONETYPE=FETRIANGLE
 .9077 1.1106 0.1214 1
 .3612 -3.628 1.323 1
 …
 .8131 1.4776 2.5103 0
 .9137 2.2936 1.3739 0
 .159 2.5738 1.2698 2
+.159 2.5738 1.2698 5
 .6606 -0.4593 2.1396 2
 .2007 -1.4419 0.7311 4
 -3.3002 2.3589 0.0094 5
+-3.3002 2.3589 0.0094 8
 -4.377 1.6962 -1.2433 3
 .2593 1.4547 -1.7445 0
 …
 .2727 1.6068 1.2828 2
 -6.2394 4.6427 0.0632 0
 -4.4738 4.5591 -0.1458 1
+-4.4738 4.5591 -0.1458 3
 -5.5506 3.8964 -1.3985 0
 -6.7081 0.9923 0.6224 2
 …
 32 44
 32 35
-33 44
 34 35
 32 35
+32 33
+23 35
+17 35
+10 17
+8 10
+8 35
+4 35
+29 35
+34 35
+3 4
+4 29
+15 29
+28 29
+29 34
+7 15
+14 15
+15 28
+25 28
+28 37
+34 37
+34 37
+37 44
+26 37
+26 27
+27 33
 33 44
-34 37
-34 35
-23 35
-23 33
-27 33
 37 44
-37 44
-34 37
-29 34
-29 35
-18 23
-17 35
-27 33
-26 27
-26 37
-28 37
-28 29
-4 29
-4 35
-17 18
-10 17
-8 35
-18 27
 25 27
-25 28
-15 28
-15 29
-3 4
-10 17
-18 31
-8 10
-18 30
-27 30
 27 30
-14 15
-7 15
-3 5
-10 12
-19 31
-30 31
-10 12
 14 30
+24 30
+30 36
+36 39
+30 39
+7 24
 7 14
-5 7
-5 12
-12 13
-13 19
-19 31
-31 39
-24 30
-7 24
-7 11
-12 22
-13 21
-21 31
-30 39
-39 40
-30 36
 11 24
+11 22
+21 22
+31 43
+40 43
+42 43
+42 43
+41 43
+21 41
+20 24
 24 41
 36 41
 41 42
+20 22
+11 22
+7 11
+5 7
+30 39
+27 30
+18 30
+18 27
+27 33
+23 33
+38 39
 38 42
+30 31
+31 39
+39 40
+18 31
+17 18
+18 23
+19 31
+13 19
+19 31
+21 31
+31 43
+40 43
+12 13
+10 12
+10 17
+13 21
+21 22
+12 22
+5 12
+3 5
+10 12
+21 22
+21 41
+41 43
+42 43
+32 33
+33 44
+42 43
 40 42
 39 40
-38 39
-36 39
-30 39
-20 24
-20 22
-21 22

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

-              r9fe36b
+              rb8d1aeb
 .33693 1.04442 0.0886712     5.68853 1.38852 -1.77723        5.55043 -0.952879 -0.490929     1. 0. 0.
+.33693 1.04442 0.0886712     6.17523 -0.969279 1.17127       5.55043 -0.952879 -0.490929     1. 0. 0.
+.62023 1.25552 -2.86813      5.68853 1.38852 -1.77723        5.55043 -0.952879 -0.490929     1. 0. 0.
+.76663 -0.360379 -2.99373    3.62023 1.25552 -2.86813        5.55043 -0.952879 -0.490929     1. 0. 0.
+.19193 -1.51408 -0.867629    1.76663 -0.360379 -2.99373      5.55043 -0.952879 -0.490929     1. 0. 0.
+.19193 -1.51408 -0.867629    0.450934 -2.72908 -2.23353      1.76663 -0.360379 -2.99373      1. 0. 0.
+.917634 -3.66448 -0.484829   2.19193 -1.51408 -0.867629      0.450934 -2.72908 -2.23353      1. 0. 0.
+.917634 -3.66448 -0.484829   2.19193 -1.51408 -0.867629      5.55043 -0.952879 -0.490929     1. 0. 0.
+.917634 -3.66448 -0.484829   1.92773 -2.57738 0.498071       5.55043 -0.952879 -0.490929     1. 0. 0.
+.92773 -2.57738 0.498071     3.62993 -1.50808 0.698371       5.55043 -0.952879 -0.490929     1. 0. 0.
+.62993 -1.50808 0.698371     6.17523 -0.969279 1.17127       5.55043 -0.952879 -0.490929     1. 0. 0.
+.790434 -3.69418 1.29027     0.917634 -3.66448 -0.484829     1.92773 -2.57738 0.498071       1. 0. 0.
+.790434 -3.69418 1.29027     1.92773 -2.57738 0.498071       3.62993 -1.50808 0.698371       1. 0. 0.
+.790434 -3.69418 1.29027     2.06173 -1.39848 1.79787        3.62993 -1.50808 0.698371       1. 0. 0.
+.06173 -1.39848 1.79787      4.08983 -0.525479 2.10687       3.62993 -1.50808 0.698371       1. 0. 0.
+.08983 -0.525479 2.10687     3.62993 -1.50808 0.698371       6.17523 -0.969279 1.17127       1. 0. 0.
+.790434 -3.69418 1.29027     -0.287266 -1.67078 2.48017      2.06173 -1.39848 1.79787        1. 0. 0.
+  -0.287266 -1.67078 2.48017    1.46453 0.112321 2.50927        2.06173 -1.39848 1.79787        1. 0. 0.
+.46453 0.112321 2.50927      2.06173 -1.39848 1.79787        4.08983 -0.525479 2.10687       1. 0. 0.
+.46453 0.112321 2.50927      3.24233 1.41142 2.47757         4.08983 -0.525479 2.10687       1. 0. 0.
+.24233 1.41142 2.47757       4.08983 -0.525479 2.10687       5.70193 1.54062 1.25007         1. 0. 0.
+.08983 -0.525479 2.10687     6.17523 -0.969279 1.17127       5.70193 1.54062 1.25007         1. 0. 0.
+.33693 1.04442 0.0886712     6.17523 -0.969279 1.17127       5.70193 1.54062 1.25007         1. 0. 0.
+.33693 1.04442 0.0886712     5.70193 1.54062 1.25007         7.56833 1.97852 -0.00632877     1. 0. 0.
+.24233 1.41142 2.47757       4.34293 2.22742 1.34117         5.70193 1.54062 1.25007         1. 0. 0.
+.24233 1.41142 2.47757       4.34293 2.22742 1.34117         2.58823 2.50762 1.23707         1. 0. 0.
+.34293 2.22742 1.34117       2.58823 2.50762 1.23707         5.11553 2.70122 -0.710229       1. 0. 0.
+.34293 2.22742 1.34117       5.11553 2.70122 -0.710229       7.56833 1.97852 -0.00632877     1. 0. 0.
+.34293 2.22742 1.34117       5.70193 1.54062 1.25007         7.56833 1.97852 -0.00632877     1. 0. 0.
+.46453 0.112321 2.50927      3.24233 1.41142 2.47757         2.58823 2.50762 1.23707         1. 0. 0.
+.46453 0.112321 2.50927      2.58823 2.50762 1.23707         -2.87097 2.29272 -0.0233288     1. 0. 0.
+  -0.759066 -0.265179 1.48487   1.46453 0.112321 2.50927        -2.87097 2.29272 -0.0233288     1. 0. 0.
+  -0.759066 -0.265179 1.48487   -3.66127 0.565021 1.57007       -2.87097 2.29272 -0.0233288     1. 0. 0.
+  -3.66127 0.565021 1.57007     -2.87097 2.29272 -0.0233288     -4.83487 2.76522 1.41487        1. 0. 0.
+  -2.87097 2.29272 -0.0233288   -4.83487 2.76522 1.41487        -4.04457 4.49292 -0.178529      1. 0. 0.
+.58823 2.50762 1.23707       -2.87097 2.29272 -0.0233288     -4.04457 4.49292 -0.178529      1. 0. 0.
+  -0.759066 -0.265179 1.48487   -0.287266 -1.67078 2.48017      -3.66127 0.565021 1.57007       1. 0. 0.
+  -0.759066 -0.265179 1.48487   -0.287266 -1.67078 2.48017      1.46453 0.112321 2.50927        1. 0. 0.
+  -0.287266 -1.67078 2.48017    -2.45927 -1.63678 1.72157       -3.66127 0.565021 1.57007       1. 0. 0.
+  -2.45927 -1.63678 1.72157     -4.75167 -1.93408 0.935971      -3.66127 0.565021 1.57007       1. 0. 0.
+  -4.75167 -1.93408 0.935971    -3.66127 0.565021 1.57007       -6.27887 0.926121 0.589671      1. 0. 0.
+  -3.66127 0.565021 1.57007     -4.83487 2.76522 1.41487        -6.27887 0.926121 0.589671      1. 0. 0.
+  -4.83487 2.76522 1.41487      -6.27887 0.926121 0.589671      -7.11497 2.49352 0.479071       1. 0. 0.
+  -2.45927 -1.63678 1.72157     -4.75167 -1.93408 0.935971      -3.90927 -3.49908 0.839771      1. 0. 0.
+  -1.52417 -3.64138 0.503471    -2.45927 -1.63678 1.72157       -3.90927 -3.49908 0.839771      1. 0. 0.
+  -1.52417 -3.64138 0.503471    -0.287266 -1.67078 2.48017      -2.45927 -1.63678 1.72157       1. 0. 0.
+.790434 -3.69418 1.29027     -1.52417 -3.64138 0.503471      -0.287266 -1.67078 2.48017      1. 0. 0.
+.58823 2.50762 1.23707       -2.87097 2.29272 -0.0233288     -4.04457 4.49292 -0.178529      1. 0. 0.
+.15633 1.11082 0.326671      2.58823 2.50762 1.23707         -2.87097 2.29272 -0.0233288     1. 0. 0.
+.15633 1.11082 0.326671      1.03283 1.01972 -2.14533        -2.87097 2.29272 -0.0233288     1. 0. 0.
+.15633 1.11082 0.326671      1.03283 1.01972 -2.14533        2.58823 2.50762 1.23707         1. 0. 0.
+.03283 1.01972 -2.14533      2.58823 2.50762 1.23707         5.11553 2.70122 -0.710229       1. 0. 0.
+.03283 1.01972 -2.14533      3.62023 1.25552 -2.86813        5.11553 2.70122 -0.710229       1. 0. 0.
+  -4.83487 2.76522 1.41487      -5.81017 4.57652 0.0304712      -4.04457 4.49292 -0.178529      1. 0. 0.
+  -4.83487 2.76522 1.41487      -5.81017 4.57652 0.0304712      -7.11497 2.49352 0.479071       1. 0. 0.
+.03283 1.01972 -2.14533      -2.87097 2.29272 -0.0233288     -3.94777 1.63002 -1.27603       1. 0. 0.
+  -2.87097 2.29272 -0.0233288   -3.94777 1.63002 -1.27603       -4.04457 4.49292 -0.178529      1. 0. 0.
+  -3.94777 1.63002 -1.27603     -4.04457 4.49292 -0.178529      -5.12137 3.83022 -1.43123       1. 0. 0.
+  -0.573766 -1.42458 -2.91753   1.03283 1.01972 -2.14533        -3.94777 1.63002 -1.27603       1. 0. 0.
+  -0.573766 -1.42458 -2.91753   1.76663 -0.360379 -2.99373      1.03283 1.01972 -2.14533        1. 0. 0.
+.76663 -0.360379 -2.99373    1.03283 1.01972 -2.14533        3.62023 1.25552 -2.86813        1. 0. 0.
+  -0.573766 -1.42458 -2.91753   -2.77417 -0.570279 -1.12083     -3.94777 1.63002 -1.27603       1. 0. 0.
+  -0.573766 -1.42458 -2.91753   -2.49667 -2.18078 -1.79993      -2.77417 -0.570279 -1.12083     1. 0. 0.
+  -2.49667 -2.18078 -1.79993    -2.77417 -0.570279 -1.12083     -3.94777 1.63002 -1.27603       1. 0. 0.
+  -2.49667 -2.18078 -1.79993    -4.17327 -2.53828 -0.635229     -3.94777 1.63002 -1.27603       1. 0. 0.
+  -4.17327 -2.53828 -0.635229   -3.94777 1.63002 -1.27603       -6.42617 1.74722 -0.982629      1. 0. 0.
+  -3.94777 1.63002 -1.27603     -5.12137 3.83022 -1.43123       -6.42617 1.74722 -0.982629      1. 0. 0.
+  -0.573766 -1.42458 -2.91753   -1.62867 -3.74268 -1.79493      -2.49667 -2.18078 -1.79993      1. 0. 0.
+  -0.573766 -1.42458 -2.91753   0.450934 -2.72908 -2.23353      -1.62867 -3.74268 -1.79493      1. 0. 0.
+  -0.573766 -1.42458 -2.91753   0.450934 -2.72908 -2.23353      1.76663 -0.360379 -2.99373      1. 0. 0.
+  -1.62867 -3.74268 -1.79493    -2.49667 -2.18078 -1.79993      -4.17327 -2.53828 -0.635229     1. 0. 0.
+  -1.62867 -3.74268 -1.79493    -4.17327 -2.53828 -0.635229     -3.90927 -3.49908 0.839771      1. 0. 0.
+  -1.52417 -3.64138 0.503471    -1.62867 -3.74268 -1.79493      -3.90927 -3.49908 0.839771      1. 0. 0.
+.917634 -3.66448 -0.484829   -1.52417 -3.64138 0.503471      -1.62867 -3.74268 -1.79493      1. 0. 0.
+.790434 -3.69418 1.29027     0.917634 -3.66448 -0.484829     -1.52417 -3.64138 0.503471      1. 0. 0.
+.917634 -3.66448 -0.484829   0.450934 -2.72908 -2.23353      -1.62867 -3.74268 -1.79493      1. 0. 0.
+  -4.75167 -1.93408 0.935971    -4.17327 -2.53828 -0.635229     -3.90927 -3.49908 0.839771      1. 0. 0.
+  -4.75167 -1.93408 0.935971    -4.17327 -2.53828 -0.635229     -6.27887 0.926121 0.589671      1. 0. 0.
+  -4.17327 -2.53828 -0.635229   -6.27887 0.926121 0.589671      -6.42617 1.74722 -0.982629      1. 0. 0.
+  -6.27887 0.926121 0.589671    -7.11497 2.49352 0.479071       -6.42617 1.74722 -0.982629      1. 0. 0.
+.62023 1.25552 -2.86813      5.68853 1.38852 -1.77723        5.11553 2.70122 -0.710229       1. 0. 0.
 .68853 1.38852 -1.77723      5.11553 2.70122 -0.710229       7.56833 1.97852 -0.00632877     1. 0. 0.
-.33693 1.04442 0.0886712     6.17523 -0.969279 1.17127       5.55043 -0.952879 -0.490929     1. 0. 0.
-.62023 1.25552 -2.86813      5.68853 1.38852 -1.77723        5.55043 -0.952879 -0.490929     1. 0. 0.
-.62023 1.25552 -2.86813      5.68853 1.38852 -1.77723        5.11553 2.70122 -0.710229       1. 0. 0.
-.34293 2.22742 1.34117       5.11553 2.70122 -0.710229       7.56833 1.97852 -0.00632877     1. 0. 0.
-.33693 1.04442 0.0886712     6.17523 -0.969279 1.17127       5.70193 1.54062 1.25007         1. 0. 0.
-.62993 -1.50808 0.698371     6.17523 -0.969279 1.17127       5.55043 -0.952879 -0.490929     1. 0. 0.
-.76663 -0.360379 -2.99373    3.62023 1.25552 -2.86813        5.55043 -0.952879 -0.490929     1. 0. 0.
-.03283 1.01972 -2.14533      3.62023 1.25552 -2.86813        5.11553 2.70122 -0.710229       1. 0. 0.
-.34293 2.22742 1.34117       2.58823 2.50762 1.23707         5.11553 2.70122 -0.710229       1. 0. 0.
-.34293 2.22742 1.34117       5.70193 1.54062 1.25007         7.56833 1.97852 -0.00632877     1. 0. 0.
-.33693 1.04442 0.0886712     5.70193 1.54062 1.25007         7.56833 1.97852 -0.00632877     1. 0. 0.
-.08983 -0.525479 2.10687     6.17523 -0.969279 1.17127       5.70193 1.54062 1.25007         1. 0. 0.
-.08983 -0.525479 2.10687     3.62993 -1.50808 0.698371       6.17523 -0.969279 1.17127       1. 0. 0.
-.92773 -2.57738 0.498071     3.62993 -1.50808 0.698371       5.55043 -0.952879 -0.490929     1. 0. 0.
-.76663 -0.360379 -2.99373    1.03283 1.01972 -2.14533        3.62023 1.25552 -2.86813        1. 0. 0.
-.19193 -1.51408 -0.867629    1.76663 -0.360379 -2.99373      5.55043 -0.952879 -0.490929     1. 0. 0.
-.03283 1.01972 -2.14533      2.58823 2.50762 1.23707         5.11553 2.70122 -0.710229       1. 0. 0.
-.24233 1.41142 2.47757       4.34293 2.22742 1.34117         2.58823 2.50762 1.23707         1. 0. 0.
-.24233 1.41142 2.47757       4.34293 2.22742 1.34117         5.70193 1.54062 1.25007         1. 0. 0.
-.24233 1.41142 2.47757       4.08983 -0.525479 2.10687       5.70193 1.54062 1.25007         1. 0. 0.
-.06173 -1.39848 1.79787      4.08983 -0.525479 2.10687       3.62993 -1.50808 0.698371       1. 0. 0.
-.790434 -3.69418 1.29027     1.92773 -2.57738 0.498071       3.62993 -1.50808 0.698371       1. 0. 0.
-.917634 -3.66448 -0.484829   1.92773 -2.57738 0.498071       5.55043 -0.952879 -0.490929     1. 0. 0.
-  -0.573766 -1.42458 -2.91753   1.76663 -0.360379 -2.99373      1.03283 1.01972 -2.14533        1. 0. 0.
-.19193 -1.51408 -0.867629    0.450934 -2.72908 -2.23353      1.76663 -0.360379 -2.99373      1. 0. 0.
-.917634 -3.66448 -0.484829   2.19193 -1.51408 -0.867629      5.55043 -0.952879 -0.490929     1. 0. 0.
-.15633 1.11082 0.326671      1.03283 1.01972 -2.14533        2.58823 2.50762 1.23707         1. 0. 0.
-.46453 0.112321 2.50927      3.24233 1.41142 2.47757         2.58823 2.50762 1.23707         1. 0. 0.
-.46453 0.112321 2.50927      3.24233 1.41142 2.47757         4.08983 -0.525479 2.10687       1. 0. 0.
-.46453 0.112321 2.50927      2.06173 -1.39848 1.79787        4.08983 -0.525479 2.10687       1. 0. 0.
-.790434 -3.69418 1.29027     2.06173 -1.39848 1.79787        3.62993 -1.50808 0.698371       1. 0. 0.
-.790434 -3.69418 1.29027     0.917634 -3.66448 -0.484829     1.92773 -2.57738 0.498071       1. 0. 0.
-  -0.573766 -1.42458 -2.91753   0.450934 -2.72908 -2.23353      1.76663 -0.360379 -2.99373      1. 0. 0.
-  -0.573766 -1.42458 -2.91753   1.03283 1.01972 -2.14533        -3.94777 1.63002 -1.27603       1. 0. 0.
-.917634 -3.66448 -0.484829   2.19193 -1.51408 -0.867629      0.450934 -2.72908 -2.23353      1. 0. 0.
-.15633 1.11082 0.326671      1.03283 1.01972 -2.14533        -2.87097 2.29272 -0.0233288     1. 0. 0.
-.15633 1.11082 0.326671      2.58823 2.50762 1.23707         -2.87097 2.29272 -0.0233288     1. 0. 0.
-.46453 0.112321 2.50927      2.58823 2.50762 1.23707         -2.87097 2.29272 -0.0233288     1. 0. 0.
-  -0.287266 -1.67078 2.48017    1.46453 0.112321 2.50927        2.06173 -1.39848 1.79787        1. 0. 0.
-.790434 -3.69418 1.29027     -0.287266 -1.67078 2.48017      2.06173 -1.39848 1.79787        1. 0. 0.
-.790434 -3.69418 1.29027     0.917634 -3.66448 -0.484829     -1.52417 -3.64138 0.503471      1. 0. 0.
-  -0.573766 -1.42458 -2.91753   0.450934 -2.72908 -2.23353      -1.62867 -3.74268 -1.79493      1. 0. 0.
-  -0.573766 -1.42458 -2.91753   -2.77417 -0.570279 -1.12083     -3.94777 1.63002 -1.27603       1. 0. 0.
-.03283 1.01972 -2.14533      -2.87097 2.29272 -0.0233288     -3.94777 1.63002 -1.27603       1. 0. 0.
-.917634 -3.66448 -0.484829   0.450934 -2.72908 -2.23353      -1.62867 -3.74268 -1.79493      1. 0. 0.
-  -0.759066 -0.265179 1.48487   1.46453 0.112321 2.50927        -2.87097 2.29272 -0.0233288     1. 0. 0.
-  -0.759066 -0.265179 1.48487   -0.287266 -1.67078 2.48017      1.46453 0.112321 2.50927        1. 0. 0.
-.790434 -3.69418 1.29027     -1.52417 -3.64138 0.503471      -0.287266 -1.67078 2.48017      1. 0. 0.
-.917634 -3.66448 -0.484829   -1.52417 -3.64138 0.503471      -1.62867 -3.74268 -1.79493      1. 0. 0.
-  -0.573766 -1.42458 -2.91753   -1.62867 -3.74268 -1.79493      -2.49667 -2.18078 -1.79993      1. 0. 0.
-  -0.573766 -1.42458 -2.91753   -2.49667 -2.18078 -1.79993      -2.77417 -0.570279 -1.12083     1. 0. 0.
-  -2.49667 -2.18078 -1.79993    -2.77417 -0.570279 -1.12083     -3.94777 1.63002 -1.27603       1. 0. 0.
-  -2.87097 2.29272 -0.0233288   -3.94777 1.63002 -1.27603       -4.04457 4.49292 -0.178529      1. 0. 0.
-  -0.759066 -0.265179 1.48487   -3.66127 0.565021 1.57007       -2.87097 2.29272 -0.0233288     1. 0. 0.
-  -0.759066 -0.265179 1.48487   -0.287266 -1.67078 2.48017      -3.66127 0.565021 1.57007       1. 0. 0.
-  -1.52417 -3.64138 0.503471    -0.287266 -1.67078 2.48017      -2.45927 -1.63678 1.72157       1. 0. 0.
-  -1.52417 -3.64138 0.503471    -1.62867 -3.74268 -1.79493      -3.90927 -3.49908 0.839771      1. 0. 0.
-  -1.62867 -3.74268 -1.79493    -2.49667 -2.18078 -1.79993      -4.17327 -2.53828 -0.635229     1. 0. 0.
-  -2.49667 -2.18078 -1.79993    -4.17327 -2.53828 -0.635229     -3.94777 1.63002 -1.27603       1. 0. 0.
-.58823 2.50762 1.23707       -2.87097 2.29272 -0.0233288     -4.04457 4.49292 -0.178529      1. 0. 0.
-  -3.94777 1.63002 -1.27603     -4.04457 4.49292 -0.178529      -5.12137 3.83022 -1.43123       1. 0. 0.
-  -3.66127 0.565021 1.57007     -2.87097 2.29272 -0.0233288     -4.83487 2.76522 1.41487        1. 0. 0.
-  -0.287266 -1.67078 2.48017    -2.45927 -1.63678 1.72157       -3.66127 0.565021 1.57007       1. 0. 0.
-  -1.52417 -3.64138 0.503471    -2.45927 -1.63678 1.72157       -3.90927 -3.49908 0.839771      1. 0. 0.
-  -1.62867 -3.74268 -1.79493    -4.17327 -2.53828 -0.635229     -3.90927 -3.49908 0.839771      1. 0. 0.
-  -4.17327 -2.53828 -0.635229   -3.94777 1.63002 -1.27603       -6.42617 1.74722 -0.982629      1. 0. 0.
-  -3.94777 1.63002 -1.27603     -5.12137 3.83022 -1.43123       -6.42617 1.74722 -0.982629      1. 0. 0.
   -5.12137 3.83022 -1.43123     -7.11497 2.49352 0.479071       -6.42617 1.74722 -0.982629      1. 0. 0.
-  -6.27887 0.926121 0.589671    -7.11497 2.49352 0.479071       -6.42617 1.74722 -0.982629      1. 0. 0.
-  -4.17327 -2.53828 -0.635229   -6.27887 0.926121 0.589671      -6.42617 1.74722 -0.982629      1. 0. 0.
-  -4.75167 -1.93408 0.935971    -4.17327 -2.53828 -0.635229     -6.27887 0.926121 0.589671      1. 0. 0.
-  -4.75167 -1.93408 0.935971    -3.66127 0.565021 1.57007       -6.27887 0.926121 0.589671      1. 0. 0.
-  -3.66127 0.565021 1.57007     -4.83487 2.76522 1.41487        -6.27887 0.926121 0.589671      1. 0. 0.
-  -4.83487 2.76522 1.41487      -6.27887 0.926121 0.589671      -7.11497 2.49352 0.479071       1. 0. 0.
-  -4.83487 2.76522 1.41487      -5.81017 4.57652 0.0304712      -7.11497 2.49352 0.479071       1. 0. 0.
   -5.81017 4.57652 0.0304712    -5.12137 3.83022 -1.43123       -7.11497 2.49352 0.479071       1. 0. 0.
   -5.81017 4.57652 0.0304712    -4.04457 4.49292 -0.178529      -5.12137 3.83022 -1.43123       1. 0. 0.
-  -4.83487 2.76522 1.41487      -5.81017 4.57652 0.0304712      -4.04457 4.49292 -0.178529      1. 0. 0.
-  -2.87097 2.29272 -0.0233288   -4.83487 2.76522 1.41487        -4.04457 4.49292 -0.178529      1. 0. 0.
-.58823 2.50762 1.23707       -2.87097 2.29272 -0.0233288     -4.04457 4.49292 -0.178529      1. 0. 0.
-  -2.45927 -1.63678 1.72157     -4.75167 -1.93408 0.935971      -3.66127 0.565021 1.57007       1. 0. 0.
-  -2.45927 -1.63678 1.72157     -4.75167 -1.93408 0.935971      -3.90927 -3.49908 0.839771      1. 0. 0.
-  -4.75167 -1.93408 0.935971    -4.17327 -2.53828 -0.635229     -3.90927 -3.49908 0.839771      1. 0. 0.
 #  terminating special property
 …
 .0    0.6     -1.0 -1.0 -1.0     0.2        0 0 0 0
   -4.27807 -2.65715 0.380171    5       1 0 0
+  -4.99203 4.29989 -0.526429    5       1 0 0
   terminating special property

TabularUnified tests/testsuite.at ¶

-              r9fe36b
+              rb8d1aeb
 AT_CHECK([pwd],[ignore],[ignore])
 AT_CHECK([../../molecuilder -v], 0, [stdout], [ignore])
 AT_CHECK([fgrep molecuilder stdout], 0, [ignore], [ignore])
+AT_CHECK([fgrep olecuilder stdout], 0, [ignore], [ignore])
 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([../../molecuilder -e], 255, [ignore], [stderr])
 AT_CHECK([fgrep "Not enough or invalid arguments" stderr], 0, [ignore], [ignore])
 AT_CHECK([../../molecuilder test.conf], 0, [stdout], [stderr])
 …
 AT_SETUP([Simple configuration - invalid commands on present configs])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/regression/Simple_configuration/7/pre/test.conf .], 0)
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -t -s -b -E -c -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "Not enough or invalid" stderr], 0, [9
+], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -t], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough or invalid" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -s -b -E -c -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough or invalid" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -b -E -c -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough or invalid" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -E -c -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough or invalid" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -c -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough or invalid" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -b -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough or invalid" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -a -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough or invalid" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -U -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough or invalid" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -T -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough or invalid" stderr], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -u], 255, [ignore], [stderr])
+AT_CHECK([fgrep -c "CRITICAL: Not enough or invalid" stderr], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 AT_SETUP([Graph - DFS analysis])
 AT_CHECK([/bin/cp -f ${abs_top_srcdir}/${AUTOTEST_PATH}/regression/Graph/1/pre/test.conf .], 0)
 AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -D 2.], 0, [stdout], [stderr])
+AT_CHECK([../../molecuilder test.conf -e ${abs_top_srcdir}/src/ -vvv -D 2.], 0, [stdout], [stderr])
 AT_CHECK([fgrep -c "No rings were detected in the molecular structure." stdout], 0, [1
 ], [ignore])
 …
 AT_CHECK([file=ConvexEnvelope.dat; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/regression/Tesselation/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([file=ConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/regression/Tesselation/2/post/$file], 0, [ignore], [ignore])
 AT_CHECK([fgrep "RESULT: The summed volume is 16.401577 angstrom^3" stdout], 0, [ignore], [ignore])
+AT_CHECK([fgrep "tesselated volume area is 16.4016 angstrom^3" stdout], 0, [ignore], [ignore])
 AT_CHECK([diff ConvexEnvelope.dat NonConvexEnvelope.dat], 0, [ignore], [ignore])
 AT_CLEANUP
 …
 #AT_CHECK([file=ConvexEnvelope.dat; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/regression/Tesselation/4/post/$file], 0, [ignore], [ignore])
 #AT_CHECK([file=ConvexEnvelope.r3d; diff $file ${abs_top_srcdir}/${AUTOTEST_PATH}/regression/Tesselation/4/post/$file], 0, [ignore], [ignore])
 #AT_CHECK([fgrep "RESULT: The summed volume is 16.401577 angstrom^3" stdout], 0, [ignore], [ignore])
+#AT_CHECK([fgrep "tesselated volume area is 16.4016 angstrom^3" stdout], 0, [ignore], [ignore])
 #AT_CLEANUP

Context Navigation

Changes in / [9fe36b:b8d1aeb]

Legend:

TabularUnified src/Actions/small_actions.cpp ¶

TabularUnified src/Makefile.am ¶

TabularUnified src/UIElements/Dialog.cpp ¶

TabularUnified src/UIElements/Dialog.hpp ¶

TabularUnified src/UIElements/QT4/QTDialog.cpp ¶

TabularUnified src/UIElements/QT4/QTDialog.hpp ¶

TabularUnified src/UIElements/TextDialog.cpp ¶

TabularUnified src/UIElements/TextDialog.hpp ¶

TabularUnified src/analysis_correlation.cpp ¶

TabularUnified src/analysis_correlation.hpp ¶

TabularUnified src/analyzer.cpp ¶

TabularUnified src/atom_bondedparticle.cpp ¶

TabularUnified src/bondgraph.cpp ¶

TabularUnified src/boundary.cpp ¶

TabularUnified src/boundary.hpp ¶

TabularUnified src/builder.cpp ¶

TabularUnified src/config.cpp ¶

TabularUnified src/helpers.hpp ¶

TabularUnified src/joiner.cpp ¶

TabularUnified src/memoryallocator.hpp ¶

TabularUnified src/memoryusageobserver.cpp ¶

TabularUnified src/molecule.cpp ¶

TabularUnified src/molecule.hpp ¶

TabularUnified src/molecule_dynamics.cpp ¶

TabularUnified src/molecule_fragmentation.cpp ¶

TabularUnified src/molecule_geometry.cpp ¶

TabularUnified src/molecule_graph.cpp ¶

TabularUnified src/molecule_pointcloud.cpp ¶

TabularUnified src/moleculelist.cpp ¶

TabularUnified src/parser.cpp ¶

TabularUnified src/periodentafel.cpp ¶

TabularUnified src/tesselation.cpp ¶

TabularUnified src/tesselation.hpp ¶

TabularUnified src/tesselationhelpers.cpp ¶

TabularUnified src/tesselationhelpers.hpp ¶

TabularUnified src/unittests/AnalysisCorrelationToPointUnitTest.cpp ¶

TabularUnified src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp ¶

TabularUnified src/unittests/AnalysisPairCorrelationUnitTest.cpp ¶

TabularUnified src/unittests/Makefile.am ¶

TabularUnified src/unittests/analysisbondsunittest.cpp ¶

TabularUnified src/unittests/bondgraphunittest.cpp ¶

TabularUnified src/unittests/listofbondsunittest.cpp ¶

TabularUnified src/unittests/tesselationunittest.cpp ¶

TabularUnified src/unittests/tesselationunittest.hpp ¶

TabularUnified src/vector.cpp ¶

TabularUnified src/vector.hpp ¶

TabularUnified src/verbose.cpp ¶

TabularUnified tests/Tesselations/1_2-dimethoxyethane/NonConvexEnvelope-1_2-dimethoxyethane.dat ¶

TabularUnified tests/Tesselations/1_2-dimethylbenzene/NonConvexEnvelope-1_2-dimethylbenzene.dat ¶

TabularUnified tests/Tesselations/2-methylcyclohexanone/NonConvexEnvelope-2-methylcyclohexanone.dat ¶

TabularUnified tests/Tesselations/C16_0-Torus/NonConvexEnvelope-C16_0-Torus.dat ¶

TabularUnified tests/Tesselations/Makefile.am ¶

TabularUnified tests/Tesselations/N_N-dimethylacetamide/NonConvexEnvelope-N_N-dimethylacetamide.dat ¶

TabularUnified tests/Tesselations/cholesterol/NonConvexEnvelope-cholesterol.dat ¶

TabularUnified tests/Tesselations/cluster/NonConvexEnvelope-cluster.dat ¶

TabularUnified tests/Tesselations/cycloheptane/NonConvexEnvelope-cycloheptane.dat ¶

TabularUnified tests/Tesselations/defs.in ¶

TabularUnified tests/Tesselations/dimethyl_bromomalonate/NonConvexEnvelope-dimethyl_bromomalonate.dat ¶

TabularUnified tests/Tesselations/glucose/NonConvexEnvelope-glucose.dat ¶

TabularUnified tests/Tesselations/heptan/NonConvexEnvelope-heptan.dat ¶

TabularUnified tests/Tesselations/isoleucine/NonConvexEnvelope-isoleucine.dat ¶

TabularUnified tests/Tesselations/neohexane/NonConvexEnvelope-neohexane.dat ¶

TabularUnified tests/Tesselations/proline/NonConvexEnvelope-proline.dat ¶

TabularUnified tests/Tesselations/putrescine/NonConvexEnvelope-putrescine.dat ¶

TabularUnified tests/Tesselations/round_cluster/NonConvexEnvelope-round_cluster.dat ¶

TabularUnified tests/Tesselations/tartaric_acid/NonConvexEnvelope-tartaric_acid.dat ¶

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

TabularUnified tests/regression/Tesselation/1/post/NonConvexEnvelope.r3d ¶

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

TabularUnified tests/regression/Tesselation/2/post/ConvexEnvelope.r3d ¶

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

TabularUnified tests/regression/Tesselation/2/post/NonConvexEnvelope.r3d ¶

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

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

TabularUnified tests/testsuite.at ¶

Download in other formats: