condensate.h

// -*-c++-*-
#ifndef STORMM_CONDENSATE_H
#define STORMM_CONDENSATE_H
 
#include <typeinfo>
#include <typeindex>
#include <sys/types.h>
#include "copyright.h"
#include "Accelerator/gpu_details.h"
#include "Accelerator/hybrid.h"
#include "Accelerator/hybrid_util.h"
#include "Constants/behavior.h"
#include "Constants/hpc_bounds.h"
#include "DataTypes/common_types.h"
#include "Math/rounding.h"
#include "Math/series_ops.h"
#include "Topology/atomgraph_abstracts.h"
#include "Trajectory/coordinateframe.h"
#include "Trajectory/coordinate_series.h"
#include "phasespace_synthesis.h"
#include "synthesis_enumerators.h"
 
namespace stormm {
namespace synthesis {
 
using card::default_hpc_format;
using card::GpuDetails;
using card::Hybrid;
using card::HybridFormat;
using card::HybridTargetLevel;
using constants::CartesianDimension;
using constants::PrecisionModel;
using stmath::incrementingSeries;
using stmath::roundUp;
using topology::UnitCellType;
using trajectory::CoordinateFrame;
using trajectory::CoordinateSeries;
using trajectory::CoordinateSeriesReader;

struct CondensateBorders {

  CondensateBorders(int system_count_in, const size_t* atom_starts_in, const int* atom_counts_in);

  CondensateBorders(const CondensateBorders &original) = default;
  CondensateBorders(CondensateBorders &&other) = default;
  
  const int system_count;     
  const size_t* atom_starts;  
  const int* atom_counts;     
};

struct CondensateWriter {

  CondensateWriter(PrecisionModel mode_in, StructureSource basis_in, int system_count_in,
                   UnitCellType unit_cell_in, const size_t* atom_starts_in,
                   const int* atom_counts_in, float* xcrd_sp, float* ycrd_sp, float* zcrd_sp,
                   double* xcrd, double* ycrd, double* zcrd, double* umat_in, double* invu_in,
                   double* boxdim_in);

  CondensateWriter(const CondensateWriter &original) = default;
  CondensateWriter(CondensateWriter &&original) = default;
 
  const PrecisionModel mode;     
  const StructureSource basis;   
  const int system_count;        
  const UnitCellType unit_cell;  
  const size_t* atom_starts;     
  const int* atom_counts;        
  float* xcrd_sp;                
  float* ycrd_sp;                
  float* zcrd_sp;                
  double* xcrd;                  
  double* ycrd;                  
  double* zcrd;                  
  double* umat;                  
  double* invu;                  
  double* boxdims;               
};

struct CondensateReader {

  CondensateReader(PrecisionModel mode_in, StructureSource basis_in, int system_count_in,
                   UnitCellType unit_cell_in, const size_t* atom_starts_in,
                   const int* atom_counts_in, const float* xcrd_sp, const float* ycrd_sp,
                   const float* zcrd_sp, const double* xcrd, const double* ycrd,
                   const double* zcrd, const double* umat_in, const double* invu_in,
                   const double* boxdim_in);
 
  CondensateReader(const CondensateWriter &cdw);

  CondensateReader(const CondensateReader &original) = default;
  CondensateReader(CondensateReader &&original) = default;
 
  const PrecisionModel mode;     
  const StructureSource basis;   
  const int system_count;        
  const UnitCellType unit_cell;  
  const size_t* atom_starts;     
  const int* atom_counts;        
  const float* xcrd_sp;          
  const float* ycrd_sp;          
  const float* zcrd_sp;          
  const double* xcrd;            
  const double* ycrd;            
  const double* zcrd;            
  const double* umat;            
  const double* invu;            
  const double* boxdims;         
};

class Condensate {
public:

  Condensate(HybridFormat format_in = default_hpc_format);
  
  Condensate(const PhaseSpaceSynthesis *poly_ps_in, PrecisionModel mode_in,
             const GpuDetails &gpu = null_gpu);
 
  Condensate(const PhaseSpaceSynthesis &poly_ps_in, PrecisionModel mode_in,
             const GpuDetails &gpu = null_gpu);
 
