Changes in src/molecules.cpp [29812d:f7f7a4]

File:

• src/molecules.cpp (modified) (73 diffs)

src/molecules.cpp

@@ -6 +6 @@
 
 #include "config.hpp"
-#include "memoryallocator.hpp"
 #include "molecules.hpp"
 
@@ -56 +55 @@
   if (ListOfBondsPerAtom != NULL)
     for(int i=AtomCount;i--;)
-      Free(&ListOfBondsPerAtom[i]);
-  Free(&ListOfBondsPerAtom);
-  Free(&NumberOfBondsPerAtom);
+      Free((void **)&ListOfBondsPerAtom[i], "molecule::~molecule: ListOfBondsPerAtom[i]");
+  Free((void **)&ListOfBondsPerAtom, "molecule::~molecule: ListOfBondsPerAtom");
+  Free((void **)&NumberOfBondsPerAtom, "molecule::~molecule: NumberOfBondsPerAtom");
   if (TesselStruct != NULL)
     delete(TesselStruct);
@@ -164 +163 @@
         NoNonHydrogen++;
       if (pointer->Name == NULL) {
-        Free(&pointer->Name);
-        pointer->Name = Malloc<char>(6, "molecule::AddAtom: *pointer->Name");
+        Free((void **)&pointer->Name, "molecule::AddAtom: *pointer->Name");
+        pointer->Name = (char *) Malloc(sizeof(char)*6, "molecule::AddAtom: *pointer->Name");
         sprintf(pointer->Name, "%2s%02d", pointer->type->symbol, pointer->nr+1);
       }
@@ -177 +176 @@
  * Increases molecule::last_atom and gives last number to added atom.
  * \param *pointer allocated and set atom
- * \return pointer to the newly added atom
+ * \return true - succeeded, false - atom not found in list
  */
 atom * molecule::AddCopyAtom(atom *pointer)
@@ -183 +182 @@
   if (pointer != NULL) {
     atom *walker = new atom(pointer);
-    walker->Name = Malloc<char>(strlen(pointer->Name) + 1, "atom::atom: *Name");
+    walker->Name = (char *) Malloc(sizeof(char)*strlen(pointer->Name)+1, "atom::atom: *Name");
     strcpy (walker->Name, pointer->Name);
     walker->nr = last_atom++;  // increase number within molecule
@@ -268 +267 @@
     Orthovector1.MatrixMultiplication(matrix);
     InBondvector.SubtractVector(&Orthovector1); // subtract just the additional translation
-    Free(&matrix);
+    Free((void **)&matrix, "molecule::AddHydrogenReplacementAtom: *matrix");
     bondlength = InBondvector.Norm();
 //    *out << Verbose(4) << "Corrected InBondvector is now: ";
@@ -614 +613 @@
 };
 
