Context Navigation

-              r4f44ae
+              rbae7bc
   LOG(0, "STATUS: Fragmenting molecular system with current connection matrix maximum bond distance "
       << params.distance.get() << " up to "
+      << params.order.get() << " order. Fragment files begin with "
+      << params.prefix.get() << " and are stored as: "
+      << params.types.get() << "." << std::endl);
+      << params.order.get() << " order. ");
+  if (params.types.get().size() != 0)
+    LOG(0, "STATUS: Fragment files begin with "
+        << params.prefix.get() << " and are stored as: "
+        << params.types.get() << "." << std::endl);
   // check for selected atoms

src/Actions/FragmentationAction/FragmentationAutomationAction.cpp

-              r4f44ae
+              rbae7bc
 #include "Fragmentation/Automation/FragmentationResults.hpp"
 #include "Fragmentation/Automation/MPQCFragmentController.hpp"
-#include "Fragmentation/Automation/parseKeySetFile.hpp"
 #include "Fragmentation/Automation/VMGDebugGridFragmentController.hpp"
 #include "Fragmentation/Automation/VMGFragmentController.hpp"
 …
+ *
  * @param fragmentData MPQCData resulting from the jobs, associated to job id
+ * @param KeySetFilename filename with keysets to associate forces correctly
+ * @param MatrixNrLookup map with enumerated jobids
+ * @param KeySet KeySets of all (non-hydrogen) atoms
+ * @param ForceKeySet KeySets of all atoms except those added by saturation
  * @param NoAtoms total number of atoms
- * @param full_sample summed up charge from fragments on return
  */
 bool printReceivedMPQCResults(
     const std::map<JobId_t, MPQCData> &fragmentData,
+    const std::string &KeySetFilename,
+    const std::map< JobId_t, size_t > MatrixNrLookup,
+    KeySetsContainer KeySet,
+    const KeySetsContainer &ForceKeySet,
     size_t NoAtoms)
