mesh_rulers.h

// -*-c++-*-
#ifndef STORMM_MESH_COMPONENTS_H
#define STORMM_MESH_COMPONENTS_H
 
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "DataTypes/stormm_vector_types.h"
#include "Numerics/split_fixed_precision.h"
#include "local_arrangement.h"
#include "mesh_parameters.h"
 
namespace stormm {
namespace structure {
 
using card::Hybrid;
using card::HybridTargetLevel;
#ifndef STORMM_USE_HPC
using data_types::double3;
#endif
 
struct MeshRulerKit {

  MeshRulerKit(const llint* avec_x_in, const llint* avec_y_in, const llint* avec_z_in,
               const llint* bvec_x_in, const llint* bvec_y_in, const llint* bvec_z_in,
               const llint* cvec_x_in, const llint* cvec_y_in, const llint* cvec_z_in,
               const llint* avec_abs_x_in, const llint* avec_abs_y_in, const llint* avec_abs_z_in,
               const int* avec_x_ovrf_in, const int* avec_y_ovrf_in, const int* avec_z_ovrf_in,
               const int* bvec_x_ovrf_in, const int* bvec_y_ovrf_in, const int* bvec_z_ovrf_in,
               const int* cvec_x_ovrf_in, const int* cvec_y_ovrf_in, const int* cvec_z_ovrf_in,
               const int* avec_abs_x_ovrf_in, const int* avec_abs_y_ovrf_in,
               const int* avec_abs_z_ovrf_in);
 
  // As with other abstracts, the default copy and move constructors are acceptable, but the copy
  // and move assignment operators are implicitly deleted because of const member variables.
  MeshRulerKit(const MeshRulerKit &original) = default;
  MeshRulerKit(MeshRulerKit &&original) = default;
  
  // Public, const member variables for the coordinates of tick marks along each axis
  const llint* avec_x;         
  const llint* avec_y;         
  const llint* avec_z;         
  const llint* bvec_x;         
  const llint* bvec_y;         
  const llint* bvec_z;         
  const llint* cvec_x;         
  const llint* cvec_y;         
  const llint* cvec_z;         
  const llint* avec_abs_x;     
  const llint* avec_abs_y;     
  const llint* avec_abs_z;     
  const int* avec_x_ovrf;      
  const int* avec_y_ovrf;      
  const int* avec_z_ovrf;      
  const int* bvec_x_ovrf;      
  const int* bvec_y_ovrf;      
  const int* bvec_z_ovrf;      
  const int* cvec_x_ovrf;      
  const int* cvec_y_ovrf;      
  const int* cvec_z_ovrf;      
  const int* avec_abs_x_ovrf;  
  const int* avec_abs_y_ovrf;  
  const int* avec_abs_z_ovrf;  
};

class MeshRulers {
public:
  
  MeshRulers(const MeshParameters &mps = MeshParameters());

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

  double3 getMeshOrigin() const;

  double3 getRealLocation(const double3 mesh_loc) const;

  double3 getMeshLocation(const double3 real_loc) const;

  const MeshRulerKit data(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
 
#ifdef STORMM_USE_HPC
  void upload();

  void download();
 
#  ifdef STORMM_USE_CUDA
  const MeshRulerKit deviceViewToHostData() const;
#  endif
#endif
  
private:
  
  Hybrid<llint> a_line_x;      //
  Hybrid<llint> a_line_y;      // Positions of "a" vector tick marks relative to the mesh origin
  Hybrid<llint> a_line_z;      //
  Hybrid<llint> b_line_x;      //
  Hybrid<llint> b_line_y;      // Positions of "b" vector tick marks relative to the mesh origin
  Hybrid<llint> b_line_z;      //
  Hybrid<llint> c_line_x;      //
  Hybrid<llint> c_line_y;      // Positions of "c" vector tick marks relative to the mesh origin
  Hybrid<llint> c_line_z;      //
  Hybrid<llint> a_abs_line_x;  //
  Hybrid<llint> a_abs_line_y;  // Absolute positions of the "a" vector tick marks
  Hybrid<llint> a_abs_line_z;  //

  Hybrid<int> a_line_x_overflow;      // Overflow bits for positions of the "a" vector tick marks
  Hybrid<int> a_line_y_overflow;      //   relative to the mesh origin.  These engage when the mesh
  Hybrid<int> a_line_z_overflow;      //   serves double-precision coefficients and calculatons.
  Hybrid<int> b_line_x_overflow;      //
  Hybrid<int> b_line_y_overflow;      // Overflow bits for "b" vector tick mark relative positions
  Hybrid<int> b_line_z_overflow;      //
  Hybrid<int> c_line_x_overflow;      //
  Hybrid<int> c_line_y_overflow;      // Overflow bits for "c" vector tick mark relative positions
  Hybrid<int> c_line_z_overflow;      //
  Hybrid<int> a_abs_line_x_overflow;  //
  Hybrid<int> a_abs_line_y_overflow;  // Overflow bits for "a" vector tick mark absolute positions
  Hybrid<int> a_abs_line_z_overflow;  //

  Hybrid<int> int_data;

  Hybrid<llint> llint_data;

  MeshParameters *mps_pointer;
  
  void rebasePointers();
};
 
} // namespace structure
} // namespace stormm
 
#endif