Changeset 13a574

Timestamp:

Oct 5, 2009, 6:45:06 PM (16 years ago)

Author:

Frederik Heber <heber@…>

Branches:

Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable

Children:

33f9f7

Parents:

aba92d (diff), fa861b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'ConvexHull' into ActOnAll

Conflicts:

molecuilder/src/Makefile.am

Boost implementation commit was overlapping with ActOnAllTest

Files:

• configure.ac (modified) (1 diff)
• m4/ax_boost_base.m4 (added)
• m4/ax_boost_program_options.m4 (added)
• src/Makefile.am (modified) (2 diffs, 1 prop)
• src/analyzer.cpp (modified) (3 diffs)
• src/atom.cpp (modified) (4 diffs)
• src/boundary.cpp (modified) (1 diff)
• src/builder.cpp (modified) (4 diffs, 1 prop)
• src/config.cpp (modified) (19 diffs)
• src/defs.hpp (modified) (1 diff)
• src/helpers.cpp (modified) (4 diffs, 1 prop)
• src/helpers.hpp (modified) (4 diffs)
• src/joiner.cpp (modified) (3 diffs)
• src/memoryallocator.hpp (added)
• src/memoryallocatorunittest.cpp (added)
• src/memoryallocatorunittest.hpp (added)
• src/memoryusageobserver.cpp (added)
• src/memoryusageobserver.hpp (added)
• src/memoryusageobserverunittest.cpp (added)
• src/memoryusageobserverunittest.hpp (added)
• src/moleculelist.cpp (modified) (9 diffs)
• src/molecules.cpp (modified) (69 diffs)
• src/molecules.hpp (modified) (1 diff)
• src/parser.cpp (modified) (28 diffs)
• src/stackclass.hpp (modified) (3 diffs)
• src/tesselation.cpp (modified) (1 diff)
• src/tesselationunittest.cpp (modified) (2 diffs)
• src/vector.cpp (modified) (5 diffs)
• src/vector.hpp (modified) (1 diff)
• src/vectorunittest.cpp (modified) (2 diffs)
• src/vectorunittest.hpp (modified) (1 diff)
• tests/testsuite.at (modified) (2 diffs)

configure.ac

@@ -24 +24 @@
 # Checks for libraries.
 AC_CHECK_LIB(m, sqrt, ,AC_MSG_ERROR([compatible libc math library not found]))
+
+# Boost libraries
+AX_BOOST_BASE([1.33.1])
+AX_BOOST_PROGRAM_OPTIONS
+#AX_BOOST_FOREACH
+#AX_BOOST_FILESYSTEM
+#AX_BOOST_THREAD
+#AX_BOOST_PROGRAM_OPTIONS
+#AX_BOOST_SERIALIZATION
 
 # Checks for header files.

src/Makefile.am

@@ -1 +1 @@
 SOURCE = atom.cpp bond.cpp boundary.cpp config.cpp element.cpp ellipsoid.cpp helpers.cpp leastsquaremin.cpp linkedcell.cpp moleculelist.cpp molecules.cpp parser.cpp periodentafel.cpp tesselation.cpp tesselationhelpers.cpp vector.cpp verbose.cpp
-HEADER = atom.hpp bond.hpp boundary.hpp config.hpp defs.hpp element.hpp ellipsoid.hpp helpers.hpp leastsquaremin.hpp linkedcell.hpp molecules.hpp parser.hpp periodentafel.hpp stackclass.hpp tesselation.hpp tesselationhelpers.hpp vector.hpp verbose.hpp
+HEADER = atom.hpp bond.hpp boundary.hpp config.hpp defs.hpp element.hpp ellipsoid.hpp helpers.hpp leastsquaremin.hpp linkedcell.hpp memoryallocator.hpp memoryusageobserver.cpp memoryusageobserver.hpp molecules.hpp parser.hpp periodentafel.hpp stackclass.hpp tesselation.hpp tesselationhelpers.hpp vector.hpp verbose.hpp
 
-noinst_PROGRAMS =  ActOnAllTest VectorUnitTest TesselationUnitTest
+noinst_PROGRAMS =  ActOnAllTest VectorUnitTest MemoryAllocatorUnitTest MemoryUsageObserverUnitTest TesselationUnitTest
+
+BOOST_LIB = $(BOOST_LDFLAGS) $(BOOST_MPL_LIB)
 
 bin_PROGRAMS = molecuilder joiner analyzer
 molecuilderdir = ${bindir}
 molecuilder_DATA = elements.db valence.db orbitals.db Hbonddistance.db Hbondangle.db
+molecuilder_LDFLAGS = $(BOOST_LIB)
 molecuilder_SOURCES =  ${SOURCE} builder.cpp  ${HEADER}
-joiner_SOURCES = joiner.cpp datacreator.cpp element.cpp helpers.cpp periodentafel.cpp parser.cpp verbose.cpp datacreator.hpp helpers.hpp parser.hpp periodentafel.hpp 
-analyzer_SOURCES = analyzer.cpp datacreator.cpp element.cpp helpers.cpp periodentafel.cpp parser.cpp verbose.cpp helpers.hpp periodentafel.hpp parser.hpp datacreator.hpp 
+joiner_SOURCES = joiner.cpp datacreator.cpp element.cpp helpers.cpp memoryallocator.hpp memoryusageobserver.cpp memoryusageobserver.hpp periodentafel.cpp parser.cpp verbose.cpp datacreator.hpp helpers.hpp parser.hpp periodentafel.hpp 
+analyzer_SOURCES = analyzer.cpp datacreator.cpp element.cpp helpers.cpp memoryallocator.hpp memoryusageobserver.cpp memoryusageobserver.hpp periodentafel.cpp parser.cpp verbose.cpp helpers.hpp periodentafel.hpp parser.hpp datacreator.hpp 
 
-TESTS = VectorUnitTest TesselationUnitTest
+TESTS = VectorUnitTest MemoryAllocatorUnitTest MemoryUsageObserverUnitTest TesselationUnitTest
 check_PROGRAMS = $(TESTS)
-VectorUnitTest_SOURCES = defs.hpp helpers.cpp helpers.hpp leastsquaremin.cpp leastsquaremin.hpp vectorunittest.cpp vectorunittest.hpp vector.cpp vector.hpp verbose.cpp verbose.hpp 
+VectorUnitTest_SOURCES = defs.hpp helpers.cpp helpers.hpp leastsquaremin.cpp leastsquaremin.hpp memoryallocator.hpp memoryusageobserver.cpp memoryusageobserver.hpp vectorunittest.cpp vectorunittest.hpp vector.cpp vector.hpp verbose.cpp verbose.hpp 
 VectorUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS)
 VectorUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
-TesselationUnitTest_SOURCES = defs.hpp helpers.cpp helpers.hpp leastsquaremin.cpp leastsquaremin.hpp linkedcell.cpp linkedcell.hpp tesselation.cpp tesselation.hpp tesselationhelpers.cpp tesselationhelpers.hpp tesselationunittest.cpp tesselationunittest.hpp vector.cpp vector.hpp verbose.cpp verbose.hpp
+TesselationUnitTest_SOURCES = defs.hpp helpers.cpp helpers.hpp leastsquaremin.cpp leastsquaremin.hpp linkedcell.cpp linkedcell.hpp memoryallocator.hpp memoryusageobserver.cpp memoryusageobserver.hpp tesselation.cpp tesselation.hpp tesselationhelpers.cpp tesselationhelpers.hpp tesselationunittest.cpp tesselationunittest.hpp vector.cpp vector.hpp verbose.cpp verbose.hpp
 TesselationUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS)
 TesselationUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
@@ -24 +27 @@
 
 
+MemoryAllocatorUnitTest_SOURCES = defs.hpp helpers.cpp helpers.hpp memoryallocatorunittest.cpp memoryallocatorunittest.hpp memoryallocator.hpp memoryusageobserver.cpp memoryusageobserver.hpp verbose.cpp verbose.hpp 
+MemoryAllocatorUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS)
+MemoryAllocatorUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
+
+MemoryUsageObserverUnitTest_SOURCES = defs.hpp helpers.cpp helpers.hpp memoryusageobserverunittest.cpp memoryusageobserverunittest.hpp memoryusageobserver.hpp memoryusageobserver.cpp verbose.cpp verbose.hpp 
+MemoryUsageObserverUnitTest_CXXFLAGS = $(CPPUNIT_CFLAGS)
+MemoryUsageObserverUnitTest_LDFLAGS = $(CPPUNIT_LIBS) -ldl
+
 EXTRA_DIST = ${molecuilder_DATA}

src/analyzer.cpp

@@ -10 +10 @@
 #include "datacreator.hpp"
 #include "helpers.hpp"
+#include "memoryallocator.hpp"
 #include "parser.hpp"
 #include "periodentafel.hpp"
@@ -72 +73 @@
     return 1;
   } else {
-    dir = (char *) Malloc(sizeof(char)*(strlen(argv[2])+2), "main: *dir");
+    dir = Malloc<char>(strlen(argv[2]) + 2, "main: *dir");
     strcpy(dir, "/");
     strcat(dir, argv[2]);
@@ -555 +556 @@
   // ++++++++++++++++ exit ++++++++++++++++++++++++++++++++++
   delete(periode);
-  Free((void **)&dir, "main: *dir");
+  Free(&dir);
   cout << "done." << endl;
   return 0;

src/atom.cpp

@@ -6 +6 @@
 
 #include "atom.hpp"
+#include "memoryallocator.hpp"
 
 /************************************* Functions for class atom *************************************/
@@ -38 +39 @@
   previous = NULL;
   next = NULL;
-  father = this;  // generally, father is itself
+  father = pointer;  // generally, father is itself
   Ancestor = NULL;
   GraphNr = -1;
@@ -53 +54 @@
   nr = -1;
   sort = &nr;
+  node = &x;
 }
 
@@ -60 +62 @@
 atom::~atom()
 {
-  Free((void **)&ComponentNr, "atom::~atom: *ComponentNr");
-  Free((void **)&Name, "atom::~atom: *Name");
+  Free<int>(&ComponentNr, "atom::~atom: *ComponentNr");
+  Free<char>(&Name, "atom::~atom: *Name");
 };
 

src/boundary.cpp

@@ -6 +6 @@
 
 #include "boundary.hpp"
+#include "memoryallocator.hpp"
 
 #include<gsl/gsl_poly.h>

src/builder.cpp

@@ -53 +53 @@
 #include "ellipsoid.hpp"
 #include "helpers.hpp"
+#include "memoryusageobserverunittest.hpp"
 #include "molecules.hpp"
 /********************************************* Subsubmenu routine ************************************/
@@ -1558 +1559 @@
                   delete(Subgraphs);
                   for (int i=0;i<FragmentCounter;i++)
-                    Free((void **)&ListOfLocalAtoms[FragmentCounter], "ParseCommandLineOptions: **ListOfLocalAtoms[]");
-                  Free((void **)&ListOfLocalAtoms, "ParseCommandLineOptions: ***ListOfLocalAtoms");
+                    Free(&ListOfLocalAtoms[FragmentCounter]);
+                  Free(&ListOfLocalAtoms);
                 }
                 delete(BackEdgeStack);
@@ -2041 +2042 @@
       delete(molecules); // also free's all molecules contained
       delete(periode);
-      return j;
+      cout << Verbose(0) <<  "Maximum of allocated memory: "
+        << MemoryUsageObserver::getInstance()->getMaximumUsedMemory() << endl;
+      cout << Verbose(0) <<  "Remaining non-freed memory: "
+        << MemoryUsageObserver::getInstance()->getUsedMemorySize() << endl;
+     return j;
       break;
     case 1:  // just for -v and -h options
       delete(molecules); // also free's all molecules contained
       delete(periode);
+      cout << Verbose(0) <<  "Maximum of allocated memory: "
+        << MemoryUsageObserver::getInstance()->getMaximumUsedMemory() << endl;
+      cout << Verbose(0) <<  "Remaining non-freed memory: "
+        << MemoryUsageObserver::getInstance()->getUsedMemorySize() << endl;
       return 0;
+      break;
+    case 2:  // just for -f option
+      delete(molecules); // also free's all molecules contained
+      delete(periode);
+      cout << Verbose(0) <<  "Maximum of allocated memory: "
+        << MemoryUsageObserver::getInstance()->getMaximumUsedMemory() << endl;
+      cout << Verbose(0) <<  "Remaining non-freed memory: "
+        << MemoryUsageObserver::getInstance()->getUsedMemorySize() << endl;
+      return 2;
       break;
     default:
@@ -2144 +2162 @@
   delete(molecules); // also free's all molecules contained
   delete(periode);
+
+  cout << Verbose(0) <<  "Maximum of allocated memory: "
+    << MemoryUsageObserver::getInstance()->getMaximumUsedMemory() << endl;
+  cout << Verbose(0) <<  "Remaining non-freed memory: "
+    << MemoryUsageObserver::getInstance()->getUsedMemorySize() << endl;
+
   return (0);
 }

src/config.cpp

@@ -6 +6 @@
 
 #include "config.hpp"
+#include "memoryallocator.hpp"
 
 /******************************** Functions for class ConfigFileBuffer **********************/
@@ -86 +87 @@
     return;
   } else
-    buffer = (char **) Malloc(sizeof(char *)*NoLines, "ConfigFileBuffer::ConfigFileBuffer: **buffer");
+    buffer = Malloc<char*>(NoLines, "ConfigFileBuffer::ConfigFileBuffer: **buffer");
 
   // scan each line and put into buffer
