Changeset 358ddb for src/Actions/FragmentationAction/FragmentationAutomationAction.cpp

Timestamp:

Nov 21, 2012, 12:46:30 PM (12 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:

06865e

Parents:

a0f8d3

git-author:

Frederik Heber <heber@…> (08/08/12 16:56:24)

git-committer:

Frederik Heber <heber@…> (11/21/12 12:46:30)

Message:

FragmentationAutomationAction now also sums up potential and obtain long-range energy.

• this does not yet seem to be fully working but all the pieces are in place and the failure might also be connected to various issues (e.g. bohr radii) of mpqc.

File:

• src/Actions/FragmentationAction/FragmentationAutomationAction.cpp (modified) (10 diffs)

src/Actions/FragmentationAction/FragmentationAutomationAction.cpp

@@ -60 +60 @@
 #include "Fragmentation/Summation/AllLevelOrthogonalSummator.hpp"
 #include "Fragmentation/Summation/AllLevelSummator.hpp"
+#include "Fragmentation/Summation/OrthogonalFullSummator.hpp"
+#include "Fragmentation/Summation/OrthogonalSummation.hpp"
 #include "Fragmentation/Summation/writeTable.hpp"
 #include "Graph/DepthFirstSearchAnalysis.hpp"
@@ -70 +72 @@
 #ifdef HAVE_VMG
 #include "Jobs/VMGJob.hpp"
+#include "Jobs/VMGData.hpp"
+#include "Jobs/VMGDataFused.hpp"
+#include "Jobs/VMGDataMap.hpp"
+#include "Jobs/VMGData_printKeyNames.hpp"
 #endif
 #include "molecule.hpp"
@@ -336 +342 @@
 }
 
