Add eigen dependency

.github/workflows/sonarcloud.yml

@@ -37,6 +37,8 @@ jobs:
           curl -sSLo $HOME/.sonar/build-wrapper-linux-x86.zip ${{ env.BUILD_WRAPPER_DOWNLOAD_URL }}
           unzip -o $HOME/.sonar/build-wrapper-linux-x86.zip -d $HOME/.sonar/
           echo "$HOME/.sonar/build-wrapper-linux-x86" >> $GITHUB_PATH
+      - name: Install eigen
+        run: sudo apt-get install -y libeigen3-dev
       - name: Run build-wrapper
         run: |
           mkdir build

.travis.yml

@@ -4,6 +4,7 @@ dist: xenial
 addons:
   apt:
     update: true
+    packages: libeigen3-dev
 
 language: cpp
 
@@ -17,6 +18,7 @@ jobs:
       compiler: gcc
       script: ./scripts/deploy.bash
       apt:
+        packages: libeigen3-dev
         packages: gcov
         packages: lcov
 

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 2.8)
+cmake_minimum_required (VERSION 3.12)
 project (calc_J)
 
 ##############################################################################
@@ -12,8 +12,8 @@ option(CODE_COVERAGE "Enable coverage reporting" OFF)
 ##############################################################################
 # Defining settings 
 ##############################################################################
-set(calcJ_VERSION_MAJOR 1 )
-set(calcJ_VERSION_MINOR 9 )
+set(calcJ_VERSION_MAJOR 2 )
+set(calcJ_VERSION_MINOR 0 )
 set(calcJ_YEAR_PUBLISHED 2018 )
 set(calcJ_AUTHOR_SURNAME "\"Brown\"" )
 set(calcJ_AUTHOR_INITIALS "\"J. S.\"" )
