Changeset 34af97 for src/Fragmentation

Timestamp:

Sep 9, 2016, 1:51:36 PM (8 years ago)

Author:

Frederik Heber <heber@…>

Branches:

Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_StructOpt_integration_tests, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, 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_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, GeometryObjects, Gui_displays_atomic_force_velocity, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, Ubuntu_1604_changes, stable

Children:

61fc12

Parents:

9bdbc7

git-author:

Frederik Heber <heber@…> (09/01/16 20:31:45)

git-committer:

Frederik Heber <heber@…> (09/09/16 13:51:36)

Message:

FIX: KeySetsContainer::insert(KeySetsContainer&) was not fully working.

• sets were simply appended and according to their index sets.
• this works for normal index sets but not for forceindexsets, which have the additional (excluded) hydrogens that take not part when counting the bond order.
• As FragmentationResultsContainer relied on index and forceindex to have the same fragment order, this was no longer true.
• Added extensive unit test on KeySetsContainer::insert().

Location:

src/Fragmentation

Files:

• KeySetsContainer.cpp (modified) (2 diffs)
• unittests/KeySetsContainerUnitTest.cpp (modified) (3 diffs)
• unittests/KeySetsContainerUnitTest.hpp (modified) (2 diffs)

src/Fragmentation/KeySetsContainer.cpp

@@ -42 +42 @@
 #include <boost/tokenizer.hpp>
 
+#include "CodePatterns/Assert.hpp"
 #include "CodePatterns/Log.hpp"
 
@@ -247 +248 @@
 void KeySetsContainer::insert(const KeySetsContainer &other)
 {
-  KeySets.reserve(KeySets.size()+other.KeySets.size());
-  AtomCounter.reserve(AtomCounter.size()+other.AtomCounter.size());
-  for (ArrayOfIntVectors::const_iterator iter = other.KeySets.begin();
-      iter != other.KeySets.end(); ++iter)
-    insert(*iter, iter->size());
+  // append sets and their atom count
+  KeySets.insert(KeySets.end(), other.KeySets.begin(), other.KeySets.end());
+  AtomCounter.insert(AtomCounter.end(), other.AtomCounter.begin(), other.AtomCounter.end());
+
+  // ASSUME: that the fragments inside other are number consecutively
+
+  // find the smallest number
+  int smallest_index = std::numeric_limits<int>::max();
+  for(size_t i=0;i<other.OrderSet.size();++i)
+    for(IntVector::const_iterator iter = other.OrderSet[i].begin();
+        iter != other.OrderSet[i].end(); ++iter)
+      smallest_index = std::min(smallest_index, (*iter));
+
+  // renumber incoming fragments and insert into OrderSets
+  int nr_fragments = 0;
+  for(size_t i=0;i<other.OrderSet.size();++i) {
+    for(IntVector::const_iterator iter = other.OrderSet[i].begin();
+        iter != other.OrderSet[i].end(); ++iter) {
+      if (i >= OrderSet.size() )
+        OrderSet.resize(i+1);
+      OrderSet[i].push_back((*iter)+FragmentCounter-smallest_index);
+      if (i >= FragmentsPerOrder.size())
+        FragmentsPerOrder.resize(i+1);
+      ++(FragmentsPerOrder[i]);
+    }
+    nr_fragments += other.OrderSet[i].size();
+  }
+  Order = std::max(Order, other.Order);
+  // the following assert must not necessarily be true because of cycles: 
+  // Order 4 with added cycles is still order 4.
+  //ASSERT( Order == (int)OrderSet.size(),
+  //    "KeySetsContainer::insert() - order not max of either container?");
+  FragmentCounter += nr_fragments;
 }
 

src/Fragmentation/unittests/KeySetsContainerUnitTest.cpp

@@ -43 +43 @@
 #include <boost/archive/text_iarchive.hpp>
 
+#include <boost/assign.hpp>
+
 #include "Fragmentation/KeySetsContainer.hpp"
 