-
-/**
- * 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.
  * Also updates molecule::BondCount and molecule::NoNonBonds.
@@ -687 +662 @@
 {
   int length = 0;
-  char *molname = strrchr(filename, '/')+sizeof(char);  // search for filename without dirs
+  const char *molname = strrchr(filename, '/');
+  if (molname != NULL)
+    molname += sizeof(char);  // search for filename without dirs
+  else
+    molname = filename; // contains no slashes
   char *endname = strchr(molname, '.');
   if ((endname == NULL) || (endname < molname))
@@ -1081 +1060 @@
     }
   } while (!flag);
-  Free(&matrix);
+  Free((void **)&matrix, "molecule::DetermineCenter: *matrix");
   Center.Scale(1./(double)AtomCount);
 };
@@ -1193 +1172 @@
 /** Evaluates the potential energy used for constrained molecular dynamics.
  * \f$V_i^{con} = c^{bond} \cdot | r_{P(i)} - R_i | + sum_{i \neq j} C^{min} \cdot \frac{1}{C_{ij}} + C^{inj} \Bigl (1 - \theta \bigl (\prod_{i \neq j} (P(i) - P(j)) \bigr ) \Bigr )\f$
- *     where the first term points to the target in minimum distance, the second is a penalty for trajectories lying too close to each other (\f$C_{ij}$ is minimum distance between 
+ *     where the first term points to the target in minimum distance, the second is a penalty for trajectories lying too close to each other (\f$C_{ij}\f$ is minimum distance between
  *     trajectories i and j) and the third term is a penalty for two atoms trying to each the same target point.
  * Note that for the second term we have to solve the following linear system:
@@ -1340 +1319 @@
 {
   stringstream zeile1, zeile2;
-  int *DoubleList = Malloc<int>(Nr, "PrintPermutationMap: *DoubleList");
+  int *DoubleList = (int *) Malloc(Nr*sizeof(int), "PrintPermutationMap: *DoubleList");
   int doubles = 0;
   for (int i=0;i<Nr;i++)
@@ -1355 +1334 @@
     doubles++;
  // *out << "Found " << doubles << " Doubles." << endl;
-  Free(&DoubleList);
+  Free((void **)&DoubleList, "PrintPermutationMap: *DoubleList");
 //  *out << zeile1.str() << endl << zeile2.str() << endl;
 };
@@ -1389 +1368 @@
 {
   double Potential, OldPotential, OlderPotential;
-  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");
+  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");
   double constants[3];
   int round;
@@ -1469 +1448 @@
     }
   *out << Verbose(1) << "done." << endl;
-  Free(&DoubleList);
+  Free((void **)&DoubleList, "molecule::MinimiseConstrainedPotential: *DoubleList");
   // argument minimise the constrained potential in this injective PermutationMap
   *out << Verbose(1) << "Argument minimising the PermutationMap, at current potential " << OldPotential << " ... " << endl;
@@ -1550 +1529 @@
   for (int i=AtomCount; i--;)
     DistanceList[i]->clear();
-  Free(&DistanceList);
-  Free(&DistanceIterators);
+  Free((void **)&DistanceList, "molecule::MinimiseConstrainedPotential: **DistanceList");
+  Free((void **)&DistanceIterators, "molecule::MinimiseConstrainedPotential: *DistanceIterators");
   return ConstrainedPotential(out, PermutationMap, startstep, endstep, constants, IsAngstroem);
 };
@@ -1587 +1566 @@
  * \param endstep stating final configuration in molecule::Trajectories
  * \param &config configuration structure
+ * \param MapByIdentity if true we just use the identity to map atoms in start config to end config, if not we find mapping by \sa MinimiseConstrainedPotential()
  * \return true - success in writing step files, false - error writing files or only one step in molecule::Trajectories
  */
-bool molecule::LinearInterpolationBetweenConfiguration(ofstream *out, int startstep, int endstep, const char *prefix, config &configuration) 
+bool molecule::LinearInterpolationBetweenConfiguration(ofstream *out, int startstep, int endstep, const char *prefix, config &configuration, bool MapByIdentity)
 {
   molecule *mol = NULL;
@@ -1598 +1578 @@
   atom **PermutationMap = NULL;
   atom *Walker = NULL, *Sprinter = NULL;
-  MinimiseConstrainedPotential(out, PermutationMap, startstep, endstep, configuration.GetIsAngstroem());
+  if (!MapByIdentity)
+    MinimiseConstrainedPotential(out, PermutationMap, startstep, endstep, configuration.GetIsAngstroem());
+  else {
+    PermutationMap = (atom **) Malloc(AtomCount*sizeof(atom *), "molecule::LinearInterpolationBetweenConfiguration: **PermutationMap");
+    Walker = start;
+    while (Walker->next != end) {
+      Walker = Walker->next;
+      PermutationMap[Walker->nr] = Walker;   // always pick target with the smallest distance
+    }
+  }
 
   // check whether we have sufficient space in Trajectories for each atom
@@ -1648 +1637 @@
   
   // store the list to single step files
-  int *SortIndex = Malloc<int>(AtomCount, "molecule::LinearInterpolationBetweenConfiguration: *SortIndex");
+  int *SortIndex = (int *) Malloc(AtomCount*sizeof(int), "molecule::LinearInterpolationBetweenConfiguration: *SortIndex");
   for (int i=AtomCount; i--; )
     SortIndex[i] = i;
@@ -1654 +1643 @@
   
   // free and return
-  Free(&PermutationMap);
+  Free((void **)&PermutationMap, "molecule::MinimiseConstrainedPotential: *PermutationMap");
   delete(MoleculePerStep);
   return status;
@@ -1713 +1702 @@
       ConstrainedPotentialEnergy = MinimiseConstrainedPotential(out, PermutationMap,configuration.DoConstrainedMD, 0, configuration.GetIsAngstroem());
       EvaluateConstrainedForces(out, configuration.DoConstrainedMD, 0, PermutationMap, &Force);
-      Free(&PermutationMap);
+      Free((void **)&PermutationMap, "molecule::MinimiseConstrainedPotential: *PermutationMap");
     }
     