  template <typename T>
  Condensate(const CoordinateSeries<T> *cs_in, PrecisionModel mode_in,
             const GpuDetails &gpu = null_gpu);
 
  template <typename T>
  Condensate(const CoordinateSeries<T> &cs_in, PrecisionModel mode_in,
             const GpuDetails &gpu = null_gpu);

  Condensate(const Condensate &original);
  Condensate(Condensate &&original);
  Condensate& operator=(const Condensate &original);
  Condensate& operator=(Condensate &&original);
  
  HybridFormat getFormat() const;

  PrecisionModel getMode() const;

  StructureSource getBasis() const;

  int getSystemCount() const;
  
  bool ownsCoordinates() const;

  size_t getAtomOffset(int system_index) const;

  int getAtomCount(int system_index) const;
  
  size_t getCoordinateSeriesTypeID() const;
  
  template <typename T>
  const CoordinateSeries<T>* getSeriesPointer() const;

  const PhaseSpaceSynthesis* getSynthesisPointer() const;

  CoordinateFrame exportCoordinateFrame(int system_index,
                                        HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<double>
  getInterlacedCoordinates(int system_index,
                           HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  const Condensate* getSelfPointer() const;
  
  const CondensateReader data(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  CondensateWriter data(HybridTargetLevel tier = HybridTargetLevel::HOST);

  const CondensateBorders borders(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
#ifdef STORMM_USE_HPC
  const CondensateReader deviceViewToHostData() const;
  CondensateWriter deviceViewToHostData();
  
  void upload();

  void download();

  void launchCondensateUpdate(const GpuDetails &gpu);
#endif
  
  void rebuild(const PhaseSpaceSynthesis *poly_ps_in,
               PrecisionModel mode_in = PrecisionModel::SINGLE, const GpuDetails &gpu = null_gpu);
 
  void rebuild(const PhaseSpaceSynthesis &poly_ps_in,
               PrecisionModel mode_in = PrecisionModel::SINGLE, const GpuDetails &gpu = null_gpu);
 
  template <typename T>
  void rebuild(const CoordinateSeries<T> *cs_in,
               const PrecisionModel mode_in = PrecisionModel::SINGLE,
               const GpuDetails &gpu = null_gpu);

  void update(HybridTargetLevel tier = HybridTargetLevel::HOST, const GpuDetails &gpu = null_gpu);
  
  template <typename T>
  void update(const CoordinateSeries<T> *cs_basis,
              HybridTargetLevel tier = HybridTargetLevel::HOST, const GpuDetails &gpu = null_gpu);
  
  template <typename T>
  void update(const CoordinateSeries<T> &cs_basis,
              HybridTargetLevel tier = HybridTargetLevel::HOST, const GpuDetails &gpu = null_gpu);
 
private:
  HybridFormat format;             
  PrecisionModel mode;             
  StructureSource basis;           
  int system_count;                
  UnitCellType unit_cell;          
  bool holds_own_data;             
  size_t csptr_data_type;          
  Hybrid<size_t> atom_starts;      
  Hybrid<int> atom_counts;         
  Hybrid<float> x_coordinates_sp;  
  Hybrid<float> y_coordinates_sp;  
  Hybrid<float> z_coordinates_sp;  
  Hybrid<double> x_coordinates;    
  Hybrid<double> y_coordinates;    
  Hybrid<double> z_coordinates;    
  Hybrid<double> box_transforms;   
  Hybrid<double> inv_transforms;   
  Hybrid<double> box_dimensions;   
 
  // Pointers to the original coordinate objects
  PhaseSpaceSynthesis *pps_ptr;   
  CoordinateSeries<int> *cs_ptr;  
 
  // ARRAY-kind Hybrid objects targeted by POINTER-kind Hybrids of like types above
  Hybrid<float> float_data;       
  Hybrid<double> double_data;     

  void repairPointers();

  void validateSystemIndex(int index) const;
};

static const size_t condensate_type_index = std::type_index(typeid(Condensate)).hash_code();
 
} // namespace synthesis
} // namespace stormm
 
#include "condensate.tpp"
 
// As with common types and STORMM vector types, define the type indices for general use in the
// STORMM namespace.
namespace stormm {
using synthesis::condensate_type_index;
} // namespace stormm
 
#endif