@@ -92 +93 @@
   int i;
   do {
-    buffer[lines] = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "ConfigFileBuffer::ConfigFileBuffer: *buffer[]");
+    buffer[lines] = Malloc<char>(MAXSTRINGSIZE, "ConfigFileBuffer::ConfigFileBuffer: *buffer[]");
     file->getline(buffer[lines], MAXSTRINGSIZE-1);
     i = strlen(buffer[lines]);
@@ -112 +113 @@
 {
   for(int i=0;i<NoLines;++i)
-    Free((void **)&buffer[i], "ConfigFileBuffer::~ConfigFileBuffer: *buffer[]");
-  Free((void **)&buffer, "ConfigFileBuffer::~ConfigFileBuffer: **buffer");
-  Free((void **)&LineMapping, "ConfigFileBuffer::~ConfigFileBuffer: *LineMapping");
+    Free(&buffer[i]);
+  Free(&buffer);
+  Free(&LineMapping);
 }
 
@@ -122 +123 @@
 void ConfigFileBuffer::InitMapping()
 {
-  LineMapping = (int *) Malloc(sizeof(int)*NoLines, "ConfigFileBuffer::InitMapping: *LineMapping");
+  LineMapping = Malloc<int>(NoLines, "ConfigFileBuffer::InitMapping: *LineMapping");
   for (int i=0;i<NoLines;i++)
     LineMapping[i] = i;
@@ -163 +164 @@
 config::config()
 {
-  mainname = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: mainname");
-  defaultpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: defaultpath");
-  pseudopotpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: pseudopotpath");
-  databasepath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: databasepath");
-  configpath = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: configpath");
-  configname = (char *) MallocString(sizeof(char)*MAXSTRINGSIZE,"config constructor: configname");
-  ThermostatImplemented = (int *) Malloc((MaxThermostats)*(sizeof(int)), "config constructor: *ThermostatImplemented");
-  ThermostatNames = (char **) Malloc((MaxThermostats)*(sizeof(char *)), "config constructor: *ThermostatNames");
+  mainname = Malloc<char>(MAXSTRINGSIZE,"config constructor: mainname");
+  defaultpath = Malloc<char>(MAXSTRINGSIZE,"config constructor: defaultpath");
+  pseudopotpath = Malloc<char>(MAXSTRINGSIZE,"config constructor: pseudopotpath");
+  databasepath = Malloc<char>(MAXSTRINGSIZE,"config constructor: databasepath");
+  configpath = Malloc<char>(MAXSTRINGSIZE,"config constructor: configpath");
+  configname = Malloc<char>(MAXSTRINGSIZE,"config constructor: configname");
+  ThermostatImplemented = Malloc<int>(MaxThermostats, "config constructor: *ThermostatImplemented");
+  ThermostatNames = Malloc<char*>(MaxThermostats, "config constructor: *ThermostatNames");
   for (int j=0;j<MaxThermostats;j++)
-    ThermostatNames[j] = (char *) MallocString(12*(sizeof(char)), "config constructor: ThermostatNames[]");
+    ThermostatNames[j] = Malloc<char>(12, "config constructor: ThermostatNames[]");
   Thermostat = 4;
   alpha = 0.;
@@ -263 +264 @@
 config::~config()
 {
-  Free((void **)&mainname, "config::~config: *mainname");
-  Free((void **)&defaultpath, "config::~config: *defaultpath");
-  Free((void **)&pseudopotpath, "config::~config: *pseudopotpath");
-  Free((void **)&databasepath, "config::~config: *databasepath");
-  Free((void **)&configpath, "config::~config: *configpath");
-  Free((void **)&configname, "config::~config: *configname");
-  Free((void **)&ThermostatImplemented, "config::~config: *ThermostatImplemented");
+  Free(&mainname);
+  Free(&defaultpath);
+  Free(&pseudopotpath);
+  Free(&databasepath);
+  Free(&configpath);
+  Free(&configname);
+  Free(&ThermostatImplemented);
   for (int j=0;j<MaxThermostats;j++)
-    Free((void **)&ThermostatNames[j], "config::~config: *ThermostatNames[]");
-  Free((void **)&ThermostatNames, "config::~config: **ThermostatNames");
+    Free(&ThermostatNames[j]);
+  Free(&ThermostatNames);
 };
 
@@ -280 +281 @@
 void config::InitThermostats(class ConfigFileBuffer *fb)
 {
-  char *thermo = MallocString(12, "IonsInitRead: thermo");
+  char *thermo = Malloc<char>(12, "IonsInitRead: thermo");
   int verbose = 0;
 
@@ -347 +348 @@
     Thermostat = None;
   }
-  Free((void **)&thermo, "InitThermostats: thermo");
+  Free(&thermo);
 };
 
@@ -1536 +1537 @@
   long file_position = file->tellg(); // mark current position
   char *dummy1, *dummy, *free_dummy;    // pointers in the line that is read in per step
-  dummy1 = free_dummy = (char *) Malloc(256 * sizeof(char), "config::ParseForParameter: *free_dummy");
+  dummy1 = free_dummy = Malloc<char>(256, "config::ParseForParameter: *free_dummy");
 
   //fprintf(stderr,"Parsing for %s\n",name);
@@ -1551 +1552 @@
       if (file->eof()) {
         if ((critical) && (found == 0)) {
-          Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+          Free(&free_dummy);
           //Error(InitReading, name);
           fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
@@ -1559 +1560 @@
           file->clear();
           file->seekg(file_position, ios::beg);  // rewind to start position
-          Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+          Free(&free_dummy);
           return 0;
         }
@@ -1611 +1612 @@
               if (file->eof()) {
                 if ((critical) && (found == 0)) {
-                  Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+                  Free(&free_dummy);
                   //Error(InitReading, name);
                   fprintf(stderr,"Error:InitReading, critical %s not found\n", name);
@@ -1619 +1620 @@
                   file->clear();
                   file->seekg(file_position, ios::beg);  // rewind to start position
-                  Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+                  Free(&free_dummy);
                   return 0;
                 }
@@ -1660 +1661 @@
                   if (critical) {
                     if (verbose) fprintf(stderr,"Error: EoL at %i and still missing %i value(s) for parameter %s\n", line, yth-j, name);
-                    Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+                    Free(&free_dummy);
                     //return 0;
                     exit(255);
@@ -1668 +1669 @@
                     file->clear();
                     file->seekg(file_position, ios::beg);  // rewind to start position
-                    Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+                    Free(&free_dummy);
                     return 0;
                   }
@@ -1681 +1682 @@
                   file->seekg(file_position, ios::beg);  // rewind to start position
                 }
-                Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+                Free(&free_dummy);
                 return 0;
               }
@@ -1735 +1736 @@
     }
   }