@@ -2413 +2402 @@
         if (Walker->type->Z != 1) // count non-hydrogen atoms whilst at it
           NoNonHydrogen++;
-        Free(&Walker->Name);
-        Walker->Name = Malloc<char>(6, "molecule::CountAtoms: *walker->Name");
+        Free((void **)&Walker->Name, "molecule::CountAtoms: *walker->Name");
+        Walker->Name = (char *) Malloc(sizeof(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;
@@ -2625 +2614 @@
     NumberCells = divisor[0]*divisor[1]*divisor[2];
     *out << Verbose(1) << "Allocating " << NumberCells << " cells." << endl;
-    CellList = Malloc<molecule*>(NumberCells, "molecule::CreateAdjacencyList - ** CellList");
+    CellList = (molecule **) Malloc(sizeof(molecule *)*NumberCells, "molecule::CreateAdjacencyList - ** CellList");
     for (int i=NumberCells;i--;)
       CellList[i] = NULL;
@@ -2707 +2696 @@
         delete(CellList[i]);
       }
-    Free(&CellList);
+    Free((void **)&CellList, "molecule::CreateAdjacencyList - ** CellList");
 
     // create the adjacency list per atom
@@ -2772 +2761 @@
     *out << Verbose(1) << "AtomCount is " << AtomCount << ", thus no bonds, no connections!." << endl;
   *out << Verbose(0) << "End of CreateAdjacencyList." << endl;
-  Free(&matrix);
+  Free((void **)&matrix, "molecule::CreateAdjacencyList: *matrix");
 
 };
@@ -2982 +2971 @@
 void molecule::CyclicStructureAnalysis(ofstream *out, class StackClass<bond *> *  BackEdgeStack, int *&MinimumRingSize)
 {
-  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");
+  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");
   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)
@@ -3175 +3164 @@
     *out << Verbose(1) << "No rings were detected in the molecular structure." << endl;
 
-  Free(&PredecessorList);
-  Free(&ShortestPathList);
-  Free(&ColorList);
+  Free((void **)&PredecessorList, "molecule::CyclicStructureAnalysis: **PredecessorList");
+  Free((void **)&ShortestPathList, "molecule::CyclicStructureAnalysis: **ShortestPathList");
+  Free((void **)&ColorList, "molecule::CyclicStructureAnalysis: **ColorList");
   delete(BFSStack);
 };
@@ -3221 +3210 @@
     Walker = Walker->next;
     if (Walker->ComponentNr != NULL)
-      Free(&Walker->ComponentNr);
-    Walker->ComponentNr = Malloc<int>(NumberOfBondsPerAtom[Walker->nr], "molecule::InitComponentNumbers: *Walker->ComponentNr");
+      Free((void **)&Walker->ComponentNr, "molecule::InitComponentNumbers: **Walker->ComponentNr");
+    Walker->ComponentNr = (int *) Malloc(sizeof(int)*NumberOfBondsPerAtom[Walker->nr], "molecule::InitComponentNumbers: *Walker->ComponentNr");
     for (int i=NumberOfBondsPerAtom[Walker->nr];i--;)
       Walker->ComponentNr[i] = -1;
@@ -3345 +3334 @@
   int NumberOfFragments = 0;
   double TEFactor;
