lbfgs.h

Go to the documentation of this file.

#ifndef LBFGS_H
#define LBFGS_H
 
#include <vector>
#include <tuple> 
#include <algorithm>
#include <cmath>
//#include "line_search.h"
#include "source_base/matrix.h"
#include "source_base/matrix3.h"
#include "source_cell/unitcell.h"
#include "source_esolver/esolver.h"
#include "source_esolver/esolver_ks.h"
 
class LBFGS
{
public:
    void allocate(const int _size);
 
    void relax_step(const ModuleBase::matrix _force,
                    UnitCell& ucell,
                    const double &etot);
 
private:
    //LineSearch l_search;
    double alpha;                           
    double maxstep;                         
    int size;                               
    int memory;                             
    double H0;                              
    int iteration;                          
    double energy;                          
    double alpha_k;                         
 
    ModuleESolver::ESolver* solver = nullptr;         
    std::vector<double> steplength;//the length of atoms displacement 
    std::vector<std::vector<double>> H;//Hessian matrix
    std::vector<double> force0;//force in previous step
    std::vector<ModuleBase::Vector3<double>> force;
    std::vector<double> pos0;//atom pos in previous step(cartesian coordinates)
    std::vector<ModuleBase::Vector3<double>> pos;
    std::vector<double> pos_taud0;//atom pos in previous step(relative coordinates)
    std::vector<ModuleBase::Vector3<double>> pos_taud;
    std::vector<ModuleBase::Vector3<double>> dpos;
    std::vector<std::vector<double>> s;     
    std::vector<std::vector<double>> y;     
    std::vector<double> rho;                
 
    void prepare_step(std::vector<ModuleBase::Vector3<double>>& force,
                      std::vector<ModuleBase::Vector3<double>>& pos,
                      std::vector<std::vector<double>>& H,
                      std::vector<double>& pos0,
                      std::vector<double>& force0,
                      std::vector<ModuleBase::Vector3<double>>& dpos,
                      UnitCell& ucell,
                      const double &etot);
 
    void is_restrain();
 
    void calculate_largest_grad(const ModuleBase::matrix& _force,
                                UnitCell& ucell);
 
    void get_pos(UnitCell& ucell,
                 std::vector<ModuleBase::Vector3<double>>& pos);
 
    void get_pos_taud(UnitCell& ucell,
                      std::vector<ModuleBase::Vector3<double>>& pos_taud);
 
    void update(std::vector<ModuleBase::Vector3<double>>& pos_taud, 
                std::vector<double>& pos_taud0, 
                std::vector<double>& force,
                std::vector<double>& force0, 
                UnitCell& ucell,
                int iteration,
                int memory,
                std::vector<std::vector<double>>& s,
                std::vector<std::vector<double>>& y,
                std::vector<double>& rho);
 
    void determine_step(std::vector<double>& steplength,
                       std::vector<ModuleBase::Vector3<double>>& dpos,
                       double& maxstep);
 
    void update_pos(UnitCell& ucell);  
};
 
#endif