forward_exclusionmask.h

// -*-c++-*-
#ifndef STORMM_FORWARD_EXCLUSIONMASK_H
#define STORMM_FORWARD_EXCLUSIONMASK_H
 
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "DataTypes/stormm_vector_types.h"
#include "Topology/atomgraph.h"
 
namespace stormm {
namespace energy {
 
using card::Hybrid;
using card::HybridTargetLevel;
using topology::AtomGraph;

struct ForwardExclusionMaskReader {

  ForwardExclusionMaskReader(int natom_in, int mask2_size_in, const int* primary_idx_in,
                             const uint2* mask1_in, const uint2* mask2_in);
 
  const int natom;         
  const int mask2_size;    
  const int* primary_idx;  
  const uint2* mask1;      
  const uint2* mask2;      
};

class ForwardExclusionMask {
public:

  ForwardExclusionMask(const AtomGraph *ag_in = nullptr);
  ForwardExclusionMask(const AtomGraph &ag_in);

  ForwardExclusionMask(const ForwardExclusionMask &original) = default;
  ForwardExclusionMask(ForwardExclusionMask &&original) = default;
  ForwardExclusionMask& operator=(const ForwardExclusionMask &other) = default;
  ForwardExclusionMask& operator=(ForwardExclusionMask &&other) = default;

  int getAtomCount() const;

  int getPrimaryMaskCount() const;

  int getExtendedMaskCount() const;

  int getSecondaryMaskCount() const;

  int getTotalExclusionsCount() const;

  uint2 getPrimaryMask(int index) const;

  std::vector<uint2> getSecondaryMasks(int start, int length) const;

  const ForwardExclusionMaskReader data(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  bool testExclusion(int atom_i, int atom_j) const;
 
private:

  int atom_count;

  Hybrid<int> primary_mask_indices;

  Hybrid<uint2> primary_masks;

  Hybrid<uint2> secondary_masks;

  AtomGraph *ag_pointer;
};
 
}
}
 
#endif