source: src/Fragmentation/Summation/Containers/FragmentationResultContainer.hpp@ bcc29ca

/*
 * FragmentationResultContainer.hpp
 *
 *  Created on: Mar 8, 2013
 *      Author: heber
 */

#ifndef FRAGMENTATIONRESULTCONTAINER_HPP_
#define FRAGMENTATIONRESULTCONTAINER_HPP_

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

#include <boost/serialization/access.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/split_member.hpp>
#include <boost/serialization/version.hpp>
#include "CodePatterns/Singleton.hpp"

#include <boost/filesystem/path.hpp>
#include <map>

#include "CodePatterns/Observer/Observable.hpp"

#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/Containers/FragmentationShortRangeResults.hpp"
#include "Fragmentation/Summation/Containers/MPQCData.hpp"
#include "Fragmentation/Summation/Containers/MPQCDataMap.hpp"
#if defined(HAVE_JOBMARKET) && defined(HAVE_VMG)
#include "Fragmentation/Summation/Containers/VMGData.hpp"
#endif

/** This class stores results from lengthy fragmentation calculations, e.g.
 * coming out of FragmentationAutomationAction.
 *
 * The idea is that we can play around with results without having to recalculate
 * results in between. Hence, we place results into this container which we may
 * full serialize.
 */
class FragmentationResultContainer :
    public Singleton<FragmentationResultContainer>,
    public Observable
{
  //!> Singleton patterns needs access to private cstor/dtor.
  friend class Singleton<FragmentationResultContainer>;
private:
  FragmentationResultContainer() :
    Observable("FragmentationResultContainer"),
    ResultsType(BothRanges)
  {}
  ~FragmentationResultContainer() {}

public:
  //!> typedef for short range data container
  typedef std::map<JobId_t, MPQCData> shortrangedata_t;
  //!> use FragmentJobQueue's typedef here
  typedef FragmentationEdges::edges_per_fragment_t edges_per_fragment_t;
#if defined(HAVE_JOBMARKET) && defined(HAVE_VMG)
  //!> typedef for long range data container
  typedef std::map<JobId_t, VMGData> longrangedata_t;
#endif

#if defined(HAVE_JOBMARKET) && defined(HAVE_VMG)
  /** Adds a a set of both short and long range results.
   *
   * Adds all the containers to the ones present in this instance.
   *
   * \param _keysets
   * \param _forcekeysetskeysets
   * \param _edges_per_fragment
   * \param _shortrangedata
   * \param _longrangedata
   */
  void addFullResults(
      const KeySetsContainer &_keysets,
      const KeySetsContainer &_forcekeysets,
      const edges_per_fragment_t &_edges_per_fragment,
      const shortrangedata_t &_shortrangedata,
      const longrangedata_t &_longrangedata
      );
#endif

  /** Adds a a set of short range results only.
   *
   * Adds all the containers to the ones present in this instance.
   *
   * \param _keysets
   * \param _forcekeysets
   * \param _edges_per_fragment
   * \param _shortrangedata
   */
  void addShortRangeResults(
      const KeySetsContainer &_keysets,
      const KeySetsContainer &_forcekeysets,
      const edges_per_fragment_t &_edges_per_fragment,
      const shortrangedata_t &_shortrangedata
      );

  /** Adds a a set of summed short range results.
   *
   * Adds all the containers to the ones present in this instance.
   *
   * \param _summedshortrange energy results per index set
   */
  void addShortRangeSummedResults(
      const FragmentationShortRangeResults::summedshortrange_t &_summedshortrange
      );

  /** Adds given cycles to internal keyset list.
   *
   * \param _cycles keysets of cycles to add
   */
  void addCycles(const KeySetsContainer &_cycles)
  { cycles.insert(_cycles); }

  /** Clears all internal containers.
   *
   * \note Also resets ResultsType.
   */
  void clear()
  {
    OBSERVE;
    keysets.clear();
    forcekeysets.clear();
    cycles.clear();
    shortrangedata.clear();
    summedshortrange.clear();
    edges_per_fragment.clear();
#if defined(HAVE_JOBMARKET) && defined(HAVE_VMG)
    longrangedata.clear();
#endif
    ResultsType = BothRanges;
  }

  const KeySetsContainer &getKeySets() const { return keysets; }
  const KeySetsContainer &getCycles() const { return cycles; }
  const KeySetsContainer &getForceKeySets() const  { return forcekeysets; }
  const shortrangedata_t& getShortRangeResults() const  { return shortrangedata; }
  const FragmentationShortRangeResults::summedshortrange_t& getShortRangeSummedResults() const
  { return summedshortrange; }
  const edges_per_fragment_t& getEdgesPerFragment() const
  { return edges_per_fragment; }
#if defined(HAVE_JOBMARKET) && defined(HAVE_VMG)
  const longrangedata_t& getLongRangeResults() const;
#endif
  bool areFullRangeResultsPresent() const { return (ResultsType == BothRanges); }

private:
  //!> indicates whether we contain short range only or both results
  enum ResultsType_t {
    ShortRangeOnly,
    BothRanges,
  } ResultsType;

  //!> container for all KeySet's without hydrogens to the jobs
  KeySetsContainer keysets;
  //!> container for all KeySet's with all except saturation hydrogen to the jobs
  KeySetsContainer forcekeysets;
  //!> container for all short-range results
  std::map<JobId_t, MPQCData> shortrangedata;
  //! container of all cycle keysets
  KeySetsContainer cycles;
  //!> container for summed up results per index set
  FragmentationShortRangeResults::summedshortrange_t summedshortrange;
  //!> container for the edge set per index set (starting at 0)
  edges_per_fragment_t edges_per_fragment;

#if defined(HAVE_JOBMARKET) && defined(HAVE_VMG)
  //!> container for all long-range results
  std::map<JobId_t, VMGData> longrangedata;
#endif

  friend class boost::serialization::access;
  // serialization
  template <typename Archive>
  void load(Archive& ar, const unsigned int version)
  {
    OBSERVE;
    ar & ResultsType;
    ar & keysets;
    ar & forcekeysets;
    ar & shortrangedata;
    if (version > 0)
      ar & cycles;
    if (version > 1)
      ar & summedshortrange;
    if (version > 2)
      ar & edges_per_fragment;
#if defined(HAVE_JOBMARKET) && defined(HAVE_VMG)
    ar & longrangedata;
#endif
  }
  template <typename Archive>
  void save(Archive& ar, const unsigned int version) const
  {
    ar & ResultsType;
    ar & keysets;
    ar & forcekeysets;
    ar & shortrangedata;
    if (version > 0)
      ar & cycles;
    if (version > 1)
      ar & summedshortrange;
    if (version > 2)
      ar & edges_per_fragment;
#if defined(HAVE_JOBMARKET) && defined(HAVE_VMG)
    ar & longrangedata;
#endif
  }
  BOOST_SERIALIZATION_SPLIT_MEMBER()
};

// version for serialized information associated to FragmentationResultContainer
BOOST_CLASS_VERSION(FragmentationResultContainer, 3)

#endif /* FRAGMENTATIONRESULTCONTAINER_HPP_ */