source: src/Fragmentation/Summation/Containers/FragmentationShortRangeResults.hpp@ 745290

/*
 * FragmentationShortRangeResults.hpp
 *
 *  Created on: Mar 7, 2013
 *      Author: heber
 */

#ifndef FRAGMENTATIONSHORTRANGERESULTS_HPP_
#define FRAGMENTATIONSHORTRANGERESULTS_HPP_


// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <map>
#include <vector>

#ifdef HAVE_JOBMARKET
#include "JobMarket/types.hpp"
#else
typedef size_t JobId_t;
#endif

#include "Fragmentation/EdgesPerFragment.hpp"
#include "Fragmentation/KeySetsContainer.hpp"
#include "Fragmentation/Summation/IndexSet.hpp"
#include "Fragmentation/Summation/IndexSetContainer.hpp"
#include "Fragmentation/Summation/SubsetMap.hpp"

#include "Fragmentation/Summation/Containers/MPQCData.hpp"
#include "Fragmentation/Summation/Containers/MPQCDataMap.hpp"

/** FragmentationShortRangeResults contains the summed up results per level resulting
 * from the fragmentation of the molecular system and clever combination of
 * fragmentary energies, forces, timings, and so on.
 *
 * This structure is mostly a storage wherein the summed up results are
 * contained for subsequent pretty printing and so on.
 *
 */
struct FragmentationShortRangeResults
{
  typedef FragmentationEdges::edges_per_fragment_t edges_per_fragment_t;

  /** Constructor for class FragmentationShortRangeResults, based on KeySets.
   *
   * @param fragmentData results from short-range fragment calculations
   * @param _KeySet KeySets of all (non-hydrogen) atoms
   * @param _ForceKeySet KeySets of all atoms except those added by saturation
   * @param _edges_per_fragment edges of the bond graph over all fragment jobs
   * @param _ValueMask masks whether to use a value (true) or not (false),
   *        default is true for all values
   */
  FragmentationShortRangeResults(
      const std::map<JobId_t,MPQCData> &fragmentData,
      const KeySetsContainer& _KeySet,
      const KeySetsContainer& _ForceKeySet,
      const edges_per_fragment_t &_edges_per_fragment,
      std::vector<bool> &_ValueMask);

  /** Performs the summation and fills all result vectors.
   *
   * @param fragmentData results from short-range fragment calculations
   */
  void operator()(
      const std::map<JobId_t,MPQCData> &fragmentData);

  size_t getMaxLevel() const {
    return MaxLevel;
  }

  IndexSetContainer::Container_t getContainer() const {
    return container->getContainer();
  }

  const KeySetsContainer& getKeySet() const {
    return KeySet;
  }

  const KeySetsContainer& getForceKeySet() const {
    return ForceKeySet;
  }

  const edges_per_fragment_t& getEdgesPerFragment() const {
    return edges_per_fragment;
  }

  typedef std::map<IndexSet::ptr, std::pair<MPQCData,MPQCData> > summedshortrange_t;
  const summedshortrange_t getSummedShortRangeResults() const;

private:
  void initLookups(
      const std::map<JobId_t,MPQCData> &fragmentData,
      std::vector<bool> &_ValueMask);

private:
  std::map< JobId_t, size_t > MPQCMatrixNrLookup;
  KeySetsContainer KeySet;
  KeySetsContainer ForceKeySet;
  edges_per_fragment_t edges_per_fragment;
  IndexSetContainer::ptr container;
  SubsetMap::ptr subsetmap;

public:
  //!> results per level of summed up energy
  std::vector<MPQCDataEnergyMap_t> Result_Energy_fused;
  //!> results per level of summed up fragment positions and charges
  std::vector<MPQCDataFragmentMap_t> Result_Fragment_fused;
  //!> results per level of summed up times
  std::vector<MPQCDataTimeMap_t> Result_Time_fused;
  //!> results per level of summed up forces
  std::vector<MPQCDataForceMap_t> Result_Force_fused;

  //!> results per IndexSet of summed up energy
  std::map<IndexSet::ptr, std::pair<MPQCDataEnergyMap_t,MPQCDataEnergyMap_t> > Result_perIndexSet_Energy;
  //!> results per IndexSet of summed up fragment positions and charges
  std::map<IndexSet::ptr, std::pair<MPQCDataFragmentMap_t,MPQCDataFragmentMap_t> > Result_perIndexSet_Fragment;
  //!> results per IndexSet of summed up times
  std::map<IndexSet::ptr, std::pair<MPQCDataTimeMap_t,MPQCDataTimeMap_t> > Result_perIndexSet_Time;
  //!> results per IndexSet of summed up forces
  std::map<IndexSet::ptr, std::pair<MPQCDataForceMap_t, MPQCDataForceMap_t> > Result_perIndexSet_Force;
  // we don't need the map pendant for Result_LongRangeIntegrated_fused, as this
  // quantity makes sense only level-wise

private:
  //!> maximum level of summation
  size_t MaxLevel;
};


#endif /* FRAGMENTATIONSHORTRANGERESULTS_HPP_ */