Fix several compiler warnings

src/DMStrategyFactory.cc

@@ -36,14 +36,17 @@ DMStrategy<LocGridOrbitals>* DMStrategyFactory<LocGridOrbitals,
 template <>
 DMStrategy<LocGridOrbitals>* DMStrategyFactory<LocGridOrbitals,
     ReplicatedMatrix>::createHamiltonianMVP_DMStrategy(MPI_Comm comm,
-    std::ostream& os, Ions& ions, Rho<LocGridOrbitals>* rho,
-    Energy<LocGridOrbitals>* energy, Electrostatic* electrostat,
-    MGmol<LocGridOrbitals>* mgmol_strategy,
-    ProjectedMatricesInterface* /*proj_matrices*/, LocGridOrbitals* orbitals,
-    const bool short_sighted)
+    std::ostream& /*os*/, Ions& /*ions*/, Rho<LocGridOrbitals>* /*rho*/,
+    Energy<LocGridOrbitals>* /*energy*/, Electrostatic* /*electrostat*/,
+    MGmol<LocGridOrbitals>* /*mgmol_strategy*/,
+    ProjectedMatricesInterface* /*proj_matrices*/,
+    LocGridOrbitals* /*orbitals*/, const bool /*short_sighted*/)
 {
-    std::cerr << "Not implemented" << std::endl;
-    assert(0 == 1);
+
+    std::cerr << "DMStrategy not implemented" << std::endl;
+    MPI_Abort(comm, EXIT_FAILURE);
+
+    return nullptr;
 }
 
 template <>

src/DensityMatrix.cc