-  if ((type >= row_int) && (verbose)) fprintf(stderr,"\n");
-  Free((void **)&free_dummy, "config::ParseForParameter: *free_dummy");
+  if ((type >= row_int) && (verbose))
+    fprintf(stderr,"\n");
+  Free(&free_dummy);
   if (!sequential) {
     file->clear();
@@ -1814 +1816 @@
         dummy = strchr(dummy1, '\n'); // set on line end then (whole line = keyword)
         //fprintf(stderr,"Error: Cannot find tabs or spaces on line %i in search for %s\n", line, name);
-        //Free((void **)&free_dummy);
+        //Free(&free_dummy);
         //Error(FileOpenParams, NULL);
       } else {

src/defs.hpp

@@ -7 +7 @@
 #ifndef DEFS_HPP_
 #define DEFS_HPP_
-
-using namespace std;
 
 #define MYEPSILON 1e-13   //!< machine epsilon precision

src/helpers.cpp

@@ -6 +6 @@
 
 #include "helpers.hpp"
+#include "memoryusageobserver.hpp"
 
 /********************************************** helpful functions *********************************/
@@ -34 +35 @@
 void debug_in(const char *output, const char *file, const int line) {}  // print nothing
 #endif
-
-/** Wrapper for allocating'ing a memory range with *output if it fails.
- * \param size number of chars to alloc for \a *buffer
- * \param *output message if malloc fails
- * \return pointer to memory range
- */
-void * Malloc(size_t size, const char* output)
-{
-  void *buffer = NULL;
-  buffer = (void *)malloc(size); // alloc
-  if (buffer == NULL)
-    cout << Verbose(0) << "Malloc failed - pointer is NULL: " << output << endl;
-  return(buffer);
-};
-
-/** Wrapper for allocating'ing a memory range with *output if it fails.
- * \param size number of chars to alloc for \a *buffer
- * \param *output message if malloc fails
- * \return pointer to memory range
- */
-void * Calloc(size_t size, const char* output)
-{
-  void *buffer = NULL;
-  buffer = (void *)calloc(size, (size_t)0); // alloc
-  if (buffer == NULL)
-    cout << Verbose(0) << "Calloc failed - pointer is NULL: " << output << endl;
-  return(buffer);
-};
-
-/** Wrapper for reallocating'ing a memory range with *output if it fails.
- * \param *OldPointer pointer to old memory range
- * \param size number of chars to alloc for \a *buffer
- * \param *output message if malloc fails
- * \return pointer to memory range
- */
-void * ReAlloc(void * OldPointer, size_t size, const char* output)
-{
-  void *buffer = NULL;
-  if (OldPointer == NULL)
-    //cout << Verbose(0) << "ReAlloc impossible - old is NULL: " << output << endl;
-    buffer = (void *)malloc(size); // malloc
-  else
-    buffer = (void *)realloc(OldPointer, size); // realloc
-  if (buffer == NULL)
-    cout << Verbose(0) << "ReAlloc failed - new is NULL: " << output << endl;
-  return(buffer);
-};
-
-/** Wrapper for free'ing an allocated memory range with *output if it fails.
- * \param *buffer pointer to buffer to be free'd
- * \param *output message if free fails
- */
-void Free(void ** buffer, const char* output)
-{
-  if (*buffer == NULL) {
-    //cout << Verbose(5) << "Free not necesary: " << output << endl;
-  } else {
-    free(*buffer);
-    *buffer = NULL;
-  }
-};
-
-/** Malloc string array and set its length to the allocated length.
- * \param *output message if malloc fails
- * \param size number of chars to alloc for \a *buffer
- * \return pointer to string array
- */
-char* MallocString(size_t size, const char* output)
-{
-  size_t i;
-  char *buffer;
-  buffer = (char *)malloc(sizeof(char) * (size+1)); // alloc
-  if (buffer == NULL)
-    cout << Verbose(0) << output << endl;
-  for (i=size;i--;)  // reset
-    buffer[i] = i % 2 == 0 ? 'p': 'c';
-  buffer[size] = '\0'; // and set length marker on its end
-  return(buffer);
-}
 
 /** modulo operator for doubles.
@@ -170 +92 @@
   }
   // allocate string
-  returnstring = (char *) Malloc(sizeof(char)*(order+2), "FixedDigitNumber: *returnstring");
+  returnstring = Malloc<char>(order + 2, "FixedDigitNumber: *returnstring");
   // terminate  and fill string array from end backward
   returnstring[order] = '\0';
@@ -196 +118 @@
 };
 
+/**
+ * Allocates a memory range using malloc().
+ * Prints the provided error message in case of a failure.
+ *
+ * \param number of memory slices of type X to allocate
+ * \param failure message which is printed if the allocation fails
+ * \return pointer to the allocated memory range, will be NULL if a failure occurred
+ */
+template <> char* Malloc<char>(size_t size, const char* output)
+{
+  char* buffer = NULL;
+  buffer = (char*) malloc(sizeof(char) * (size + 1));
+  for (size_t i = size; i--;)
+    buffer[i] = (i % 2 == 0) ? 'p': 'c';
+  buffer[size] = '\0';
 
+  if (buffer != NULL) {
+    MemoryUsageObserver::getInstance()->addMemory(buffer, size);
+  } else {
+    cout << Verbose(0) << "Malloc for datatype " << typeid(char).name()
+      << " failed - pointer is NULL: " << output << endl;
+  }
+
+  return buffer;
+};
+
+

src/helpers.hpp

@@ -23 +23 @@
 #include "defs.hpp"
 #include "verbose.hpp"
+#include "memoryallocator.hpp"
 
 /********************************************** helpful functions *********************************/
@@ -50 +51 @@
 void flip(double *x, double *y);
 int pot(int base, int n);
-void * Malloc(size_t size, const char* output);
-void * Calloc(size_t size, const char* output);
-void * ReAlloc(void * OldPointer, size_t size, const char* output);
-char* MallocString(size_t size, const char* output);
-void Free(void ** buffer, const char* output);
+//void * Malloc(size_t size, const char* output);
+//void * Calloc(size_t size, const char* output);
+//void * ReAlloc(void * OldPointer, size_t size, const char* output);
+//char* MallocString(size_t size, const char* output);
+//void Free(void ** buffer, const char* output);
 char *FixedDigitNumber(const int FragmentNumber, const int digits);
 bool IsValidNumber( const char *string);
@@ -93 +94 @@
 
   // allocat and fill
-  LookupTable = (T **) Malloc(sizeof(T *)*count, "CreateFatherLookupTable - **LookupTable");
+  LookupTable = Malloc<T*>(count, "CreateFatherLookupTable - **LookupTable");
   if (LookupTable == NULL) {
     cerr << "LookupTable memory allocation failed!" << endl;
@@ -273 +274 @@
 
 
+
 #endif /*HELPERS_HPP_*/

src/joiner.cpp

@@ -10 +10 @@
 #include "datacreator.hpp"
 #include "helpers.hpp"
+#include "memoryallocator.hpp"
 #include "parser.hpp"
 #include "periodentafel.hpp"
@@ -55 +56 @@
     return 1;
   } else {
-    dir = (char *) Malloc(sizeof(char)*(strlen(argv[2])+2), "main: *dir");
+    dir = Malloc<char>(strlen(argv[2]) + 2, "main: *dir");
     strcpy(dir, "/");
     strcat(dir, argv[2]);
@@ -240 +241 @@
   // exit
   delete(periode);
-  Free((void **)&dir, "main: *dir");
+  Free(&dir);
   cout << "done." << endl;
   return 0;

src/moleculelist.cpp

@@ -8 +8 @@
 #include "config.hpp"
 #include "molecules.hpp"
+#include "memoryallocator.hpp"
 
 /*********************************** Functions for class MoleculeListClass *************************/
@@ -412 +413 @@
 
   // 0b. allocate memory for constants
-  FitConstant = (double ***) Malloc(sizeof(double **) * 3, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
+  FitConstant = Malloc<double**>(3, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
   for (int k = 0; k < 3; k++) {
-    FitConstant[k] = (double **) Malloc(sizeof(double *) * a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
+    FitConstant[k] = Malloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
     for (int i = a; i--;) {
-      FitConstant[k][i] = (double *) Malloc(sizeof(double) * b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
+      FitConstant[k][i] = Malloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
     }
   }
@@ -461 +462 @@
 
   // 0d. allocate final correction matrix
-  correction = (double **) Malloc(sizeof(double *) * a, "MoleculeListClass::AddHydrogenCorrection: **correction");
+  correction = Malloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **correction");
   for (int i = a; i--;)
-    correction[i] = (double *) Malloc(sizeof(double) * b, "MoleculeListClass::AddHydrogenCorrection: *correction[]");
+    correction[i] = Malloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *correction[]");
 
   // 1a. go through every molecule in the list
@@ -537 +538 @@
   output.close();
   // 6. free memory of parsed matrices
-  FitConstant = (double ***) Malloc(sizeof(double **) * a, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
+  FitConstant = Malloc<double**>(a, "MoleculeListClass::AddHydrogenCorrection: ***FitConstant");
   for (int k = 0; k < 3; k++) {
-    FitConstant[k] = (double **) Malloc(sizeof(double *) * a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
+    FitConstant[k] = Malloc<double*>(a, "MoleculeListClass::AddHydrogenCorrection: **FitConstant[]");
     for (int i = a; i--;) {
-      FitConstant[k][i] = (double *) Malloc(sizeof(double) * b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
+      FitConstant[k][i] = Malloc<double>(b, "MoleculeListClass::AddHydrogenCorrection: *FitConstant[][]");
     }
   }
@@ -702 +703 @@
     //outputFragment.clear();
     delete (FragmentNumber);
-    //Free((void **)&FragmentNumber, "MoleculeListClass::OutputConfigForListOfFragments: *FragmentNumber");
+    //Free(&FragmentNumber);
   }
   cout << " done." << endl;
@@ -845 +846 @@
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
-    Free((void **) &ListOfLocalAtoms[FragmentCounter], "MoleculeLeafClass::FillBondStructureFromReference - **ListOfLocalAtoms[]");
+    Free(&ListOfLocalAtoms[FragmentCounter]);
     if (FragmentCounter == 0) // first fragments frees the initial pointer to list
-      Free((void **) &ListOfLocalAtoms, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
+      Free(&ListOfLocalAtoms);
   }
   FragmentCounter--;
@@ -910 +911 @@
   if (ListOfLocalAtoms == NULL) { // allocated initial pointer
     // allocate and set each field to NULL
-    ListOfLocalAtoms = (atom ***) Malloc(sizeof(atom **) * Counter, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
+    ListOfLocalAtoms = Malloc<atom**>(Counter, "MoleculeLeafClass::FillBondStructureFromReference - ***ListOfLocalAtoms");
     if (ListOfLocalAtoms != NULL) {
       for (int i = Counter; i--;)
@@ -954 +955 @@
   if (FragmentList == NULL) {
     KeySetCounter = Count();
-    FragmentList = (Graph **) Malloc(sizeof(Graph *) * KeySetCounter, "MoleculeLeafClass::AssignKeySetsToFragment - **FragmentList");
+    FragmentList = Malloc<Graph*>(KeySetCounter, "MoleculeLeafClass::AssignKeySetsToFragment - **FragmentList");
     for (int i = KeySetCounter; i--;)
       FragmentList[i] = NULL;
@@ -990 +991 @@
   if ((FreeList) && (ListOfLocalAtoms != NULL)) {
     // free the index lookup list
-    Free((void **) &ListOfLocalAtoms[FragmentCounter], "MoleculeLeafClass::AssignKeySetsToFragment - **ListOfLocalAtoms[]");
+    Free(&ListOfLocalAtoms[FragmentCounter]);
     if (FragmentCounter == 0) // first fragments frees the initial pointer to list
-      Free((void **) &ListOfLocalAtoms, "MoleculeLeafClass::AssignKeySetsToFragment - ***ListOfLocalAtoms");
+      Free(&ListOfLocalAtoms);
   }
   *out << Verbose(1) << "End of AssignKeySetsToFragment." << endl;

src/molecules.cpp

@@ -6 +6 @@
 
 #include "config.hpp"
+#include "memoryallocator.hpp"
 #include "molecules.hpp"
 
@@ -55 +56 @@
   if (ListOfBondsPerAtom != NULL)
     for(int i=AtomCount;i--;)
-      Free((void **)&ListOfBondsPerAtom[i], "molecule::~molecule: ListOfBondsPerAtom[i]");
-  Free((void **)&ListOfBondsPerAtom, "molecule::~molecule: ListOfBondsPerAtom");
-  Free((void **)&NumberOfBondsPerAtom, "molecule::~molecule: NumberOfBondsPerAtom");
+      Free(&ListOfBondsPerAtom[i]);
+  Free(&ListOfBondsPerAtom);
+  Free(&NumberOfBondsPerAtom);
   if (TesselStruct != NULL)
     delete(TesselStruct);
@@ -163 +164 @@
         NoNonHydrogen++;
       if (pointer->Name == NULL) {
-        Free((void **)&pointer->Name, "molecule::AddAtom: *pointer->Name");
-        pointer->Name = (char *) Malloc(sizeof(char)*6, "molecule::AddAtom: *pointer->Name");
+        Free(&pointer->Name);
+        pointer->Name = Malloc<char>(6, "molecule::AddAtom: *pointer->Name");
         sprintf(pointer->Name, "%2s%02d", pointer->type->symbol, pointer->nr+1);
       }
@@ -176 +177 @@
  * Increases molecule::last_atom and gives last number to added atom.
  * \param *pointer allocated and set atom
- * \return true - succeeded, false - atom not found in list
+ * \return pointer to the newly added atom
  */
 atom * molecule::AddCopyAtom(atom *pointer)
@@ -182 +183 @@
   if (pointer != NULL) {
     atom *walker = new atom(pointer);
-    walker->Name = (char *) Malloc(sizeof(char)*strlen(pointer->Name)+1, "atom::atom: *Name");
+    walker->Name = Malloc<char>(strlen(pointer->Name) + 1, "atom::atom: *Name");
     strcpy (walker->Name, pointer->Name);
     walker->nr = last_atom++;  // increase number within molecule
@@ -267 +268 @@
     Orthovector1.MatrixMultiplication(matrix);
     InBondvector.SubtractVector(&Orthovector1); // subtract just the additional translation
-    Free((void **)&matrix, "molecule::AddHydrogenReplacementAtom: *matrix");
+    Free(&matrix);
     bondlength = InBondvector.Norm();
 //    *out << Verbose(4) << "Corrected InBondvector is now: ";
@@ -612 +613 @@
   return copy;
 };
+
+
+/**
+ * Copies all atoms of a molecule which are within the defined parallelepiped.
+ *
+ * @param offest for the origin of the parallelepiped
+ * @param three vectors forming the matrix that defines the shape of the parallelpiped
+ */
+molecule* molecule::CopyMoleculeFromSubRegion(Vector offset, double *parallelepiped) {
+  molecule *copy = new molecule(elemente);
+  atom *Walker = start;
+
+  while(Walker->next != end) {
+    Walker = Walker->next;
+    if (Walker->x.IsInParallelepiped(offset, parallelepiped)) {
+      cout << "Adding atom " << *Walker << endl;
+      copy->AddCopyAtom(Walker);
+    }
+  }
+
+  //TODO: copy->BuildInducedSubgraph((ofstream *)&cout, this);
+
+  return copy;
+}
 
 /** Adds a bond to a the molecule specified by two atoms, \a *first and \a *second.
@@ -1060 +1085 @@
     }
   } while (!flag);
-  Free((void **)&matrix, "molecule::DetermineCenter: *matrix");
+  Free(&matrix);
   Center.Scale(1./(double)AtomCount);
 };
@@ -1319 +1344 @@
 {
   stringstream zeile1, zeile2;
-  int *DoubleList = (int *) Malloc(Nr*sizeof(int), "PrintPermutationMap: *DoubleList");
+  int *DoubleList = Malloc<int>(Nr, "PrintPermutationMap: *DoubleList");
   int doubles = 0;
   for (int i=0;i<Nr;i++)
@@ -1334 +1359 @@
     doubles++;
  // *out << "Found " << doubles << " Doubles." << endl;
-  Free((void **)&DoubleList, "PrintPermutationMap: *DoubleList");
+  Free(&DoubleList);
 //  *out << zeile1.str() << endl << zeile2.str() << endl;
 };
@@ -1368 +1393 @@
 {
   double Potential, OldPotential, OlderPotential;
-  PermutationMap = (atom **) Malloc(AtomCount*sizeof(atom *), "molecule::MinimiseConstrainedPotential: **PermutationMap");
-  DistanceMap **DistanceList = (DistanceMap **) Malloc(AtomCount*sizeof(DistanceMap *), "molecule::MinimiseConstrainedPotential: **DistanceList");
-  DistanceMap::iterator *DistanceIterators = (DistanceMap::iterator *) Malloc(AtomCount*sizeof(DistanceMap::iterator), "molecule::MinimiseConstrainedPotential: *DistanceIterators");
-  int *DoubleList = (int *) Malloc(AtomCount*sizeof(int), "molecule::MinimiseConstrainedPotential: *DoubleList");
-  DistanceMap::iterator *StepList = (DistanceMap::iterator *) Malloc(AtomCount*sizeof(DistanceMap::iterator), "molecule::MinimiseConstrainedPotential: *StepList");
+  PermutationMap = Malloc<atom*>(AtomCount, "molecule::MinimiseConstrainedPotential: **PermutationMap");
+  DistanceMap **DistanceList = Malloc<DistanceMap*>(AtomCount, "molecule::MinimiseConstrainedPotential: **DistanceList");
+  DistanceMap::iterator *DistanceIterators = Malloc<DistanceMap::iterator>(AtomCount, "molecule::MinimiseConstrainedPotential: *DistanceIterators");
+  int *DoubleList = Malloc<int>(AtomCount, "molecule::MinimiseConstrainedPotential: *DoubleList");
+  DistanceMap::iterator *StepList = Malloc<DistanceMap::iterator>(AtomCount, "molecule::MinimiseConstrainedPotential: *StepList");
   double constants[3];
   int round;
@@ -1448 +1473 @@
     }
   *out << Verbose(1) << "done." << endl;
-  Free((void **)&DoubleList, "molecule::MinimiseConstrainedPotential: *DoubleList");
+  Free(&DoubleList);
   // argument minimise the constrained potential in this injective PermutationMap
   *out << Verbose(1) << "Argument minimising the PermutationMap, at current potential " << OldPotential << " ... " << endl;
@@ -1529 +1554 @@
   for (int i=AtomCount; i--;)
     DistanceList[i]->clear();
-  Free((void **)&DistanceList, "molecule::MinimiseConstrainedPotential: **DistanceList");
-  Free((void **)&DistanceIterators, "molecule::MinimiseConstrainedPotential: *DistanceIterators");
+  Free(&DistanceList);
+  Free(&DistanceIterators);
   return ConstrainedPotential(out, PermutationMap, startstep, endstep, constants, IsAngstroem);
 };
@@ -1581 +1606 @@
     MinimiseConstrainedPotential(out, PermutationMap, startstep, endstep, configuration.GetIsAngstroem());
   else {
-    PermutationMap = (atom **) Malloc(AtomCount*sizeof(atom *), "molecule::LinearInterpolationBetweenConfiguration: **PermutationMap");
+    PermutationMap = Malloc<atom *>(AtomCount, "molecule::LinearInterpolationBetweenConfiguration: **PermutationMap");
     Walker = start;
     while (Walker->next != end) {
@@ -1637 +1662 @@
   
   // store the list to single step files
-  int *SortIndex = (int *) Malloc(AtomCount*sizeof(int), "molecule::LinearInterpolationBetweenConfiguration: *SortIndex");
+  int *SortIndex = Malloc<int>(AtomCount, "molecule::LinearInterpolationBetweenConfiguration: *SortIndex");
   for (int i=AtomCount; i--; )
     SortIndex[i] = i;
@@ -1643 +1668 @@
   
   // free and return
-  Free((void **)&PermutationMap, "molecule::MinimiseConstrainedPotential: *PermutationMap");
+  Free(&PermutationMap);
   delete(MoleculePerStep);
   return status;
@@ -1702 +1727 @@
       ConstrainedPotentialEnergy = MinimiseConstrainedPotential(out, PermutationMap,configuration.DoConstrainedMD, 0, configuration.GetIsAngstroem());
       EvaluateConstrainedForces(out, configuration.DoConstrainedMD, 0, PermutationMap, &Force);
-      Free((void **)&PermutationMap, "molecule::MinimiseConstrainedPotential: *PermutationMap");
+      Free(&PermutationMap);
     }
     
@@ -2402 +2427 @@
         if (Walker->type->Z != 1) // count non-hydrogen atoms whilst at it
           NoNonHydrogen++;
-        Free((void **)&Walker->Name, "molecule::CountAtoms: *walker->Name");
-        Walker->Name = (char *) Malloc(sizeof(char)*6, "molecule::CountAtoms: *walker->Name");
+        Free(&Walker->Name);
+        Walker->Name = Malloc<char>(6, "molecule::CountAtoms: *walker->Name");
         sprintf(Walker->Name, "%2s%02d", Walker->type->symbol, Walker->nr+1);
         *out << "Naming atom nr. " << Walker->nr << " " << Walker->Name << "." << endl;
@@ -2614 +2639 @@
     NumberCells = divisor[0]*divisor[1]*divisor[2];
     *out << Verbose(1) << "Allocating " << NumberCells << " cells." << endl;
-    CellList = (molecule **) Malloc(sizeof(molecule *)*NumberCells, "molecule::CreateAdjacencyList - ** CellList");
+    CellList = Malloc<molecule*>(NumberCells, "molecule::CreateAdjacencyList - ** CellList");
     for (int i=NumberCells;i--;)
       CellList[i] = NULL;
@@ -2696 +2721 @@
         delete(CellList[i]);
       }
-    Free((void **)&CellList, "molecule::CreateAdjacencyList - ** CellList");
+    Free(&CellList);
 
     // create the adjacency list per atom
@@ -2761 +2786 @@
     *out << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl;
   *out << Verbose(0) << "End of CreateAdjacencyList." << endl;
-  Free((void **)&matrix, "molecule::CreateAdjacencyList: *matrix");
+  Free(&matrix);
 
 };
@@ -2971 +2996 @@
 void molecule::CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> *  BackEdgeStack, int *&MinimumRingSize)
 {
-  atom **PredecessorList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::CyclicStructureAnalysis: **PredecessorList");
-  int *ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CyclicStructureAnalysis: *ShortestPathList");
-  enum Shading *ColorList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::CyclicStructureAnalysis: *ColorList");
+  atom **PredecessorList = Malloc<atom*>(AtomCount, "molecule::CyclicStructureAnalysis: **PredecessorList");
+  int *ShortestPathList = Malloc<int>(AtomCount, "molecule::CyclicStructureAnalysis: *ShortestPathList");
+  enum Shading *ColorList = Malloc<enum Shading>(AtomCount, "molecule::CyclicStructureAnalysis: *ColorList");
   class StackClass<atom *> *BFSStack = new StackClass<atom *> (AtomCount);   // will hold the current ring
   class StackClass<atom *> *TouchedStack = new StackClass<atom *> (AtomCount);   // contains all "touched" atoms (that need to be reset after BFS loop)
@@ -3164 +3189 @@
     *out << Verbose(1) << "No rings were detected in the molecular structure." << endl;
 
-  Free((void **)&PredecessorList, "molecule::CyclicStructureAnalysis: **PredecessorList");
-  Free((void **)&ShortestPathList, "molecule::CyclicStructureAnalysis: **ShortestPathList");
-  Free((void **)&ColorList, "molecule::CyclicStructureAnalysis: **ColorList");
+  Free(&PredecessorList);
+  Free(&ShortestPathList);
+  Free(&ColorList);
   delete(BFSStack);
 };
@@ -3210 +3235 @@
     Walker = Walker->next;
     if (Walker->ComponentNr != NULL)
-      Free((void **)&Walker->ComponentNr, "molecule::InitComponentNumbers: **Walker->ComponentNr");
-    Walker->ComponentNr = (int *) Malloc(sizeof(int)*NumberOfBondsPerAtom[Walker->nr], "molecule::InitComponentNumbers: *Walker->ComponentNr");
+      Free(&Walker->ComponentNr);
+    Walker->ComponentNr = Malloc<int>(NumberOfBondsPerAtom[Walker->nr], "molecule::InitComponentNumbers: *Walker->ComponentNr");
     for (int i=NumberOfBondsPerAtom[Walker->nr];i--;)
       Walker->ComponentNr[i] = -1;
@@ -3334 +3359 @@
   int NumberOfFragments = 0;
   double TEFactor;
-  char *filename = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::ParseKeySetFile - filename");
+  char *filename = Malloc<char>(MAXSTRINGSIZE, "molecule::ParseKeySetFile - filename");
 
   if (FragmentList == NULL) { // check list pointer
@@ -3346 +3371 @@
   if (InputFile != NULL) {
     // each line represents a new fragment
-    char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::ParseKeySetFile - *buffer");
+    char *buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::ParseKeySetFile - *buffer");
     // 1. parse keysets and insert into temp. graph
     while (!InputFile.eof()) {
@@ -3361 +3386 @@
     InputFile.close();
     InputFile.clear();
-    Free((void **)&buffer, "molecule::ParseKeySetFile - *buffer");
+    Free(&buffer);
     *out << Verbose(1) << "done." << endl;
   } else {
@@ -3394 +3419 @@
 
   // free memory
-  Free((void **)&filename, "molecule::ParseKeySetFile - filename");
+  Free(&filename);
 
   return status;
@@ -3501 +3526 @@
   stringstream filename;
   bool status = true;
-  char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
+  char *buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
 
   filename << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
@@ -3509 +3534 @@
     // allocate storage structure
     int NonMatchNumber = 0;   // will number of atoms with differing bond structure
-    int *CurrentBonds = (int *) Malloc(sizeof(int)*8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
+    int *CurrentBonds = Malloc<int>(8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
     int CurrentBondsOfAtom;
 
@@ -3554 +3579 @@
     } else
       *out << Verbose(1) << "done: Not equal by " << NonMatchNumber << " atoms." << endl;
-    Free((void **)&CurrentBonds, "molecule::CheckAdjacencyFileAgainstMolecule - **CurrentBonds");
+    Free(&CurrentBonds);
   } else {
     *out << Verbose(1) << "Adjacency file not found." << endl;
@@ -3560 +3585 @@
   }
   *out << endl;
-  Free((void **)&buffer, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
+  Free(&buffer);
 
   return status;
@@ -3588 +3613 @@
       return false;
     // parse the EnergyPerFragment file
-    char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::CheckOrderAtSite: *buffer");
+    char *buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::CheckOrderAtSite: *buffer");
     sprintf(buffer, "%s/%s%s.dat", path, FRAGMENTPREFIX, ENERGYPERFRAGMENT);
     InputFile.open(buffer, ios::in);
@@ -3695 +3720 @@
       }
     }
-    Free((void **)&buffer, "molecule::CheckOrderAtSite: *buffer");
+    Free(&buffer);
     // pick a given number of highest values and set AtomMask
   } else { // global increase of Bond Order
@@ -3748 +3773 @@
     return false;
   }
-  SortIndex = (int *) Malloc(sizeof(int)*AtomCount, "molecule::FragmentMolecule: *SortIndex");
+  SortIndex = Malloc<int>(AtomCount, "molecule::FragmentMolecule: *SortIndex");
   for(int i=AtomCount;i--;)
     SortIndex[i] = -1;
@@ -3822 +3847 @@
   // === compare it with adjacency file ===
   FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(out, configuration->configpath, ListOfAtoms);
-  Free((void **)&ListOfAtoms, "molecule::FragmentMolecule - **ListOfAtoms");
+  Free(&ListOfAtoms);
 
   // ===== 2. perform a DFS analysis to gather info on cyclic structure and a list of disconnected subgraphs =====
@@ -3911 +3936 @@
     delete(Subgraphs);
   }
-  Free((void **)&FragmentList, "molecule::FragmentMolecule - **FragmentList");
+  Free(&FragmentList);
 
   // ===== 8b. gather keyset lists (graphs) from all subgraphs and transform into MoleculeListClass =====
@@ -3958 +3983 @@
       *out << Verbose(1) << "Freeing bond memory" << endl;
       delete(FragmentList); // remove bond molecule from memory
-      Free((void **)&SortIndex, "molecule::FragmentMolecule: *SortIndex");
+      Free(&SortIndex);
     } else
       *out << Verbose(1) << "FragmentList is zero on return, splitting failed." << endl;
@@ -4046 +4071 @@
 bool molecule::ParseOrderAtSiteFromFile(ofstream *out, char *path)
 {
-  unsigned char *OrderArray = (unsigned char *) Malloc(sizeof(unsigned char)*AtomCount, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
-  bool *MaxArray = (bool *) Malloc(sizeof(bool)*AtomCount, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
+  unsigned char *OrderArray = Malloc<unsigned char>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
+  bool *MaxArray = Malloc<bool>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
   bool status;
   int AtomNr, value;
@@ -4088 +4113 @@
     status = false;
   }
-  Free((void **)&OrderArray, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
-  Free((void **)&MaxArray, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
+  Free(&OrderArray);
+  Free(&MaxArray);
 
   *out << Verbose(1) << "End of ParseOrderAtSiteFromFile" << endl;
@@ -4112 +4137 @@
   if (ListOfBondsPerAtom != NULL) {
     for(int i=AtomCount;i--;)
-      Free((void **)&ListOfBondsPerAtom[i], "molecule::CreateListOfBondsPerAtom: ListOfBondsPerAtom[i]");
-    Free((void **)&ListOfBondsPerAtom, "molecule::CreateListOfBondsPerAtom: ListOfBondsPerAtom");
+      Free(&ListOfBondsPerAtom[i]);
+    Free(&ListOfBondsPerAtom);
   }
   if (NumberOfBondsPerAtom != NULL)
-    Free((void **)&NumberOfBondsPerAtom, "molecule::CreateListOfBondsPerAtom: NumberOfBondsPerAtom");
-  ListOfBondsPerAtom = (bond ***) Malloc(sizeof(bond **)*AtomCount, "molecule::CreateListOfBondsPerAtom: ***ListOfBondsPerAtom");
-  NumberOfBondsPerAtom = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfBondsPerAtom: *NumberOfBondsPerAtom");
+    Free(&NumberOfBondsPerAtom);
+  ListOfBondsPerAtom = Malloc<bond**>(AtomCount, "molecule::CreateListOfBondsPerAtom: ***ListOfBondsPerAtom");
+  NumberOfBondsPerAtom = Malloc<int>(AtomCount, "molecule::CreateListOfBondsPerAtom: *NumberOfBondsPerAtom");
 
   // reset bond counts per atom
@@ -4132 +4157 @@
   for(int i=AtomCount;i--;) {
     // allocate list of bonds per atom
-    ListOfBondsPerAtom[i] = (bond **) Malloc(sizeof(bond *)*NumberOfBondsPerAtom[i], "molecule::CreateListOfBondsPerAtom: **ListOfBondsPerAtom[]");
+    ListOfBondsPerAtom[i] = Malloc<bond*>(NumberOfBondsPerAtom[i], "molecule::CreateListOfBondsPerAtom: **ListOfBondsPerAtom[]");
     // clear the list again, now each NumberOfBondsPerAtom marks current free field
     NumberOfBondsPerAtom[i] = 0;
@@ -4174 +4199 @@
 void molecule::BreadthFirstSearchAdd(ofstream *out, molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem)
 {
-  atom **PredecessorList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::BreadthFirstSearchAdd: **PredecessorList");
-  int *ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::BreadthFirstSearchAdd: *ShortestPathList");
-  enum Shading *ColorList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::BreadthFirstSearchAdd: *ColorList");
+  atom **PredecessorList = Malloc<atom*>(AtomCount, "molecule::BreadthFirstSearchAdd: **PredecessorList");
+  int *ShortestPathList = Malloc<int>(AtomCount, "molecule::BreadthFirstSearchAdd: *ShortestPathList");
+  enum Shading *ColorList = Malloc<enum Shading>(AtomCount, "molecule::BreadthFirstSearchAdd: *ColorList");
   class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
   atom *Walker = NULL, *OtherAtom = NULL;
@@ -4281 +4306 @@
     *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
   }
-  Free((void **)&PredecessorList, "molecule::BreadthFirstSearchAdd: **PredecessorList");
-  Free((void **)&ShortestPathList, "molecule::BreadthFirstSearchAdd: **ShortestPathList");
-  Free((void **)&ColorList, "molecule::BreadthFirstSearchAdd: **ColorList");
+  Free(&PredecessorList);
+  Free(&ShortestPathList);
+  Free(&ColorList);
   delete(AtomStack);
 };
@@ -4300 +4325 @@
   atom *Walker = NULL, *OtherAtom = NULL;
   bool status = true;
-  atom **ParentList = (atom **) Malloc(sizeof(atom *)*Father->AtomCount, "molecule::BuildInducedSubgraph: **ParentList");
+  atom **ParentList = Malloc<atom*>(Father->AtomCount, "molecule::BuildInducedSubgraph: **ParentList");
 
   *out << Verbose(2) << "Begin of BuildInducedSubgraph." << endl;
@@ -4339 +4364 @@
   }
 
-  Free((void **)&ParentList, "molecule::BuildInducedSubgraph: **ParentList");
+  Free(&ParentList);
   *out << Verbose(2) << "End of BuildInducedSubgraph." << endl;
   return status;
@@ -4382 +4407 @@
 {
   atom *Runner = NULL, *FatherOfRunner = NULL, *OtherFather = NULL;
-  atom **SonList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::StoreFragmentFromStack: **SonList");
+  atom **SonList = Malloc<atom*>(AtomCount, "molecule::StoreFragmentFromStack: **SonList");
   molecule *Leaf = new molecule(elemente);
   bool LonelyFlag = false;
@@ -4452 +4477 @@
   Leaf->CreateListOfBondsPerAtom(out);
   //Leaflet->Leaf->ScanForPeriodicCorrection(out);
-  Free((void **)&SonList, "molecule::StoreFragmentFromStack: **SonList");
+  Free(&SonList);
 //  *out << Verbose(1) << "End of StoreFragmentFromKeyset." << endl;
   return Leaf;
@@ -4473 +4498 @@
 MoleculeListClass * molecule::CreateListOfUniqueFragmentsOfOrder(ofstream *out, int Order, config *configuration)
 {
-  atom **PredecessorList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: **PredecessorList");
-  int *ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ShortestPathList");
-  int *Labels = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *Labels");
-  enum Shading *ColorVertexList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorList");
-  enum Shading *ColorEdgeList = (enum Shading *) Malloc(sizeof(enum Shading)*BondCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorBondList");
+  atom **PredecessorList = Malloc<atom*>(AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: **PredecessorList");
+  int *ShortestPathList = Malloc<int>(AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ShortestPathList");
+  int *Labels = Malloc<int>(AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *Labels");
+  enum Shading *ColorVertexList = Malloc<enum Shading>(AtomCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorList");
+  enum Shading *ColorEdgeList = Malloc<enum Shading>(BondCount, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorBondList");
   StackClass<atom *> *RootStack = new StackClass<atom *>(AtomCount);
   StackClass<atom *> *TouchedStack = new StackClass<atom *>((int)pow(4,Order)+2); // number of atoms reached from one with maximal 4 bonds plus Root itself
@@ -4607 +4632 @@
 
   // free memory and exit
-  Free((void **)&PredecessorList, "molecule::CreateListOfUniqueFragmentsOfOrder: **PredecessorList");
-  Free((void **)&ShortestPathList, "molecule::CreateListOfUniqueFragmentsOfOrder: *ShortestPathList");
-  Free((void **)&Labels, "molecule::CreateListOfUniqueFragmentsOfOrder: *Labels");
-  Free((void **)&ColorVertexList, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorList");
+  Free(&PredecessorList);
+  Free(&ShortestPathList);
+  Free(&Labels);
+  Free(&ColorVertexList);
   delete(RootStack);
   delete(TouchedStack);
@@ -4660 +4685 @@
   int Removal;
   int SpaceLeft;
-  int *TouchedList = (int *) Malloc(sizeof(int)*(SubOrder+1), "molecule::SPFragmentGenerator: *TouchedList");
+  int *TouchedList = Malloc<int>(SubOrder + 1, "molecule::SPFragmentGenerator: *TouchedList");
   bond *Binder = NULL;
   bond **BondsList = NULL;
@@ -4668 +4693 @@
 
   // Hier muessen von 1 bis NumberOfBondsPerAtom[Walker->nr] alle Kombinationen
-  // von Endstuecken (aus den Bonds) hinzugefￜￜgt werden und fￜￜr verbleibende ANOVAOrder
-  // rekursiv GraphCrawler in der nￜￜchsten Ebene aufgerufen werden
+  // von Endstuecken (aus den Bonds) hinzugefuegt werden und fuer verbleibende ANOVAOrder
+  // rekursiv GraphCrawler in der naechsten Ebene aufgerufen werden
 
   *out << Verbose(1+verbosity) << "Begin of SPFragmentGenerator." << endl;
@@ -4729 +4754 @@
           }
           // then allocate and fill the list
-          BondsList = (bond **) Malloc(sizeof(bond *)*SubSetDimension, "molecule::SPFragmentGenerator: **BondsList");
+          BondsList = Malloc<bond*>(SubSetDimension, "molecule::SPFragmentGenerator: **BondsList");
           SubSetDimension = 0;
           Binder = FragmentSearch->BondsPerSPList[2*SP];
@@ -4741 +4766 @@
           *out << Verbose(2+verbosity) << "Calling subset generator " << SP << " away from root " << *FragmentSearch->Root << " with sub set dimension " << SubSetDimension << "." << endl;
           SPFragmentGenerator(out, FragmentSearch, SP, BondsList, SubSetDimension, SubOrder-bits);
-          Free((void **)&BondsList, "molecule::SPFragmentGenerator: **BondsList");
+          Free(&BondsList);
         }
       } else {
@@ -4775 +4800 @@
     }
   }
-  Free((void **)&TouchedList, "molecule::SPFragmentGenerator: *TouchedList");
+  Free(&TouchedList);
   *out << Verbose(1+verbosity) << "End of SPFragmentGenerator, " << RootDistance << " away from Root " << *FragmentSearch->Root << " and SubOrder is " << SubOrder << "." << endl;
 };
@@ -4953 +4978 @@
     *out << Verbose(0) << "Preparing subset for this root and calling generator." << endl;
     // prepare the subset and call the generator
-    BondsList = (bond **) Malloc(sizeof(bond *)*FragmentSearch.BondsPerSPCount[0], "molecule::PowerSetGenerator: **BondsList");
+    BondsList = Malloc<bond*>(FragmentSearch.BondsPerSPCount[0], "molecule::PowerSetGenerator: **BondsList");
     BondsList[0] = FragmentSearch.BondsPerSPList[0]->next;  // on SP level 0 there's only the root bond
 
     SPFragmentGenerator(out, &FragmentSearch, 0, BondsList, FragmentSearch.BondsPerSPCount[0], Order);
 
-    Free((void **)&BondsList, "molecule::PowerSetGenerator: **BondsList");
+    Free(&BondsList);
   } else {
     *out << Verbose(0) << "Not enough total number of edges to build " << Order << "-body fragments." << endl;
@@ -5012 +5037 @@
   *out << Verbose(2) << "Begin of ScanForPeriodicCorrection." << endl;
 
-  ColorList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::ScanForPeriodicCorrection: *ColorList");
+  ColorList = Malloc<enum Shading>(AtomCount, "molecule::ScanForPeriodicCorrection: *ColorList");
   while (flag) {
     // remove bonds that are beyond bonddistance
@@ -5073 +5098 @@
   // free allocated space from ReturnFullMatrixforSymmetric()
   delete(AtomStack);
-  Free((void **)&ColorList, "molecule::ScanForPeriodicCorrection: *ColorList");
-  Free((void **)&matrix, "molecule::ScanForPeriodicCorrection: *matrix");
+  Free(&ColorList);
+  Free(&matrix);
   *out << Verbose(2) << "End of ScanForPeriodicCorrection." << endl;
 };
@@ -5084 +5109 @@
 double * molecule::ReturnFullMatrixforSymmetric(double *symm)
 {
-  double *matrix = (double *) Malloc(sizeof(double)*NDIM*NDIM, "molecule::ReturnFullMatrixforSymmetric: *matrix");
+  double *matrix = Malloc<double>(NDIM * NDIM, "molecule::ReturnFullMatrixforSymmetric: *matrix");
   matrix[0] = symm[0];
   matrix[1] = symm[1];
@@ -5211 +5236 @@
   // FragmentLowerOrdersList is a 2D-array of pointer to MoleculeListClass objects, one dimension represents the ANOVA expansion of a single order (i.e. 5)
   // with all needed lower orders that are subtracted, the other dimension is the BondOrder (i.e. from 1 to 5)
-  NumMoleculesOfOrder = (int *) Malloc(sizeof(int)*UpgradeCount, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
-  FragmentLowerOrdersList = (Graph ***) Malloc(sizeof(Graph **)*UpgradeCount, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
+  NumMoleculesOfOrder = Malloc<int>(UpgradeCount, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
+  FragmentLowerOrdersList = Malloc<Graph**>(UpgradeCount, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
 
   // initialise the fragments structure
-  FragmentSearch.ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::PowerSetGenerator: *ShortestPathList");
+  FragmentSearch.ShortestPathList = Malloc<int>(AtomCount, "molecule::PowerSetGenerator: *ShortestPathList");
   FragmentSearch.FragmentCounter = 0;
   FragmentSearch.FragmentSet = new KeySet;
@@ -5250 +5275 @@
 
       // initialise Order-dependent entries of UniqueFragments structure
-      FragmentSearch.BondsPerSPList = (bond **) Malloc(sizeof(bond *)*Order*2, "molecule::PowerSetGenerator: ***BondsPerSPList");
-      FragmentSearch.BondsPerSPCount = (int *) Malloc(sizeof(int)*Order, "molecule::PowerSetGenerator: *BondsPerSPCount");
+      FragmentSearch.BondsPerSPList = Malloc<bond*>(Order * 2, "molecule::PowerSetGenerator: ***BondsPerSPList");
+      FragmentSearch.BondsPerSPCount = Malloc<int>(Order, "molecule::PowerSetGenerator: *BondsPerSPCount");
       for (int i=Order;i--;) {
         FragmentSearch.BondsPerSPList[2*i] = new bond();    // start node
@@ -5262 +5287 @@
       // allocate memory for all lower level orders in this 1D-array of ptrs
       NumLevels = 1 << (Order-1); // (int)pow(2,Order);
-      FragmentLowerOrdersList[RootNr] = (Graph **) Malloc(sizeof(Graph *)*NumLevels, "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
+      FragmentLowerOrdersList[RootNr] = Malloc<Graph*>(NumLevels, "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
       for (int i=0;i<NumLevels;i++)
         FragmentLowerOrdersList[RootNr][i] = NULL;
@@ -5329 +5354 @@
 
       // free Order-dependent entries of UniqueFragments structure for next loop cycle
-      Free((void **)&FragmentSearch.BondsPerSPCount, "molecule::PowerSetGenerator: *BondsPerSPCount");
+      Free(&FragmentSearch.BondsPerSPCount);
       for (int i=Order;i--;) {
         delete(FragmentSearch.BondsPerSPList[2*i]);
         delete(FragmentSearch.BondsPerSPList[2*i+1]);
       }
-      Free((void **)&FragmentSearch.BondsPerSPList, "molecule::PowerSetGenerator: ***BondsPerSPList");
+      Free(&FragmentSearch.BondsPerSPList);
     }
   }
@@ -5342 +5367 @@
 
   // cleanup FragmentSearch structure
-  Free((void **)&FragmentSearch.ShortestPathList, "molecule::PowerSetGenerator: *ShortestPathList");
+  Free(&FragmentSearch.ShortestPathList);
   delete(FragmentSearch.FragmentSet);
 
@@ -5373 +5398 @@
       }
     }
-    Free((void **)&FragmentLowerOrdersList[RootNr], "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
+    Free(&FragmentLowerOrdersList[RootNr]);
     RootNr++;
   }
-  Free((void **)&FragmentLowerOrdersList, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
-  Free((void **)&NumMoleculesOfOrder, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
+  Free(&FragmentLowerOrdersList);
+  Free(&NumMoleculesOfOrder);
 
   *out << Verbose(0) << "End of FragmentBOSSANOVA." << endl;
@@ -5467 +5492 @@
   if (result) {
     *out << Verbose(5) << "Calculating distances" << endl;
-    Distances = (double *) Malloc(sizeof(double)*AtomCount, "molecule::IsEqualToWithinThreshold: Distances");
-    OtherDistances = (double *) Malloc(sizeof(double)*AtomCount, "molecule::IsEqualToWithinThreshold: OtherDistances");
+    Distances = Malloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: Distances");
+    OtherDistances = Malloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: OtherDistances");
     Walker = start;
     while (Walker->next != end) {
@@ -5482 +5507 @@
     /// ... sort each list (using heapsort (o(N log N)) from GSL)
     *out << Verbose(5) << "Sorting distances" << endl;
-    PermMap = (size_t *) Malloc(sizeof(size_t)*AtomCount, "molecule::IsEqualToWithinThreshold: *PermMap");
-    OtherPermMap = (size_t *) Malloc(sizeof(size_t)*AtomCount, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
+    PermMap = Malloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermMap");
+    OtherPermMap = Malloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
     gsl_heapsort_index (PermMap, Distances, AtomCount, sizeof(double), CompareDoubles);
     gsl_heapsort_index (OtherPermMap, OtherDistances, AtomCount, sizeof(double), CompareDoubles);
-    PermutationMap = (int *) Malloc(sizeof(int)*AtomCount, "molecule::IsEqualToWithinThreshold: *PermutationMap");
+    PermutationMap = Malloc<int>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermutationMap");
     *out << Verbose(5) << "Combining Permutation Maps" << endl;
     for(int i=AtomCount;i--;)
       PermutationMap[PermMap[i]] = (int) OtherPermMap[i];
 
-    /// ... and compare them step by step, whether the difference is individiually(!) below \a threshold for all
+    /// ... and compare them step by step, whether the difference is individually(!) below \a threshold for all
     *out << Verbose(4) << "Comparing distances" << endl;
     flag = 0;
@@ -5499 +5524 @@
         flag = 1;
     }
-    Free((void **)&PermMap, "molecule::IsEqualToWithinThreshold: *PermMap");
-    Free((void **)&OtherPermMap, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
-
-    /// free memory
-    Free((void **)&Distances, "molecule::IsEqualToWithinThreshold: Distances");
-    Free((void **)&OtherDistances, "molecule::IsEqualToWithinThreshold: OtherDistances");
+
+    // free memory
+    Free(&PermMap);
+    Free(&OtherPermMap);
+    Free(&Distances);
+    Free(&OtherDistances);
     if (flag) { // if not equal
-      Free((void **)&PermutationMap, "molecule::IsEqualToWithinThreshold: *PermutationMap");
+      Free(&PermutationMap);
       result = false;
     }
@@ -5532 +5557 @@
   atom *Walker = NULL, *OtherWalker = NULL;
   *out << Verbose(3) << "Begin of GetFatherAtomicMap." << endl;
-  int *AtomicMap = (int *) Malloc(sizeof(int)*AtomCount, "molecule::GetAtomicMap: *AtomicMap");  //Calloc
+  int *AtomicMap = Malloc<int>(AtomCount, "molecule::GetAtomicMap: *AtomicMap");
   for (int i=AtomCount;i--;)
     AtomicMap[i] = -1;

src/molecules.hpp

@@ -207 +207 @@
 
   molecule *CopyMolecule();
+  molecule* CopyMoleculeFromSubRegion(Vector offset, double *parallelepiped);
 
   /// Fragment molecule by two different approaches:

src/parser.cpp

@@ -8 +8 @@
 
 #include "helpers.hpp"
+#include "memoryallocator.hpp"
 #include "parser.hpp"
 
@@ -56 +57 @@
 MatrixContainer::MatrixContainer() {
   Indices = NULL;
-  Header = (char **) Malloc(sizeof(char)*1, "MatrixContainer::MatrixContainer: **Header");
-  Matrix = (double ***) Malloc(sizeof(double **)*(1), "MatrixContainer::MatrixContainer: ***Matrix"); // one more each for the total molecule
-  RowCounter = (int *) Malloc(sizeof(int)*(1), "MatrixContainer::MatrixContainer: *RowCounter");
-  ColumnCounter = (int *) Malloc(sizeof(int)*(1), "MatrixContainer::MatrixContainer: *ColumnCounter");
+  Header = Malloc<char*>(1, "MatrixContainer::MatrixContainer: **Header");
+  Matrix = Malloc<double**>(1, "MatrixContainer::MatrixContainer: ***Matrix"); // one more each for the total molecule
+  RowCounter = Malloc<int>(1, "MatrixContainer::MatrixContainer: *RowCounter");
+  ColumnCounter = Malloc<int>(1, "MatrixContainer::MatrixContainer: *ColumnCounter");
   Header[0] = NULL;
   Matrix[0] = NULL;
@@ -74 +75 @@
       if ((ColumnCounter != NULL) && (RowCounter != NULL)) {
           for(int j=RowCounter[i]+1;j--;)
-            Free((void **)&Matrix[i][j], "MatrixContainer::~MatrixContainer: *Matrix[][]");
-        Free((void **)&Matrix[i], "MatrixContainer::~MatrixContainer: **Matrix[]");
+            Free(&Matrix[i][j]);
+        Free(&Matrix[i]);
       }
     }
     if ((ColumnCounter != NULL) && (RowCounter != NULL) && (Matrix[MatrixCounter] != NULL))
       for(int j=RowCounter[MatrixCounter]+1;j--;)
-        Free((void **)&Matrix[MatrixCounter][j], "MatrixContainer::~MatrixContainer: *Matrix[MatrixCounter][]");
+        Free(&Matrix[MatrixCounter][j]);
     if (MatrixCounter != 0)
-      Free((void **)&Matrix[MatrixCounter], "MatrixContainer::~MatrixContainer: **Matrix[MatrixCounter]");
-    Free((void **)&Matrix, "MatrixContainer::~MatrixContainer: ***Matrix");
+      Free(&Matrix[MatrixCounter]);
+    Free(&Matrix);
   }
   if (Indices != NULL)
     for(int i=MatrixCounter+1;i--;) {
-      Free((void **)&Indices[i], "MatrixContainer::~MatrixContainer: *Indices[]");
-    }
-  Free((void **)&Indices, "MatrixContainer::~MatrixContainer: **Indices"); 
+      Free(&Indices[i]);
+    }
+  Free(&Indices);
   
   if (Header != NULL)
     for(int i=MatrixCounter+1;i--;)
-      Free((void **)&Header[i], "MatrixContainer::~MatrixContainer: *Header[]");
-  Free((void **)&Header, "MatrixContainer::~MatrixContainer: **Header");
-  Free((void **)&RowCounter, "MatrixContainer::~MatrixContainer: *RowCounter");
-  Free((void **)&ColumnCounter, "MatrixContainer::~MatrixContainer: *RowCounter");
+      Free(&Header[i]);
+  Free(&Header);
+  Free(&RowCounter);
+  Free(&ColumnCounter);
 };
 
@@ -109 +110 @@
   if (Matrix == NULL) {
     cout << " with trivial mapping." << endl;
-    Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "MatrixContainer::InitialiseIndices: **Indices");
+    Indices = Malloc<int*>(MatrixCounter + 1, "MatrixContainer::InitialiseIndices: **Indices");
     for(int i=MatrixCounter+1;i--;) {
-      Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
+      Indices[i] = Malloc<int>(RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
       for(int j=RowCounter[i];j--;)
         Indices[i][j] = j;
@@ -119 +120 @@
     if (MatrixCounter != Matrix->MatrixCounter)
       return false;
-    Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "MatrixContainer::InitialiseIndices: **Indices");
+    Indices = Malloc<int*>(MatrixCounter + 1, "MatrixContainer::InitialiseIndices: **Indices");
     for(int i=MatrixCounter+1;i--;) {
       if (RowCounter[i] != Matrix->RowCounter[i])
         return false;
-      Indices[i] = (int *) Malloc(sizeof(int)*Matrix->RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
+      Indices[i] = Malloc<int>(Matrix->RowCounter[i], "MatrixContainer::InitialiseIndices: *Indices[]");
       for(int j=Matrix->RowCounter[i];j--;) {
         Indices[i][j] = Matrix->Indices[i][j];
@@ -162 +163 @@
 
   // parse header
-  Header[MatrixNr] = (char *) Malloc(sizeof(char)*1024, "MatrixContainer::ParseMatrix: *Header[]");
+  Header[MatrixNr] = Malloc<char>(1024, "MatrixContainer::ParseMatrix: *Header[]");
   for (int m=skiplines+1;m--;)
     input.getline(Header[MatrixNr], 1023);
@@ -197 +198 @@
   // allocate matrix if it's not zero dimension in one direction
   if ((ColumnCounter[MatrixNr] > 0) && (RowCounter[MatrixNr] > -1)) {
-    Matrix[MatrixNr] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixNr]+1), "MatrixContainer::ParseMatrix: **Matrix[]");
+    Matrix[MatrixNr] = Malloc<double*>(RowCounter[MatrixNr] + 1, "MatrixContainer::ParseMatrix: **Matrix[]");
   
     // parse in each entry for this matrix
@@ -209 +210 @@
     strncpy(Header[MatrixNr], line.str().c_str(), 1023);  
     for(int j=0;j<RowCounter[MatrixNr];j++) {
-      Matrix[MatrixNr][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[][]");
+      Matrix[MatrixNr][j] = Malloc<double>(ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[][]");
       input.getline(filename, 1023);
       stringstream lines(filename);
@@ -220 +221 @@
       }
       //cout << endl;
-      Matrix[MatrixNr][ RowCounter[MatrixNr] ] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[RowCounter[MatrixNr]][]");
+      Matrix[MatrixNr][ RowCounter[MatrixNr] ] = Malloc<double>(ColumnCounter[MatrixNr], "MatrixContainer::ParseMatrix: *Matrix[RowCounter[MatrixNr]][]");
       for(int j=ColumnCounter[MatrixNr];j--;)
         Matrix[MatrixNr][ RowCounter[MatrixNr] ][j] = 0.;
@@ -274 +275 @@
 
   cout << "Parsing through each fragment and retrieving " << prefix << suffix << "." << endl;
-  Header = (char **) ReAlloc(Header, sizeof(char *)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: **Header"); // one more each for the total molecule
-  Matrix = (double ***) ReAlloc(Matrix, sizeof(double **)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: ***Matrix"); // one more each for the total molecule
-  RowCounter = (int *) ReAlloc(RowCounter, sizeof(int)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: *RowCounter");
-  ColumnCounter = (int *) ReAlloc(ColumnCounter, sizeof(int)*(MatrixCounter+1), "MatrixContainer::ParseFragmentMatrix: *ColumnCounter");
+  Header = ReAlloc<char*>(Header, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: **Header"); // one more each for the total molecule
+  Matrix = ReAlloc<double**>(Matrix, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: ***Matrix"); // one more each for the total molecule
+  RowCounter = ReAlloc<int>(RowCounter, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: *RowCounter");
+  ColumnCounter = ReAlloc<int>(ColumnCounter, MatrixCounter + 1, "MatrixContainer::ParseFragmentMatrix: *ColumnCounter");
   for(int i=MatrixCounter+1;i--;) {
     Matrix[i] = NULL;
@@ -291 +292 @@
     if (!ParseMatrix(file.str().c_str(), skiplines, skipcolumns, i))
       return false;
-    Free((void **)&FragmentNumber, "MatrixContainer::ParseFragmentMatrix: *FragmentNumber");
+    Free(&FragmentNumber);
   }
   return true;
@@ -306 +307 @@
 {
   MatrixCounter = MCounter;
-  Header = (char **) Malloc(sizeof(char *)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: *Header");
-  Matrix = (double ***) Malloc(sizeof(double **)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: ***Matrix"); // one more each for the total molecule
-  RowCounter = (int *) Malloc(sizeof(int)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: *RowCounter");
-  ColumnCounter = (int *) Malloc(sizeof(int)*(MatrixCounter+1), "MatrixContainer::AllocateMatrix: *ColumnCounter");
+  Header = Malloc<char*>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: *Header");
+  Matrix = Malloc<double**>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: ***Matrix"); // one more each for the total molecule
+  RowCounter = Malloc<int>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: *RowCounter");
+  ColumnCounter = Malloc<int>(MatrixCounter + 1, "MatrixContainer::AllocateMatrix: *ColumnCounter");
   for(int i=MatrixCounter+1;i--;) {
-    Header[i] = (char *) Malloc(sizeof(char)*1024, "MatrixContainer::AllocateMatrix: *Header[i]");
+    Header[i] = Malloc<char>(1024, "MatrixContainer::AllocateMatrix: *Header[i]");
     strncpy(Header[i], GivenHeader[i], 1023);
     RowCounter[i] = RCounter[i];
     ColumnCounter[i] = CCounter[i];
-    Matrix[i] = (double **) Malloc(sizeof(double *)*(RowCounter[i]+1), "MatrixContainer::AllocateMatrix: **Matrix[]");  
+    Matrix[i] = Malloc<double*>(RowCounter[i] + 1, "MatrixContainer::AllocateMatrix: **Matrix[]");
     for(int j=RowCounter[i]+1;j--;) {
-      Matrix[i][j] = (double *) Malloc(sizeof(double)*ColumnCounter[i], "MatrixContainer::AllocateMatrix: *Matrix[][]");
+      Matrix[i][j] = Malloc<double>(ColumnCounter[i], "MatrixContainer::AllocateMatrix: *Matrix[][]");
       for(int k=ColumnCounter[i];k--;)
         Matrix[i][j][k] = 0.;
@@ -466 +467 @@
     FragmentNumber = FixedDigitNumber(MatrixCounter, i);
     line << name << FRAGMENTPREFIX << FragmentNumber << "/" << prefix;
-    Free((void **)&FragmentNumber, "*FragmentNumber");
+    Free(&FragmentNumber);
     output.open(line.str().c_str(), ios::out);
     if (output == NULL) {
@@ -520 +521 @@
 {
   cout << "Parsing energy indices." << endl;
-  Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "EnergyMatrix::ParseIndices: **Indices");
+  Indices = Malloc<int*>(MatrixCounter + 1, "EnergyMatrix::ParseIndices: **Indices");
   for(int i=MatrixCounter+1;i--;) {
-    Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "EnergyMatrix::ParseIndices: *Indices[]");
+    Indices[i] = Malloc<int>(RowCounter[i], "EnergyMatrix::ParseIndices: *Indices[]");
     for(int j=RowCounter[i];j--;)
       Indices[i][j] = j;
@@ -579 +580 @@
     // allocate last plus one matrix
     cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl;
-    Matrix[MatrixCounter] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixCounter]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    Matrix[MatrixCounter] = Malloc<double*>(RowCounter[MatrixCounter] + 1, "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
     for(int j=0;j<=RowCounter[MatrixCounter];j++)
-      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = Malloc<double>(ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
     
     // try independently to parse global energysuffix file if present
@@ -606 +607 @@
 
   cout << "Parsing force indices for " << MatrixCounter << " matrices." << endl;
-  Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "ForceMatrix::ParseIndices: **Indices");
+  Indices = Malloc<int*>(MatrixCounter + 1, "ForceMatrix::ParseIndices: **Indices");
   line << name << FRAGMENTPREFIX << FORCESFILE;
   input.open(line.str().c_str(), ios::in);
@@ -619 +620 @@
     line.str(filename);
     // parse the values
-    Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "ForceMatrix::ParseIndices: *Indices[]");
+    Indices[i] = Malloc<int>(RowCounter[i], "ForceMatrix::ParseIndices: *Indices[]");
     FragmentNumber = FixedDigitNumber(MatrixCounter, i);
     //cout << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
-    Free((void **)&FragmentNumber, "ForceMatrix::ParseIndices: *FragmentNumber");
+    Free(&FragmentNumber);
     for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
       line >> Indices[i][j];
@@ -629 +630 @@
     //cout << endl;
   }
-  Indices[MatrixCounter] = (int *) Malloc(sizeof(int)*RowCounter[MatrixCounter], "ForceMatrix::ParseIndices: *Indices[]");
+  Indices[MatrixCounter] = Malloc<int>(RowCounter[MatrixCounter], "ForceMatrix::ParseIndices: *Indices[]");
   for(int j=RowCounter[MatrixCounter];j--;) {
     Indices[MatrixCounter][j] = j;
@@ -714 +715 @@
     // allocate last plus one matrix
     cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl;
-    Matrix[MatrixCounter] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixCounter]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    Matrix[MatrixCounter] = Malloc<double*>(RowCounter[MatrixCounter] + 1, "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
     for(int j=0;j<=RowCounter[MatrixCounter];j++)
-      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = Malloc<double>(ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
 
     // try independently to parse global forcesuffix file if present
@@ -743 +744 @@
   
   cout << "Parsing hessian indices for " << MatrixCounter << " matrices." << endl;
-  Indices = (int **) Malloc(sizeof(int *)*(MatrixCounter+1), "HessianMatrix::ParseIndices: **Indices");
+  Indices = Malloc<int*>(MatrixCounter + 1, "HessianMatrix::ParseIndices: **Indices");
   line << name << FRAGMENTPREFIX << FORCESFILE;
   input.open(line.str().c_str(), ios::in);
@@ -756 +757 @@
     line.str(filename);
     // parse the values
-    Indices[i] = (int *) Malloc(sizeof(int)*RowCounter[i], "HessianMatrix::ParseIndices: *Indices[]");
+    Indices[i] = Malloc<int>(RowCounter[i], "HessianMatrix::ParseIndices: *Indices[]");
     FragmentNumber = FixedDigitNumber(MatrixCounter, i);
     //cout << FRAGMENTPREFIX << FragmentNumber << "[" << RowCounter[i] << "]:";
-    Free((void **)&FragmentNumber, "HessianMatrix::ParseIndices: *FragmentNumber");
+    Free(&FragmentNumber);
     for(int j=0;(j<RowCounter[i]) && (!line.eof());j++) {
       line >> Indices[i][j];
@@ -766 +767 @@
     //cout << endl;
   }
-  Indices[MatrixCounter] = (int *) Malloc(sizeof(int)*RowCounter[MatrixCounter], "HessianMatrix::ParseIndices: *Indices[]");
+  Indices[MatrixCounter] = Malloc<int>(RowCounter[MatrixCounter], "HessianMatrix::ParseIndices: *Indices[]");
   for(int j=RowCounter[MatrixCounter];j--;) {
     Indices[MatrixCounter][j] = j;
@@ -938 +939 @@
     // allocate last plus one matrix
     cout << "Allocating last plus one matrix with " << (RowCounter[MatrixCounter]+1) << " rows and " << ColumnCounter[MatrixCounter] << " columns." << endl;
-    Matrix[MatrixCounter] = (double **) Malloc(sizeof(double *)*(RowCounter[MatrixCounter]+1), "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
+    Matrix[MatrixCounter] = Malloc<double*>(RowCounter[MatrixCounter] + 1, "MatrixContainer::ParseFragmentMatrix: **Matrix[]");
     for(int j=0;j<=RowCounter[MatrixCounter];j++)
-      Matrix[MatrixCounter][j] = (double *) Malloc(sizeof(double)*ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
+      Matrix[MatrixCounter][j] = Malloc<double>(ColumnCounter[MatrixCounter], "MatrixContainer::ParseFragmentMatrix: *Matrix[][]");
 
     // try independently to parse global forcesuffix file if present
@@ -970 +971 @@
 KeySetsContainer::~KeySetsContainer() {
   for(int i=FragmentCounter;i--;)
-    Free((void **)&KeySets[i], "KeySetsContainer::~KeySetsContainer: *KeySets[]");
+    Free(&KeySets[i]);
   for(int i=Order;i--;)
-    Free((void **)&OrderSet[i], "KeySetsContainer::~KeySetsContainer: *OrderSet[]");
-  Free((void **)&KeySets, "KeySetsContainer::~KeySetsContainer: **KeySets");
-  Free((void **)&OrderSet, "KeySetsContainer::~KeySetsContainer: **OrderSet");
-  Free((void **)&AtomCounter, "KeySetsContainer::~KeySetsContainer: *AtomCounter");
-  Free((void **)&FragmentsPerOrder, "KeySetsContainer::~KeySetsContainer: *FragmentsPerOrder");
+    Free(&OrderSet[i]);
+  Free(&KeySets);
+  Free(&OrderSet);
+  Free(&AtomCounter);
+  Free(&FragmentsPerOrder);
 };
 
@@ -993 +994 @@
   FragmentCounter = FCounter;
   cout << "Parsing key sets." << endl;
-  KeySets = (int **) Malloc(sizeof(int *)*FragmentCounter, "KeySetsContainer::ParseKeySets: **KeySets");
+  KeySets = Malloc<int*>(FragmentCounter, "KeySetsContainer::ParseKeySets: **KeySets");
   for(int i=FragmentCounter;i--;)
     KeySets[i] = NULL;
@@ -1003 +1004 @@
   }
 
-  AtomCounter = (int *) Malloc(sizeof(int)*FragmentCounter, "KeySetsContainer::ParseKeySets: *RowCounter");
+  AtomCounter = Malloc<int>(FragmentCounter, "KeySetsContainer::ParseKeySets: *RowCounter");
   for(int i=0;(i<FragmentCounter) && (!input.eof());i++) {
     stringstream line;
     AtomCounter[i] = ACounter[i];
     // parse the values
-    KeySets[i] = (int *) Malloc(sizeof(int)*AtomCounter[i], "KeySetsContainer::ParseKeySets: *KeySets[]");
+    KeySets[i] = Malloc<int>(AtomCounter[i], "KeySetsContainer::ParseKeySets: *KeySets[]");
     for(int j=AtomCounter[i];j--;)
       KeySets[i][j] = -1;
     FragmentNumber = FixedDigitNumber(FragmentCounter, i);
     //cout << FRAGMENTPREFIX << FragmentNumber << "[" << AtomCounter[i] << "]:";
-    Free((void **)&FragmentNumber, "KeySetsContainer::ParseKeySets: *FragmentNumber");
+    Free(&FragmentNumber);
     input.getline(filename, 1023);
     line.str(filename);
@@ -1047 +1048 @@
 
   // scan through all to determine fragments per order
-  FragmentsPerOrder = (int *) Malloc(sizeof(int)*Order, "KeySetsContainer::ParseManyBodyTerms: *FragmentsPerOrder");
+  FragmentsPerOrder = Malloc<int>(Order, "KeySetsContainer::ParseManyBodyTerms: *FragmentsPerOrder");
   for(int i=Order;i--;)
     FragmentsPerOrder[i] = 0;
@@ -1061 +1062 @@
 
   // scan through all to gather indices to each order set
-  OrderSet = (int **) Malloc(sizeof(int *)*Order, "KeySetsContainer::ParseManyBodyTerms: **OrderSet");
+  OrderSet = Malloc<int*>(Order, "KeySetsContainer::ParseManyBodyTerms: **OrderSet");
   for(int i=Order;i--;)
-    OrderSet[i] = (int *) Malloc(sizeof(int)*FragmentsPerOrder[i], "KeySetsContainer::ParseManyBodyTermsKeySetsContainer::ParseManyBodyTerms: *OrderSet[]");
+    OrderSet[i] = Malloc<int>(FragmentsPerOrder[i], "KeySetsContainer::ParseManyBodyTermsKeySetsContainer::ParseManyBodyTerms: *OrderSet[]");
   for(int i=Order;i--;)
     FragmentsPerOrder[i] = 0;

src/stackclass.hpp

@@ -3 +3 @@
 
 #include "verbose.hpp"
+#include "memoryallocator.hpp"
 
 template <typename T> class StackClass;
@@ -43 +44 @@
   NextFreeField = 0;
   EntryCount = dimension;
-  StackList = (T *) Malloc(sizeof(T)*EntryCount, "StackClass::StackClass: **StackList");
+  StackList = Malloc<T>(EntryCount, "StackClass::StackClass: **StackList");
 };
 
@@ -50 +51 @@
 template <typename T> StackClass<T>::~StackClass()
 {
-  Free((void **)&StackList, "StackClass::StackClass: **StackList");
+  Free(&StackList);
 };
 

src/tesselation.cpp

@@ -8 +8 @@
 #include "helpers.hpp"
 #include "linkedcell.hpp"
+#include "memoryallocator.hpp"
 #include "tesselation.hpp"
 #include "tesselationhelpers.hpp"

src/tesselationunittest.cpp

@@ -84 +84 @@
   delete(TesselStruct);
   for (LinkedNodes::iterator Runner = Corners.begin(); Runner != Corners.end(); Runner++) {
-    delete((*Runner)->Name);
+    delete[]((*Runner)->Name);
     delete((*Runner)->node);
     delete(*Runner);
@@ -178 +178 @@
     for (set<BoundaryTriangleSet*>::iterator TriangleRunner = triangles->begin(); TriangleRunner != triangles->end(); TriangleRunner++)
       CPPUNIT_ASSERT_EQUAL( true, (*TriangleRunner)->ContainsBoundaryPoint(Walker) );
+    delete(triangles);
   }
 }

src/vector.cpp

@@ -8 +8 @@
 #include "defs.hpp"
 #include "helpers.hpp"
+#include "memoryallocator.hpp"
 #include "leastsquaremin.hpp"
 #include "vector.hpp"
@@ -473 +474 @@
 };
 
-/** Rotates the vector around the axis given by \a *axis by an angle of \a alpha.
+/** Rotates the vector relative to the origin around the axis given by \a *axis by an angle of \a alpha.
  * \param *axis rotation axis
  * \param alpha rotation angle in radian
@@ -484 +485 @@
   a.ProjectOntoPlane(axis);
   // construct normal vector
-  y.MakeNormalVector(axis,this);
+  bool rotatable = y.MakeNormalVector(axis,&a);
+  // The normal vector cannot be created if there is linar dependency.
+  // Then the vector to rotate is on the axis and any rotation leads to the vector itself.
+  if (!rotatable) {
+    return;
+  }
   y.Scale(Norm());
   // scale normal vector by sine and this vector by cosine
   y.Scale(sin(alpha));
-  Scale(cos(alpha));
+  a.Scale(cos(alpha));
+  CopyVector(Projection(axis));
   // add scaled normal vector onto this vector
   AddVector(&y);
@@ -674 +681 @@
 double * Vector::InverseMatrix(double *A)
 {
-  double *B = (double *) Malloc(sizeof(double)*NDIM*NDIM, "Vector::InverseMatrix: *B");
+  double *B = Malloc<double>(NDIM * NDIM, "Vector::InverseMatrix: *B");
   double detA = RDET3(A);
   double detAReci;
@@ -1221 +1228 @@
   return true;
 };
+
+/**
+ * Checks whether this vector is within the parallelepiped defined by the given three vectors and
+ * their offset.
+ *
+ * @param offest for the origin of the parallelepiped
+ * @param three vectors forming the matrix that defines the shape of the parallelpiped
+ */
+bool Vector::IsInParallelepiped(Vector offset, double *parallelepiped)
+{
+  Vector a;
+  a.CopyVector(this);
+  a.SubtractVector(&offset);
+  a.InverseMatrixMultiplication(parallelepiped);
+  bool isInside = true;
+
+  for (int i=NDIM;i--;)
+    isInside = isInside && ((a.x[i] <= 1) && (a.x[i] >= 0));
+
+  return isInside;
+}

src/vector.hpp

@@ -68 +68 @@
   void AskPosition(double *cell_size, bool check);
   bool Output(ofstream *out) const;
+  bool IsInParallelepiped(Vector offset, double *parallelepiped);
 };
 

src/vectorunittest.cpp

@@ -55 +55 @@
 void VectorTest::SimpleAlgebraTest()
 {
-  Vector helper;
   double factor;
+  // copy vector
+  fixture.Init(2.,3.,4.);
+  CPPUNIT_ASSERT_EQUAL( Vector(2.,3.,4.), fixture );
   // summation and scaling
-  helper.CopyVector(&zero);
-  helper.AddVector(&unit);
-  CPPUNIT_ASSERT_EQUAL( true, helper.IsOne() );
-  helper.CopyVector(&zero);
-  helper.SubtractVector(&unit);
-  CPPUNIT_ASSERT_EQUAL( true, helper.IsOne() );
-  CPPUNIT_ASSERT_EQUAL( false, helper.IsZero() );
-  helper.CopyVector(&zero);
-  helper.AddVector(&zero);
-  CPPUNIT_ASSERT_EQUAL( true, helper.IsZero() );
-  helper.CopyVector(&notunit);
-  helper.SubtractVector(&otherunit);
-  CPPUNIT_ASSERT_EQUAL( true, helper.IsOne() );
-  helper.CopyVector(&unit);
-  helper.AddVector(&otherunit);
-  CPPUNIT_ASSERT_EQUAL( false, helper.IsOne() );
-  helper.CopyVector(&notunit);
-  helper.SubtractVector(&unit);
-  helper.SubtractVector(&otherunit);
-  CPPUNIT_ASSERT_EQUAL( false, helper.IsZero() );
-  helper.CopyVector(&unit);
-  helper.Scale(0.98);
-  CPPUNIT_ASSERT_EQUAL( false, helper.IsOne() );
-  helper.CopyVector(&unit);
-  helper.Scale(1.);
-  CPPUNIT_ASSERT_EQUAL( true, helper.IsOne() );
-  helper.CopyVector(&unit);
+  fixture.CopyVector(&zero);
+  fixture.AddVector(&unit);
+  CPPUNIT_ASSERT_EQUAL( true, fixture.IsOne() );
+  fixture.CopyVector(&zero);
+  fixture.SubtractVector(&unit);
+  CPPUNIT_ASSERT_EQUAL( true, fixture.IsOne() );
+  CPPUNIT_ASSERT_EQUAL( false, fixture.IsZero() );
+  fixture.CopyVector(&zero);
+  fixture.AddVector(&zero);
+  CPPUNIT_ASSERT_EQUAL( true, fixture.IsZero() );
+  fixture.CopyVector(&notunit);
+  fixture.SubtractVector(&otherunit);
+  CPPUNIT_ASSERT_EQUAL( true, fixture.IsOne() );
+  fixture.CopyVector(&unit);
+  fixture.AddVector(&otherunit);
+  CPPUNIT_ASSERT_EQUAL( false, fixture.IsOne() );
+  fixture.CopyVector(&notunit);
+  fixture.SubtractVector(&unit);
+  fixture.SubtractVector(&otherunit);
+  CPPUNIT_ASSERT_EQUAL( false, fixture.IsZero() );
+  fixture.CopyVector(&unit);
+  fixture.Scale(0.98);
+  CPPUNIT_ASSERT_EQUAL( false, fixture.IsOne() );
+  fixture.CopyVector(&unit);
+  fixture.Scale(1.);
+  CPPUNIT_ASSERT_EQUAL( true, fixture.IsOne() );
+  fixture.CopyVector(&unit);
   factor = 0.98;
-  helper.Scale(factor);
-  CPPUNIT_ASSERT_EQUAL( false, helper.IsOne() );
-  helper.CopyVector(&unit);
+  fixture.Scale(factor);
+  CPPUNIT_ASSERT_EQUAL( false, fixture.IsOne() );
+  fixture.CopyVector(&unit);
   factor = 1.;
-  helper.Scale(factor);
-  CPPUNIT_ASSERT_EQUAL( true, helper.IsOne() );
+  fixture.Scale(factor);
+  CPPUNIT_ASSERT_EQUAL( true, fixture.IsOne() );
 };
 
@@ -183 +185 @@
 void VectorTest::LineIntersectionTest()
 {
-  Vector helper;
   // plane at (0,0,0) normal to (1,0,0) cuts line from (0,0,0) to (2,1,0) at ???
-  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionWithPlane((ofstream *)&cout, &unit, &zero, &zero, &two) );
-  CPPUNIT_ASSERT_EQUAL( zero, helper );
+  CPPUNIT_ASSERT_EQUAL( true, fixture.GetIntersectionWithPlane((ofstream *)&cout, &unit, &zero, &zero, &two) );
+  CPPUNIT_ASSERT_EQUAL( zero, fixture );
 
   // plane at (2,1,0) normal to (0,1,0) cuts line from (1,0,0) to (0,1,1) at ???
-  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionWithPlane((ofstream *)&cout, &otherunit, &two, &unit, &notunit) );
-  CPPUNIT_ASSERT_EQUAL( Vector(0., 1., 1.), helper );
+  CPPUNIT_ASSERT_EQUAL( true, fixture.GetIntersectionWithPlane((ofstream *)&cout, &otherunit, &two, &unit, &notunit) );
+  CPPUNIT_ASSERT_EQUAL( Vector(0., 1., 1.), fixture );
 
   // four vectors equal to zero
-  CPPUNIT_ASSERT_EQUAL( false, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &zero, &zero, &zero, &zero, NULL) );
-  CPPUNIT_ASSERT_EQUAL( zero, helper );
+  CPPUNIT_ASSERT_EQUAL( false, fixture.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &zero, &zero, &zero, &zero, NULL) );
+  CPPUNIT_ASSERT_EQUAL( zero, fixture );
 
   // four vectors equal to unit
-  CPPUNIT_ASSERT_EQUAL( false, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &unit, &unit, &unit, NULL) );
-  CPPUNIT_ASSERT_EQUAL( zero, helper );
+  CPPUNIT_ASSERT_EQUAL( false, fixture.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &unit, &unit, &unit, NULL) );
+  CPPUNIT_ASSERT_EQUAL( zero, fixture );
 
   // two equal lines
-  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &two, &unit, &two, NULL) );
-  CPPUNIT_ASSERT_EQUAL( unit, helper );
+  CPPUNIT_ASSERT_EQUAL( true, fixture.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &two, &unit, &two, NULL) );
+  CPPUNIT_ASSERT_EQUAL( unit, fixture );
 
   // line from (1,0,0) to (2,1,0) cuts line from (1,0,0) to (0,1,0) at ???
-  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &two, &unit, &otherunit, NULL) );
-  CPPUNIT_ASSERT_EQUAL( unit, helper );
+  CPPUNIT_ASSERT_EQUAL( true, fixture.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &two, &unit, &otherunit, NULL) );
+  CPPUNIT_ASSERT_EQUAL( unit, fixture );
 
   // line from (1,0,0) to (0,0,0) cuts line from (0,0,0) to (2,1,0) at ???
