WIP: Refactor

.gitignore

@@ -50,3 +50,6 @@ lib/
 
 #clang
 clang.sh
+
+#visual studio
+.vscode

.travis.yml

@@ -1,9 +1,17 @@
-sudo: true
+sudo: false
 
 language: cpp
-
-os:
-  - linux
+
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - cmake
+      - libblas-dev
+      - liblapack-dev
+      - gfortran-7
+      - libopenmpi-dev
 
 dist: bionic
 
@@ -16,7 +24,14 @@ branches:
 before_install:
   - sudo add-apt-repository ppa:ubuntu-toolchain-r/test -y
   - sudo apt-get update -q
-  - sudo apt-get install cmake libblas-dev liblapack-dev libopenmpi-dev
+  # Install elemental
+  - git clone --branch master git://github.com/elemental/Elemental.git ${HOME}/elemental
+  - ls /usr/lib/gcc/x86_64-linux-gnu/7
+  - |
+    cd ${HOME}/elemental && 
+    cmake -H. -Bbuild -DCMAKE_INSTALL_PREFIX=${HOME}/local -DCMAKE_Fortran_COMPILER=/usr/bin/gfortran-7 -DGFORTRAN_LIB=/usr/lib/gcc/x86_64-linux-gnu/7 -DEL_C_INTERFACE=OFF -DEL_BUILT_OPENBLAS=OFF && 
+    cmake --build build --target install 
 script:
   - cmake -H. -Bbuild
   - cmake --build build
+  - ctest --output-on-failure

CMakeLists.txt

@@ -20,7 +20,11 @@ endif(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CXX_FLAGS)
 ###############################################################################
 # User input options
 ###############################################################################
-option(ENABLE_TESTING "Build and enable tests" OFF)
+option(ENABLE_TESTING "Build and enable tests" ON)
+if(ENABLE_TESTING)
+  enable_testing()
+  find_package(Boost REQUIRED COMPONENTS unit_test_framework)
+endif(ENABLE_TESTING)
 
 ###############################################################################
 # Dependencies

README.md