+{
+  // create a vector of all job ids
+  std::vector<JobId_t> jobids;
+  std::transform(fragmentData.begin(),fragmentData.end(),
+      std::back_inserter(jobids),
+      boost::bind( &std::map<JobId_t,MPQCData>::value_type::first, boost::lambda::_1 )
+  );
+  // create lookup from job nr to fragment number
+  size_t FragmentCounter = 0;
+  const std::map< JobId_t, size_t > MatrixNrLookup=
+      createMatrixNrLookup(jobids, FragmentCounter);
+  size_t FragmentCounter = MatrixNrLookup.size();
   // place results into maps
 …
   if (!Energy.InitialiseIndices()) return false;
+  if (!Force.ParseIndices(KeySetFilename.c_str())) return false;
+  // initialise keysets
+  KeySetsContainer KeySet;
+  parseKeySetFile(KeySet, KeySetFilename, FragmentCounter, NonHydrogenKeySets);
+  KeySetsContainer ForceKeySet;
+  parseKeySetFile(ForceKeySet, KeySetFilename, FragmentCounter, HydrogenKeySets);
+  if (!Force.ParseIndices(ForceKeySet)) return false;
   // combine all found data
 …
   return true;
+}
+/** Print MPQCData from received results.
+ *
+ * @param fragmentData MPQCData resulting from the jobs, associated to job id
+ * @param KeySetFilename filename with keysets to associate forces correctly
+ * @param NoAtoms total number of atoms
+ */
+bool printReceivedMPQCResults(
+    const std::map<JobId_t, MPQCData> &fragmentData,
+    const std::string &KeySetFilename,
+    size_t NoAtoms)
+{
+  // create a vector of all job ids
+  std::vector<JobId_t> jobids;
+  std::transform(fragmentData.begin(),fragmentData.end(),
+      std::back_inserter(jobids),
+      boost::bind( &std::map<JobId_t,MPQCData>::value_type::first, boost::lambda::_1 )
+  );
+  // create lookup from job nr to fragment number
+  size_t FragmentCounter = 0;
+  const std::map< JobId_t, size_t > MatrixNrLookup =
+      createMatrixNrLookup(jobids, FragmentCounter);
+  // initialise keysets
+  KeySetsContainer KeySet;
+  parseKeySetFile(KeySet, KeySetFilename, FragmentCounter, NonHydrogenKeySets);
+  KeySetsContainer ForceKeySet;
+  parseKeySetFile(ForceKeySet, KeySetFilename, FragmentCounter, HydrogenKeySets);
+  return printReceivedMPQCResults(
+      fragmentData,
+      MatrixNrLookup,
+      KeySet,
+      ForceKeySet,
+      NoAtoms);
+}
+/** Print MPQCData from received results.
+ *
+ * @param fragmentData MPQCData resulting from the jobs, associated to job id
+ * @param KeySet KeySets of all (non-hydrogen) atoms
+ * @param ForceKeySet KeySets of all atoms except those added by saturation
+ * @param NoAtoms total number of atoms
+ */
+bool printReceivedMPQCResults(
+    const std::map<JobId_t, MPQCData> &fragmentData,
+    const KeySetsContainer &KeySet,
+    const KeySetsContainer &ForceKeySet,
+    size_t NoAtoms)
+{
+  // create a vector of all job ids
+  std::vector<JobId_t> jobids;
+  std::transform(fragmentData.begin(),fragmentData.end(),
+      std::back_inserter(jobids),
+      boost::bind( &std::map<JobId_t,MPQCData>::value_type::first, boost::lambda::_1 )
+  );
+  // create lookup from job nr to fragment number
+  size_t FragmentCounter = 0;
+  const std::map< JobId_t, size_t > MatrixNrLookup =
+      createMatrixNrLookup(jobids, FragmentCounter);
+  return printReceivedMPQCResults(
+      fragmentData,
+      MatrixNrLookup,
+      KeySet,
+      ForceKeySet,
+      NoAtoms);
+}
 …
 bool appendToHomologyFile(
     const boost::filesystem::path &homology_file,
+    const FragmentationResults &results,
+    const std::string &KeySetFilename)
+    const FragmentationResults &results)
+{
   /// read homology container (if present)
 …
   // TODO: Have io_service run in second thread and merge with current again eventually
-  // check some things prior to work
-  enum OutputType_t {
-    ToFiles,
-    ToJobs,
-    ToNone
-  };
-  enum OutputType_t outputtype = ToNone;
-  if (params.jobfiles.get().size() != 0) {
-    // we got no job files, hence we use FragmentJobQueue
-    if (params.path.get().size() == 0) {
-      ELOG(1, "Missing path to fragment files.");
-      return Action::failure;
+    }
-    outputtype = ToFiles;
-    // parse in fragment-jobs if given
-    if(!FragmentJobQueue::getInstance().addJobsFromFiles(
-        params.jobfiles.get(),
-        params.level.get()))
-      return Action::failure;
-  } else {
-    if (params.path.get().size() != 0) {
-      ELOG(2, "Path to fragment given although we use FragmentJobQueue.");
+    }
-    outputtype = ToJobs;
+  }
   size_t Exitflag = 0;
   std::map<JobId_t, MPQCData> fragmentData;
 …
   FragmentationChargeDensity summedChargeDensity(
       fragmentData,
       params.path.get());
+      FragmentJobQueue::getInstance().getKeySets());
   const std::vector<SamplingGrid> full_sample = summedChargeDensity.getFullSampledGrid();
   LOG(1, "INFO: There are " << fragmentData.size() << " short-range and "
       << full_sample.size() << " level-wise long-range jobs.");
 …
       fragmentData,
       longrangeData,
+      params.path.get());
+      FragmentJobQueue::getInstance().getKeySets(),
+      FragmentJobQueue::getInstance().getFullKeySets());
   results(
       fragmentData,
 …
       fullsolutionData,
       full_sample);
+  {
+    LOG(1, "INFO: Parsing fragment files from " << params.path.get() << ".");
+    printReceivedFullResults(results);
+  }
+  printReceivedFullResults(results);
   // append all keysets to homology file
 …
     if (homology_file.string() != "") {
       LOG(1, "INFO: Appending HomologyGraphs to file " << homology_file.string() << ".");
       if (!appendToHomologyFile(homology_file, results, params.path.get()))
+      if (!appendToHomologyFile(homology_file, results))
         Exitflag = 1;
+    }
 …
     printReceivedMPQCResults(
         fragmentData,
+        params.path.get(),
+        getNoAtomsFromAdjacencyFile(params.path.get()));
+        FragmentJobQueue::getInstance().getKeySets(),
+        FragmentJobQueue::getInstance().getFullKeySets(),
+        World::getInstance().getAllAtoms().size()));
+  }
 #endif