-  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &zero, &zero, &two, NULL) );
-  CPPUNIT_ASSERT_EQUAL( zero, helper );
+  CPPUNIT_ASSERT_EQUAL( true, fixture.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &zero, &zero, &two, NULL) );
+  CPPUNIT_ASSERT_EQUAL( zero, fixture );
 
   // line from (1,0,0) to (2,1,0) cuts line from (0,0,0) to (0,1,0) at ???
-  CPPUNIT_ASSERT_EQUAL( true, helper.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &two, &zero, &otherunit, NULL) );
-  CPPUNIT_ASSERT_EQUAL( Vector(0., -1., 0.), helper );
-};
+  CPPUNIT_ASSERT_EQUAL( true, fixture.GetIntersectionOfTwoLinesOnPlane((ofstream *)&cout, &unit, &two, &zero, &otherunit, NULL) );
+  CPPUNIT_ASSERT_EQUAL( Vector(0., -1., 0.), fixture );
+};
+
+/** UnitTest for vector rotations.
+ */
+void VectorTest::VectorRotationTest()
+{
+  fixture.Init(-1.,0.,0.);
+
+  // zero vector does not change
+  fixture.CopyVector(&zero);
+  fixture.RotateVector(&unit, 1.);
+  CPPUNIT_ASSERT_EQUAL( zero, fixture );
+
+  fixture.RotateVector(&two, 1.);
+  CPPUNIT_ASSERT_EQUAL( zero,  fixture);
+
+  // vector on axis does not change
+  fixture.CopyVector(&unit);
+  fixture.RotateVector(&unit, 1.);
+  CPPUNIT_ASSERT_EQUAL( unit, fixture );
+
+  fixture.RotateVector(&unit, 1.);
+  CPPUNIT_ASSERT_EQUAL( unit, fixture );
+
+  // rotations
+  fixture.CopyVector(&otherunit);
+  fixture.RotateVector(&unit, M_PI);
+  CPPUNIT_ASSERT_EQUAL( Vector(0.,-1.,0.), fixture );
+
+  fixture.CopyVector(&otherunit);
+  fixture.RotateVector(&unit, 2. * M_PI);
+  CPPUNIT_ASSERT_EQUAL( otherunit, fixture );
+
+  fixture.CopyVector(&otherunit);
+  fixture.RotateVector(&unit, 0);
+  CPPUNIT_ASSERT_EQUAL( otherunit, fixture );
+
+  fixture.Init(0.,0.,1.);
+  fixture.RotateVector(&notunit, M_PI);
+  CPPUNIT_ASSERT_EQUAL( otherunit, fixture );
+}
+
+/**
+ * UnitTest for Vector::IsInParallelepiped().
+ */
+void VectorTest::IsInParallelepipedTest()
+{
+  double parallelepiped[NDIM*NDIM];
+  parallelepiped[0] = 1;
+  parallelepiped[1] = 0;
+  parallelepiped[2] = 0;
+  parallelepiped[3] = 0;
+  parallelepiped[4] = 1;
+  parallelepiped[5] = 0;
+  parallelepiped[6] = 0;
+  parallelepiped[7] = 0;
+  parallelepiped[8] = 1;
+
+  fixture.CopyVector(zero);
+  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
+  fixture.Init(2.5,2.5,2.5);
+  CPPUNIT_ASSERT_EQUAL( true, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
+  fixture.Init(1.,1.,1.);
+  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
+  fixture.Init(3.5,3.5,3.5);
+  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
+  fixture.Init(2.,2.,2.);
+  CPPUNIT_ASSERT_EQUAL( true, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
+  fixture.Init(2.,3.,2.);
+  CPPUNIT_ASSERT_EQUAL( true, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
+  fixture.Init(-2.,2.,-1.);
+  CPPUNIT_ASSERT_EQUAL( false, fixture.IsInParallelepiped(Vector(2.,2.,2.), parallelepiped) );
+}
+
 
 /********************************************** Main routine **************************************/

src/vectorunittest.hpp

@@ -27 +27 @@
     CPPUNIT_TEST ( ProjectionTest );
     CPPUNIT_TEST ( LineIntersectionTest );
+    CPPUNIT_TEST ( VectorRotationTest );
+    CPPUNIT_TEST ( IsInParallelepipedTest );
     CPPUNIT_TEST_SUITE_END();
 
 public:
-      void setUp();
-      void tearDown();
+    void setUp();
+    void tearDown();
 
-     void UnityTest();
-     void OperatorAlgebraTest();
-     void SimpleAlgebraTest();
-     void EuclidianScalarProductTest();
-     void EuclidianNormTest();
-     void EuclidianDistancesTest();
-     void EuclidianAnglesTest();
-     void ProjectionTest();
-     void LineIntersectionTest();
+    void UnityTest();
+    void OperatorAlgebraTest();
+    void SimpleAlgebraTest();
+    void EuclidianScalarProductTest();
+    void EuclidianNormTest();
+    void EuclidianDistancesTest();
+    void EuclidianAnglesTest();
+    void ProjectionTest();
+    void LineIntersectionTest();
+    void VectorRotationTest();
+    void IsInParallelepipedTest();
 
 private:
-     Vector zero;
-     Vector unit;
-     Vector otherunit;
-     Vector notunit;
-     Vector two;
+    // vector to execute tests on, may be modified during run
+    Vector fixture;
+    // never modify these during run, other tests might rely on them
+    Vector zero;
+    Vector unit;
+    Vector otherunit;
+    Vector notunit;
+    Vector two;
 };
 

tests/testsuite.at

@@ -33 +33 @@
 AT_DATA([test.conf], [])
 AT_CHECK([../../molecuilder test.conf -e ./ -p test.xyz], 0, [ignore], [ignore])
-AT_CHECK([fgrep "Ion_Type1_1" test.conf], 0, [Ion_Type1_1       10.000000000    10.000000000    10.000000000    0 # Number in molecule 0
+AT_CHECK([fgrep "Ion_Type1_1" test.conf], 0, [Ion_Type1_1       10.000000000    10.000000000    10.000000000    0 # molecule nr 0
 ], [ignore])
-AT_CHECK([cp test.conf main_pcp_linux], 0, [ignore], [ignore])
-AT_DATA([input], [aa 10. 10. 10. 1
+AT_CHECK([mv test.conf main_pcp_linux], 0, [ignore], [ignore])
+AT_DATA([input], [maa 10. 10. 10. 1
 s
 q
 ])
-AT_CHECK([../../molecuilder -e ./ <input], 0, [ignore], [ignore])
+AT_CHECK([../../molecuilder test.conf -e ./ <input], 0, [ignore], [ignore])
 AT_CHECK([diff main_pcp_linux test.conf], 0, [ignore], [ignore])
 # 4. test some more configuration
-AT_CHECK([../../molecuilder test.conf -e ./ -t -s -b -F -E -c -b -a -U -T -u], 0, [ignore], [stderr])
-AT_CHECK([fgrep -c "Not enough or invalid" stderr], 0, [10
+AT_CHECK([../../molecuilder test.conf -e ./ -t -s -b -E -c -b -a -U -T -u], 0, [ignore], [stderr])
+AT_CHECK([fgrep -c "Not enough or invalid" stderr], 0, [9
 ], [ignore])
 AT_CLEANUP
@@ -75 +75 @@
 # 4. create the config and check it
 AT_CHECK([../../molecuilder test.conf -e ./ -p test.xyz], 0, [ignore], [ignore])
-AT_CHECK([fgrep "Ion_Type1_4" test.conf], 0, [Ion_Type1_4       8.532785963     4.787886018     2.645886050     0 # Number in molecule 6
+AT_CHECK([fgrep "Ion_Type1_4" test.conf], 0, [Ion_Type1_4       8.532785963     4.787886018     2.645886050     0 # molecule nr 6
 ], [ignore])
 AT_CHECK([fgrep "Ion_Type2_4" test.conf], 1, [ignore], [ignore])