coordinate_swap.h

// -*-c++-*-
#ifndef STORMM_COORDINATE_SWAP_H
#define STORMM_COORDINATE_SWAP_H
 
#include <algorithm>
#include "copyright.h"
#include "Accelerator/card_utilities.h"
#include "Accelerator/gpu_details.h"
#include "Accelerator/hybrid.h"
#include "Reporting/error_format.h"
#include "Synthesis/condensate.h"
#include "Synthesis/phasespace_synthesis.h"
#include "Topology/atomgraph_enumerators.h"
#include "coordinate_series.h"
#include "coordinate_util.h"
 
namespace stormm {
namespace trajectory {
 
using card::GpuDetails;
using card::HpcKernelSync;
using card::Hybrid;
using card::HybridTargetLevel;
using synthesis::Condensate;
using synthesis::CondensateBorders;
using synthesis::CondensateWriter;
using synthesis::PhaseSpaceSynthesis;
using synthesis::PsSynthesisBorders;
using synthesis::PsSynthesisWriter;
using topology::UnitCellType;

void swapValidatePrecisionModels(int first_bits, int second_bits, const char* desc);

void swapValidateFrameIndices(int frm_first, int count_first, int frm_second, int count_second);
 
void swapValidateFrameIndices(const int2* frm_pairs, int pair_count, int count_first,
                              int count_second);

void swapValidateUnitCells(UnitCellType uca, UnitCellType ucb);
  
void swapCheckSameObject(bool is_same, const int2* frm_pairs, int pair_count,
                         HybridTargetLevel tier_first, HybridTargetLevel tier_second);
  
void swapValidateAtomCounts(int natom_first, int natom_second);
 
template <typename T>
void swapValidateAtomCounts(int frm_first, const T* natom_first, int frm_second,
                            const T* natom_second);
 
template <typename T>
void swapValidateAtomCounts(const int2* frm_pairs, int pair_count, const T* natom_first,
                            const T* natom_second);

template <typename T>
void swapCoordinates(T* first_x, T* first_y, T* first_z, T* second_x, T* second_y, T* second_z,
                     size_t first_ofs, size_t second_ofs, size_t natom, size_t frm_first = 0,
                     size_t frm_second = 0, int* first_xovrf = nullptr, int* first_yovrf = nullptr,
                     int* first_zovrf = nullptr, int* second_xovrf = nullptr,
                     int* second_yovrf = nullptr, int* second_zovrf = nullptr,
                     double* first_umat = nullptr, double* first_invu = nullptr,
                     double* first_bdim = nullptr, double* second_umat = nullptr,
                     double* second_invu = nullptr, double* second_bdim = nullptr);
 
template <typename T>
void swapCoordinates(T* first_x, T* first_y, T* first_z, T* second_x, T* second_y, T* second_z,
                     size_t first_ofs, size_t second_ofs, size_t natom, size_t frm_first,
                     size_t frm_second, double* first_umat, double* first_invu, double* first_bdim,
                     double* second_umat, double* second_invu, double* second_bdim);
 
template <typename T>
void swapCoordinates(CoordinateSeriesWriter<void> *v_first, size_t frm_first,
                     CoordinateSeriesWriter<void> *v_second, size_t frm_second);
 
template <typename T>
void swapCoordinates(CoordinateSeriesWriter<void> *v_first, CoordinateSeriesWriter<void> *v_second,
                     const int2* frm_pairs, int pair_count);

void coordSwap(CoordinateSeriesWriter<void> *first, size_t frm_first,
               CoordinateSeriesWriter<void> *second, size_t frm_second, size_t ct,
               HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
 
void coordSwap(CoordinateSeriesWriter<void> *first, CoordinateSeriesWriter<void> *second,
               const int2* frm_pairs, int pair_count, size_t ct,
               HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
 
template <typename T>
void coordSwap(CoordinateSeries<T> *first, size_t frm_first, CoordinateSeries<T> *second,
               size_t frm_second, HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
 
template <typename T>
void coordSwap(CoordinateSeries<T> *first, CoordinateSeries<T> *second,
               const Hybrid<int2> &frm_pairs,
               HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
 
void coordSwap(PsSynthesisWriter *first, int idx_first, PsSynthesisWriter *second,
               int idx_second, const PsSynthesisBorders &first_bdrs,
               const PsSynthesisBorders &second_bdrs,
               HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
 
void coordSwap(PsSynthesisWriter *first, PsSynthesisWriter *second, const int2* idx_pairs,
               int pair_count, const PsSynthesisBorders &first_bdrs,
               const PsSynthesisBorders &second_bdrs,
               HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
 
void coordSwap(PhaseSpaceSynthesis *first, int idx_first, PhaseSpaceSynthesis *second,
               int idx_second, HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
 
void coordSwap(PhaseSpaceSynthesis *first, PhaseSpaceSynthesis *second,
               const Hybrid<int2> &idx_pairs,
               HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
 
void coordSwap(CondensateWriter *first, size_t idx_first, CondensateWriter *second,
               size_t idx_second, const CondensateBorders &first_bdrs,
               const CondensateBorders &second_bdrs,
               HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
 
void coordSwap(CondensateWriter *first, CondensateWriter *second, const int2* idx_pairs,
               int pair_count, const CondensateBorders &first_bdrs,
               const CondensateBorders &second_bdrs,
               HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
 
void coordSwap(Condensate *first, size_t idx_first, Condensate *second, size_t idx_second,
               HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
 
void coordSwap(Condensate *first, Condensate *second, const Hybrid<int2> &idx_pairs,
               HybridTargetLevel tier_first = HybridTargetLevel::HOST,
               HybridTargetLevel tier_second = HybridTargetLevel::HOST,
               const GpuDetails &gpu = null_gpu, HpcKernelSync sync = HpcKernelSync::MEMORY_AUTO);
  
} // namespace trajetory
} // namespace stormm
 
#include "coordinate_swap.tpp"
 
#endif