source: src/Fragmentation/Converter/DataConverter.hpp@ 0398bd

/*
 * DataConverter.hpp
 *
 *  Created on: Aug 27, 2012
 *      Author: heber
 */

#ifndef DATACONVERTER_HPP_
#define DATACONVERTER_HPP_


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

#include <vector>
#include <boost/fusion/sequence.hpp>

#include "CodePatterns/Assert.hpp"

#include "JobMarket/types.hpp"

#include "Fragmentation/KeySetsContainer.hpp"
#include "Fragmentation/SetValues/Histogram.hpp"
#include "Fragmentation/SetValues/Fragment.hpp"
#include "Fragmentation/SetValues/IndexedVectors.hpp"

#include "Jobs/MPQCData.hpp"
#include "Jobs/MPQCDataFused.hpp"
#include "Jobs/MPQCDataMap.hpp"
#ifdef HAVE_VMG
#include "Jobs/VMGData.hpp"
#include "Jobs/VMGDataFused.hpp"
#include "Jobs/VMGDataMap.hpp"
#endif

template <typename source, typename dest>
inline void convertDataTo(
    const std::vector<source> &fragmentData,
    std::vector<dest> &MPQCData_fused)
{
  MPQCData_fused.clear();
}

template <>
inline void convertDataTo<MPQCData, MPQCDataEnergyMap_t>(
    const std::vector<MPQCData> &fragmentData,
    std::vector<MPQCDataEnergyMap_t> &MPQCData_Energy_fused)
{
  // energy_t
  MPQCData_Energy_fused.clear();
  MPQCData_Energy_fused.reserve(fragmentData.size());
  for(std::vector<MPQCData>::const_iterator dataiter = fragmentData.begin();
      dataiter != fragmentData.end(); ++dataiter) {
    const MPQCData &extractedData = *dataiter;
    LOG(4, "DEBUG: Current extracted Data is " << extractedData << ".");
    MPQCDataEnergyMap_t instance;
    boost::fusion::at_key<MPQCDataFused::energy_total>(instance) = extractedData.energies.total;
    boost::fusion::at_key<MPQCDataFused::energy_nuclear_repulsion>(instance) = extractedData.energies.nuclear_repulsion;
    boost::fusion::at_key<MPQCDataFused::energy_electron_coulomb>(instance) = extractedData.energies.electron_coulomb;
    boost::fusion::at_key<MPQCDataFused::energy_electron_exchange>(instance) = extractedData.energies.electron_exchange;
    boost::fusion::at_key<MPQCDataFused::energy_correlation>(instance) = extractedData.energies.correlation;
    boost::fusion::at_key<MPQCDataFused::energy_overlap>(instance) = extractedData.energies.overlap;
    boost::fusion::at_key<MPQCDataFused::energy_kinetic>(instance) = extractedData.energies.kinetic;
    boost::fusion::at_key<MPQCDataFused::energy_hcore>(instance) = extractedData.energies.hcore;
    boost::fusion::at_key<MPQCDataFused::energy_eigenvalues>(instance) = extractedData.energies.eigenvalues;
    MPQCData_Energy_fused.push_back(instance);
  }
}

#ifdef HAVE_VMG
template <>
inline void convertDataTo<VMGData, VMGDataMap_t>(
    const std::vector<VMGData> &longrangeData,
    std::vector<VMGDataMap_t> &VMGData_fused)
{
  // energy_t
  VMGData_fused.clear();
  VMGData_fused.reserve(longrangeData.size());
  for(std::vector<VMGData>::const_iterator dataiter = longrangeData.begin();
      dataiter != longrangeData.end(); ++dataiter) {
    const VMGData &extractedData = *dataiter;
    LOG(4, "DEBUG: Current extracted Data is " << extractedData << ".");
    VMGDataMap_t instance;
    boost::fusion::at_key<VMGDataFused::sampled_potential>(instance) = extractedData.sampled_potential;
    boost::fusion::at_key<VMGDataFused::energy_potential>(instance) = extractedData.sampled_potential.integral();
    boost::fusion::at_key<VMGDataFused::energy_long>(instance) = extractedData.e_long;
    VMGData_fused.push_back(instance);
  }
}
#endif