-  char *filename = Malloc<char>(MAXSTRINGSIZE, "molecule::ParseKeySetFile - filename");
+  char *filename = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::ParseKeySetFile - filename");
 
   if (FragmentList == NULL) { // check list pointer
@@ -3357 +3346 @@
   if (InputFile != NULL) {
     // each line represents a new fragment
-    char *buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::ParseKeySetFile - *buffer");
+    char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::ParseKeySetFile - *buffer");
     // 1. parse keysets and insert into temp. graph
     while (!InputFile.eof()) {
@@ -3372 +3361 @@
     InputFile.close();
     InputFile.clear();
-    Free(&buffer);
+    Free((void **)&buffer, "molecule::ParseKeySetFile - *buffer");
     *out << Verbose(1) << "done." << endl;
   } else {
@@ -3405 +3394 @@
 
   // free memory
-  Free(&filename);
+  Free((void **)&filename, "molecule::ParseKeySetFile - filename");
 
   return status;
@@ -3512 +3501 @@
   stringstream filename;
   bool status = true;
-  char *buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
+  char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
 
   filename << path << "/" << FRAGMENTPREFIX << ADJACENCYFILE;
@@ -3520 +3509 @@
     // allocate storage structure
     int NonMatchNumber = 0;   // will number of atoms with differing bond structure
-    int *CurrentBonds = Malloc<int>(8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
+    int *CurrentBonds = (int *) Malloc(sizeof(int)*8, "molecule::CheckAdjacencyFileAgainstMolecule - CurrentBonds"); // contains parsed bonds of current atom
     int CurrentBondsOfAtom;
 
@@ -3565 +3554 @@
     } else
       *out << Verbose(1) << "done: Not equal by " << NonMatchNumber << " atoms." << endl;
-    Free(&CurrentBonds);
+    Free((void **)&CurrentBonds, "molecule::CheckAdjacencyFileAgainstMolecule - **CurrentBonds");
   } else {
     *out << Verbose(1) << "Adjacency file not found." << endl;
@@ -3571 +3560 @@
   }
   *out << endl;
-  Free(&buffer);
+  Free((void **)&buffer, "molecule::CheckAdjacencyFileAgainstMolecule: *buffer");
 
   return status;
@@ -3599 +3588 @@
       return false;
     // parse the EnergyPerFragment file
-    char *buffer = Malloc<char>(MAXSTRINGSIZE, "molecule::CheckOrderAtSite: *buffer");
+    char *buffer = (char *) Malloc(sizeof(char)*MAXSTRINGSIZE, "molecule::CheckOrderAtSite: *buffer");
     sprintf(buffer, "%s/%s%s.dat", path, FRAGMENTPREFIX, ENERGYPERFRAGMENT);
     InputFile.open(buffer, ios::in);
@@ -3706 +3695 @@
       }
     }
-    Free(&buffer);
+    Free((void **)&buffer, "molecule::CheckOrderAtSite: *buffer");
     // pick a given number of highest values and set AtomMask
   } else { // global increase of Bond Order
@@ -3747 +3736 @@
  * \param *&SortIndex Mapping array of size molecule::AtomCount
  * \return true - success, false - failure of SortIndex alloc
+ * \todo do we really need this still as the IonType may appear in any order due to recent changes
  */
 bool molecule::CreateMappingLabelsToConfigSequence(ofstream *out, int *&SortIndex)
@@ -3758 +3748 @@
     return false;
   }
-  SortIndex = Malloc<int>(AtomCount, "molecule::FragmentMolecule: *SortIndex");
+  SortIndex = (int *) Malloc(sizeof(int)*AtomCount, "molecule::FragmentMolecule: *SortIndex");
   for(int i=AtomCount;i--;)
     SortIndex[i] = -1;
@@ -3832 +3822 @@
   // === compare it with adjacency file ===
   FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(out, configuration->configpath, ListOfAtoms);
-  Free(&ListOfAtoms);
+  Free((void **)&ListOfAtoms, "molecule::FragmentMolecule - **ListOfAtoms");
 
   // ===== 2. perform a DFS analysis to gather info on cyclic structure and a list of disconnected subgraphs =====
@@ -3921 +3911 @@
     delete(Subgraphs);
   }
-  Free(&FragmentList);
+  Free((void **)&FragmentList, "molecule::FragmentMolecule - **FragmentList");
 
   // ===== 8b. gather keyset lists (graphs) from all subgraphs and transform into MoleculeListClass =====
@@ -3968 +3958 @@
       *out << Verbose(1) << "Freeing bond memory" << endl;
       delete(FragmentList); // remove bond molecule from memory
-      Free(&SortIndex);
+      Free((void **)&SortIndex, "molecule::FragmentMolecule: *SortIndex");
     } else
       *out << Verbose(1) << "FragmentList is zero on return, splitting failed." << endl;
