rmsd_plan.h

// -*-c++-*-
#ifndef STORMM_RMSD_PLAN_H
#define STORMM_RMSD_PLAN_H
 
#include <vector>
#include "copyright.h"
#include "Accelerator/hybrid.h"
#include "Accelerator/gpu_details.h"
#include "Chemistry/atom_equivalence.h"
#include "Synthesis/phasespace_synthesis.h"
#include "Synthesis/synthesis_cache_map.h"
#include "Synthesis/synthesis_enumerators.h"
#include "Synthesis/systemcache.h"
#include "Topology/atomgraph.h"
#include "Topology/atomgraph_abstracts.h"
#include "Trajectory/coordinateframe.h"
#include "Trajectory/coordinate_series.h"
#include "structure_enumerators.h"
 
namespace stormm {
namespace structure {
 
using card::GpuDetails;
using card::Hybrid;
using card::HybridTargetLevel;
using chemistry::AtomEquivalence;
using synthesis::PhaseSpaceSynthesis;
using synthesis::PsSynthesisReader;
using synthesis::SynthesisCacheMap;
using synthesis::SystemCache;
using synthesis::SystemGrouping;
using topology::AtomGraph;
using topology::ChemicalDetailsKit;
using trajectory::CoordinateFrame;
using trajectory::CoordinateSeries;

constexpr double default_required_mass_fraction = 0.75;

template <typename T> struct RMSDPlanReader {

  RMSDPlanReader(int plan_count_in, RMSDMethod strategy_in, double mass_fraction_in,
                 const T* masses_in, const int* atom_counts_in, const int* atom_starts_in,
                 const int* alignment_steps_in, const int* core_atoms_in,
                 const int* core_counts_in, const int* core_starts_in, const int* symm_atoms_in,
                 const int4* symm_bounds_in, const int2* symm_ranges_in);
  
  RMSDPlanReader(const RMSDPlanReader &original);
  RMSDPlanReader(RMSDPlanReader &&original);
 
  const int plan_count;        
  const RMSDMethod strategy;   
  const double mass_fraction;  
  const T* masses;             
  const int* atom_counts;      
  const int* atom_starts;      
  const int* alignment_steps;  
  const int* core_atoms;       
  const int* core_counts;      
  const int* core_starts;      
  const int* symm_atoms;       
  const int4* symm_bounds;     
  const int2* symm_ranges;     
};
  
class RMSDPlan {
public:

  RMSDPlan(RMSDMethod strategy_in = RMSDMethod::ALIGN_MASS,
           double rmf_in = default_required_mass_fraction,
           const PhaseSpaceSynthesis *poly_ps_in = nullptr, const SystemCache *sc_in = nullptr,
           const SynthesisCacheMap *scmap_in = nullptr);
 
  RMSDPlan(const AtomGraph &ag_in, const CoordinateFrame &cf_in,
           RMSDMethod strategy_in = RMSDMethod::ALIGN_MASS,
           double rmf_in = default_required_mass_fraction, const GpuDetails &gpu = null_gpu,
           int low_mol_idx = 0, int high_mol_idx = -1);
 
  RMSDPlan(const AtomEquivalence &eq_in, RMSDMethod strategy_in = RMSDMethod::ALIGN_MASS,
           double rmf_in = default_required_mass_fraction, const GpuDetails &gpu = null_gpu);
  
  RMSDPlan(const PhaseSpaceSynthesis *poly_ps_in, RMSDMethod strategy_in = RMSDMethod::ALIGN_MASS,
           double rmf_in = default_required_mass_fraction, const GpuDetails &gpu = null_gpu,
           int low_mol_idx = 0, int high_mol_idx = -1);
 
  RMSDPlan(const PhaseSpaceSynthesis *poly_ps_in, const std::vector<AtomEquivalence> &eq_list_in,
           RMSDMethod strategy_in = RMSDMethod::ALIGN_MASS,
           double rmf_in = default_required_mass_fraction, const GpuDetails &gpu = null_gpu);
 
