Changeset 51e0e3 for src/FunctionApproximation/Extractors.cpp

Timestamp:

Aug 9, 2013, 2:20:35 PM (11 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:

a633f6

Parents:

0f5d38

git-author:

Frederik Heber <heber@…> (06/25/13 12:41:01)

git-committer:

Frederik Heber <heber@…> (08/09/13 14:20:35)

Message:

Added two filter functions to Extractors.

• renamed reorderArgumentsByParticleTypes()->filterArgumentsByParticleTypes().
• added reorderArgumentsByParticleTypes() that expects arguments matching to given particle types and which reorders into matching bunches with associated indices.
• added suitable combination of the two filter as each potential's specific filter.
• had to add specific comparator for Particle_Types_t to allow flipped types in argument_map.
• reorderArgumentsByParticleTypes() prints with enhanced toString.
• FIX: Histogram did not use the pair-wise operator<<(). (this occured because of new operator<<(..,pair) from toString.hpp).
• we enforce CodePatterns 1.2.7 now.

File:

• src/FunctionApproximation/Extractors.cpp (modified) (4 diffs)

src/FunctionApproximation/Extractors.cpp

@@ -45 +45 @@
 
 #include "CodePatterns/Assert.hpp"
+#include "CodePatterns/IteratorAdaptors.hpp"
 #include "CodePatterns/Log.hpp"
+#include "CodePatterns/toString.hpp"
 
 #include "LinearAlgebra/Vector.hpp"
@@ -538 +540 @@
 }
 
