line_minimization.h

// -*-c++-*-
#ifndef STORMM_LINE_MINIMIZATION_H
#define STORMM_LINE_MINIMIZATION_H
 
#include "copyright.h"
#include "Accelerator/hybrid.h"
 
namespace stormm {
namespace mm {
 
using card::Hybrid;
using card::HybridTargetLevel;

struct LinMinWriter {

  LinMinWriter(const int nsys_in, double* l_move_in, double* s_move_in, double* mfac_a_in,
               double* mfac_b_in, double* mfac_c_in, double* nrg_a_in, double* nrg_b_in,
               double* nrg_c_in, double* nrg_d_in);

  LinMinWriter(const LinMinWriter &original) = default;
  LinMinWriter(LinMinWriter &&original) = default;
  
  // Member variables
  const int nsys;  
  double* l_move;  
  double* s_move;  
  double* mfac_a;  
  double* mfac_b;  
  double* mfac_c;  
  double* nrg_a;   
  double* nrg_b;   
  double* nrg_c;   
  double* nrg_d;   
};

struct LinMinReader {

  LinMinReader(const int nsys_in, const double* l_move_in, const double* s_move_in,
               const double* mfac_a_in, const double* mfac_b_in, const double* mfac_c_in,
               const double* nrg_a_in, const double* nrg_b_in, const double* nrg_c_in,
               const double* nrg_d_in);

  LinMinReader(const LinMinReader &original) = default;
  LinMinReader(LinMinReader &&original) = default;
  
  // Member variables
  const int nsys;  
  const double* l_move;  
  const double* s_move;  
  const double* mfac_a;  
  const double* mfac_b;  
  const double* mfac_c;  
  const double* nrg_a;   
  const double* nrg_b;   
  const double* nrg_c;   
  const double* nrg_d;   
};

class LineMinimization {
public:

  LineMinimization(int system_count_in = 0, double dx0 = 0.0);

  LineMinimization(const LineMinimization &original);
  LineMinimization& operator=(const LineMinimization &other);
  LineMinimization(LineMinimization &&original) = default;
  LineMinimization& operator=(LineMinimization &&other) = default;
  
  int getSystemCount() const;

  std::vector<double> getMoveLength(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  double getMoveLength(int system_index,
                       HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  std::vector<double> getMoveFactor(int move_index,
                                    HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  double getMoveFactor(int move_index, int system_index,
                       HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  

  std::vector<double> getEnergy(int move_index,
                                HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  double getEnergy(int move_index, int system_index,
                   HybridTargetLevel tier = HybridTargetLevel::HOST) const;

  LinMinReader data(HybridTargetLevel tier = HybridTargetLevel::HOST) const;
  LinMinWriter data(HybridTargetLevel tier = HybridTargetLevel::HOST);

  void primeMoveLengths(double dx0);
 
#ifdef STORMM_USE_HPC
  void upload();

  void download();
#endif
 
private:
  int system_count;             
  Hybrid<double> move_length;   
  Hybrid<double> save_length;   
  Hybrid<double> move_factor_a; 
  Hybrid<double> move_factor_b; 
  Hybrid<double> move_factor_c; 
  Hybrid<double> energy_a;      
  Hybrid<double> energy_b;      
  Hybrid<double> energy_c;      
  Hybrid<double> energy_d;      
  Hybrid<double> storage;       
};
 
} // namespace mm
} // namespace stormm
 
#endif