Context Navigation

-              ra3112d
+              r376a3b
 #include "Fragmentation/Automation/createMatrixNrLookup.hpp"
 #include "Fragmentation/Automation/extractJobIds.hpp"
+#include "Fragmentation/Automation/FragmentationResults.hpp"
 #include "Fragmentation/Automation/MPQCFragmentController.hpp"
 #include "Fragmentation/Automation/VMGDebugGridFragmentController.hpp"
 …
 #include "Fragmentation/KeySetsContainer.hpp"
 #include "Fragmentation/Summation/OrthogonalSumUpPerLevel.hpp"
-#include "Fragmentation/Summation/SumUpPerLevel.hpp"
-#include "Fragmentation/Summation/OrthogonalFullSummator.hpp"
 #include "Fragmentation/Summation/writeTable.hpp"
 #include "Graph/DepthFirstSearchAnalysis.hpp"
 …
 /** Print MPQCData from received results.
+ *
+ * @param fragmentData MPQCData resulting from the jobs
+ * @param longrangeData VMGData resulting from long-range jobs
+ * @param fullsolutionData VMGData resulting from long-range of full problem from level 2 onward
+ * @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::map<JobId_t,MPQCData> &fragmentData,
+    const std::map<JobId_t,VMGData> &longrangeData,
+    const std::vector<VMGData> &fullsolutionData,
+    const std::string &KeySetFilename,
+    size_t NoAtoms,
+    std::vector<SamplingGrid> &full_sample)
+ * @param results summed up results container
+ */
+void printReceivedFullResults(
+    const FragmentationResults &results)
+{
+  // create lookup from job nr to fragment number
+  size_t MPQCFragmentCounter = 0;
+  const std::vector<JobId_t> mpqcjobids = extractJobIds<MPQCData>(fragmentData);
+  const std::map< JobId_t, size_t > MPQCMatrixNrLookup =
+      createMatrixNrLookup(mpqcjobids, MPQCFragmentCounter);
+  size_t VMGFragmentCounter = 0;
+  const std::vector<JobId_t> vmgjobids = extractJobIds<VMGData>(longrangeData);
+  const std::map< JobId_t, size_t > VMGMatrixNrLookup =
+      createMatrixNrLookup(vmgjobids, VMGFragmentCounter);
+  // initialise keysets
+  KeySetsContainer KeySet;
+  KeySetsContainer ForceKeySet;
+  {
+    // else needs keysets without hydrogens
+    std::stringstream filename;
+    filename << FRAGMENTPREFIX << KEYSETFILE;
+    if (!KeySet.ParseKeySets(KeySetFilename, filename.str(), MPQCFragmentCounter)) return false;
+  }
+  {
+    // forces need keysets including hydrogens
+    std::stringstream filename;
+    filename << FRAGMENTPREFIX << FORCESFILE;
+    if (!ForceKeySet.ParseKeySets(KeySetFilename, filename.str(), MPQCFragmentCounter)) 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));
+  /// convert all MPQCData to MPQCDataMap_t
+  {
+    ASSERT( ForceKeySet.KeySets.size() == fragmentData.size(),
+        "printReceivedFullResults() - 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(
+        OrthogonalSumUpPerLevel<MPQCDataEnergyMap_t, MPQCData, MPQCDataEnergyVector_t>(
+            fragmentData, MPQCMatrixNrLookup, container, subsetmap));
+    std::vector<MPQCDataGridMap_t> Result_Grid_fused(
+      OrthogonalSumUpPerLevel<MPQCDataGridMap_t, MPQCData, MPQCDataGridVector_t>(
+          fragmentData, MPQCMatrixNrLookup, container, subsetmap));
+    std::vector<MPQCDataTimeMap_t> Result_Time_fused(
+      SumUpPerLevel<MPQCDataTimeMap_t, MPQCData, MPQCDataTimeVector_t>(
+          fragmentData, MPQCMatrixNrLookup, container, subsetmap));
+    std::vector<MPQCDataFragmentMap_t> Result_Fragment_fused(
+      OrthogonalSumUpPerLevel<MPQCDataFragmentMap_t, MPQCData, MPQCDataFragmentVector_t>(
+          fragmentData, MPQCMatrixNrLookup, container, subsetmap));
+    // force has extra converter
+    std::map<JobId_t, 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,
+                container->getContainer(),
+                MPQCMatrixNrLookup,
+                Result_Force_fused);
+    boost::mpl::for_each<MPQCDataForceVector_t>(boost::ref(forceSummer));
+    // obtain full grid
+    std::map<JobId_t, VMGDataMap_t> VMGData_Potential_fused;
+    convertDataTo<VMGData, VMGDataMap_t>(longrangeData, VMGData_Potential_fused);
+    OrthogonalFullSummator<VMGDataMap_t, VMGDataFused::sampled_potential> potentialSummer(
+                subsetmap,
+                VMGData_Potential_fused,
+                container->getContainer(),
+                VMGMatrixNrLookup);
+    potentialSummer(subsetmap->getMaximumSubsetLevel());
+    OrthogonalFullSummator<VMGDataMap_t, VMGDataFused::energy_potential> epotentialSummer(
+                subsetmap,
+                VMGData_Potential_fused,
+                container->getContainer(),
+                VMGMatrixNrLookup);
+    epotentialSummer(subsetmap->getMaximumSubsetLevel());
+    std::vector<VMGDataLongRangeMap_t> Result_LongRange_fused;
+    Result_LongRange_fused.reserve(subsetmap->getMaximumSubsetLevel());
+    for (size_t level = 1; level <= subsetmap->getMaximumSubsetLevel(); ++level) {
+      // weight times correct charge density of the same level
+      // NOTE: potential for level 1 is not calculated as saturation hydrogen
+      // are not removed on this level yet
+      const size_t potentiallevel = level < 2 ? 0 : (level-2);
+      SamplingGrid charge_weight = boost::fusion::at_key<MPQCDataFused::sampled_grid>(Result_Grid_fused[level-1]);
+      SamplingGrid full_sample_solution = fullsolutionData[potentiallevel].sampled_potential;
+      SamplingGrid short_range_correction = potentialSummer(level);
+  //    LOG(0, "Remaining long-range energy from energy_potential is " << full_sample_solution.integral()-epotentialSummer.getFullContribution() << ".");
+      full_sample_solution -= short_range_correction;
+      // multiply element-wise with charge distribution
+      VMGDataLongRangeMap_t instance;
+      boost::fusion::at_key<VMGDataFused::potential_longrange>(instance) = full_sample_solution.integral();
+      LOG(0, "Remaining long-range potential integral of level " << level << " is "
+          << full_sample_solution.integral() << ".");
+      boost::fusion::at_key<VMGDataFused::potential_shortrange>(instance) = short_range_correction.integral();
+      LOG(0, "Short-range correction potential integral of level " << level << " is "
+          << short_range_correction.integral() << ".");
+      boost::fusion::at_key<VMGDataFused::energy_longrange>(instance) = full_sample_solution.integral(charge_weight);
+      LOG(0, "Remaining long-range energy from potential integral of level " << level << " is "
+          << full_sample_solution.integral(charge_weight) << ".");
+      boost::fusion::at_key<VMGDataFused::energy_shortrange>(instance) = short_range_correction.integral(charge_weight);
+      LOG(0, "Short-range correction energy from potential integral of level " << level << " is "
+          << short_range_correction.integral(charge_weight) << ".");
+      Result_LongRange_fused.push_back(instance);
+    }
+    {
+      //    LOG(0, "Remaining long-range energy from energy_potential is " << full_sample_solution.integral()-epotentialSummer.getFullContribution() << ".");
+      SamplingGrid full_sample_solution = fullsolutionData.back().sampled_potential;
+      SamplingGrid short_range_correction = potentialSummer.getFullContribution();
+      full_sample_solution -= short_range_correction;
+      // multiply element-wise with charge distribution
+      LOG(0, "Remaining long-range potential integral is " << full_sample_solution.integral() << ".");
+      LOG(0, "Short-range correction potential integral of level is " << short_range_correction.integral() << ".");
+      LOG(0, "Remaining long-range energy from potential integral is "
+          << full_sample_solution.integral(full_sample.back()) << ".");
+      LOG(0, "Short-range correction energy from potential integral is "
+          << short_range_correction.integral(full_sample.back()) << ".");
+    }
+    // TODO: Extract long-range corrections to forces
+    // NOTE: potential is in atomic length units, NOT IN ANGSTROEM!
+    OrthogonalFullSummator<VMGDataMap_t, VMGDataFused::energy_long> elongSummer(
+                subsetmap,
+                VMGData_Potential_fused,
+                container->getContainer(),
+                VMGMatrixNrLookup);
+    elongSummer(subsetmap->getMaximumSubsetLevel());
+    double e_long = fullsolutionData.back().e_long;
+    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 gridresult =
+        writeTable<VMGDataLongRangeMap_t, VMGDataLongRangeVector_t >()(
+            Result_LongRange_fused, MaxLevel);
+    LOG(0, "LongRange table is \n" << gridresult);
+    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<
+        boost::mpl::remove<MPQCDataTimeVector_t, MPQCDataFused::times_total_flops>::type,
+        MPQCDataFused::times_gather_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;
+  // print tables (without eigenvalues, they go extra)
+typedef boost::mpl::remove<MPQCDataEnergyVector_t, MPQCDataFused::energy_eigenvalues>::type
+    MPQCDataEnergyVector_noeigenvalues_t;
+  const std::string energyresult =
+      writeTable<MPQCDataEnergyMap_t, MPQCDataEnergyVector_noeigenvalues_t >()(
+          results.Result_Energy_fused, results.getMaxLevel());
+  LOG(0, "Energy table is \n" << energyresult);
+  const std::string gridresult =
+      writeTable<VMGDataLongRangeMap_t, VMGDataLongRangeVector_t >()(
+          results.Result_LongRangeIntegrated_fused, results.getMaxLevel());
+  LOG(0, "LongRange table is \n" << gridresult);
+  const std::string eigenvalueresult;
+  LOG(0, "Eigenvalue table is \n" << eigenvalueresult);
+  const std::string forceresult =
+      writeTable<MPQCDataForceMap_t, MPQCDataForceVector_t>()(
+          results.Result_Force_fused, results.getMaxLevel());
+  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<
+      boost::mpl::remove<MPQCDataTimeVector_t, MPQCDataFused::times_total_flops>::type,
+      MPQCDataFused::times_gather_flops>::type
+      MPQCDataTimeVector_noflops_t;
+  const std::string timesresult =
+      writeTable<MPQCDataTimeMap_t, MPQCDataTimeVector_noflops_t >()(
+          results.Result_Time_fused, results.getMaxLevel());
+  LOG(0, "Times table is \n" << timesresult);
+}
 …
   longrangeData.erase(remove_iter, longrangeData.end());
   // Final phase: print result
+  // Final phase: sum up and print result
+  {
+    LOG(1, "INFO: Parsing fragment files from " << params.path.get() << ".");
+    printReceivedFullResults(
+    FragmentationResults results(
         fragmentData,
         longrangeData,
 …
         full_sample);
+    LOG(1, "INFO: Parsing fragment files from " << params.path.get() << ".");
+    printReceivedFullResults(results);
     if (!full_sample.empty()) {
       // create debug jobs to print the summed-up potential to vtk files
+      // create debug jobs for each level to print the summed-up potential to vtk files
       debugcontroller.requestIds(full_sample.size());
       if (!debugcontroller.createDebugJobs(full_sample))

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset 376a3b for src/Actions/FragmentationAction/FragmentationAutomationAction.cpp

Legend:

src/Actions/FragmentationAction/FragmentationAutomationAction.cpp

Download in other formats: