clang-format

Author: gitpeterwind

src/analyticfunctions/NuclearGradientFunction.h

@@ -31,7 +31,7 @@
 
 namespace mrchem {
 
-    class NuclearGradientFunction : public mrcpp::RepresentableFunction<3, double> {
+class NuclearGradientFunction : public mrcpp::RepresentableFunction<3, double> {
 public:
     /*!
      *  @brief NuclearGradientFunction represents the function: Z * [x,y,z]/|r - o|^3

src/chemistry/Molecule.h

@@ -44,14 +44,14 @@
 #include "Nucleus.h"
 #include "properties/DipoleMoment.h"
 #include "properties/GeometricDerivative.h"
+#include "properties/HirshfeldCharges.h"
 #include "properties/Magnetizability.h"
 #include "properties/NMRShielding.h"
 #include "properties/OrbitalEnergies.h"
 #include "properties/Polarizability.h"
 #include "properties/QuadrupoleMoment.h"
 #include "properties/SCFEnergy.h"
 #include "qmfunctions/Orbital.h"
-#include "properties/HirshfeldCharges.h"
 
 /** @class Molecule
  *

src/driver.cpp

@@ -27,8 +27,8 @@
 #include <MRCPP/Printer>
 #include <MRCPP/Timer>
 
-#include <filesystem>
 #include "driver.h"
+#include <filesystem>
 
 #include "chemistry/Molecule.h"
 #include "chemistry/Nucleus.h"
@@ -51,12 +51,12 @@
 #include "qmfunctions/density_utils.h"
 #include "qmfunctions/orbital_utils.h"
 
+#include "qmoperators/one_electron/AZoraPotential.h"
 #include "qmoperators/one_electron/ElectricFieldOperator.h"
 #include "qmoperators/one_electron/KineticOperator.h"
 #include "qmoperators/one_electron/NuclearGradientOperator.h"
 #include "qmoperators/one_electron/NuclearOperator.h"
 #include "qmoperators/one_electron/ZoraOperator.h"
-#include "qmoperators/one_electron/AZoraPotential.h"
 
 #include "qmoperators/one_electron/H_BB_dia.h"
 #include "qmoperators/one_electron/H_BM_dia.h"
@@ -83,8 +83,8 @@
 #include "environment/LPBESolver.h"
 #include "environment/PBESolver.h"
 #include "environment/Permittivity.h"
-#include "surface_forces/SurfaceForce.h"
 #include "properties/hirshfeld/HirshfeldPartition.h"
+#include "surface_forces/SurfaceForce.h"
 
 #include "mrdft/Factory.h"
 
@@ -563,7 +563,7 @@ void driver::scf::calc_properties(const json &json_prop, Molecule &mol, const js
                 el.row(k) = h.trace(Phi).real();
                 h.clear();
             }
-        // calculate electronic gradient using the surface integrals method
+            // calculate electronic gradient using the surface integrals method
         } else if (json_prop["geometric_derivative"]["geom-1"]["method"] == "surface_integrals") {
             double prec = json_prop["geometric_derivative"]["geom-1"]["precision"];
             std::string leb_prec = json_prop["geometric_derivative"]["geom-1"]["surface_integral_precision"];
@@ -573,9 +573,7 @@ void driver::scf::calc_properties(const json &json_prop, Molecule &mol, const js
             auto &nuc = G.getNuclear();
             auto &el = G.getElectronic();
             // set electronic gradient
-            for (int k = 0; k < mol.getNNuclei(); k++) {
-                el.row(k) = surfaceForces.row(k) - nuc.row(k);
-            }
+            for (int k = 0; k < mol.getNNuclei(); k++) { el.row(k) = surfaceForces.row(k) - nuc.row(k); }
         } else {
             MSG_ABORT("Invalid method for geometric derivative");
         }
@@ -639,9 +637,9 @@ void driver::scf::calc_properties(const json &json_prop, Molecule &mol, const js
             mrchem::density::compute(prec, rho, Phi, DensityType::Total);
             Eigen::VectorXd charges = Eigen::VectorXd::Zero(mol.getNNuclei());
             for (int i = 0; i < mol.getNNuclei(); i++) {
-                if ( ! mrcpp::mpi::my_func(i) ) continue; // my_orb also works for atoms.
+                if (!mrcpp::mpi::my_func(i)) continue; // my_orb also works for atoms.
                 double charge = partitioner.getHirshfeldPartitionIntegral(i, rho, prec);
-                charge = - charge + mol.getNuclei()[i].getCharge();
+                charge = -charge + mol.getNuclei()[i].getCharge();
                 charges(i) = charge;
             }
             mrcpp::mpi::allreduce_vector(charges, mrcpp::mpi::comm_wrk);
@@ -1105,9 +1103,7 @@ void driver::build_fock_operator(const json &json_fock, Molecule &mol, FockBuild
             std::string azora_dir_src = AZORA_POTENTIALS_SOURCE_DIR;
             std::string azora_dir_install = AZORA_POTENTIALS_INSTALL_DIR;
             std::string azora_dir = "";
-            if (json_fock["zora_operator"].contains("azora_potential_path")) {
-                azora_dir = json_fock["zora_operator"]["azora_potential_path"];
-            }
+            if (json_fock["zora_operator"].contains("azora_potential_path")) { azora_dir = json_fock["zora_operator"]["azora_potential_path"]; }
 
             std::string azora_dir_final;
             if (azora_dir != "") {

src/environment/GPESolver.cpp

@@ -103,7 +103,7 @@ void GPESolver::computeGamma(mrcpp::CompFunction<3> &potential, mrcpp::CompFunct
         mrcpp::AnalyticFunction<3> d_cav(C_pin->getGradVector()[d]);
         mrcpp::CompFunction<3> cplxfunc_prod;
 
-        mrcpp::FunctionTree<3, double>& Tree =  get_func(d_V, d);
+        mrcpp::FunctionTree<3, double> &Tree = get_func(d_V, d);
         mrcpp::multiply(cplxfunc_prod, Tree, d_cav, this->apply_prec, 1);
         // add result into out_gamma
         if (d == 0) {
@@ -247,13 +247,13 @@ mrcpp::CompFunction<3> &GPESolver::solveEquation(double prec, const Density &rho
 
     Timer t_gamma;
     if (Vr_n.Ncomp() == 0) {
-         mrcpp::CompFunction<3> gamma_0;
-         mrcpp::CompFunction<3> V_tot;
-         gamma_0.func_ptr->isreal = 1;
-         gamma_0.alloc(1);
+        mrcpp::CompFunction<3> gamma_0;
+        mrcpp::CompFunction<3> V_tot;
+        gamma_0.func_ptr->isreal = 1;
+        gamma_0.alloc(1);
 
-         computeGamma(V_vac, gamma_0);
-         this->Vr_n = solvePoissonEquation(gamma_0, rho_el);
+        computeGamma(V_vac, gamma_0);
+        this->Vr_n = solvePoissonEquation(gamma_0, rho_el);
     }
 
     // update the potential/gamma before doing anything with them

src/environment/PBESolver.cpp

@@ -78,7 +78,7 @@ void PBESolver::computeGamma(mrcpp::CompFunction<3> &potential, mrcpp::CompFunct
         auto C_pin = this->epsilon.getCavity_p();
         mrcpp::AnalyticFunction<3> d_cav(C_pin->getGradVector()[d]);
         mrcpp::CompFunction<3> cplxfunc_prod;
-        mrcpp::FunctionTree<3, double>& Tree =  get_func(d_V, d);
+        mrcpp::FunctionTree<3, double> &Tree = get_func(d_V, d);
         mrcpp::multiply(cplxfunc_prod, Tree, d_cav, this->apply_prec, 1);
         // add result into out_gamma
         if (d == 0) {

src/mrdft/Functional.h

@@ -48,7 +48,7 @@ class Functional {
 
     void setLogGradient(bool log) { log_grad = log; }
     void setDensityCutoff(double cut) { cutoff = cut; }
-    void setDerivOp(std::unique_ptr<mrcpp::DerivativeOperator<3>> &d) {derivOp = std::move(d);}
+    void setDerivOp(std::unique_ptr<mrcpp::DerivativeOperator<3>> &d) { derivOp = std::move(d); }
 
     virtual bool isSpin() const = 0;
     bool isLDA() const { return (not(isGGA() or isMetaGGA())); }

src/mrenv.cpp

@@ -23,10 +23,10 @@
  * <https://mrchem.readthedocs.io/>
  */
 
+#include "MRCPP/utils/parallel.h"
 #include <MRCPP/Printer>
 #include <XCFun/xcfun.h>
 #include <fstream>
-#include "MRCPP/utils/parallel.h"
 
 #include "mrchem.h"
 #include "mrenv.h"

src/properties/GeometricDerivative.h

@@ -74,11 +74,11 @@ class GeometricDerivative final {
      * @brief Compute the variance of the total force using the formula
      * sigma = sqrt(1/(3N) * sum_i sum_j (F_{ij})^2) presented in
      * Gubler et al.: Journal of Computational Physics: X Volume 17, November 2023, 100131
-    */
+     */
     double variance() const {
         DoubleMatrix forces = getTensor();
         Eigen::Vector3d total_force = forces.colwise().sum();
-        double force_variance = total_force.norm() * std::sqrt( 1.0 / (3.0 * forces.rows()) );
+        double force_variance = total_force.norm() * std::sqrt(1.0 / (3.0 * forces.rows()));
         return force_variance;
     }
 

src/properties/HirshfeldCharges.h

@@ -12,14 +12,13 @@ namespace mrchem {
 
 class HirshfeldCharges final {
 public:
-
     DoubleVector getVector() const { return this->hirshfeld_charges; }
 
     void setVector(const DoubleVector &v) { this->hirshfeld_charges = v; }
 
     void print(const std::string &id) const {
         mrcpp::print::header(0, "Hirshfeld Charges (" + id + ")");
-        mrcpp::print::separator(0, '-');    
+        mrcpp::print::separator(0, '-');
         for (int i = 0; i < hirshfeld_charges.size(); i++) {
             std::string text = "Charge of atom " + std::to_string(i);
             print_utils::scalar(0, text, hirshfeld_charges(i));
@@ -29,9 +28,7 @@ class HirshfeldCharges final {
         mrcpp::print::separator(0, '=');
     }
 
-    nlohmann::json json() const {
-        return {{"total", print_utils::eigen_to_vector(getVector(), 1.0e-12)}};
-    }
+    nlohmann::json json() const { return {{"total", print_utils::eigen_to_vector(getVector(), 1.0e-12)}}; }
 
 protected:
     DoubleVector hirshfeld_charges;

src/properties/hirshfeld/HirshfeldInterpolator.cpp

@@ -27,9 +27,7 @@ HirshfeldRadInterpolater::HirshfeldRadInterpolater(const std::string element, st
     rhoGrid = rhoGrid.array().log();
 
     lnRho = std::make_shared<interpolation_utils::PolyInterpolator>(rGrid, rhoGrid);
-    if (writeToFile) {
-        writeInterpolatedDensity(element + ".interpolated");
-    }
+    if (writeToFile) { writeInterpolatedDensity(element + ".interpolated"); }
 }
 
 // Function to evaluate the interpolated function

src/properties/hirshfeld/HirshfeldInterpolator.h

@@ -1,8 +1,8 @@
 #pragma once
 
-#include <vector>
-#include <Eigen/Dense>
 #include "utils/PolyInterpolator.h"
+#include <Eigen/Dense>
+#include <vector>
 
 class HirshfeldRadInterpolater {
 
@@ -11,18 +11,18 @@ class HirshfeldRadInterpolater {
      * @brief Construct a new Rad Interpolater object
      * @param element The element for which the ZORA potential is to be interpolated
      * @param data_dir The directory containing the ZORA potential data
-    */
+     */
     HirshfeldRadInterpolater(const std::string element, std::string data_dir, bool writeToFile = false);
 
     /**
      * @brief Evaluate the interpolated function at a given point
      * @param r The point at which to evaluate
      * @return The interpolated value at the given point
-    */
+     */
     double evalf(const double &r) const;
 
     /**
-     * @brief Integrates the atomic charge density to get the charge of the tabulated 
+     * @brief Integrates the atomic charge density to get the charge of the tabulated
      * atomic density. The numeric is performed from 0 to 20 bohr. Only useful for debugging.
      */
     double getNorm() const;

src/properties/hirshfeld/HirshfeldPartition.cpp

@@ -12,13 +12,10 @@ HirshfeldPartition::HirshfeldPartition(const mrchem::Molecule &mol, std::string
         // Uncomment the following line to print the charge of the atomic density
         // std::cout << "Norm of " << element << " = " << this->logDensities[i].getNorm() << std::endl;
     }
-
 }
 
 double HirshfeldPartition::getHirshfeldPartitionIntegral(int index, mrcpp::CompFunction<3> &rho, double prec) const {
-    auto w_i_analytic = [index, this](const mrcpp::Coord<3> &r) {
-        return this->evalf(r, index);
-    };
+    auto w_i_analytic = [index, this](const mrcpp::Coord<3> &r) { return this->evalf(r, index); };
     mrcpp::CompFunction<3> w_i_MW;
     mrcpp::AnalyticFunction<3> w_i_analytic_func(w_i_analytic);
     mrcpp::multiply(w_i_MW, rho.real(), w_i_analytic_func, prec);
@@ -34,18 +31,14 @@ double HirshfeldPartition::lseLogDens(const mrcpp::Coord<3> &r) const {
     mrcpp::Coord<3> nucPos;
     for (int i = 0; i < this->nNucs; i++) {
         nucPos = this->nucs->at(i).getCoord();
-        rr = std::sqrt((r[0] - nucPos[0]) * (r[0] - nucPos[0])
-            + (r[1] - nucPos[1]) * (r[1] - nucPos[1])
-            + (r[2] - nucPos[2]) * (r[2] - nucPos[2]));
+        rr = std::sqrt((r[0] - nucPos[0]) * (r[0] - nucPos[0]) + (r[1] - nucPos[1]) * (r[1] - nucPos[1]) + (r[2] - nucPos[2]) * (r[2] - nucPos[2]));
         lseLogDens_r(i) = this->logDensities[i].evalf(rr);
     }
     return mrchem::math_utils::logsumexp(lseLogDens_r);
 }
 
 double HirshfeldPartition::evalf(const mrcpp::Coord<3> &r, int iAt) const {
     mrcpp::Coord<3> nucPos = this->nucs->at(iAt).getCoord();
-    double rr = std::sqrt((r[0] - nucPos[0]) * (r[0] - nucPos[0])
-        + (r[1] - nucPos[1]) * (r[1] - nucPos[1])
-        + (r[2] - nucPos[2]) * (r[2] - nucPos[2]));
+    double rr = std::sqrt((r[0] - nucPos[0]) * (r[0] - nucPos[0]) + (r[1] - nucPos[1]) * (r[1] - nucPos[1]) + (r[2] - nucPos[2]) * (r[2] - nucPos[2]));
     return std::exp(this->logDensities[iAt].evalf(rr) - this->lseLogDens(r));
 }

src/properties/hirshfeld/HirshfeldPartition.h

@@ -1,19 +1,19 @@
 #pragma once
 
-#include <Eigen/Dense>
-#include <mrchem.h>
 #include "chemistry/Molecule.h"
-#include <string>
 #include "chemistry/Nucleus.h"
 #include "properties/hirshfeld/HirshfeldInterpolator.h"
+#include <Eigen/Dense>
+#include <mrchem.h>
+#include <string>
 
 /**
  * @brief Class for computing the Hirshfeld partitioning of a molecule. Reads and interpolates the Hirshfeld partitioning data.
  * can create MW representation of the Hirshfeld partitioning functions.
  */
-class HirshfeldPartition{
+class HirshfeldPartition {
 
-    public:
+public:
     /**
      * @brief Construct a new Hirshfeld Partition object
      * @param mol The molecule for which the Hirshfeld partitioning is to be computed
@@ -26,8 +26,7 @@ class HirshfeldPartition{
      */
     double getHirshfeldPartitionIntegral(int index, mrcpp::CompFunction<3> &rho, double prec) const;
 
-    protected:
-
+protected:
     /**
      * @brief Evaluate the analytic, interpolated Hirshfeld partitioning function at a given point
      */
@@ -52,6 +51,4 @@ class HirshfeldPartition{
      * @brief The atomic density interpolators for the nuclei
      */
     std::vector<HirshfeldRadInterpolater> logDensities;
-
-
 };

src/qmfunctions/Orbital.cpp

@@ -60,7 +60,7 @@ Orbital::Orbital(SPIN::type spin)
  *
  */
 Orbital::Orbital(int spin, double occ, int rank)
-        : mrcpp::CompFunction<3>(spin){
+        : mrcpp::CompFunction<3>(spin) {
     if (this->spin() < 0) INVALID_ARG_ABORT;
     if (this->occ() < 0) {
         // d1 is defined as occupancy
@@ -71,7 +71,6 @@ Orbital::Orbital(int spin, double occ, int rank)
     this->func_ptr->rank = rank;
 }
 
-
 /** @brief Copy constructor
  *
  * @param orb: orbital to copy
@@ -83,7 +82,6 @@ Orbital::Orbital(int spin, double occ, int rank)
 Orbital::Orbital(Orbital &orb)
         : mrcpp::CompFunction<3>(orb) {}
 
-
 /** @brief Copy constructor
  *
  * @param orb: orbital to copy
@@ -92,11 +90,10 @@ Orbital::Orbital(Orbital &orb)
  * NO transfer of ownership:
  * both orbitals are pointing to the same tree
  */
-//Orbital::Orbital(const mrcpp::CompFunction<3> &orb)
-//        : mrcpp::CompFunction<3>(orb) {}
-Orbital::Orbital(const mrcpp::CompFunction<3>& orb)
-    : mrcpp::CompFunction<3>(orb) {}
-
+// Orbital::Orbital(const mrcpp::CompFunction<3> &orb)
+//         : mrcpp::CompFunction<3>(orb) {}
+Orbital::Orbital(const mrcpp::CompFunction<3> &orb)
+        : mrcpp::CompFunction<3>(orb) {}
 
 /** @brief Complex conjugation
  *