+
+struct ParticleTypesComparator {
+  bool operator()(const argument_t::types_t &a, const argument_t::types_t &b)
+  {
+    if (a.first < a.second) {
+      if (b.first < b.second) {
+        if (a.first < b.first)
+          return true;
+        else if (a.first > b.first)
+          return false;
+        else
+          return (a.second < b.second);
+      } else {
+        if (a.first < b.second)
+          return true;
+        else if (a.first > b.second)
+          return false;
+        else
+          return (a.second < b.first);
+      }
+    } else {
+      if (b.first < b.second) {
+        if (a.second < b.first)
+          return true;
+        else if (a.second > b.first)
+          return false;
+        else
+          return (a.first < b.second);
+      } else {
+        if (a.second < b.second)
+          return true;
+        else if (a.second > b.second)
+          return false;
+        else
+          return (a.first < b.first);
+      }
+    }
+  }
+};
+
+std::ostream& operator<<(std::ostream &out, const argument_t::types_t &a)
+{
+  out << "[" << a.first << "," << a.second << "]";
+  return out;
+}
+
 FunctionModel::arguments_t Extractors::reorderArgumentsByParticleTypes(
+    const FunctionModel::arguments_t &args,
+    const ParticleTypes_t &_types
+    )
+{
+  /// We  place all arguments into multimap according to particle type pair.
+  // here, we need a special comparator such that types in key pair are always
+  // properly ordered.
+  typedef std::multimap<
+      argument_t::types_t,
+      argument_t,
+      ParticleTypesComparator> TypePair_Argument_Map_t;
+  TypePair_Argument_Map_t argument_map;
+  for(FunctionModel::arguments_t::const_iterator iter = args.begin();
+      iter != args.end(); ++iter) {
+    argument_map.insert( std::make_pair(iter->types, *iter) );
+  }
+  LOG(4, "DEBUG: particle_type map is " << argument_map << ".");
+
+  /// Then, we create the desired unique keys
+  typedef std::vector<argument_t::types_t> UniqueTypes_t;
+  UniqueTypes_t UniqueTypes;
+  for (ParticleTypes_t::const_iterator firstiter = _types.begin();
+      firstiter != _types.end();
+      ++firstiter) {
+    for (ParticleTypes_t::const_iterator seconditer = firstiter;
+        seconditer != _types.end();
+        ++seconditer) {
+      if (seconditer == firstiter)
+        continue;
+      UniqueTypes.push_back( std::make_pair(*firstiter, *seconditer) );
+    }
+  }
+  LOG(4, "DEBUG: Created unique types as keys " << UniqueTypes << ".");
+
+  /// Finally, we use the unique key list to pick corresponding arguments from the map
+  FunctionModel::arguments_t returnargs;
+  returnargs.reserve(args.size());
+  while (!argument_map.empty()) {
+    // note that particle_types_t may be flipped, i.e. 1,8 is equal to 8,1, but we
+    // must maintain the correct order in indices in accordance with the order
+    // in _types, i.e. 1,8,1 must match with e.g. ids 1,0,2 where 1 has type 1,
+    // 0 has type 8, and 2 has type 2.
+    // In other words: We do not want to flip/modify arguments such that they match
+    // with the specific type pair we seek but then this comes at the price that we
+    // have flip indices when the types in a pair are flipped.
+
+    typedef std::vector<size_t> indices_t;
+    //!> here, we gather the indices as we discover them
+    indices_t indices;
+    indices.resize(_types.size(), (size_t)-1);
+
+    // these are two iterators that create index pairs in the same way as we have
+    // created type pairs. If a -1 is still present in indices, then the index is
+    // still arbitrary but is then set by the next found index
+    indices_t::iterator firstindex = indices.begin();
+    indices_t::iterator secondindex = firstindex+1;
+
+    //!> here, we gather the current bunch of arguments as we find them
+    FunctionModel::arguments_t argumentbunch;
+    argumentbunch.reserve(UniqueTypes.size());
+
+    for (UniqueTypes_t::const_iterator typeiter = UniqueTypes.begin();
+        typeiter != UniqueTypes.end(); ++typeiter) {
+      // have all arguments to same type pair as list within the found range
+      std::pair<
+          TypePair_Argument_Map_t::iterator,
+          TypePair_Argument_Map_t::iterator> range_t =
+              argument_map.equal_range(*typeiter);
+      LOG(4, "DEBUG: Set of arguments to current key [" << typeiter->first << ","
+          << typeiter->second << "] is " << std::list<argument_t>(
+              MapValueIterator<TypePair_Argument_Map_t::iterator>(range_t.first),
+              MapValueIterator<TypePair_Argument_Map_t::iterator>(range_t.second)
+              ) << ".");
+      // the first key is always easy and is pivot which the rest has to be associated to
+      if (typeiter == UniqueTypes.begin()) {
+        const argument_t & arg = range_t.first->second;
+        if ((typeiter->first == arg.types.first) && (typeiter->second == arg.types.second)) {
+          // store in correct order
+          *firstindex = arg.indices.first;
+          *secondindex = arg.indices.second;
+        } else {
+          // store in flipped order
+          *firstindex = arg.indices.second;
+          *secondindex = arg.indices.first;
+        }
+        argumentbunch.push_back(arg);
+        argument_map.erase(range_t.first);
+        LOG(4, "DEBUG: Gathered first argument " << arg << ".");
+      } else {
+        // go through the range and pick the first argument matching the index constraints
+        for (TypePair_Argument_Map_t::iterator argiter = range_t.first;
+            argiter != range_t.second; ++argiter) {
+          // seconditer may be -1 still
+          const argument_t &arg = argiter->second;
+          if (arg.indices.first == *firstindex) {
+            if ((arg.indices.second == *secondindex) || (*secondindex == (size_t)-1)) {
+              if (*secondindex == -1)
+                *secondindex = arg.indices.second;
+              argumentbunch.push_back(arg);
+              argument_map.erase(argiter);
+              LOG(4, "DEBUG: Gathered another argument " << arg << ".");
+              break;
+            }
+          } else if ((arg.indices.first == *secondindex) || (*secondindex == (size_t)-1)) {
+            if (arg.indices.second == *firstindex) {
+              if (*secondindex == (size_t)-1)
+                *secondindex = arg.indices.first;
+              argumentbunch.push_back(arg);
+              argument_map.erase(argiter);
+              LOG(4, "DEBUG: Gathered another (flipped) argument " << arg << ".");
+              break;
+            }
+          }
+        }
+      }
+      // move along in indices and check bounds
+      ++secondindex;
+      if (secondindex == indices.end()) {
+        ++firstindex;
+        if (firstindex != indices.end()-1)
+          secondindex = firstindex+1;
+      }
+    }
+    ASSERT( (firstindex == indices.end()-1) && (secondindex == indices.end()),
+        "Extractors::reorderArgumentsByParticleTypes() - we have not gathered enough arguments.");
+    ASSERT( argumentbunch.size() == UniqueTypes.size(),
+        "Extractors::reorderArgumentsByParticleTypes() - we have not gathered enough arguments.");
+    // place bunch of arguments in return args
+    LOG(3, "DEBUG: Given types " << _types << " and found indices " << indices << ".");
+    LOG(3, "DEBUG: Final bunch of arguments is " << argumentbunch << ".");
+    returnargs.insert(returnargs.end(), argumentbunch.begin(), argumentbunch.end());
+  }
+
+  return returnargs;
+}
+
+FunctionModel::arguments_t Extractors::filterArgumentsByParticleTypes(
     const FunctionModel::arguments_t &args,
     const ParticleTypes_t &_types
@@ -557 +742 @@
 
   // basically, we have two choose any two pairs out of types but only those
-  // where the first is less than the letter. Hence, we start the second
+  // where the first is less than the latter. Hence, we start the second
   // iterator at the current position of the first one and skip the equal case.
   for (ParticleTypes_t::const_iterator firstiter = _types.begin();
@@ -580 +765 @@
         else if ((iter->types.first == *seconditer)
               && (iter->types.second == *firstiter)) {
-          argument_t flippedtypes(*iter);
-          std::swap( flippedtypes.indices.first, flippedtypes.indices.second );
-          std::swap( flippedtypes.types.first, flippedtypes.types.second );
-          returnargs.push_back( flippedtypes );
-          break;
+//          argument_t flippedtypes(*iter);
+//          std::swap( flippedtypes.indices.first, flippedtypes.indices.second );
+//          std::swap( flippedtypes.types.first, flippedtypes.types.second );
+          returnargs.push_back( *iter );
+          iter = availableList.erase(iter);
+          LOG(4, "DEBUG: Accepted (flipped) argument.");
+        } else {
+          ++iter;
+          LOG(4, "DEBUG: Rejected argument.");
         }
       }