mesh_foundation.h

// -*-c++-*-
#ifndef STORMM_MESH_FOUNDATION_H
#define STORMM_MESH_FOUNDATION_H
 
#include "copyright.h"
#include "Accelerator/gpu_details.h"
#include "Accelerator/hybrid.h"
#include "Accelerator/mesh_kernel_manager.h"
#include "Constants/behavior.h"
#include "Topology/atomgraph.h"
#include "Trajectory/coordinateframe.h"
#include "Trajectory/coordinate_series.h"
#include "mesh_parameters.h"
#include "mesh_rulers.h"
 
namespace stormm {
namespace structure {
 
using card::Hybrid;
using card::HybridTargetLevel;
using card::MeshKlManager;
using constants::PrecisionModel;
using topology::AtomGraph;
using trajectory::CoordinateFrame;
using trajectory::CoordinateSeries;
  
struct MeshBasicsKit {

  MeshBasicsKit(const int* ngbr_in, const size_t* ngbr_bounds_in, const uint* frozen_atoms_in);

  MeshBasicsKit(const MeshBasicsKit &original) = default;
  MeshBasicsKit(MeshBasicsKit &&original) = default;
 
  // Member variables
  const int* ngbr;            
  const size_t* ngbr_bounds;  
  const uint* frozen_atoms;   
};
  
class MeshFoundation {
public:

  MeshFoundation(const CoordinateFrame *cf_in = nullptr, const AtomGraph *ag_in = nullptr,
                 const std::vector<std::string> &comments = {1, "Generated by STORMM"});
 
  MeshFoundation(const CoordinateFrame &cf, const AtomGraph &ag_in,
                 const std::vector<std::string> &comments = {1, "Generated by STORMM"});
 
  template <typename T>
  MeshFoundation(const CoordinateSeries<T> *cs, const AtomGraph *ag_in = nullptr, 
                 const std::vector<std::string> &comments = {1, "Generated by STORMM"});
 
  template <typename T>
  MeshFoundation(const CoordinateSeries<T> &cs, const AtomGraph &ag_in,
                 const std::vector<std::string> &comments = {1, "Generated by STORMM"});

  int getReadyFrameCount() const;
  
  const AtomGraph* getTopologyPointer() const;

  const CoordinateFrame* getCoordinatePointer() const;

  template <typename Tcoord>
  const CoordinateSeries<Tcoord>* getEnsemblePointer() const;

  size_t getEnsembleTypeCode() const;

  std::vector<uint> getFrozenAtomMask() const;

  int getCommentCount() const;

  const std::string& getComment(int comm_index) const;
  
  MeshBasicsKit data(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
#ifdef STORMM_USE_HPC
  void upload();

  void download();
  
#  ifdef STORMM_USE_CUDA
  MeshBasicsKit deviceViewToHostData(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
#  endif
#endif

  void setTopology(const AtomGraph *ag_in);

  void setCoordinates(const CoordinateFrame *cf_in);
  void setCoordinates(const CoordinateFrame &cf_in);

  template <typename Tcoord> void setEnsemble(const CoordinateSeries<Tcoord> *cs_in);
  template <typename Tcoord> void setEnsemble(const CoordinateSeries<Tcoord> &cs_in);
  
  void computeNeighborLists(const MeshParameters &mps, const MeshRulers &rlrs,
                            const MeshKlManager &launcher = MeshKlManager(),
                            PrecisionModel prec = PrecisionModel::SINGLE,
                            HybridTargetLevel availability = HybridTargetLevel::HOST);

  void addComment(const std::string &verbiage);

  void clearComments();
  
private:

  int frames_ready;
  
  CoordinateFrame *cf_pointer;

  CoordinateSeries<void> *cf_ensemble;

  size_t ensemble_data_type;

  AtomGraph *ag_pointer;

  Hybrid<int> neighbor_list;

  Hybrid<size_t> neighbor_list_bounds;

  Hybrid<uint> frozen_atoms;

  std::vector<std::string> comments;

  int validateAtomCounts() const;

  void testReadiness();
};
 
} // namespace structure
} // namespace stormm
 
#include "mesh_foundation.tpp"
 
#endif