inline void convertMPQCDatatoForceMap(
    const std::vector<MPQCData> &fragmentData,
    const KeySetsContainer &ForceKeySet,
    std::vector<MPQCDataForceMap_t> &MPQCData_Force_fused)
{
  // forces
  ASSERT( ForceKeySet.KeySets.size() == fragmentData.size(),
      "FragmentationAutomationAction::performCall() - indices and fragmentData differ in size.");
  MPQCData_Force_fused.clear();
  MPQCData_Force_fused.reserve(fragmentData.size());
  std::vector<MPQCData>::const_iterator dataiter = fragmentData.begin();
  KeySetsContainer::ArrayOfIntVectors::const_iterator arrayiter = ForceKeySet.KeySets.begin();
  for(;dataiter != fragmentData.end(); ++dataiter, ++arrayiter) {
    const MPQCData &extractedData = *dataiter;
    LOG(4, "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(indices, extractedData.forces);
    MPQCData_Force_fused.push_back(instance);
  }
}

template <>
inline void convertDataTo<MPQCData, MPQCDataGridMap_t>(
    const std::vector<MPQCData> &fragmentData,
    std::vector<MPQCDataGridMap_t> &MPQCData_Grid_fused)
{
  // sampled_grid
  MPQCData_Grid_fused.clear();
  MPQCData_Grid_fused.reserve(fragmentData.size());
  for(std::vector<MPQCData>::const_iterator dataiter = fragmentData.begin();
      dataiter != fragmentData.end(); ++dataiter) {
    const MPQCData &extractedData = *dataiter;
    LOG(4, "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);
  }
}

template <>
inline void convertDataTo<MPQCData, MPQCDataFragmentMap_t>(
    const std::vector<MPQCData> &fragmentData,
    std::vector<MPQCDataFragmentMap_t> &MPQCData_Fragment_fused)
{
  // fragment
  MPQCData_Fragment_fused.clear();
  MPQCData_Fragment_fused.reserve(fragmentData.size());
  for(std::vector<MPQCData>::const_iterator dataiter = fragmentData.begin();
      dataiter != fragmentData.end(); ++dataiter) {
    const MPQCData &extractedData = *dataiter;
    LOG(4, "DEBUG: Current extracted Data is " << extractedData << ".");
    MPQCDataFragmentMap_t instance;
    boost::fusion::at_key<MPQCDataFused::fragment>(instance) =
        Fragment(extractedData.positions, extractedData.charges);
    MPQCData_Fragment_fused.push_back(instance);
  }
}

template <>
inline void convertDataTo<MPQCData, MPQCDataTimeMap_t>(
    const std::vector<MPQCData> &fragmentData,
    std::vector<MPQCDataTimeMap_t> &MPQCData_Time_fused)
{
  // times
  MPQCData_Time_fused.clear();
  MPQCData_Time_fused.reserve(fragmentData.size());
  for(std::vector<MPQCData>::const_iterator dataiter = fragmentData.begin();
      dataiter != fragmentData.end(); ++dataiter) {
    const MPQCData &extractedData = *dataiter;
    LOG(4, "DEBUG: Current extracted Data is " << extractedData << ".");
    MPQCDataTimeMap_t instance;
    boost::fusion::at_key<MPQCDataFused::times_walltime>(instance) = extractedData.times.walltime;
    boost::fusion::at_key<MPQCDataFused::times_cputime>(instance) = extractedData.times.cputime;
    boost::fusion::at_key<MPQCDataFused::times_flops>(instance) = extractedData.times.flops;
    MPQCData_Time_fused.push_back(instance);
  }
}


#endif /* DATACONVERTER_HPP_ */