Changeset 36bb2d for src/Actions

Timestamp:

Nov 20, 2012, 11:04:12 AM (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:

a22e05

Parents:

cebac0 (diff), a1436b (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'VMGJob_SamplingNucleiCharges' into Candidate_v1.3.5

Location:

src/Actions/FragmentationAction

Files:

• FragmentationAutomationAction.cpp (modified) (17 diffs)
• FragmentationAutomationAction.def (modified) (2 diffs)

src/Actions/FragmentationAction/FragmentationAutomationAction.cpp

@@ -39 +39 @@
 #include "CodePatterns/MemDebug.hpp"
 
-#include <boost/assign.hpp>
+#include <boost/mpl/remove.hpp>
 
 #include "CodePatterns/Assert.hpp"
@@ -48 +48 @@
 
 #include "Atom/atom.hpp"
+#include "Box.hpp"
 #include "Fragmentation/EnergyMatrix.hpp"
 #include "Fragmentation/ForceMatrix.hpp"
@@ -56 +57 @@
 #include "Fragmentation/KeySet.hpp"
 #include "Fragmentation/KeySetsContainer.hpp"
-#include "Fragmentation/Summation/printSum.hpp"
+#include "Fragmentation/Summation/AllLevelOrthogonalSummator.hpp"
+#include "Fragmentation/Summation/AllLevelSummator.hpp"
+#include "Fragmentation/Summation/writeTable.hpp"
 #include "Graph/DepthFirstSearchAnalysis.hpp"
+#include "Helpers/defs.hpp"
 #include "Jobs/MPQCJob.hpp"
 #include "Jobs/MPQCData.hpp"
 #include "Jobs/MPQCData_printKeyNames.hpp"
+#include "LinearAlgebra/RealSpaceMatrix.hpp"
+#ifdef HAVE_VMG
+#include "Jobs/VMGJob.hpp"
+#endif
 #include "molecule.hpp"
 #include "World.hpp"
@@ -73 +81 @@
 
 using namespace MoleCuilder;
-
-using namespace boost::assign;
 
 // and construct the stuff
@@ -88 +94 @@
   return NULL;
 }
+
+const int LEVEL = 5;
 
 /** Creates a MPQCCommandJob with argument \a filename.
@@ -107 +115 @@
   std::string output((std::istreambuf_iterator<char>(file)),
       std::istreambuf_iterator<char>());
-  FragmentJob::ptr testJob( new MPQCJob(nextid, output) );
+  double begin[NDIM] = { 0., 0., 0. };
+  const RealSpaceMatrix& M = World::getInstance().getDomain().getM();
+  const double size = M.at(0,0);
+  ASSERT( M.determinant() == size*size*size,
+      "parsejob() - current domain matrix "+toString(M)+" is not cubic.");
+  const int level = LEVEL;
+  FragmentJob::ptr testJob( new MPQCJob(nextid, output, begin, size, level) );
   jobs.push_back(testJob);
   file.close();
@@ -142 +156 @@
 }
 
+/** Extracts MPQCData from received vector of FragmentResults.
+ *
+ * @param results results to extract MPQCData from
+ * @param fragmentData on return array filled with extracted MPQCData
+ */
+void ConvertFragmentResultToMPQCData(
+    const std::vector<FragmentResult::ptr> &results,
+    std::vector<MPQCData> &fragmentData)
+{
+  // extract results
+  fragmentData.clear();
+  fragmentData.reserve(results.size());
+
+  LOG(2, "DEBUG: Parsing now through " << results.size() << " results.");
+  for (std::vector<FragmentResult::ptr>::const_iterator iter = results.begin();
+      iter != results.end(); ++iter) {
+    //LOG(1, "RESULT: job #"+toString((*iter)->getId())+": "+toString((*iter)->result));
+    MPQCData extractedData;
+    std::stringstream inputstream((*iter)->result);
+    LOG(2, "DEBUG: First 50 characters FragmentResult's string: "+(*iter)->result.substr(0, 50));
+    boost::archive::text_iarchive ia(inputstream);
+    ia >> extractedData;
+    LOG(1, "INFO: extracted data is " << extractedData << ".");
+    fragmentData.push_back(extractedData);
+  }
+
+  ASSERT( results.size() == fragmentData.size(),
+      "ConvertFragmentResultToMPQCData() - the number of extracted data differs from the number of results.");
+}
+
 
 /** Print MPQCData from received results.
  *
- * @param results received results to extract MPQCData from
+ * @param results results with ids to associate with fragment number
+ * @param fragmentData MPQCData resulting from the jobs
  * @param KeySetFilename filename with keysets to associate forces correctly
  * @param NoAtoms total number of atoms
@@ -151 +196 @@
 bool printReceivedMPQCResults(
     const std::vector<FragmentResult::ptr> &results,
+    const std::vector<MPQCData> &fragmentData,
     const std::string &KeySetFilename,
     size_t NoAtoms)
@@ -173 +219 @@
       IdResultMap.insert( make_pair((*iter)->getId(), *iter) );
       ASSERT( inserter.second,
-          "printReceivedMPQCResults() - two results have same id "
+          "ExtractMPQCDataFromResults() - two results have same id "
           +toString((*iter)->getId())+".");
     }
@@ -183 +229 @@
   LOG(1, "INFO: There are " << FragmentCounter << " fragments.");
 
-  // extract results
-  std::vector<MPQCData> fragmentData(results.size());
-  MPQCData combinedData;
-
-  LOG(2, "DEBUG: Parsing now through " << results.size() << " results.");
-  for (std::vector<FragmentResult::ptr>::const_iterator iter = results.begin();
-      iter != results.end(); ++iter) {
-    LOG(1, "RESULT: job #"+toString((*iter)->getId())+": "+toString((*iter)->result));
-    MPQCData extractedData;
-    std::stringstream inputstream((*iter)->result);
-    LOG(2, "DEBUG: First 50 characters FragmentResult's string: "+(*iter)->result.substr(0, 50));
-    boost::archive::text_iarchive ia(inputstream);
-    ia >> extractedData;
-    LOG(1, "INFO: extracted data is " << extractedData << ".");
-
+  std::vector<MPQCData>::const_iterator dataiter = fragmentData.begin();
+  std::vector<FragmentResult::ptr>::const_iterator resultiter = results.begin();
+  for (; dataiter != fragmentData.end(); ++dataiter, ++resultiter) {
+    const MPQCData &extractedData = *dataiter;
     // place results into EnergyMatrix ...
     {
@@ -204 +239 @@
       matrix[0].resize(1, extractedData.energies.total);
       if (!Energy.AddMatrix(
-          std::string("MPQCJob ")+toString((*iter)->getId()),
+          std::string("MPQCJob ")+toString((*resultiter)->getId()),
           matrix,
-          MatrixNrLookup[(*iter)->getId()])) {
+          MatrixNrLookup[(*resultiter)->getId()])) {
         ELOG(1, "Adding energy matrix failed.");
         return false;
@@ -225 +260 @@
       }
       if (!Force.AddMatrix(
-          std::string("MPQCJob ")+toString((*iter)->getId()),
+          std::string("MPQCJob ")+toString((*resultiter)->getId()),
           matrix,
-          MatrixNrLookup[(*iter)->getId()])) {
+          MatrixNrLookup[(*resultiter)->getId()])) {
         ELOG(1, "Adding force matrix failed.");
         return false;
@@ -248 +283 @@
   // initialise indices
   KeySetsContainer KeySet;
+  KeySetsContainer ForceKeySet;
   if (!Energy.InitialiseIndices()) return false;
 
   if (!Force.ParseIndices(KeySetFilename.c_str())) return false;
 
-  if (!KeySet.ParseKeySets(KeySetFilename.c_str(), Force.RowCounter, Force.MatrixCounter)) return false;
+  {
+    std::stringstream filename;
+    filename << FRAGMENTPREFIX << KEYSETFILE;
+    if (!KeySet.ParseKeySets(KeySetFilename, filename.str(), FragmentCounter)) return false;
+  }
+
+  {
+    std::stringstream filename;
+    filename << FRAGMENTPREFIX << FORCESFILE;
+    if (!ForceKeySet.ParseKeySets(KeySetFilename, filename.str(), FragmentCounter)) return false;
+  }
 
   /// prepare for OrthogonalSummation
 
-  // gather all present indices in AllIndices
-  IndexSet::ptr AllIndices(new IndexSet);
-  for (KeySetsContainer::ArrayOfIntVectors::const_iterator iter = KeySet.KeySets.begin();
-      iter != KeySet.KeySets.end(); ++iter)
-    for(KeySetsContainer::IntVector::const_iterator keyiter = (*iter).begin();
-        keyiter != (*iter).end(); ++keyiter) {
-      if (*keyiter != -1)
-        (*AllIndices) += *keyiter;
-    }
-  LOG(1, "INFO: AllIndices is " << AllIndices << ".");
-  // create container with all keysets
-  IndexSetContainer::ptr container(new IndexSetContainer(AllIndices));
-  for (KeySetsContainer::ArrayOfIntVectors::const_iterator iter = KeySet.KeySets.begin();
-      iter != KeySet.KeySets.end(); ++iter) {
-    IndexSet tempset;
-    for(KeySetsContainer::IntVector::const_iterator keyiter = (*iter).begin();
-        keyiter != (*iter).end(); ++keyiter)
-      if (*keyiter != -1)
-        tempset += *keyiter;
-    container->insert(tempset);
-  }
+  // convert KeySetContainer to IndexSetContainer
+  IndexSetContainer::ptr container(new IndexSetContainer(KeySet));
   // create the map of all keysets
   SubsetMap::ptr subsetmap(new SubsetMap(*container));
+
+// we probably don't need this, it suffices if IndexedVectors has some extra indices
+//  // forces need different keysets: they must include hydrogen
+//  // (though without ones added by saturation)
+//  IndexSetContainer::ptr forceindices(new IndexSetContainer(ForceKeySet));
+//  // create the map of all keysets
+//  SubsetMap::ptr subsetmapforces(new SubsetMap(*forceindices));
 
   /// convert all MPQCData to MPQCDataMap_t
@@ -303 +337 @@
 
     // forces
-    const IndexSetContainer::Container_t &indices = container->getContainer();
-    ASSERT( indices.size() == fragmentData.size(),
-        "FragmentationAutomationAction::performCall() - indices and fragmentData differ in size.");
+    ASSERT( ForceKeySet.KeySets.size() == fragmentData.size(),
+        "FragmentationAutomationAction::performCall() - ForceKeySet's KeySets and fragmentData differ in size.");
     std::vector<MPQCDataForceMap_t> MPQCData_Force_fused;
     MPQCData_Force_fused.reserve(fragmentData.size());
     std::vector<MPQCData>::const_iterator dataiter = fragmentData.begin();
-    IndexSetContainer::Container_t::const_iterator indexiter = indices.begin();
-    for(;dataiter != fragmentData.end(); ++dataiter, ++indexiter) {
+    KeySetsContainer::ArrayOfIntVectors::const_iterator arrayiter = ForceKeySet.KeySets.begin();
+    for(;dataiter != fragmentData.end(); ++dataiter, ++arrayiter) {
       const MPQCData &extractedData = *dataiter;
       LOG(2, "DEBUG: Current extracted Data is " << extractedData << ".");
       MPQCDataForceMap_t instance;
+      // must convert int to index_t
+      IndexedVectors::indices_t indices(arrayiter->begin(), arrayiter->end());
       boost::fusion::at_key<MPQCDataFused::forces>(instance) =
-          IndexedVectors(**indexiter, extractedData.forces);
+          IndexedVectors(indices, extractedData.forces);
       MPQCData_Force_fused.push_back(instance);
+    }
+
+    // sampled_grid
+    std::vector<MPQCDataGridMap_t> MPQCData_Grid_fused;
+    MPQCData_Grid_fused.reserve(fragmentData.size());
+    for(std::vector<MPQCData>::const_iterator dataiter = fragmentData.begin();
+        dataiter != fragmentData.end(); ++dataiter) {
+      const MPQCData &extractedData = *dataiter;
+      LOG(2, "DEBUG: Current extracted Data is " << extractedData << ".");
+      MPQCDataGridMap_t instance;
+      boost::fusion::at_key<MPQCDataFused::sampled_grid>(instance) = extractedData.sampled_grid;
+      MPQCData_Grid_fused.push_back(instance);
     }
 
@@ -339 +386 @@
             boost::bind(&FragmentResult::ptr::operator->, _1)));
 
-    // sum up and print energies
-    boost::mpl::for_each<MPQCDataEnergyVector_t>(
-        printSum<MPQCDataEnergyMap_t>(
-            subsetmap,
-            MPQCData_Energy_fused,
-            jobids,
-            container->getContainer(),
-            MatrixNrLookup)
-        );
-
-    // sum up and print forces
-    boost::mpl::for_each<MPQCDataForceVector_t>(
-        printSum<MPQCDataForceMap_t>(
-            subsetmap,
-            MPQCData_Force_fused,
-            jobids,
-            container->getContainer(),
-            MatrixNrLookup)
-        );
-
-    // TODO: Times should just be summed not orthogonalized
-//    // sum up and print times
-//    boost::mpl::for_each<MPQCDataTimeVector_t>(
-//        printSum<MPQCDataTimeMap_t>(
-//            subsetmap,
-//            MPQCData_Time_fused,
-//            jobids,
-//            container->getContainer(),
-//            MatrixNrLookup)
-//        );
+    // create summation instances
+    std::vector<MPQCDataEnergyMap_t> Result_Energy_fused(subsetmap->getMaximumSubsetLevel());
+    AllLevelOrthogonalSummator<MPQCDataEnergyMap_t> energySummer(
+                subsetmap,
+                MPQCData_Energy_fused,
+                jobids,
+                container->getContainer(),
+                MatrixNrLookup,
+                Result_Energy_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);
+    std::vector<MPQCDataGridMap_t> Result_Grid_fused(subsetmap->getMaximumSubsetLevel());
+    AllLevelOrthogonalSummator<MPQCDataGridMap_t> gridSummer(
+                subsetmap,
+                MPQCData_Grid_fused,
+                jobids,
+                container->getContainer(),
+                MatrixNrLookup,
+                Result_Grid_fused);
+    std::vector<MPQCDataTimeMap_t> Result_Time_fused(subsetmap->getMaximumSubsetLevel());
+    AllLevelSummator<MPQCDataTimeMap_t> timeSummer(
+                subsetmap,
+                MPQCData_Time_fused,
+                jobids,
+                container->getContainer(),
+                MatrixNrLookup,
+                Result_Time_fused);
+
+    // sum up
+    boost::mpl::for_each<MPQCDataEnergyVector_t>(boost::ref(energySummer));
+    boost::mpl::for_each<MPQCDataForceVector_t>(boost::ref(forceSummer));
+    boost::mpl::for_each<MPQCDataGridVector_t>(boost::ref(gridSummer));
+    boost::mpl::for_each<MPQCDataTimeVector_t>(boost::ref(timeSummer));
+
+    // 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 >()(
+            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);
   }
 
@@ -448 +526 @@
 }
 
+#ifdef HAVE_VMG
+bool createLongRangeJobs(
+    FragmentController &controller,
+    const FragmentationFragmentationAutomationAction::FragmentationFragmentationAutomationParameters &params,
+    const std::vector<MPQCData> &fragmentData)
+{
+  std::vector<FragmentJob::ptr> jobs;
+  // add one job for each fragment as the short-range correction which we need
+  // to subtract from the obtained full potential to get the long-range part only
+  for (std::vector<MPQCData>::const_iterator iter = fragmentData.begin();
+      iter != fragmentData.end(); ++iter) {
+    const JobId_t next_id = controller.getAvailableId();
+    LOG(1, "INFO: Creating VMGJob with " << iter->sampled_grid.sampled_grid.size()
+        << " gridpoints and " << iter->charges.size() << " particle charges.");
+    FragmentJob::ptr testJob(
+        new VMGJob(next_id, iter->sampled_grid, iter->positions, iter->charges) );
+    jobs.push_back(testJob);
+  }
+
+  // add one more job for the full calculation
+  // TODO: Here, we actually have to combine all the other sampled_grids
+  {
+    const int level = LEVEL;
+    const int GRID = pow(2, level);
+    std::vector<double> full_sample(GRID*GRID*GRID, 0.);
+    double begin[NDIM] = { 0., 0., 0. };
+    const RealSpaceMatrix& M = World::getInstance().getDomain().getM();
+    const double size = M.at(0,0);
+    ASSERT( M.determinant() == size*size*size,
+        "createLongRangeJobs() - current domain matrix "+toString(M)+" is not cubic.");
+    const SamplingGrid full_sampled_grid(begin, size, level, full_sample);
+    const std::vector< std::vector<double> > positions;
+    const std::vector<double> charges;
+    const JobId_t next_id = controller.getAvailableId();
+    LOG(1, "INFO: Creating full VMGJob with " << full_sample.size()
+        << " gridpoints and " << charges.size() << " particle charges.");
+    FragmentJob::ptr testJob(
+        new VMGJob(next_id, full_sampled_grid, positions, charges) );
+    jobs.push_back(testJob);
+  }
+
+  // then send jobs to controller
+  controller.addJobs(jobs);
+  controller.sendJobs(params.host.get(), params.port.get());
+  return true;
+}
+#endif
+
 void WaitforResults(
     boost::asio::io_service &io_service,
@@ -483 +609 @@
   RunService(io_service, "Requesting ids");
 
-  // Phase Two: create and add jobs
+  // Phase Two: create and add MPQCJobs
   if (!createJobsFromFiles(controller, params, jobfiles))
     return Action::failure;
-  RunService(io_service, "Adding jobs");
+  RunService(io_service, "Adding MPQCJobs");
 
   // Phase Three: calculate result
   WaitforResults(io_service, controller, params, jobfiles.size());
-
-  // Phase Three: get result
   controller.receiveResults(params.host.get(), params.port.get());
-  RunService(io_service, "Phase Four");
+  RunService(io_service, "Requesting short-range results");
+  std::vector<FragmentResult::ptr> MPQCresults = controller.getReceivedResults();
+  std::vector<MPQCData> fragmentData;
+  ConvertFragmentResultToMPQCData(MPQCresults, fragmentData);
+
+  // print intermediate short-range results
+  {
+    LOG(1, "INFO: Parsing fragment files from " << params.path.get() << ".");
+    printReceivedMPQCResults(
+        MPQCresults,
+        fragmentData,
+        params.path.get(),
+        getNoAtomsFromAdjacencyFile(params.path.get()));
+  }
+
+#ifdef HAVE_VMG
+  if (params.DoLongrange.get()) {
+  // Phase Four: obtain more ids
+  requestIds(controller, params, fragmentData.size()+1);
+  RunService(io_service, "Requesting ids");
+
+  // Phase Five: create VMGJobs
+  if (!createLongRangeJobs(controller, params, fragmentData))
+    return Action::failure;
+  RunService(io_service, "Adding VMGJobs");
+
+  // Phase Six: calculate result
+  WaitforResults(io_service, controller, params, fragmentData.size()+1);
+  controller.receiveResults(params.host.get(), params.port.get());
+  RunService(io_service, "Requesting long-range results");
+  std::vector<FragmentResult::ptr> VMGresults = controller.getReceivedResults();
+  ASSERT( MPQCresults.size()+1 == VMGresults.size(),
+      "FragmentationFragmentationAutomationAction::performCall() - number of MPQCresultd and VMGresults don't match.");
 
   // Final phase: print result
   {
     LOG(1, "INFO: Parsing fragment files from " << params.path.get() << ".");
-    std::vector<FragmentResult::ptr> results = controller.getReceivedResults();
     printReceivedMPQCResults(
-        results,
+        MPQCresults,
+        fragmentData,
         params.path.get(),
         getNoAtomsFromAdjacencyFile(params.path.get()));
   }
+  }
+#endif
   size_t Exitflag = controller.getExitflag();
 

src/Actions/FragmentationAction/FragmentationAutomationAction.def

@@ -20 +20 @@
 // ValueStorage by the token "Z" -> first column: int, Z, "Z"
 // "undefine" if no parameters are required, use (NOPARAM_DEFAULT) for each (undefined) default value
-#define paramtypes (std::vector< boost::filesystem::path >)(std::string)(std::string)(std::string)(boost::filesystem::path)
-#define paramtokens ("fragment-jobs")("fragment-path")("server-address")("server-port")("fragment-executable")
-#define paramdescriptions ("vector of fragment files")("prefix of each fragment file")("hostname of server")("controller port of server")("executable to launch on clients")
-#define paramdefaults (NOPARAM_DEFAULT)(NOPARAM_DEFAULT)(PARAM_DEFAULT("127.0.0.1"))(PARAM_DEFAULT("1026"))(NOPARAM_DEFAULT)
-#define paramreferences (jobfiles)(path)(host)(port)(executable)
+#define paramtypes (std::vector< boost::filesystem::path >)(std::string)(std::string)(std::string)(boost::filesystem::path)(bool)
+#define paramtokens ("fragment-jobs")("fragment-path")("server-address")("server-port")("fragment-executable")("DoLongrange")
+#define paramdescriptions ("vector of fragment files")("prefix of each fragment file")("hostname of server")("controller port of server")("executable to launch on clients")("whether to calculate long-range contributions")
+#define paramdefaults (NOPARAM_DEFAULT)(NOPARAM_DEFAULT)(PARAM_DEFAULT("127.0.0.1"))(PARAM_DEFAULT("1026"))(NOPARAM_DEFAULT)(PARAM_DEFAULT("0"))
+#define paramreferences (jobfiles)(path)(host)(port)(executable)(DoLongrange)
 #define paramvalids \
 (STLVectorValidator< std::vector< boost::filesystem::path > >(ParserFileValidator() && FilePresentValidator())) \
@@ -30 +30 @@
 (DummyValidator< std::string >()) \
 (DummyValidator< std::string >()) \
-(DummyValidator< boost::filesystem::path >())
+(DummyValidator< boost::filesystem::path >()) \
+(DummyValidator< bool >())
 
 #undef statetypes