@@ -4056 +4046 @@
 bool molecule::ParseOrderAtSiteFromFile(ofstream *out, char *path)
 {
-  unsigned char *OrderArray = Malloc<unsigned char>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
-  bool *MaxArray = Malloc<bool>(AtomCount, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
+  unsigned char *OrderArray = (unsigned char *) Malloc(sizeof(unsigned char)*AtomCount, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
+  bool *MaxArray = (bool *) Malloc(sizeof(bool)*AtomCount, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
   bool status;
   int AtomNr, value;
@@ -4098 +4088 @@
     status = false;
   }
-  Free(&OrderArray);
-  Free(&MaxArray);
+  Free((void **)&OrderArray, "molecule::ParseOrderAtSiteFromFile - *OrderArray");
+  Free((void **)&MaxArray, "molecule::ParseOrderAtSiteFromFile - *MaxArray");
 
   *out << Verbose(1) << "End of ParseOrderAtSiteFromFile" << endl;
@@ -4122 +4112 @@
   if (ListOfBondsPerAtom != NULL) {
     for(int i=AtomCount;i--;)
-      Free(&ListOfBondsPerAtom[i]);
-    Free(&ListOfBondsPerAtom);
+      Free((void **)&ListOfBondsPerAtom[i], "molecule::CreateListOfBondsPerAtom: ListOfBondsPerAtom[i]");
+    Free((void **)&ListOfBondsPerAtom, "molecule::CreateListOfBondsPerAtom: ListOfBondsPerAtom");
   }
   if (NumberOfBondsPerAtom != NULL)
-    Free(&NumberOfBondsPerAtom);
-  ListOfBondsPerAtom = Malloc<bond**>(AtomCount, "molecule::CreateListOfBondsPerAtom: ***ListOfBondsPerAtom");
-  NumberOfBondsPerAtom = Malloc<int>(AtomCount, "molecule::CreateListOfBondsPerAtom: *NumberOfBondsPerAtom");
+    Free((void **)&NumberOfBondsPerAtom, "molecule::CreateListOfBondsPerAtom: NumberOfBondsPerAtom");
+  ListOfBondsPerAtom = (bond ***) Malloc(sizeof(bond **)*AtomCount, "molecule::CreateListOfBondsPerAtom: ***ListOfBondsPerAtom");
+  NumberOfBondsPerAtom = (int *) Malloc(sizeof(int)*AtomCount, "molecule::CreateListOfBondsPerAtom: *NumberOfBondsPerAtom");
 
   // reset bond counts per atom
@@ -4142 +4132 @@
   for(int i=AtomCount;i--;) {
     // allocate list of bonds per atom
-    ListOfBondsPerAtom[i] = Malloc<bond*>(NumberOfBondsPerAtom[i], "molecule::CreateListOfBondsPerAtom: **ListOfBondsPerAtom[]");
+    ListOfBondsPerAtom[i] = (bond **) Malloc(sizeof(bond *)*NumberOfBondsPerAtom[i], "molecule::CreateListOfBondsPerAtom: **ListOfBondsPerAtom[]");
     // clear the list again, now each NumberOfBondsPerAtom marks current free field
     NumberOfBondsPerAtom[i] = 0;
@@ -4184 +4174 @@
 void molecule::BreadthFirstSearchAdd(ofstream *out, molecule *Mol, atom **&AddedAtomList, bond **&AddedBondList, atom *Root, bond *Bond, int BondOrder, bool IsAngstroem)
 {
-  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");
+  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");
   class StackClass<atom *> *AtomStack = new StackClass<atom *>(AtomCount);
   atom *Walker = NULL, *OtherAtom = NULL;
@@ -4291 +4281 @@
     *out << Verbose(1) << "Coloring Walker " << Walker->Name << " black." << endl;
   }
-  Free(&PredecessorList);
-  Free(&ShortestPathList);
-  Free(&ColorList);
+  Free((void **)&PredecessorList, "molecule::BreadthFirstSearchAdd: **PredecessorList");
+  Free((void **)&ShortestPathList, "molecule::BreadthFirstSearchAdd: **ShortestPathList");
+  Free((void **)&ColorList, "molecule::BreadthFirstSearchAdd: **ColorList");
   delete(AtomStack);
 };
@@ -4310 +4300 @@
   atom *Walker = NULL, *OtherAtom = NULL;
   bool status = true;
-  atom **ParentList = Malloc<atom*>(Father->AtomCount, "molecule::BuildInducedSubgraph: **ParentList");
+  atom **ParentList = (atom **) Malloc(sizeof(atom *)*Father->AtomCount, "molecule::BuildInducedSubgraph: **ParentList");
 
   *out << Verbose(2) << "Begin of BuildInducedSubgraph." << endl;
@@ -4349 +4339 @@
   }
 
-  Free(&ParentList);
+  Free((void **)&ParentList, "molecule::BuildInducedSubgraph: **ParentList");
   *out << Verbose(2) << "End of BuildInducedSubgraph." << endl;
   return status;
@@ -4392 +4382 @@
 {
   atom *Runner = NULL, *FatherOfRunner = NULL, *OtherFather = NULL;
-  atom **SonList = Malloc<atom*>(AtomCount, "molecule::StoreFragmentFromStack: **SonList");
+  atom **SonList = (atom **) Malloc(sizeof(atom *)*AtomCount, "molecule::StoreFragmentFromStack: **SonList");
   molecule *Leaf = new molecule(elemente);
   bool LonelyFlag = false;
@@ -4462 +4452 @@
   Leaf->CreateListOfBondsPerAtom(out);
   //Leaflet->Leaf->ScanForPeriodicCorrection(out);
-  Free(&SonList);
+  Free((void **)&SonList, "molecule::StoreFragmentFromStack: **SonList");
 //  *out << Verbose(1) << "End of StoreFragmentFromKeyset." << endl;
   return Leaf;
@@ -4483 +4473 @@
 MoleculeListClass * molecule::CreateListOfUniqueFragmentsOfOrder(ofstream *out, int Order, config *configuration)
 {
-  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");
+  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");
   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
@@ -4617 +4607 @@
 
   // free memory and exit
-  Free(&PredecessorList);
-  Free(&ShortestPathList);
-  Free(&Labels);
-  Free(&ColorVertexList);
+  Free((void **)&PredecessorList, "molecule::CreateListOfUniqueFragmentsOfOrder: **PredecessorList");
+  Free((void **)&ShortestPathList, "molecule::CreateListOfUniqueFragmentsOfOrder: *ShortestPathList");
+  Free((void **)&Labels, "molecule::CreateListOfUniqueFragmentsOfOrder: *Labels");
+  Free((void **)&ColorVertexList, "molecule::CreateListOfUniqueFragmentsOfOrder: *ColorList");
   delete(RootStack);
   delete(TouchedStack);
@@ -4670 +4660 @@
   int Removal;
   int SpaceLeft;
-  int *TouchedList = Malloc<int>(SubOrder + 1, "molecule::SPFragmentGenerator: *TouchedList");
+  int *TouchedList = (int *) Malloc(sizeof(int)*(SubOrder+1), "molecule::SPFragmentGenerator: *TouchedList");
   bond *Binder = NULL;
   bond **BondsList = NULL;
@@ -4678 +4668 @@
 
   // Hier muessen von 1 bis NumberOfBondsPerAtom[Walker->nr] alle Kombinationen
-  // von Endstuecken (aus den Bonds) hinzugefuegt werden und fuer verbleibende ANOVAOrder
-  // rekursiv GraphCrawler in der naechsten Ebene aufgerufen werden
+  // von Endstuecken (aus den Bonds) hinzugefￜￜgt werden und fￜￜr verbleibende ANOVAOrder
+  // rekursiv GraphCrawler in der nￜￜchsten Ebene aufgerufen werden
 
   *out << Verbose(1+verbosity) << "Begin of SPFragmentGenerator." << endl;
@@ -4739 +4729 @@
           }
           // then allocate and fill the list
-          BondsList = Malloc<bond*>(SubSetDimension, "molecule::SPFragmentGenerator: **BondsList");
+          BondsList = (bond **) Malloc(sizeof(bond *)*SubSetDimension, "molecule::SPFragmentGenerator: **BondsList");
           SubSetDimension = 0;
           Binder = FragmentSearch->BondsPerSPList[2*SP];
@@ -4751 +4741 @@
           *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(&BondsList);
+          Free((void **)&BondsList, "molecule::SPFragmentGenerator: **BondsList");
         }
       } else {
@@ -4785 +4775 @@
     }
   }