@@ -50 +52 @@
 #include "UnitTestMain.hpp"
 #endif /*HAVE_TESTRUNNER*/
+
+using namespace boost::assign;
 
 /********************************************** Test classes **************************************/
@@ -105 +109 @@
   delete Keys2;
 };
+
+static void fillKeySetsContainer(KeySetsContainer *_Keys)
+{
+  // insert keysets
+  KeySetsContainer::IntVector keyset;
+  keyset += 1;
+  _Keys->KeySets.push_back(keyset);
+  keyset += 2;
+  _Keys->KeySets.push_back(keyset);
+  keyset += 3;
+  _Keys->KeySets.push_back(keyset);
+  // insert number of keys per keyset
+  _Keys->AtomCounter += 1,2,3;
+  // insert total number of keysets/fragments
+  _Keys->FragmentCounter = 3;
+  // insert maximum number of keys over all contained keysets
+  _Keys->Order = 3;
+  // insert number of keysets with the same number of keys
+  _Keys->FragmentsPerOrder += 1,1,1;
+  // insert keyset index in keysets per same number of keys
+  _Keys->OrderSet.resize(3);
+  _Keys->OrderSet[0] = KeySetsContainer::IntVector(1, 0);
+  _Keys->OrderSet[1] = KeySetsContainer::IntVector(1, 1);
+  _Keys->OrderSet[2] = KeySetsContainer::IntVector(1, 2);
+}
+
+/** UnitTest for insert() into an empty container
+ */
+void KeySetsContainerTest::insertIntoEmptyTest()
+{
+  // fill other container
+  KeySetsContainer *Keys2 = new KeySetsContainer();
+  fillKeySetsContainer(Keys2);
+
+  // insert filled one (Keys2) into empty (Keys)
+  Keys->insert(*Keys2);
+
+  CPPUNIT_ASSERT (*Keys == *Keys2);
+
+  delete Keys2;
+}
+
+/** UnitTest for insert() empty into a filled container
+ */
+void KeySetsContainerTest::insertEmptyIntoTest()
+{
+  // fill other container
+  KeySetsContainer *Keys2 = new KeySetsContainer();
+  fillKeySetsContainer(Keys2);
+
+  // create result container (we know this works from insertIntoEmptyTest())
+  KeySetsContainer *resultKeys = new KeySetsContainer();
+  resultKeys->insert(*Keys2);
+
+  // fill empty (Keys) into filled oned (Keys2)
+  Keys2->insert(*Keys);
+
+  // create empty for comparison
+  KeySetsContainer *emptyKeys = new KeySetsContainer();
+
+  CPPUNIT_ASSERT (*Keys2 == *resultKeys);
+  CPPUNIT_ASSERT (*Keys == *emptyKeys);
+
+  delete Keys2;
+  delete resultKeys;
+  delete emptyKeys;
+}
+
+/** UnitTest for insert() smaller filled into another filled container
+ */
+void KeySetsContainerTest::insertSmallerIntoTest()
+{
+  // fill other container
+  KeySetsContainer *Keys2 = new KeySetsContainer();
+  fillKeySetsContainer(Keys2);
+
+  // fill Keys, too
+  {
+    KeySetsContainer::IntVector keyset;
+    keyset += 2;
+    Keys->KeySets.push_back(keyset);
+    // insert number of keys per keyset
+    Keys->AtomCounter += 1;
+    // insert total number of keysets/fragments
+    Keys->FragmentCounter = 1;
+    // insert maximum number of keys over all contained keysets
+    Keys->Order = 1;
+    // insert number of keysets with the same number of keys
+    Keys->FragmentsPerOrder += 1;
+    // insert keyset index in keysets per same number of keys
+    Keys->OrderSet.resize(1);
+    Keys->OrderSet[0] = KeySetsContainer::IntVector(1, 0);
+  }
+
+  // create comparison container
+  KeySetsContainer *resultKeys = new KeySetsContainer();
+  {
+    fillKeySetsContainer(resultKeys);
+    KeySetsContainer::IntVector keyset;
+    keyset += 2;
+    resultKeys->KeySets.push_back(keyset);
+    resultKeys->AtomCounter += 1;
+    resultKeys->FragmentCounter = 4;
+    resultKeys->Order = 3;
+    resultKeys->FragmentsPerOrder[0] = 2;
+    CPPUNIT_ASSERT( resultKeys->OrderSet.size() == (size_t)3 );
+    resultKeys->OrderSet[0] += 3;
+  }
+
+  // insert smaller into larger one
+  Keys2->insert(*Keys);
+
+  CPPUNIT_ASSERT (*Keys != *Keys2);
+  CPPUNIT_ASSERT (*resultKeys == *Keys2);
+
+  delete Keys2;
+  delete resultKeys;
+}
+
+/** UnitTest for insert() larger filled into another filled container
+ */
+void KeySetsContainerTest::insertLargerIntoTest()
+{
+  // fill other container
+  KeySetsContainer *Keys2 = new KeySetsContainer();
+  fillKeySetsContainer(Keys2);
+
+  // fill Keys, too
+  {
+    KeySetsContainer::IntVector keyset;
+    keyset += 2;
+    Keys->KeySets.push_back(keyset);
+    // insert number of keys per keyset
+    Keys->AtomCounter += 1;
+    // insert total number of keysets/fragments
+    Keys->FragmentCounter = 1;
+    // insert maximum number of keys over all contained keysets
+    Keys->Order = 1;
+    // insert number of keysets with the same number of keys
+    Keys->FragmentsPerOrder += 1;
+    // insert keyset index in keysets per same number of keys
+    Keys->OrderSet.resize(1);
+    Keys->OrderSet[0] = KeySetsContainer::IntVector(1, 0);
+  }
+
+  // create comparison container
+  KeySetsContainer *resultKeys = new KeySetsContainer();
+  {
+    // we know this works from insertIntoEmptyTest()
+    resultKeys->insert(*Keys);
+    // add larger keysets
+    fillKeySetsContainer(resultKeys);
+
+    resultKeys->AtomCounter.clear();
+    resultKeys->AtomCounter += 1,1,2,3;
+    resultKeys->FragmentCounter = 4;
+    resultKeys->FragmentsPerOrder.clear();
+    resultKeys->FragmentsPerOrder += 2,1,1;
+    resultKeys->OrderSet.clear();
+    resultKeys->OrderSet.resize(3);
+    resultKeys->OrderSet[0] = KeySetsContainer::IntVector(1, 0);
+    resultKeys->OrderSet[0] += 1;
+    resultKeys->OrderSet[1] = KeySetsContainer::IntVector(1, 2);
+    resultKeys->OrderSet[2] = KeySetsContainer::IntVector(1, 3);
+  }
+
+  // insert larger into smaller one
+  Keys->insert(*Keys2);
+
+  CPPUNIT_ASSERT (*Keys != *Keys2);
+  CPPUNIT_ASSERT (*resultKeys == *Keys);
+
+  delete Keys2;
+  delete resultKeys;
+}

src/Fragmentation/unittests/KeySetsContainerUnitTest.hpp

@@ -26 +26 @@
     CPPUNIT_TEST ( EqualityTest );
     CPPUNIT_TEST ( SerializationTest );
+    CPPUNIT_TEST ( insertIntoEmptyTest );
+    CPPUNIT_TEST ( insertEmptyIntoTest );
+    CPPUNIT_TEST ( insertSmallerIntoTest );
+    CPPUNIT_TEST ( insertLargerIntoTest );
     CPPUNIT_TEST_SUITE_END();
 
@@ -33 +37 @@
       void EqualityTest();
       void SerializationTest();
+      void insertIntoEmptyTest();
+      void insertEmptyIntoTest();
+      void insertSmallerIntoTest();
+      void insertLargerIntoTest();
 
 private: