cluster_manager.h

// -*-c++-*-
#ifndef STORMM_CLUSTER_MANAGER_H
#define STORMM_CLUSTER_MANAGER_H
 
#include <vector>
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "Constants/hpc_bounds.h"
#include "Synthesis/condensate.h"
#include "Synthesis/phasespace_synthesis.h"
#include "Trajectory/coordinateframe.h"
#include "Trajectory/coordinate_series.h"
#include "Trajectory/phasespace.h"
#include "rounding.h"
 
namespace stormm {
namespace stmath {
 
using card::Hybrid;
using card::HybridKind;
using card::HybridTargetLevel;
using synthesis::Condensate;
using synthesis::PhaseSpaceSynthesis;
using trajectory::CoordinateFrame;
using trajectory::PhaseSpace;
using trajectory::CoordinateSeries;

template <typename Tcalc>
struct ClusterManagerKit {
public:

  ClusterManagerKit(size_t data_points_in, int clusters_in, int* cls_homes_in,
                    size_t* cls_membership_in, size_t* cls_bounds_in, size_t* cls_primes_in,
                    Tcalc* cls_rmsd_in, Tcalc* centroid_dist_in);

  ClusterManagerKit(const ClusterManagerKit &original) = default;
  ClusterManagerKit(ClusterManagerKit &&original) = default;
 
  const size_t data_points;  
  const int clusters;        
  int* cls_homes;            
  size_t* cls_membership;    
  size_t* cls_bounds;        
  size_t* cls_primes;        
  Tcalc* cls_rmsd;           
  Tcalc* centroid_dist;      
};

template <typename Tdata, typename Tcalc>
class ClusterManager {
public:

  explicit ClusterManager(size_t data_point_count_in = 0, int cluster_count_in = 1,
                          int attempt_count_in = 0);

  ClusterManager(const ClusterManager &original);
  ClusterManager(ClusterManager &&original);
  ClusterManager& operator=(const ClusterManager &original);
  ClusterManager& operator=(ClusterManager &&original);

  size_t getDataPointCount() const;

  int getClusterCount() const;
  
  int getAttemptCount() const;
  
  int getClusterHome(size_t point_index) const;

  size_t getClusterSize(int cluster_index) const;

  size_t getClusterPrime(int cluster_index) const;

  std::vector<size_t> getClusterMembers(int cluster_index) const;

  const Tdata& getClusterCentroid(int cluster_index) const;

  const std::vector<Tdata>& getClusterCentroids() const;
  
  const ClusterManagerKit<Tcalc> data(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  ClusterManagerKit<Tcalc> data(HybridTargetLevel tier = HybridTargetLevel::HOST);
  
  void resize(size_t data_point_count_in, int cluster_count_in);
  
  void setAttemptCount(int attempt_count_in);

  void setCentroid(int cluster_index, const Tdata value);
  
private:
  size_t data_point_count;            
  int cluster_count;                  
  int attempt_count;                  
  Hybrid<int> cluster_homes;          
  Hybrid<size_t> cluster_membership;  
  Hybrid<size_t> cluster_bounds;      
  Hybrid<size_t> cluster_primes;      
  Hybrid<Tcalc> cluster_rmsd;         
  Hybrid<Tcalc> centroid_distances;   
  Hybrid<size_t> sizet_data;          
  Hybrid<Tcalc> real_data;            
  std::vector<Tdata> centroids;       

  void allocate();

  void validateClusterIndex(int cluster_index) const;
};
 
} // namespace stmath
} // namespace stormm
 
#include "cluster_manager.tpp"
 
#endif