+  // now clear all present jobs as we are done
+  FragmentJobQueue::getInstance().clear();
   return (Exitflag == 0) ? Action::success : Action::failure;

src/Actions/FragmentationAction/FragmentationAutomationAction.def

-              r4f44ae
+              rbae7bc
 #include "Parameters/Validators/Ops_Validator.hpp"
 #include "Parameters/Validators/RangeValidator.hpp"
-#include "Parameters/Validators/STLVectorValidator.hpp"
-#include "Parameters/Validators/Specific/ParserFileValidator.hpp"
-#include "Parameters/Validators/Specific/FilePresentValidator.hpp"
 // i.e. there is an integer with variable name Z that can be found in
 // 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)(unsigned int)(unsigned int)(unsigned int)(bool)(boost::filesystem::path)
 #define paramtokens ("fragment-jobs")("fragment-path")("server-address")("server-port")("fragment-executable")("grid-level")("near-field-cells")("interpolation-degree")("DoLongrange")("homology-file")
 #define paramdescriptions ("vector of fragment files")("prefix of each fragment file")("hostname of server")("controller port of server")("executable to launch on clients")("resolution of multigrid")("number of cells used in smearing out core charge")("interpolation degree for getting the nuclei potential from the grid")("whether to calculate long-range contributions")("path to file containing homology containerto append to")
 #define paramdefaults (NOPARAM_DEFAULT)(NOPARAM_DEFAULT)(PARAM_DEFAULT("127.0.0.1"))(NOPARAM_DEFAULT)(PARAM_DEFAULT("mpqc"))(PARAM_DEFAULT(5))(PARAM_DEFAULT(3))(PARAM_DEFAULT(3))(PARAM_DEFAULT("0"))(PARAM_DEFAULT(""))
 #define paramreferences (jobfiles)(path)(host)(port)(executable)(level)(near_field_cells)(interpolation_degree)(DoLongrange)(homology_file)
+#define paramtypes (std::string)(std::string)(boost::filesystem::path)(unsigned int)(unsigned int)(unsigned int)(bool)(boost::filesystem::path)
+#define paramtokens ("server-address")("server-port")("fragment-executable")("grid-level")("near-field-cells")("interpolation-degree")("DoLongrange")("homology-file")
+#define paramdescriptions ("hostname of server")("controller port of server")("executable to launch on clients")("resolution of multigrid")("number of cells used in smearing out core charge")("interpolation degree for getting the nuclei potential from the grid")("whether to calculate long-range contributions")("path to file containing homology containerto append to")
+#define paramdefaults (PARAM_DEFAULT("127.0.0.1"))(NOPARAM_DEFAULT)(PARAM_DEFAULT("mpqc"))(PARAM_DEFAULT(5))(PARAM_DEFAULT(3))(PARAM_DEFAULT(3))(PARAM_DEFAULT("0"))(PARAM_DEFAULT(""))
+#define paramreferences (host)(port)(executable)(level)(near_field_cells)(interpolation_degree)(DoLongrange)(homology_file)
 #define paramvalids \
-(STLVectorValidator< std::vector< boost::filesystem::path > >(ParserFileValidator() && FilePresentValidator())) \
-(DummyValidator< std::string >()) \
 (DummyValidator< std::string >()) \
 (DummyValidator< std::string >()) \

src/Actions/GlobalListOfActions.hpp

-              r4f44ae
+              rbae7bc
 #define GLOBALLISTOFACTIONS \
     BOOST_PP_SEQ_PUSH_BACK( \
+        GLOBALLISTOFACTIONS_initial, \
+        FragmentationFragmentationAutomation \
+      )
+        BOOST_PP_SEQ_PUSH_BACK( \
+            GLOBALLISTOFACTIONS_initial, \
+            FragmentationFragmentationAutomation \
+        ), \
+        FragmentationParseFragmentJobs \
+    )
 #else
 #define GLOBALLISTOFACTIONS \

src/Actions/Makefile.am

-              r4f44ae
+              rbae7bc
 if CONDJOBMARKET
 FRAGMENTATIONACTIONSOURCE += \