  RMSDPlan(const PhaseSpaceSynthesis &poly_ps_in, RMSDMethod strategy_in = RMSDMethod::ALIGN_MASS,
           double rmf_in = default_required_mass_fraction, const GpuDetails &gpu = null_gpu,
           int low_mol_idx = 0, int high_mol_idx = -1);
 
  RMSDPlan(const PhaseSpaceSynthesis &poly_ps_in, const std::vector<AtomEquivalence> &eq_list_in,
           RMSDMethod strategy_in = RMSDMethod::ALIGN_MASS,
           double rmf_in = default_required_mass_fraction, const GpuDetails &gpu = null_gpu);
 
  RMSDPlan(const PhaseSpaceSynthesis *poly_ps_in, const SystemCache *sc_in,
           const SynthesisCacheMap *scmap_in,
           const RMSDMethod strategy_in = RMSDMethod::ALIGN_MASS,
           const double rmf_in = default_required_mass_fraction, const GpuDetails &gpu = null_gpu,
           const int low_mol_idx = 0, const int high_mol_idx = -1);
 
  RMSDPlan(const PhaseSpaceSynthesis &poly_ps_in, const SystemCache &sc_in,
           const SynthesisCacheMap &scmap_in,
           const RMSDMethod strategy_in = RMSDMethod::ALIGN_MASS,
           const double rmf_in = default_required_mass_fraction, const GpuDetails &gpu = null_gpu,
           const int low_mol_idx = 0, const int high_mol_idx = -1);

  RMSDPlan(const RMSDPlan &original) = default;
  RMSDPlan(RMSDPlan &&original) = default;
  RMSDPlan& operator=(const RMSDPlan &original) = default;
  RMSDPlan& operator=(RMSDPlan &&original) = default;
  
  int getPlanCount() const;

  int getPlanIndex(int index, SystemGrouping organization) const;
  
  RMSDMethod getGeneralStrategy() const;

  double getRequiredMassFraction() const;

  const AtomGraph* getTopologyPointer(int plan_index) const;

  RMSDAlignmentProtocol getAlignmentProtocol(int plan_index) const;

  const RMSDPlanReader<double> dpData(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  const RMSDPlanReader<float> spData(HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  const PhaseSpaceSynthesis* getCoordinateSynthesisPointer() const;

  const SystemCache* getCachePointer() const;

  const SynthesisCacheMap* getSynthesisMapPointer() const;
 
#ifdef STORMM_USE_HPC
  void upload();

  void download();
#endif

  void addSystemCache(const SystemCache *sc, const SynthesisCacheMap *scmap);
  void addSystemCache(const SystemCache &sc, const SynthesisCacheMap &scmap);
  
private:
  
  int plan_count;
 
  // Additional directives and arrays pertinent to each individual plan
  RMSDMethod general_strategy;         
  double required_mass_fraction;       
  Hybrid<double> masses;               
  Hybrid<float> sp_masses;             
  Hybrid<int> atom_counts;             
  Hybrid<int> atom_starts;             
  Hybrid<int> asymmetric_core_atoms;   
  Hybrid<int> asymmetric_core_counts;  
  Hybrid<int> asymmetric_core_starts;  
  Hybrid<int> symmetry_group_atoms;    
  Hybrid<int4> symmetry_group_bounds;  
  Hybrid<int> alignment_steps;         
  Hybrid<int2> symmetry_group_ranges;  

  Hybrid<int> alignment_prerequisites;

  Hybrid<int> alignment_protocols;

  Hybrid<int> symmetry_depth;

  Hybrid<int2> symmetry_group_membership;

  Hybrid<ullint> symmetry_group_membership_bounds;
  
  std::vector<AtomGraph*> ag_pointers; 

  PhaseSpaceSynthesis *poly_ps_ptr;

  SystemCache *sc_ptr;

  SynthesisCacheMap *scmap_ptr;

  void chartSymmetryGroups(const std::vector<AtomEquivalence> &eq_tables);
  
  void writeSymmetryGroupCodes();
};
 
} // namespace structure
} // namespace stormm
 
#include "rmsd_plan.tpp"
 
#endif