@@ -78,7 +78,7 @@ void DensityMatrix<MatrixType>::build(
 #endif
 
     // diagonal matrix with occ values in diagonal
-    MatrixType gamma("Gamma", &occ[0], dim_, dim_);
+    MatrixType gamma("Gamma", &occ[0], dim_);
     gamma.scal(orbital_occupation_); // rescale for spin
 
     // work_ = zmat*gamma with gamma symmetric
@@ -132,7 +132,7 @@ void DensityMatrix<MatrixType>::build()
         std::cout << "Warning: occupations not up to date to build DM!!!"
                   << std::endl;
 
-    MatrixType gamma("Gamma", &occupation_[0], dim_, dim_);
+    MatrixType gamma("Gamma", &occupation_[0], dim_);
     gamma.scal(orbital_occupation_); // rescale for spin
 
     *dm_ = gamma;

src/DistMatrix/DistMatrix.cc

@@ -2036,12 +2036,12 @@ DistMatrix<T>::DistMatrix(const std::string& name, const BlacsContext& bc,
 
 template <class T>
 DistMatrix<T>::DistMatrix(
-    const std::string& name, const T* const dmat, const int m, const int n)
+    const std::string& name, const T* const dmat, const int m)
     : object_name_(name),
       bc_(*default_bc_),
       comm_global_(default_bc_->comm_global())
 {
-    resize(m, n, distmatrix_def_block_size_, distmatrix_def_block_size_);
+    resize(m, m, distmatrix_def_block_size_, distmatrix_def_block_size_);
     setDiagonalValues(dmat);
 }
 

src/DistMatrix/DistMatrix.h

@@ -243,8 +243,7 @@ class DistMatrix
     // Construct a diagonal DistMatrix from a vector dmat of diagonal elements
     DistMatrix<T>(const std::string& name, const BlacsContext&,
         const T* const dmat, const int m, const int n);
-    DistMatrix<T>(
-        const std::string& name, const T* const dmat, const int m, const int n);
+    DistMatrix<T>(const std::string& name, const T* const dmat, const int m);
 
     DistMatrix<T>& operator=(const DistMatrix<T>& a);
     DistMatrix<T>& assign(const DistMatrix<T>&, const int, const int);

src/DistMatrix/DistMatrixTools.cc

@@ -120,7 +120,7 @@ void sqrtDistMatrix(dist_matrix::DistMatrix<DISTMATDTYPE>& u)
     {
         eigenvalues[i] = 1. / sqrt(eigenvalues[i]);
     }
-    dist_matrix::DistMatrix<DISTMATDTYPE> g("g", &eigenvalues[0], nst, nst);
+    dist_matrix::DistMatrix<DISTMATDTYPE> g("g", &eigenvalues[0], nst);
 
     // u = z * g * z**T
     w.symm('r', 'l', 1., g, z, 0.);

src/Energy.cc

@@ -60,9 +60,9 @@ double Energy<T>::getEVrhoRho() const
 template <class T>
 double Energy<T>::evaluateEnergyIonsInVext(Ions& ions)
 {
+#ifdef HAVE_TRICUBIC
     double energy = 0.;
 
-#ifdef HAVE_TRICUBIC
     if (!pot_.withVext()) return energy;
 
     //(*MPIdata::sout)<<"Energy<T>::evaluateEnergyIonsInVext()"<<std::endl;
@@ -86,6 +86,8 @@ double Energy<T>::evaluateEnergyIonsInVext(Ions& ions)
     std::vector<double> val(nions);
     pot_.getValVext(positions, val);
 
+    double energy = 0.;
+
     // loop over ions again
     ion           = ions.local_ions().begin();
     int ion_index = 0;
@@ -105,8 +107,13 @@ double Energy<T>::evaluateEnergyIonsInVext(Ions& ions)
     MGmol_MPI& mmpi = *(MGmol_MPI::instance());
     mmpi.allreduce(&energy, &tmp, 1, MPI_SUM);
     energy = tmp;
-#endif
+
     return energy;
+#else
+    (void)ions;
+
+    return 0.;
+#endif
 }
 
 template <class T>

src/ExtendedGridOrbitals.cc

@@ -72,7 +72,11 @@ ExtendedGridOrbitals::ExtendedGridOrbitals(std::string name,
     (void)local_cluster;
 
     // preconditions
+#ifndef NDEBUG
     assert(subdivx == 1);
+#else
+    (void)subdivx;
+#endif
     assert(proj_matrices != nullptr);
 
     for (short i = 0; i < 3; i++)

src/ExtendedGridOrbitals.h

@@ -261,7 +261,7 @@ class ExtendedGridOrbitals : public Orbitals
     }
     ORBDTYPE* getPsi(const int i, const int iloc = 0) const
     {
-        assert(iloc == 0);
+        (void)iloc;
         return block_vector_.vect(i);
     }
     template <typename T>

src/HDFrestart.cc

@@ -1655,13 +1655,13 @@ int HDFrestart::writeData(const T* const data, hid_t space_id, hid_t memspace,
 {
     if (precision == 1)
     {
-        assert(work_space_float_.size() == bsize_);
+        assert((int)work_space_float_.size() == bsize_);
         for (int i = 0; i < bsize_; i++)
             work_space_float_[i] = (float)data[i];
     }
     else
     {
-        assert(work_space_double_.size() == bsize_);
+        assert((int)work_space_double_.size() == bsize_);
         for (int i = 0; i < bsize_; i++)
             work_space_double_[i] = (double)data[i];
     }

src/Ions.cc

@@ -2766,7 +2766,7 @@ void Ions::gatherForces(std::vector<double>& forces, const int root) const
         const int index = ion->index();
         // std::cout << "index = " << index << std::endl;
         assert(index < num_ions_);
-        assert(forces.size() >= 3 * index);
+        assert((int)forces.size() >= 3 * index);
         assert(index < num_ions_);
         ion->getForce(&forces[3 * index]);
     }

src/NonOrthoDMStrategy.cc

@@ -21,7 +21,7 @@ NonOrthoDMStrategy<OrbitalsType>::NonOrthoDMStrategy(
 }
 
 template <class OrbitalsType>
-void NonOrthoDMStrategy<OrbitalsType>::initialize(OrbitalsType& orbitals)
+void NonOrthoDMStrategy<OrbitalsType>::initialize(OrbitalsType& /*orbitals*/)
 {
     Control& ct     = *(Control::instance());
     MGmol_MPI& mmpi = *(MGmol_MPI::instance());
@@ -35,7 +35,7 @@ void NonOrthoDMStrategy<OrbitalsType>::initialize(OrbitalsType& orbitals)
 }
 
 template <class OrbitalsType>
-int NonOrthoDMStrategy<OrbitalsType>::update(OrbitalsType& orbitals)
+int NonOrthoDMStrategy<OrbitalsType>::update(OrbitalsType& /*orbitals*/)
 {
     assert(proj_matrices_ != nullptr);
 

src/PowerGen.cc

@@ -46,10 +46,10 @@ void PowerGen<MatrixType, VectorType>::computeGenEigenInterval(MatrixType& mat,
 
     // initialize solution data
     // initial guess
-    VectorType sol("sol", m);
+    VectorType sol(m);
     sol = vec1_; // initialize local solution data
     // new solution
-    VectorType new_sol("new_sol", m);
+    VectorType new_sol(m);
 
     // get norm of initial sol
     double alpha = sol.nrm2();

src/ProjectedMatrices.cc

@@ -167,8 +167,8 @@ void ProjectedMatrices<ReplicatedMatrix>::convert(
 }
 
 template <>
-void ProjectedMatrices<dist_matrix::DistMatrix<DISTMATDTYPE>>::setupMPI(
-    const std::vector<std::vector<int>>& global_indexes)
+void ProjectedMatrices<dist_matrix::DistMatrix<DISTMATDTYPE>>::
+    setupGlobalIndexes(const std::vector<std::vector<int>>& global_indexes)
 {
     MGmol_MPI& mmpi = *(MGmol_MPI::instance());
     MPI_Comm comm   = mmpi.commSpin();
@@ -179,12 +179,9 @@ void ProjectedMatrices<dist_matrix::DistMatrix<DISTMATDTYPE>>::setupMPI(
 }
 
 template <>
-void ProjectedMatrices<ReplicatedMatrix>::setupMPI(
+void ProjectedMatrices<ReplicatedMatrix>::setupGlobalIndexes(
     const std::vector<std::vector<int>>& global_indexes)
 {
-    MGmol_MPI& mmpi = *(MGmol_MPI::instance());
-    MPI_Comm comm   = mmpi.commSpin();
-
     LocalMatrices2ReplicatedMatrix::setup(global_indexes);
 
     ReplicatedMatrix2SquareLocalMatrices::setup(global_indexes);
@@ -200,7 +197,7 @@ void ProjectedMatrices<MatrixType>::setup(
 
     global_indexes_ = global_indexes;
 
-    setupMPI(global_indexes);
+    setupGlobalIndexes(global_indexes);
 
     localX_.reset(new SquareLocalMatrices<MATDTYPE, memory_space_type>(
         subdiv_, chromatic_number_));

src/ProjectedMatrices.h

@@ -132,7 +132,7 @@ class ProjectedMatrices : public ProjectedMatricesInterface
     void convert(const SquareLocalMatrices<double, MemorySpace::Host>& src,
         MatrixType& dst);
 
-    void setupMPI(const std::vector<std::vector<int>>&);
+    void setupGlobalIndexes(const std::vector<std::vector<int>>&);
 
     std::string getMatrixType();
 

src/ReplicatedMatrix.cc

@@ -65,8 +65,8 @@ ReplicatedMatrix::ReplicatedMatrix(const std::string name, const int n)
     clear();
 }
 
-ReplicatedMatrix::ReplicatedMatrix(const std::string name,
-    const double* const diagonal, const int m, const int n)
+ReplicatedMatrix::ReplicatedMatrix(
+    const std::string name, const double* const diagonal, const int m)
     : dim_(m),
       ld_(roundup(dim_)),
       data_(Memory::allocate(dim_ * ld_), Memory::free),
@@ -349,7 +349,7 @@ void ReplicatedMatrix::setRandom(const double minv, const double maxv)
 #else
     double* data = data_.get();
     for (int j = 0; j < dim_; j++)
-        for (int i = 0; i < dim_ * ld_; i++)
+        for (int i = 0; i < dim_ * (int)ld_; i++)
             data[j * ld_ + i] = mat[j * dim_ + i];
 #endif
 }
@@ -855,4 +855,9 @@ void ReplicatedMatrix::shift(const double shift)
         mat[i + i * dim_] += shift;
 }
 
-void ReplicatedMatrix::printMM(std::ostream& os) const {}
+void ReplicatedMatrix::printMM(std::ostream& os) const
+{
+    (void)os;
+    std::cerr << "ReplicatedMatrix::printMM() not implemented" << std::endl;
+    MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
+}

src/ReplicatedMatrix.h

@@ -52,8 +52,8 @@ class ReplicatedMatrix
     ReplicatedMatrix(const std::string name, const int n);
 
     // construct diagonal matrix from diagonal values
-    ReplicatedMatrix(const std::string name, const double* const diagonal,
-        const int m, const int n);
+    ReplicatedMatrix(
+        const std::string name, const double* const diagonal, const int m);
 
     ReplicatedMatrix(const ReplicatedMatrix&);
 

src/ReplicatedVector.cc

@@ -22,7 +22,7 @@ using MemoryDev = MemorySpace::Memory<double, MemorySpace::Device>;
 using MemoryDev = MemorySpace::Memory<double, MemorySpace::Host>;
 #endif
 
-ReplicatedVector::ReplicatedVector(const std::string name, const int n)
+ReplicatedVector::ReplicatedVector(const int n)
     : dim_(n), data_(MemoryDev::allocate(dim_), MemoryDev::free)
 {
 }

src/ReplicatedVector.h

@@ -20,7 +20,7 @@ class ReplicatedVector
     std::unique_ptr<double, void (*)(double*)> data_;
 
 public:
-    ReplicatedVector(const std::string name, const int n);
+    ReplicatedVector(const int n);
     ReplicatedVector(const ReplicatedVector&);
     ReplicatedVector(const std::vector<double>&);
     ReplicatedVector& operator=(const ReplicatedVector&);

src/computeHij.cc

@@ -48,6 +48,10 @@ template <>
 void MGmol<LocGridOrbitals>::addHlocal2matrix(
     LocGridOrbitals& orbitalsi, LocGridOrbitals& orbitalsj, ReplicatedMatrix& H)
 {
+    (void)orbitalsi;
+    (void)orbitalsj;
+    (void)H;
+
     std::cerr << "Not implemented!" << std::endl;
     MPI_Abort(MPI_COMM_WORLD, EXIT_FAILURE);
 }