-  Free(&TouchedList);
+  Free((void **)&TouchedList, "molecule::SPFragmentGenerator: *TouchedList");
   *out << Verbose(1+verbosity) << "End of SPFragmentGenerator, " << RootDistance << " away from Root " << *FragmentSearch->Root << " and SubOrder is " << SubOrder << "." << endl;
 };
@@ -4963 +4953 @@
     *out << Verbose(0) << "Preparing subset for this root and calling generator." << endl;
     // prepare the subset and call the generator
-    BondsList = Malloc<bond*>(FragmentSearch.BondsPerSPCount[0], "molecule::PowerSetGenerator: **BondsList");
+    BondsList = (bond **) Malloc(sizeof(bond *)*FragmentSearch.BondsPerSPCount[0], "molecule::PowerSetGenerator: **BondsList");
     BondsList[0] = FragmentSearch.BondsPerSPList[0]->next;  // on SP level 0 there's only the root bond
 
     SPFragmentGenerator(out, &FragmentSearch, 0, BondsList, FragmentSearch.BondsPerSPCount[0], Order);
 
-    Free(&BondsList);
+    Free((void **)&BondsList, "molecule::PowerSetGenerator: **BondsList");
   } else {
     *out << Verbose(0) << "Not enough total number of edges to build " << Order << "-body fragments." << endl;
@@ -5022 +5012 @@
   *out << Verbose(2) << "Begin of ScanForPeriodicCorrection." << endl;
 
-  ColorList = Malloc<enum Shading>(AtomCount, "molecule::ScanForPeriodicCorrection: *ColorList");
+  ColorList = (enum Shading *) Malloc(sizeof(enum Shading)*AtomCount, "molecule::ScanForPeriodicCorrection: *ColorList");
   while (flag) {
     // remove bonds that are beyond bonddistance
@@ -5083 +5073 @@
   // free allocated space from ReturnFullMatrixforSymmetric()
   delete(AtomStack);
-  Free(&ColorList);
-  Free(&matrix);
+  Free((void **)&ColorList, "molecule::ScanForPeriodicCorrection: *ColorList");
+  Free((void **)&matrix, "molecule::ScanForPeriodicCorrection: *matrix");
   *out << Verbose(2) << "End of ScanForPeriodicCorrection." << endl;
 };
@@ -5094 +5084 @@
 double * molecule::ReturnFullMatrixforSymmetric(double *symm)
 {
-  double *matrix = Malloc<double>(NDIM * NDIM, "molecule::ReturnFullMatrixforSymmetric: *matrix");
+  double *matrix = (double *) Malloc(sizeof(double)*NDIM*NDIM, "molecule::ReturnFullMatrixforSymmetric: *matrix");
   matrix[0] = symm[0];
   matrix[1] = symm[1];
@@ -5221 +5211 @@
   // 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 = Malloc<int>(UpgradeCount, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
-  FragmentLowerOrdersList = Malloc<Graph**>(UpgradeCount, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
+  NumMoleculesOfOrder = (int *) Malloc(sizeof(int)*UpgradeCount, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
+  FragmentLowerOrdersList = (Graph ***) Malloc(sizeof(Graph **)*UpgradeCount, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
 
   // initialise the fragments structure
-  FragmentSearch.ShortestPathList = Malloc<int>(AtomCount, "molecule::PowerSetGenerator: *ShortestPathList");
+  FragmentSearch.ShortestPathList = (int *) Malloc(sizeof(int)*AtomCount, "molecule::PowerSetGenerator: *ShortestPathList");
   FragmentSearch.FragmentCounter = 0;
   FragmentSearch.FragmentSet = new KeySet;
@@ -5260 +5250 @@
 
       // initialise Order-dependent entries of UniqueFragments structure
-      FragmentSearch.BondsPerSPList = Malloc<bond*>(Order * 2, "molecule::PowerSetGenerator: ***BondsPerSPList");
-      FragmentSearch.BondsPerSPCount = Malloc<int>(Order, "molecule::PowerSetGenerator: *BondsPerSPCount");
+      FragmentSearch.BondsPerSPList = (bond **) Malloc(sizeof(bond *)*Order*2, "molecule::PowerSetGenerator: ***BondsPerSPList");
+      FragmentSearch.BondsPerSPCount = (int *) Malloc(sizeof(int)*Order, "molecule::PowerSetGenerator: *BondsPerSPCount");
       for (int i=Order;i--;) {
         FragmentSearch.BondsPerSPList[2*i] = new bond();    // start node
@@ -5272 +5262 @@
       // allocate memory for all lower level orders in this 1D-array of ptrs
       NumLevels = 1 << (Order-1); // (int)pow(2,Order);
-      FragmentLowerOrdersList[RootNr] = Malloc<Graph*>(NumLevels, "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
+      FragmentLowerOrdersList[RootNr] = (Graph **) Malloc(sizeof(Graph *)*NumLevels, "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
       for (int i=0;i<NumLevels;i++)
         FragmentLowerOrdersList[RootNr][i] = NULL;
@@ -5339 +5329 @@
 
       // free Order-dependent entries of UniqueFragments structure for next loop cycle
-      Free(&FragmentSearch.BondsPerSPCount);
+      Free((void **)&FragmentSearch.BondsPerSPCount, "molecule::PowerSetGenerator: *BondsPerSPCount");
       for (int i=Order;i--;) {
         delete(FragmentSearch.BondsPerSPList[2*i]);
         delete(FragmentSearch.BondsPerSPList[2*i+1]);
       }
-      Free(&FragmentSearch.BondsPerSPList);
+      Free((void **)&FragmentSearch.BondsPerSPList, "molecule::PowerSetGenerator: ***BondsPerSPList");
     }
   }
@@ -5352 +5342 @@
 
   // cleanup FragmentSearch structure
-  Free(&FragmentSearch.ShortestPathList);
+  Free((void **)&FragmentSearch.ShortestPathList, "molecule::PowerSetGenerator: *ShortestPathList");
   delete(FragmentSearch.FragmentSet);
 
@@ -5383 +5373 @@
       }
     }
-    Free(&FragmentLowerOrdersList[RootNr]);
+    Free((void **)&FragmentLowerOrdersList[RootNr], "molecule::FragmentBOSSANOVA: **FragmentLowerOrdersList[]");
     RootNr++;
   }
-  Free(&FragmentLowerOrdersList);
-  Free(&NumMoleculesOfOrder);
+  Free((void **)&FragmentLowerOrdersList, "molecule::FragmentBOSSANOVA: ***FragmentLowerOrdersList");
+  Free((void **)&NumMoleculesOfOrder, "molecule::FragmentBOSSANOVA: *NumMoleculesOfOrder");
 
   *out << Verbose(0) << "End of FragmentBOSSANOVA." << endl;
@@ -5477 +5467 @@
   if (result) {
     *out << Verbose(5) << "Calculating distances" << endl;
-    Distances = Malloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: Distances");
-    OtherDistances = Malloc<double>(AtomCount, "molecule::IsEqualToWithinThreshold: OtherDistances");
+    Distances = (double *) Malloc(sizeof(double)*AtomCount, "molecule::IsEqualToWithinThreshold: Distances");
+    OtherDistances = (double *) Malloc(sizeof(double)*AtomCount, "molecule::IsEqualToWithinThreshold: OtherDistances");
     Walker = start;
     while (Walker->next != end) {
@@ -5492 +5482 @@
     /// ... sort each list (using heapsort (o(N log N)) from GSL)
     *out << Verbose(5) << "Sorting distances" << endl;
-    PermMap = Malloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermMap");
-    OtherPermMap = Malloc<size_t>(AtomCount, "molecule::IsEqualToWithinThreshold: *OtherPermMap");
+    PermMap = (size_t *) Malloc(sizeof(size_t)*AtomCount, "molecule::IsEqualToWithinThreshold: *PermMap");
+    OtherPermMap = (size_t *) Malloc(sizeof(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 = Malloc<int>(AtomCount, "molecule::IsEqualToWithinThreshold: *PermutationMap");
+    PermutationMap = (int *) Malloc(sizeof(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 individually(!) below \a threshold for all
+    /// ... and compare them step by step, whether the difference is individiually(!) below \a threshold for all
     *out << Verbose(4) << "Comparing distances" << endl;
     flag = 0;
@@ -5509 +5499 @@
         flag = 1;
     }
-
-    // free memory
-    Free(&PermMap);
-    Free(&OtherPermMap);
-    Free(&Distances);
-    Free(&OtherDistances);
+    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");
     if (flag) { // if not equal
-      Free(&PermutationMap);
+      Free((void **)&PermutationMap, "molecule::IsEqualToWithinThreshold: *PermutationMap");
       result = false;
     }
@@ -5542 +5532 @@
   atom *Walker = NULL, *OtherWalker = NULL;
   *out << Verbose(3) << "Begin of GetFatherAtomicMap." << endl;
-  int *AtomicMap = Malloc<int>(AtomCount, "molecule::GetAtomicMap: *AtomicMap");
+  int *AtomicMap = (int *) Malloc(sizeof(int)*AtomCount, "molecule::GetAtomicMap: *AtomicMap");  //Calloc
   for (int i=AtomCount;i--;)
     AtomicMap[i] = -1;