static_mask_synthesis.h

// -*-c++-*-
#ifndef STORMM_STATIC_MASK_SYNTHESIS_H
#define STORMM_STATIC_MASK_SYNTHESIS_H
 
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "Potential/static_exclusionmask.h"
#include "Topology/atomgraph.h"
 
namespace stormm {
namespace synthesis {
 
using card::Hybrid;
using card::HybridTargetLevel;
using energy::StaticExclusionMask;
using topology::AtomGraph;

struct SeMaskSynthesisReader {

  SeMaskSynthesisReader(int nsys_in, const int* atom_counts_in, const int* atom_offsets_in,
                        int nsupertile_in, int ntile_in, const int* supertile_map_idx_in,
                        const int* supertile_map_bounds_in, const int* tile_map_idx_in,
                        const uint* mask_data_in);

  SeMaskSynthesisReader(const SeMaskSynthesisReader &original) = default;
  SeMaskSynthesisReader(SeMaskSynthesisReader &&original) = default;
  
  const int nsys;                   
  const int* atom_counts;           
  const int* atom_offsets;          
  const int nsupertile;             
  const int ntile;                  
  const int* supertile_map_idx;     
  const int* supertile_map_bounds;  
  const int* tile_map_idx;          
  const uint* mask_data;            
};

class StaticExclusionMaskSynthesis {
public:

  StaticExclusionMaskSynthesis();
  
  StaticExclusionMaskSynthesis(const std::vector<StaticExclusionMask*> &base_masks,
                               const std::vector<int> &topology_indices);
 
  StaticExclusionMaskSynthesis(const std::vector<StaticExclusionMask> &base_masks,
                               const std::vector<int> &topology_indices);
 
  StaticExclusionMaskSynthesis(const std::vector<AtomGraph*> &base_toplogies,
                               const std::vector<int> &topology_indices);

  StaticExclusionMaskSynthesis(const StaticExclusionMaskSynthesis &original) = default;
  StaticExclusionMaskSynthesis(StaticExclusionMaskSynthesis &&original) = default;
  StaticExclusionMaskSynthesis& operator=(const StaticExclusionMaskSynthesis &original) = default;
  StaticExclusionMaskSynthesis& operator=(StaticExclusionMaskSynthesis &&original) = default;  
  
  int getSystemCount() const;
  
  int getAtomCount(int index = 0) const;

  int getAtomOffset(int index = 0) const;

  bool testExclusion(int system_index, int atom_i, int atom_j) const;

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

  void download();
#endif
 
private:
  int system_count;                   
  Hybrid<int> atom_counts;            
  Hybrid<int> atom_offsets;           
  int unique_supertile_count;         
  int unique_tile_count;              
  Hybrid<int> supertile_map_indices;  
  Hybrid<int> supertile_map_bounds;   
  Hybrid<int> tile_map_indices;       
  Hybrid<uint> all_masks;             

  void build(const std::vector<StaticExclusionMask*> &base_masks,
             const std::vector<int> &topology_indices);
};
  
} // namespace synthesis
} // namespace stormm
 
#endif