@@ -42,6 +42,10 @@ configure_file(
 # Find bash it is important for testing using scripts
 find_program (BASH_PROGRAM bash)
 find_library (GCOV gcov)
+#find_package (Eigen3 3.3 REQUIRED NO_MODULE)
+#if (TARGET Eigen3::Eigen)
+#  message("-- Eigen found")
+#endif(TARGET Eigen3::Eigen)
 add_definitions(-DLOG_LEVEL=${LOG_LEVEL})
 
 ##############################################################################

src/libcatnip/io/file_readers/filereader.cpp

@@ -24,8 +24,6 @@ void FileReader::read() {
   close();
 }
 
-// Private member functions
-
 void FileReader::open() {
   if (!fileExist_()) {
     throw invalid_argument("File " + fileName_ + " does not exist.");
@@ -39,6 +37,7 @@ void FileReader::close() {
   fileOpen_ = false;
 }
 
+// Private member functions
 void FileReader::registerSections_() { checkSections_(); }
 
 // Basically check that for a given tag both a section reader

src/libcatnip/io/file_readers/filereader.hpp

@@ -1,4 +1,4 @@
-
+#pragma once
 #ifndef _CATNIP_FILEREADER_HPP_
 #define _CATNIP_FILEREADER_HPP_
 

src/libcatnip/io/file_readers/logreader.cpp

@@ -7,6 +7,7 @@
 #include <sstream>
 #include <string>
 
+#include <eigen3/Eigen/Core>
 #include "../../log.hpp"
 #include "../../string_support.hpp"
 #include "logreader.hpp"
@@ -126,6 +127,7 @@ void LogReader::AOFunctionSectionReader(void *ptr) {
     while (!iss.eof()) {
       string Tot_Alpha_Beta_Spin;
       iss >> Tot_Alpha_Beta_Spin;
+      trim(Tot_Alpha_Beta_Spin);
       orbVals.push_back(stod(Tot_Alpha_Beta_Spin));
     }
     LR_ptr->orb_[make_pair(atom_num, elemType)][orbType] = orbVals;
@@ -165,7 +167,6 @@ void LogReader::AOFunctionSectionReader(void *ptr) {
     }
 
     ++atom_num;
-    // getline(LR_ptr->fid_,line);
     if (foundSubStrInStr(line, end_pattern)) {
       sectionEnd = true;
     }
@@ -194,9 +195,12 @@ void LogReader::OverlapSectionReader(void *ptr) {
     getline(LR_ptr->fid_, line);
     istringstream iss(line);
     iss >> countC;
+    if( line.find("Kinetic")!=string::npos){
+      break;
+    }
     int countCint = stoi(countC);
     if (countCint != (countCoef + 1)) {
-      endFirstSection = true;
+      break;
     } else {
       ++countCoef;
       vector<double> row;
@@ -214,20 +218,14 @@ void LogReader::OverlapSectionReader(void *ptr) {
   }
 
   // Create a matrix and place all the current values in there
-  Matrix *mat_S = new Matrix(countCoef, countCoef);
+
+  Eigen::MatrixXd matrix_S(countCoef,countCoef);
+
   for (size_t row_ind = 0; row_ind < first_coefs.size(); ++row_ind) {
-    vector<double> row = first_coefs.at(row_ind);
-    size_t col_ind = 1;
-    for (auto val : row) {
-      mat_S->set_elem(val, row_ind + 1, col_ind);
-      // Because diagonally symetric
-      if (row_ind + 1 != col_ind) {
-        mat_S->set_elem(val, col_ind, row_ind + 1);
-      }
-      ++col_ind;
-    }
+    Eigen::Map<Eigen::RowVectorXd> eigen_row((first_coefs.at(row_ind).data()),first_coefs.at(row_ind).size());
+    matrix_S.block(row_ind,0,1,eigen_row.size()) = eigen_row;
+    matrix_S.block(0,row_ind,eigen_row.size(),1) = eigen_row.transpose();
   }
-
   int sectionReads = countCoef / 5;
   if (countCoef % 5 > 0) {
     ++sectionReads;
@@ -243,19 +241,16 @@ void LogReader::OverlapSectionReader(void *ptr) {
       istringstream iss(line);
       string dummy;
       iss >> dummy;
-      int localCoefCount = 1;
+      int localCoefCount = 0;
       while (!iss.eof()) {
         string s_coef;
         iss >> s_coef;
         string val = grabStrBeforeFirstOccurance(s_coef, "D");
         string expon = grabStrAfterFirstOccurance(s_coef, "D");
         double value = stod(val) * pow(10.0, stod(expon));
-        mat_S->set_elem(value, sectionCoef + 1,
-                        currentSectionStart + localCoefCount);
-        if ((sectionCoef + 1) != (currentSectionStart + localCoefCount)) {
-
-          mat_S->set_elem(value, currentSectionStart + localCoefCount,
-                          sectionCoef + 1);
+        matrix_S(sectionCoef,currentSectionStart + localCoefCount) = value;
+        if ((sectionCoef) != (currentSectionStart + localCoefCount)) {
+          matrix_S(currentSectionStart + localCoefCount,sectionCoef) = value;
         }
         ++localCoefCount;
       }
@@ -265,7 +260,8 @@ void LogReader::OverlapSectionReader(void *ptr) {
     currentSectionStart += 5;
     getline(LR_ptr->fid_, line);
   }
-  LR_ptr->S_ = mat_S;
+
+  LR_ptr->S_ = matrix_S;
   LOG("Success reading Overlap coefficients from .log file", 2);
   return;
 }
@@ -291,7 +287,7 @@ void LogReader::ReadOrbEnergies(const string &orb_type) {
 
       auto vec_str = splitStEnergies(line);
       for (size_t inc = 4; inc < vec_str.size(); inc++) {
-        OREnergies[orb_type].push_back((double)atof(vec_str.at(inc).c_str()));
+        OREnergies[orb_type].push_back(stod(vec_str.at(inc)));
         if (occFound) homoLevel[orb_type]++;
       }
     } else {

src/libcatnip/io/file_readers/logreader.hpp

@@ -1,11 +1,14 @@
-
+#pragma once
 #ifndef _CATNIP_LOGREADER_HPP_
 #define _CATNIP_LOGREADER_HPP_
 
+#include <map>
+#include <string>
 #include <vector>
 
-#include "../../matrix.hpp"
 #include "filereader.hpp"
+
+#include <eigen3/Eigen/Core>
 // Gaussian log file reader
 
 namespace catnip {
@@ -18,9 +21,9 @@ class LogReader : public FileReader {
  public:
   explicit LogReader(const std::string &str);
   orb_cont getOrbitalInfo() const { return orb_; }
-  Matrix *getOverlapMatrix() const { return S_; }
-  std::vector<double> getOE(const std::string &orb_type) const {
-    return OREnergies.at(orb_type);
+  Eigen::MatrixXd getOverlapMatrix() const { return S_; }
+  Eigen::VectorXd getOE(const std::string &orb_type) {
+    return Eigen::Map<Eigen::VectorXd>(OREnergies.at(orb_type).data(),OREnergies.at(orb_type).size());
   }
   int getHOMOLevel(const std::string &orb_type) const {
     return homoLevel.at(orb_type);
@@ -48,7 +51,8 @@ class LogReader : public FileReader {
   std::map<std::string, int> homoLevel;
   orb_cont orb_;
   // Overlap matrix
-  Matrix *S_;
+  //Matrix *S_;
+  Eigen::MatrixXd S_;
   std::map<std::string, std::vector<double>> OREnergies;
 
   std::vector<std::vector<double>> xyz;

src/libcatnip/io/file_readers/punreader.cpp

@@ -4,13 +4,16 @@
 #include <fstream>
 #include <iostream>
 #include <map>
+#include <memory>
 #include <sstream>
 #include <string>
 
 #include "../../log.hpp"
 #include "../../string_support.hpp"
 #include "punreader.hpp"
 
+#include <eigen3/Eigen/Core>
+
 using namespace catnip;
 using namespace std;
 
@@ -29,12 +32,12 @@ void PunReader::registerSections_() {
   FileReader::registerSections_();
 }
 
-Matrix *PunReader::getCoefsMatrix(const string &orb_type) {
+Eigen::MatrixXd PunReader::getCoefsMatrix(const string &orb_type) {
   if (coefs.count(orb_type) != 1) {
     throw invalid_argument("Coefficients for spin " + orb_type +
                            " were not found");
   }
-  return coefs[orb_type];
+  return *(coefs[orb_type]);
 }
 
 void PunReader::validFileName_() {
@@ -93,8 +96,12 @@ void PunReader::ReadCoef(const string &orb_type) {
     allCoefsRead = !(foundSubStrInStr(line, orb_type));
   }
 
-  Matrix *Coefs = new Matrix(v_vec);
-  coefs[orb_type] = Coefs;
+  coefs[orb_type] = unique_ptr<Eigen::MatrixXd>(new Eigen::MatrixXd(v_vec.size(),v_vec.at(0).size()));
+  for( size_t row_ind=0; row_ind<v_vec.size();++row_ind){
+    Eigen::Map<Eigen::VectorXd> eigen_vec(v_vec.at(row_ind).data(),v_vec.at(row_ind).size());
+    coefs[orb_type]->row(row_ind) = eigen_vec;
+  }
+
   LOG("Success reading atomic orbital coefficients from .pun file.", 2);
 }
 

src/libcatnip/io/file_readers/punreader.hpp

@@ -1,18 +1,19 @@
-
+#pragma once
 #ifndef _CATNIP_PUNREADER_HPP_
 #define _CATNIP_PUNREADER_HPP_
 
+#include <memory>
 #include <vector>
 
-#include "../../matrix.hpp"
 #include "filereader.hpp"
+#include <eigen3/Eigen/Dense>
 // Gaussian fort.7/.pun file reader
 namespace catnip {
 
 class PunReader : public FileReader {
  public:
   explicit PunReader(const std::string &str);
-  Matrix *getCoefsMatrix(const std::string &orb_type);
+  Eigen::MatrixXd getCoefsMatrix(const std::string &orb_type);
   bool restrictedShell() { return coefs.size() == 1; }
 
  private:
@@ -25,7 +26,7 @@ class PunReader : public FileReader {
   void ReadCoef(const std::string &orb_type);
   std::vector<double> readGausCoefLine(const std::string &line);
 
-  std::map<std::string, Matrix *> coefs;
+  std::map<std::string, std::unique_ptr<Eigen::MatrixXd>> coefs;
 };
 
 }  // namespace catnip

src/libcatnip/io/io.cpp

@@ -167,6 +167,12 @@ unique_ptr<ArgumentParser> prepareParser(void) {
   desc = "Print the version";
   flag18.push_back(desc);
 
+  vector<string> flag19;
+  flag19.push_back("--all");
+  flag19.push_back("-a");
+  desc = "Print all transfer integrals, in matrix form";
+  flag19.push_back(desc);
+
   set<vector<string>> flags;
   flags.insert(flag1);
   flags.insert(flag2);
@@ -184,6 +190,7 @@ unique_ptr<ArgumentParser> prepareParser(void) {
   flags.insert(flag16);
   flags.insert(flag17);
   flags.insert(flag18);
+  flags.insert(flag19);
 
   unique_ptr<ArgumentParser> ArgPars(new ArgumentParser(flags));
 
@@ -303,6 +310,15 @@ unique_ptr<ArgumentParser> prepareParser(void) {
     ArgPars->setFlagDefaultValue("--counter_poise", "OFF");
   }
 
+  // Set argument for allowing printing of all transfer integrals
+  {
+    ArgPars->setFlagArgOpt("--all", "ARGUMENT_SWITCH",
+        "PROPERTY_SWITCH", "DEFAULT", "OFF");
+
+    // By default the flag counter poise is turned off
+    ArgPars->setFlagDefaultValue("--all", "OFF");
+  }
+
   {
     ArgPars->setFlagArgOpt("--citation", "ARGUMENT_SWITCH", "PROPERTY_SWITCH",
                            "DEFAULT", "OFF");
@@ -424,6 +440,7 @@ unique_ptr<Parameters> prepareParameters(unique_ptr<ArgumentParser>& ArgParse) {
 
   // Determine if we are doing a counterpoise calculation
   Par->setCounterPoise(ArgParse->getInt("--counter_poise"));
+  Par->setPrintSwitch(ArgParse->getInt("--all"));
   Par->setCitation(ArgParse->getInt("--citation"));
   // Read Orbital related flags
   {

src/libcatnip/io/io.hpp

@@ -1,6 +1,5 @@
 #ifndef _CATNIP_IO_HPP
 #define _CATNIP_IO_HPP
-#include "../matrix.hpp"
 #include "../parameters.hpp"
 #include "argumentparser.hpp"
 #include <map>