Changes in src/molecule_fragmentation.cpp [112b09:c27778]

File:

• src/molecule_fragmentation.cpp (modified) (22 diffs)

src/molecule_fragmentation.cpp

@@ -82 +82 @@
  * -# Scans TEFactors file and sets the TEFactor of each key set in the temporary graph accordingly
  * Finally, the temporary graph is inserted into the given \a FragmentList for return.
- * \param *out output stream for debugging
- * \param *path path to file
+ * \param &path path to file
  * \param *FragmentList empty, filled on return
  * \return true - parsing successfully, false - failure on parsing (FragmentList will be NULL)
  */
-bool ParseKeySetFile(char *path, Graph *&FragmentList)
+bool ParseKeySetFile(std::string &path, Graph *&FragmentList)
 {
   bool status = true;
@@ -94 +93 @@
   GraphTestPair testGraphInsert;
   int NumberOfFragments = 0;
-  char filename[MAXSTRINGSIZE];
+  string filename;
 
   if (FragmentList == NULL) { // check list pointer
@@ -102 +101 @@
   // 1st pass: open file and read
   DoLog(1) && (Log() << Verbose(1) << "Parsing the KeySet file ... " << endl);
-  sprintf(filename, "%s/%s%s", path, FRAGMENTPREFIX, KEYSETFILE);
-  InputFile.open(filename);
-  if (InputFile != NULL) {
+  filename = path + KEYSETFILE;
+  InputFile.open(filename.c_str());
+  if (InputFile.good()) {
     // each line represents a new fragment
     char buffer[MAXSTRINGSIZE];
@@ -181 +180 @@
 
 /** Stores key sets to file.
- * \param *out output stream for debugging
  * \param KeySetList Graph with Keysets
- * \param *path path to file
+ * \param &path path to file
  * \return true - file written successfully, false - writing failed
  */
-bool StoreKeySetFile(Graph &KeySetList, char *path)
-{
-  ofstream output;
+bool StoreKeySetFile(Graph &KeySetList, std::string &path)
+{
   bool status =  true;
-  string line;
+  string line = path + KEYSETFILE;
+  ofstream output(line.c_str());
 
   // open KeySet file
-  line = path;
-  line.append("/");
-  line += FRAGMENTPREFIX;
-  line += KEYSETFILE;
-  output.open(line.c_str(), ios::out);
   DoLog(1) && (Log() << Verbose(1) << "Saving key sets of the total graph ... ");
-  if(output != NULL) {
+  if(output.good()) {
     for(Graph::iterator runner = KeySetList.begin(); runner != KeySetList.end(); runner++) {
       for (KeySet::iterator sprinter = (*runner).first.begin();sprinter != (*runner).first.end(); sprinter++) {
@@ -302 +295 @@
 
 /** Scans the adaptive order file and insert (index, value) into map.
- * \param *out output stream for debugging
- * \param *path path to ENERGYPERFRAGMENT file (may be NULL if Order is non-negative)
+ * \param &path path to ENERGYPERFRAGMENT file (may be NULL if Order is non-negative)
  * \param &IndexedKeySetList list to find key set for a given index \a No
  * \return adaptive criteria list from file
  */
-map<int, pair<double,int> > * ScanAdaptiveFileIntoMap(char *path, map<int,KeySet> &IndexKeySetList)
+map<int, pair<double,int> > * ScanAdaptiveFileIntoMap(std::string &path, map<int,KeySet> &IndexKeySetList)
 {
   map<int, pair<double,int> > *AdaptiveCriteriaList = new map<int, pair<double,int> >;
@@ -313 +305 @@
   double Value = 0.;
   char buffer[MAXSTRINGSIZE];
-  sprintf(buffer, "%s/%s%s.dat", path, FRAGMENTPREFIX, ENERGYPERFRAGMENT);
-  ifstream InputFile(buffer, ios::in);
+  string filename = path + ENERGYPERFRAGMENT;
+  ifstream InputFile(filename.c_str());
+
+  if (InputFile.fail()) {
+    DoeLog(1) && (eLog() << Verbose(1) << "Cannot find file " << filename << "." << endl);
+    return AdaptiveCriteriaList;
+  }
 
   if (CountLinesinFile(InputFile) > 0) {
@@ -419 +416 @@
 
 /** Checks whether the OrderAtSite is still below \a Order at some site.
- * \param *out output stream for debugging
  * \param *AtomMask defines true/false per global Atom::nr to mask in/out each nuclear site, used to activate given number of site to increment order adaptively
  * \param *GlobalKeySetList list of keysets with global ids (valid in "this" molecule) needed for adaptive increase
  * \param Order desired Order if positive, desired exponent in threshold criteria if negative (0 is single-step)
  * \param *MinimumRingSize array of max. possible order to avoid loops
- * \param *path path to ENERGYPERFRAGMENT file (may be NULL if Order is non-negative)
+ * \param path path to ENERGYPERFRAGMENT file (may be NULL if Order is non-negative)
  * \return true - needs further fragmentation, false - does not need fragmentation
  */
-bool molecule::CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, char *path)
+bool molecule::CheckOrderAtSite(bool *AtomMask, Graph *GlobalKeySetList, int Order, int *MinimumRingSize, std::string path)
 {
   bool status = false;
@@ -585 +581 @@
  * of vertex indices: Global always means the index in "this" molecule, whereas local refers to the molecule or
  * subgraph in the MoleculeListClass.
- * \param *out output stream for debugging
  * \param Order up to how many neighbouring bonds a fragment contains in BondOrderScheme::BottumUp scheme
- * \param *configuration configuration for writing config files for each fragment
+ * \param &prefix path and prefix of the bond order configs to be written
  * \return 1 - continue, 2 - stop (no fragmentation occured)
  */
-int molecule::FragmentMolecule(int Order, config *configuration)
+int molecule::FragmentMolecule(int Order, std::string &prefix)
 {
   MoleculeListClass *BondFragments = NULL;
@@ -624 +619 @@
 
   // === compare it with adjacency file ===
-  FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(configuration->configpath, ListOfAtoms);
+  FragmentationToDo = FragmentationToDo && CheckAdjacencyFileAgainstMolecule(prefix, ListOfAtoms);
   delete[](ListOfAtoms);
 
@@ -634 +629 @@
     MinimumRingSize[i] = getAtomCount();
   MolecularWalker = Subgraphs;
+  const int LeafCount = Subgraphs->next->Count();
   FragmentCounter = 0;
   while (MolecularWalker->next != NULL) {
     MolecularWalker = MolecularWalker->next;
     // fill the bond structure of the individually stored subgraphs
-    MolecularWalker->FillBondStructureFromReference(this, FragmentCounter, ListOfLocalAtoms, false);  // we want to keep the created ListOfLocalAtoms
+    ListOfAtoms = NULL;
+    MolecularWalker->FillBondStructureFromReference(this, ListOfAtoms, false);  // we want to keep the created ListOfLocalAtoms
     DoLog(0) && (Log() << Verbose(0) << "Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl);
     LocalBackEdgeStack = new StackClass<bond *> (MolecularWalker->Leaf->BondCount);
@@ -649 +646 @@
 //        Log() << Verbose(0) << "\t" << ListOfLocalAtoms[FragmentCounter][i]->Name;
     DoLog(0) && (Log() << Verbose(0) << "Gathering local back edges for subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl);
-    MolecularWalker->Leaf->PickLocalBackEdges(ListOfLocalAtoms[FragmentCounter++], BackEdgeStack, LocalBackEdgeStack);
+    MolecularWalker->Leaf->PickLocalBackEdges(ListOfAtoms, BackEdgeStack, LocalBackEdgeStack);
     DoLog(0) && (Log() << Verbose(0) << "Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl);
     MolecularWalker->Leaf->CyclicStructureAnalysis(LocalBackEdgeStack, MinimumRingSize);
     DoLog(0) && (Log() << Verbose(0) << "Done with Analysing the cycles of subgraph " << MolecularWalker->Leaf << " with nr. " << FragmentCounter << "." << endl);
     delete(LocalBackEdgeStack);
+    delete(ListOfAtoms);
+    FragmentCounter++;
   }
   delete(BackEdgeStack);
 
   // ===== 3. if structure still valid, parse key set file and others =====
-  FragmentationToDo = FragmentationToDo && ParseKeySetFile(configuration->configpath, ParsedFragmentList);
+  FragmentationToDo = FragmentationToDo && ParseKeySetFile(prefix, ParsedFragmentList);
 
   // ===== 4. check globally whether there's something to do actually (first adaptivity check)
-  FragmentationToDo = FragmentationToDo && ParseOrderAtSiteFromFile(configuration->configpath);
+  FragmentationToDo = FragmentationToDo && ParseOrderAtSiteFromFile(prefix);
 
   // =================================== Begin of FRAGMENTATION ===============================
   // ===== 6a. assign each keyset to its respective subgraph =====
-  Subgraphs->next->AssignKeySetsToFragment(this, ParsedFragmentList, ListOfLocalAtoms, FragmentList, (FragmentCounter = 0), true);
+  ListOfLocalAtoms = new atom **[LeafCount];
+  for (int i=0;i<LeafCount;i++)
+    ListOfLocalAtoms[i] = NULL;
+  FragmentCounter = 0;
+  Subgraphs->next->AssignKeySetsToFragment(this, ParsedFragmentList, ListOfLocalAtoms, FragmentList, FragmentCounter, true);
+  delete[](ListOfLocalAtoms);
 
   // ===== 6b. prepare and go into the adaptive (Order<0), single-step (Order==0) or incremental (Order>0) cycle
@@ -672 +676 @@
   AtomMask[getAtomCount()] = false;
   FragmentationToDo = false;  // if CheckOrderAtSite just ones recommends fragmentation, we will save fragments afterwards
-  while ((CheckOrder = CheckOrderAtSite(AtomMask, ParsedFragmentList, Order, MinimumRingSize, configuration->configpath))) {
+  while ((CheckOrder = CheckOrderAtSite(AtomMask, ParsedFragmentList, Order, MinimumRingSize, prefix))) {
     FragmentationToDo = FragmentationToDo || CheckOrder;
     AtomMask[getAtomCount()] = true;   // last plus one entry is used as marker that we have been through this loop once already in CheckOrderAtSite()
@@ -701 +705 @@
   delete[](MinimumRingSize);
 
-
   // ==================================== End of FRAGMENTATION ============================================
 
@@ -727 +730 @@
     KeySet test = (*runner).first;
     DoLog(0) && (Log() << Verbose(0) << "Fragment No." << (*runner).second.first << " with TEFactor " << (*runner).second.second << "." << endl);
-    BondFragments->insert(StoreFragmentFromKeySet(test, configuration));
+    BondFragments->insert(StoreFragmentFromKeySet(test, World::getInstance().getConfig()));
     k++;
   }
@@ -739 +742 @@
 
     DoLog(1) && (Log() << Verbose(1) << "Writing " << BondFragments->ListOfMolecules.size() << " possible bond fragmentation configs" << endl);
-    if (BondFragments->OutputConfigForListOfFragments(configuration, SortIndex))
+    if (BondFragments->OutputConfigForListOfFragments(prefix, SortIndex))
       DoLog(1) && (Log() << Verbose(1) << "All configs written." << endl);
     else
@@ -745 +748 @@
 
     // store force index reference file
-    BondFragments->StoreForcesFile(configuration->configpath, SortIndex);
+    BondFragments->StoreForcesFile(prefix, SortIndex);
 
     // store keysets file
-    StoreKeySetFile(TotalGraph, configuration->configpath);
+    StoreKeySetFile(TotalGraph, prefix);
 
     {
       // store Adjacency file
-      char filename[MAXSTRINGSIZE];
-      strcpy(filename, FRAGMENTPREFIX);
-      strcat(filename, ADJACENCYFILE);
-      StoreAdjacencyToFile(configuration->configpath, filename);
+      std::string filename = prefix + ADJACENCYFILE;
+      StoreAdjacencyToFile(filename);
     }
 
     // store Hydrogen saturation correction file
-    BondFragments->AddHydrogenCorrection(configuration->configpath);
+    BondFragments->AddHydrogenCorrection(prefix);
 
     // store adaptive orders into file
-    StoreOrderAtSiteFile(configuration->configpath);
+    StoreOrderAtSiteFile(prefix);
 
     // restore orbital and Stop values
-    CalculateOrbitals(*configuration);
+    //CalculateOrbitals(*configuration);
 
     // free memory for bond part
@@ -782 +783 @@
 /** Stores pairs (Atom::nr, Atom::AdaptiveOrder) into file.
  * Atoms not present in the file get "-1".
- * \param *out output stream for debugging
- * \param *path path to file ORDERATSITEFILE
+ * \param &path path to file ORDERATSITEFILE
  * \return true - file writable, false - not writable
  */
-bool molecule::StoreOrderAtSiteFile(char *path)
-{
-  stringstream line;
+bool molecule::StoreOrderAtSiteFile(std::string &path)
+{
+  string line;
   ofstream file;
 
-  line << path << "/" << FRAGMENTPREFIX << ORDERATSITEFILE;
-  file.open(line.str().c_str());
+  line = path + ORDERATSITEFILE;
+  file.open(line.c_str());
   DoLog(1) && (Log() << Verbose(1) << "Writing OrderAtSite " << ORDERATSITEFILE << " ... " << endl);
-  if (file != NULL) {
+  if (file.good()) {
     ActOnAllAtoms( &atom::OutputOrder, &file );
     file.close();
@@ -800 +800 @@
     return true;
   } else {
-    DoLog(1) && (Log() << Verbose(1) << "failed to open file " << line.str() << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "failed to open file " << line << "." << endl);
     return false;
   }
@@ -807 +807 @@
 /** Parses pairs(Atom::nr, Atom::AdaptiveOrder) from file and stores in molecule's Atom's.
  * Atoms not present in the file get "0".
- * \param *out output stream for debugging
- * \param *path path to file ORDERATSITEFILEe
+ * \param &path path to file ORDERATSITEFILEe
  * \return true - file found and scanned, false - file not found
  * \sa ParseKeySetFile() and CheckAdjacencyFileAgainstMolecule() as this is meant to be used in conjunction with the two
  */
-bool molecule::ParseOrderAtSiteFromFile(char *path)
+bool molecule::ParseOrderAtSiteFromFile(std::string &path)
 {
   unsigned char *OrderArray = new unsigned char[getAtomCount()];
@@ -818 +817 @@
   bool status;
   int AtomNr, value;
-  stringstream line;
+  string line;
   ifstream file;
 
@@ -827 +826 @@
 
   DoLog(1) && (Log() << Verbose(1) << "Begin of ParseOrderAtSiteFromFile" << endl);
-  line << path << "/" << FRAGMENTPREFIX << ORDERATSITEFILE;
-  file.open(line.str().c_str());
-  if (file != NULL) {
+  line = path + ORDERATSITEFILE;
+  file.open(line.c_str());
+  if (file.good()) {
     while (!file.eof()) { // parse from file
       AtomNr = -1;
@@ -850 +849 @@
     status = true;
   } else {
-    DoLog(1) && (Log() << Verbose(1) << "\t ... failed to open file " << line.str() << "." << endl);
+    DoLog(1) && (Log() << Verbose(1) << "\t ... failed to open file " << line << "." << endl);
     status = false;
   }