@@ -0,0 +1,60 @@
+Davidson Eigensolver
+===================
+This package contains a C++ implementation of the *Davidson diagonalization algorithms*.
+Different schemas are available to compute the correction.
+
+Available correction methods are:
+ * **davidson**: Diagonal-Preconditioned-Residue
+ * **jacobi**: Generalized Jacobi Davidson
+
+ ### Note:
+The Davidson method is suitable for **diagonal-dominant symmetric matrices**, that are quite common
+in certain scientific problems like [electronic structure](https://en.wikipedia.org/wiki/Electronic_structure). The Davidson method could be not practical
+for other kind of symmetric matrices.i
+
+Usage
+-----
+The following program calls the `solve` *subroutine* from the `davidson` module and computes
+the lowest eigenvalue and corresponding eigenvector, using the *jacobi* correction method with a tolerance of `1e-8`.
+```C++
+eigenSolver<real> solver;
+solver.solverOptions.numberOfEigenValues = numEig;
+solver.solverOptions.tolerence = 1e-8;
+solver.solverOptions.solver = "jacobi";
+solver.solverOptions.sizeOfTheMatrix = A.Height();
+solver.solve(A, grid);
+```
+
+The helper  `generateDDHermitianMatrix` function generates a diagonal dominant matrix.
+
+**Variables**:
+ * `A` (*in*) matrix to diagonalize
+ * `solver.eigenValues` (*out*) resulting eigenvalues
+ * `solver.eigenVectorsFull` (*out*) resulting eigenvectors
+ * `solver.SolverOptions.solver`(*in*) Either "davidson" or "jacobi"
+ * `solver.solverOptions.tolerance`(*in*) Numerical tolerance for convergence
+
+### References:
+ * [Davidson diagonalization method and its applications to electronic structure calculations](https://www.semanticscholar.org/paper/DAVIDSON-DIAGONALIZATION-METHOD-AND-ITS-APPLICATION-Liao/5811eaf768d1a006f505dfe24f329874a679ba59)
+ * [Numerical Methods for Large Eigenvalue Problem](https://doi.org/10.1137/1.9781611970739)
+
+Installation and Testing
+------------------------
+
+To compile execute:
+```
+cmake -H. -Bbuild && cmake --build build
+```
+
+To run the test:
+```
+cmake -H. -Bbuild -DENABLE_TEST=ON && cmake --build build
+cd build && ctest -V
+```
+
+Dependencies
+------------
+This packages assumes that you have installed the following packages:
+ * A C++ compiler >=  C++ 14
+ * [CMake](https://cmake.org/)
+ * [Elemental] (https://github.com/elemental/Elemental)

clang.sh

@@ -1,2 +1,3 @@
-clang-format -i src/*.cpp
+clang-format -i src/*.cc
+clang-format -i src/tests/*.cc
 clang-format -i include/*.hpp

include/eigenValueSolver.hpp

@@ -21,71 +21,81 @@
 
 namespace eigenValueSolver {
 
-template <typename real> class eigenSolver {
+template <typename real>
+class eigenSolver {
 
-public:
-  /**
-   * Groups all the options for the solvers
-   */
+ public:
+  // Groups all the options for the solvers
   struct options {
-    std::string solver = "davidson"; // either davidson or jacobi
-    real tolerence = 1e-8;           /** tolerence for convergence*/
-    int numberOfEigenValues = 1; /** number of eigen values to be calculated*/
-    int sizeOfTheMatrix = 100;   /**Size of the input matrix*/
+    // Type of solver used - either "davidson" or "jacobi"
+    std::string solver = "davidson";
+
+    // Tolerence criterion for convergence
+    real tolerence = 1e-8;
+
+    // The number of eigen values to be calculated
+    int numberOfEigenValues = 1;
+
+    // Size of the input matrix
+    int sizeOfTheMatrix = 100;
   };
 
+  // MEMBER VARIABLES
+
+  // Eigenvector matrix of the reduced problem
+  El::DistMatrix<real> eigenVectors;
+
+  // ritzVectors i.e. eigen vectors of the full matrix
+  El::DistMatrix<real> ritzVectors;
+
+  // Eigenvalues
+  El::DistMatrix<real, El::VR, El::STAR> eigenValues;
+
+  // The guess eigenspace
+  El::DistMatrix<real> V;
+
+  // A*V
+  El::DistMatrix<real> AV;
+
+  // The guess eigenspace per iteration
+  El::DistMatrix<real> Vsub;
+
+  // The correction vector
+  El::DistMatrix<real> correctionVector;
+
+  // The residual
+  El::DistMatrix<real> residual;
+
+  // Instance of the options struct
   options solverOptions;
-  /**
-   * This function computes the eigen value-vector pairs for the input matrix
-   */
-  void solve(El::DistMatrix<real> &, El::Grid &);
-
-private:
-  int columnsOfSearchSpace = solverOptions.numberOfEigenValues *
-                             2; /**The columns of the search space*/
-  /*************Initialise all the matrices necessary**************/
-  El::DistMatrix<real> searchSpace;      /**Matrix that holds the search space*/
-  El::DistMatrix<real> searchSpacesub;   /**Matrix that holds the search space*/
-  El::DistMatrix<real> correctionVector; /**a matrix that holds the k guess
-                                            eigen vectors each of size nx1*/
-  El::DistMatrix<real>
-      eigenVectors; /**s stores the current eigenvector matrix*/
-  El::DistMatrix<real, El::VR, El::STAR>
-      eigenValues; /**vector of eigen values*/
-  El::DistMatrix<real, El::VR, El::STAR>
-      eigenValues_old; /**vector of eigen values*/
+
+  // MEMBER FUNCTIONS
+  // This function computes the eigen value-vector pairs for the input matrix
+  void solve(const El::DistMatrix<real> &, El::Grid &);
+
+ private:
+  // The size of the search space
+  real sizeOfSearchSpace;
 
   // Range to loop over just the required number of eigenvalues in theta
   El::Range<int> begTheta;
   El::Range<int> endTheta;
-  // El::Range<int> begTheta{0, solverOptions.numberOfEigenValues};
-  // El::Range<int> endTheta{0, 1};
-
-  /**
-   * This function initialises all the required matrices
-   */
-  void initialise(El::Grid &);
-
-  /**
-   *Calculates the residual
-   */
-  void calculateResidual();
-
-  /**
-   *Calculates the correction vector
-   */
-  void calculateCorrectionVector();
-
-  /**
-   *Expands the search space with the correction vector
-   */
-  void expandSearchSpace(int, El::DistMatrix<real> &, El::Grid &);
-
-  /**
-   * solve the subspace problem i.e. VTAV and eigenvalue/vectors
-   */
-  void subspaceProblem(int, El::DistMatrix<real> &, El::Grid &);
+
+  // This function initialises all the required matrices
+  void initialise(El::Grid &, const El::DistMatrix<real> &);
+
+  // Calculates the residual
+  bool calculateResidual(int, El::Grid &);
+
+  // Calculates the correction vector
+  void calculateCorrectionVector(int, const El::DistMatrix<real> &, El::Grid &);
+
+  // Expands the search space with the correction vector
+  void expandSearchSpace(int &, const El::DistMatrix<real> &, El::Grid &);
+
+  // Solve the subspace problem i.e. VTAV and eigenvalue/vectors
+  void subspaceProblem(int, const El::DistMatrix<real> &, El::Grid &);
 };
-} // namespace eigenValueSolver
+}  // namespace eigenValueSolver
 
 #endif /* eigenValueSolver_h */

src/CMakeLists.txt

@@ -1,5 +1,5 @@
-add_library(eigenValueSolver eigenValueSolver.cpp)
-add_executable(main main.cpp utils.cpp )
+add_library(eigenValueSolver eigenValueSolver.cc utils.cc)
+add_executable(main main.cc)
 
 target_include_directories(eigenValueSolver
   PUBLIC
@@ -13,3 +13,7 @@ target_link_libraries(eigenValueSolver
 target_link_libraries(main
   PUBLIC
   eigenValueSolver)
+
+if (ENABLE_TESTING)
+  add_subdirectory(tests)
+endif()