+  Actions/FragmentationAction/FragmentationAutomationAction.cpp
+  Actions/FragmentationAction/FragmentationAutomationAction.cpp \
+  Actions/FragmentationAction/ParseFragmentJobsAction.cpp
 FRAGMENTATIONACTIONHEADER += \
+  Actions/FragmentationAction/FragmentationAutomationAction.hpp
+  Actions/FragmentationAction/FragmentationAutomationAction.hpp \
+  Actions/FragmentationAction/ParseFragmentJobsAction.hpp
 FRAGMENTATIONACTIONDEFS += \
+  Actions/FragmentationAction/FragmentationAutomationAction.def
+  Actions/FragmentationAction/FragmentationAutomationAction.def \
+  Actions/FragmentationAction/ParseFragmentJobsAction.def
 endif

src/Fragmentation/Automation/FragmentJobQueue.cpp

-              r4f44ae
+              rbae7bc
 #include "Box.hpp"
+#include "Fragmentation/Automation/parseKeySetFile.hpp"
 #include "Helpers/defs.hpp"
 #include "Jobs/MPQCJob.hpp"
 …
+}
+bool FragmentJobQueue::addKeySetsFromFiles(
+    const boost::filesystem::path &path,
+    const size_t FragmentCounter,
+    const enum KeySetFileType keysettype
+    )
+{
+  const size_t NoJobs = KeySets.KeySets.size();
+  parseKeySetFile(KeySets, path.string(), FragmentCounter, NonHydrogenKeySets);
+  ASSERT( (KeySets.KeySets.size()-NoJobs) == FragmentCounter,
+      "FragmentJobQueue::addKeySetsFromFiles() - mismatching number of new fragments "
+      +toString(KeySets.KeySets.size()-NoJobs)+" and number of Keyset "
+      +toString(FragmentCounter)+".");
+  return (KeySets.KeySets.size() > NoJobs);
+}
+bool FragmentJobQueue::addFullKeySetsFromFiles(
+    const boost::filesystem::path &path,
+    const size_t FragmentCounter,
+    const enum KeySetFileType keysettype
+    )
+{
+  const size_t NoJobs = FullKeySets.KeySets.size();
+  parseKeySetFile(FullKeySets, path.string(), FragmentCounter, NonHydrogenKeySets);
+  ASSERT( (FullKeySets.KeySets.size()-NoJobs) == FragmentCounter,
+      "FragmentJobQueue::addKeySetsFromFiles() - mismatching number of fragments "
+      +toString(FullKeySets.KeySets.size()-NoJobs)+" and number of FullKeyset "
+      +toString(FragmentCounter)+".");
+  return (FullKeySets.KeySets.size() > NoJobs);
+}
 void FragmentJobQueue::clear()
+{

src/Fragmentation/Automation/FragmentJobQueue.hpp

-              r4f44ae
+              rbae7bc
 #include "Fragmentation/KeySetsContainer.hpp"
+#include "Fragmentation/Automation/parseKeySetFile.hpp"
 #include "Jobs/MPQCJob.hpp"
 …
       const unsigned int level);
+  /** Adds keysets after fragments have been added by file.
+   *
+   */
+  bool addKeySetsFromFiles(
+      const boost::filesystem::path &path,
+      const size_t FragmentCounter,
+      const enum KeySetFileType keysettype
+      );
+  /** Adds keysets after fragments have been added by file.
+   *
+   */
+  bool addFullKeySetsFromFiles(
+      const boost::filesystem::path &path,
+      const size_t FragmentCounter,
+      const enum KeySetFileType keysettype
+      );
   /** Getter for the container of all KeySets to the jobs.
+   *

src/Fragmentation/Automation/FragmentationChargeDensity.cpp

-              r4f44ae
+              rbae7bc
 FragmentationChargeDensity::FragmentationChargeDensity(
     const std::map<JobId_t,MPQCData> &fragmentData,
     const std::string &KeySetFilename)
+    const KeySetsContainer &KeySet)
+{
   // create a vector of all job ids
 …
   const std::map< JobId_t, size_t > MatrixNrLookup =
       createMatrixNrLookup(jobids, FragmentCounter);
-  // initialise keysets
-  KeySetsContainer KeySet;
-  parseKeySetFile(KeySet, KeySetFilename, FragmentCounter, NonHydrogenKeySets);
   /// prepare for OrthogonalSummation
 …
+}
 std::vector<SamplingGrid> FragmentationChargeDensity::getFullSampledGrid()
+{

src/Fragmentation/Automation/FragmentationChargeDensity.hpp

-              r4f44ae
+              rbae7bc
 #include <map>
-#include <string>
 #include <vector>
 …
 #include "Jobs/Grid/SamplingGrid.hpp"
+class KeySetsContainer;
 /** This structure is a container for the summed up charge density per level.
+ *
 …
+   *
    * @param fragmentData MPQCData resulting from the jobs, each associated to a job
    * @param KeySetFilename filename with keysets to associate forces correctly
+   * @param KeySet KeySets of all (non-hydrogen) atoms
    */
   FragmentationChargeDensity(
       const std::map<JobId_t,MPQCData> &fragmentData,
       const std::string &KeySetFilename);