+template <>
+void convertDataTo<VMGData, VMGDataMap_t>(
+    const std::vector<VMGData> &longrangeData,
+    std::vector<VMGDataMap_t> &VMGData_fused)
+{
+  // energy_t
+  VMGData_fused.clear();
+  VMGData_fused.reserve(longrangeData.size());
+  for(std::vector<VMGData>::const_iterator dataiter = longrangeData.begin();
+      dataiter != longrangeData.end(); ++dataiter) {
+    const VMGData &extractedData = *dataiter;
+    LOG(2, "DEBUG: Current extracted Data is " << extractedData << ".");
+    VMGDataMap_t instance;
+    boost::fusion::at_key<VMGDataFused::sampled_potential>(instance) = extractedData.sampled_potential;
+    boost::fusion::at_key<VMGDataFused::energy_long>(instance) = extractedData.e_long;
+    VMGData_fused.push_back(instance);
+  }
+}
 
 void convertMPQCDatatoForceMap(
@@ -432 +456 @@
   // instantiate summator
   std::vector<TypeMap> Result_fused(subsetmap->getMaximumSubsetLevel());
+  AllLevelSummator<TypeMap> Summer(
+              subsetmap,
+              MPQCData_fused,
+              jobids,
+              container->getContainer(),
+              MatrixNrLookup,
+              Result_fused);
+  // sum up for each type key in TypeVector
+  boost::mpl::for_each<TypeVector>(boost::ref(Summer));
+  return Result_fused;
+}
+
+template <typename TypeMap, typename TypeVector>
+std::vector<TypeMap> OrthogonalSumUpPerLevel(
+    const std::vector<MPQCData> &fragmentData,
+    const std::vector<JobId_t> &jobids,
+    std::map< JobId_t, size_t > &MatrixNrLookup,
+    const IndexSetContainer::ptr &container,
+    SubsetMap::ptr &subsetmap
+    )
+{
+  // place data into boost::fusion::map instance
+  std::vector<TypeMap> MPQCData_fused;
+  convertDataTo<MPQCData, TypeMap>(fragmentData, MPQCData_fused);
+  // instantiate summator
+  std::vector<TypeMap> Result_fused(subsetmap->getMaximumSubsetLevel());
   AllLevelOrthogonalSummator<TypeMap> Summer(
               subsetmap,
@@ -489 +539 @@
   /// convert all MPQCData to MPQCDataMap_t
   std::vector<MPQCDataGridMap_t> Result_Grid_fused(
-    SumUpPerLevel<MPQCDataGridMap_t, MPQCDataGridVector_t>(
+    OrthogonalSumUpPerLevel<MPQCDataGridMap_t, MPQCDataGridVector_t>(
         fragmentData, jobids, MatrixNrLookup, container, subsetmap));
   std::vector<MPQCDataFragmentMap_t> Result_Fragment_fused(
-    SumUpPerLevel<MPQCDataFragmentMap_t, MPQCDataFragmentVector_t>(
+    OrthogonalSumUpPerLevel<MPQCDataFragmentMap_t, MPQCDataFragmentVector_t>(
         fragmentData, jobids, MatrixNrLookup, container, subsetmap));
   // obtain full grid
@@ -567 +617 @@
         "FragmentationAutomationAction::performCall() - ForceKeySet's KeySets and fragmentData differ in size.");
 
+    typedef boost::mpl::remove<MPQCDataEnergyVector_t, MPQCDataFused::energy_eigenvalues>::type MPQCDataEnergyVector_noeigenvalues_t;
     std::vector<MPQCDataEnergyMap_t> Result_Energy_fused(
-        SumUpPerLevel<MPQCDataEnergyMap_t, MPQCDataEnergyVector_t>(
+        OrthogonalSumUpPerLevel<MPQCDataEnergyMap_t, MPQCDataEnergyVector_t>(
             fragmentData, jobids, MatrixNrLookup, container, subsetmap));
     std::vector<MPQCDataGridMap_t> Result_Grid_fused(
-      SumUpPerLevel<MPQCDataGridMap_t, MPQCDataGridVector_t>(
+      OrthogonalSumUpPerLevel<MPQCDataGridMap_t, MPQCDataGridVector_t>(
           fragmentData, jobids, MatrixNrLookup, container, subsetmap));
     std::vector<MPQCDataTimeMap_t> Result_Time_fused(
@@ -595 +646 @@
     // print tables (without eigenvalues, they go extra)
     const size_t MaxLevel = subsetmap->getMaximumSubsetLevel();
-    typedef boost::mpl::remove<MPQCDataEnergyVector_t, MPQCDataFused::energy_eigenvalues>::type MPQCDataEnergyVector_noeigenvalues_t;
     const std::string energyresult =
         writeTable<MPQCDataEnergyMap_t, MPQCDataEnergyVector_noeigenvalues_t >()(
@@ -648 +698 @@
   }
   LOG(1, "INFO: Resulting forces are " << std::endl << output.str());
+
+  return true;
+}
+
+/** Print MPQCData from received results.
+ *
+ * @param fragmentresults results with short-range job ids to associate with fragment number
+ * @param longrangeresults results with long-range job ids to associate with fragment number
+ * @param fragmentData MPQCData resulting from the jobs
+ * @param longrangeData VMGData resulting from long-range jobs
+ * @param KeySetFilename filename with keysets to associate forces correctly
+ * @param NoAtoms total number of atoms
+ * @param full_sample summed up charge from fragments on return
+ */
+bool printReceivedFullResults(
+    const std::vector<FragmentResult::ptr> &fragmentresults,
+    const std::vector<FragmentResult::ptr> &longrangeresults,
+    const std::vector<MPQCData> &fragmentData,
+    const std::vector<VMGData> &longrangeData,
+    const std::string &KeySetFilename,
+    size_t NoAtoms,
+    SamplingGrid &full_sample)
+{
+  // create lookup from job nr to fragment number
+  std::map< JobId_t, size_t > MatrixNrLookup;
+  size_t FragmentCounter = 0;
+  createMatrixNrLookup(fragmentresults, MatrixNrLookup, FragmentCounter);
+  std::map< JobId_t, size_t > extraMatrixNrLookup;
+  size_t extraFragmentCounter = 0;
+  createMatrixNrLookup(longrangeresults, extraMatrixNrLookup, extraFragmentCounter);
+
+  // initialise keysets
+  KeySetsContainer KeySet;
+  KeySetsContainer ForceKeySet;
+  {
+    // else needs keysets without hydrogens
+    std::stringstream filename;
+    filename << FRAGMENTPREFIX << KEYSETFILE;
+    if (!KeySet.ParseKeySets(KeySetFilename, filename.str(), FragmentCounter)) return false;
+  }
+
+  {
+    // forces need keysets including hydrogens
+    std::stringstream filename;
+    filename << FRAGMENTPREFIX << FORCESFILE;
+    if (!ForceKeySet.ParseKeySets(KeySetFilename, filename.str(), FragmentCounter)) return false;
+  }
+
+  /// prepare for OrthogonalSummation
+
+  // convert KeySetContainer to IndexSetContainer
+  IndexSetContainer::ptr container(new IndexSetContainer(KeySet));
+  // create the map of all keysets
+  SubsetMap::ptr subsetmap(new SubsetMap(*container));
+
+  // create a vector of all job ids from short-range
+  std::vector<JobId_t> jobids(fragmentresults.size(), JobId::IllegalJob);
+  std::transform(fragmentresults.begin(), fragmentresults.end(), jobids.begin(),
+      boost::bind(&FragmentResult::getId,
+          boost::bind(&FragmentResult::ptr::operator->, _1)));
+  // create a vector of all job ids from long-range
+  std::vector<JobId_t> extrajobids(longrangeresults.size(), JobId::IllegalJob);
+  std::transform(longrangeresults.begin(), longrangeresults.end(), extrajobids.begin(),
+      boost::bind(&FragmentResult::getId,
+          boost::bind(&FragmentResult::ptr::operator->, _1)));
+
+  /// convert all MPQCData to MPQCDataMap_t
+  {
+    typedef boost::mpl::remove<MPQCDataEnergyVector_t, MPQCDataFused::energy_eigenvalues>::type MPQCDataEnergyVector_noeigenvalues_t;
+    std::vector<MPQCDataEnergyMap_t> Result_Energy_fused(
+        OrthogonalSumUpPerLevel<MPQCDataEnergyMap_t, MPQCDataEnergyVector_t>(
+            fragmentData, jobids, MatrixNrLookup, container, subsetmap));
+    std::vector<MPQCDataGridMap_t> Result_Grid_fused(
+      OrthogonalSumUpPerLevel<MPQCDataGridMap_t, MPQCDataGridVector_t>(
+          fragmentData, jobids, MatrixNrLookup, container, subsetmap));
+    std::vector<MPQCDataTimeMap_t> Result_Time_fused(
+      SumUpPerLevel<MPQCDataTimeMap_t, MPQCDataTimeVector_t>(
+          fragmentData, jobids, MatrixNrLookup, container, subsetmap));
+
+    // force has extra converter
+    std::vector<MPQCDataForceMap_t> MPQCData_Force_fused;
+    convertMPQCDatatoForceMap(fragmentData, ForceKeySet, MPQCData_Force_fused);
+    std::vector<MPQCDataForceMap_t> Result_Force_fused(subsetmap->getMaximumSubsetLevel());
+    AllLevelOrthogonalSummator<MPQCDataForceMap_t> forceSummer(
+                subsetmap,
+                MPQCData_Force_fused,
+                jobids,
+                container->getContainer(),
+                MatrixNrLookup,
+                Result_Force_fused);
+    boost::mpl::for_each<MPQCDataForceVector_t>(boost::ref(forceSummer));
+
+    // obtain full grid
+    std::vector<VMGDataMap_t> VMGData_Potential_fused;
+    convertDataTo<VMGData, VMGDataMap_t>(longrangeData, VMGData_Potential_fused);
+    OrthogonalFullSummator<VMGDataMap_t, VMGDataFused::sampled_potential> potentialSummer(
+                subsetmap,
+                VMGData_Potential_fused,
+                extrajobids,
+                container->getContainer(),
+                extraMatrixNrLookup);
+    potentialSummer(subsetmap->getMaximumSubsetLevel());
+    full_sample = potentialSummer.getFullContribution();
+    LOG(0, "Remaining long-range energy from potential integral is " << full_sample.integral() << ".");
+
+    OrthogonalFullSummator<VMGDataMap_t, VMGDataFused::energy_long> elongSummer(
+                subsetmap,
+                VMGData_Potential_fused,
+                extrajobids,
+                container->getContainer(),
+                extraMatrixNrLookup);
+    elongSummer(subsetmap->getMaximumSubsetLevel());
+    const double e_long = elongSummer.getFullContribution();
+    LOG(0, "Remaining long-range energy is " << e_long << ".");
+
+    // print tables (without eigenvalues, they go extra)
+    const size_t MaxLevel = subsetmap->getMaximumSubsetLevel();
+    const std::string energyresult =
+        writeTable<MPQCDataEnergyMap_t, MPQCDataEnergyVector_noeigenvalues_t >()(
+            Result_Energy_fused, MaxLevel);
+    LOG(0, "Energy table is \n" << energyresult);
+    const std::string eigenvalueresult;
+
+    LOG(0, "Eigenvalue table is \n" << eigenvalueresult);
+    const std::string forceresult =
+        writeTable<MPQCDataForceMap_t, MPQCDataForceVector_t>()(
+            Result_Force_fused, MaxLevel);
+    LOG(0, "Force table is \n" << forceresult);
+    // we don't want to print grid to a table
+    // print times (without flops for now)
+    typedef boost::mpl::remove<MPQCDataTimeVector_t, MPQCDataFused::times_flops>::type MPQCDataTimeVector_noflops_t;
+    const std::string timesresult =
+        writeTable<MPQCDataTimeMap_t, MPQCDataTimeVector_noflops_t >()(
+            Result_Time_fused, MaxLevel);
+    LOG(0, "Times table is \n" << timesresult);
+  }
 
   return true;
@@ -819 +1005 @@
       "FragmentationFragmentationAutomationAction::performCall() - number of MPQCresultd and VMGresults don't match.");
 
+  std::vector<VMGData> longrangeData;
+  ConvertFragmentResultTo<VMGData>(VMGresults, longrangeData);
+
+  // Final phase: print result
+  {
+    LOG(1, "INFO: Parsing fragment files from " << params.path.get() << ".");
+    printReceivedFullResults(
+        MPQCresults,
+        VMGresults,
+        fragmentData,
+        longrangeData,
+        params.path.get(),
+        getNoAtomsFromAdjacencyFile(params.path.get()),
+        full_sample);
+  }
+  }
+#else
   // Final phase: print result
   {
@@ -829 +1032 @@
         full_sample);
   }
-  }
 #endif
   size_t Exitflag = controller.getExitflag();