+      const KeySetsContainer& KeySet);
   std::vector<SamplingGrid> getFullSampledGrid();
 …
   //!> results per IndexSet of summed up fragment positions and charges
   std::map<IndexSet::ptr, std::pair<MPQCDataFragmentMap_t, MPQCDataFragmentMap_t> > Result_perIndexSet_Fragment;
+private:
+  /** Helper function to call OrthogonalSummation.
+   *
+   * \param fragmentData map of calculated jobs
+   * \param KeySet container of all keysets
+   * \param MatrixNrLookup map with enumerated job ids
+   */
+  void sumUp(
+      const std::map<JobId_t,MPQCData> &fragmentData,
+      const KeySetsContainer &KeySet,
+      const std::map< JobId_t, size_t > &MatrixNrLookup);
 };

src/Fragmentation/Automation/FragmentationResults.cpp

-              r4f44ae
+              rbae7bc
 #include "Helpers/defs.hpp"
 FragmentationResults::FragmentationResults(
     const std::map<JobId_t,MPQCData> &fragmentData,
     std::map<JobId_t,VMGData> &longrangeData,
+    const std::string &KeySetFilename)
+    const KeySetsContainer& _KeySet,
+    const KeySetsContainer& _ForceKeySet) :
+    KeySet(_KeySet),
+    ForceKeySet(_ForceKeySet)
+{
   // create lookup from job nr to fragment number
 …
   VMGMatrixNrLookup =
       createMatrixNrLookup(vmgjobids, VMGFragmentCounter);
-  // initialise keysets
-  parseKeySetFile(KeySet, KeySetFilename, MPQCFragmentCounter, NonHydrogenKeySets);
-  parseKeySetFile(ForceKeySet, KeySetFilename, MPQCFragmentCounter, HydrogenKeySets);
-  /// prepare for OrthogonalSummation
   // convert KeySetContainer to IndexSetContainer

src/Fragmentation/Automation/FragmentationResults.hpp

-              r4f44ae
+              rbae7bc
 #include <map>
-#include <string>
 #include <vector>
 …
 struct FragmentationResults
+{
+  /** Constructor for class FragmentationResults.
+   *
+   * Performs the summation and fills all result vectors.
+  /** Constructor for class FragmentationResults, based on KeySets.
+   *
    * @param fragmentData results from short-range fragment calculations
    * @param longrangeData results from long-range fragment calculations
+   * @param fullsolutionData results from long-range full calculations
+   * @param KeySetFilename path to fragment files
+   * @param NoAtoms number of atoms of full system
+   * @param full_sample summed up grid charge
+   * @param _KeySet KeySets of all (non-hydrogen) atoms
+   * @param _ForceKeySet KeySets of all atoms except those added by saturation
    */
   FragmentationResults(
       const std::map<JobId_t,MPQCData> &fragmentData,
       std::map<JobId_t,VMGData> &longrangeData,
+      const std::string &KeySetFilename);
+      const KeySetsContainer& _KeySet,
+      const KeySetsContainer& _ForceKeySet);
+  /** Performs the summation and fills all result vectors.
+   *
+   * @param fragmentData results from short-range fragment calculations
+   * @param longrangeData results from long-range fragment calculations
+   * @param fullsolutionData long-range solution
+   * @param full_sample sampled density
+   */
   void operator()(
       const std::map<JobId_t,MPQCData> &fragmentData,

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

Context Navigation

Changeset bae7bc for src

Legend:

Download in other formats: