gwbse.cc

Go to the documentation of this file.

 
 
/*
 *            Copyright 2009-2023 The VOTCA Development Team
 *                       (http://www.votca.org)
 *
 *      Licensed under the Apache License, Version 2.0 (the "License")
 *
 * You may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *              http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
 
// Third party includes
#include <boost/algorithm/string.hpp>
#include <boost/format.hpp>
 
// VOTCA includes
#include <stdexcept>
#include <votca/tools/constants.h>
#include <votca/tools/version.h>
 
// Local VOTCA includes
#include "votca/xtp/accelerate_lapack.h"
#include "votca/xtp/basisset.h"
#include "votca/xtp/bse.h"
#include "votca/xtp/citations.h"
#include "votca/xtp/ecpbasisset.h"
#include "votca/xtp/gwbse.h"
#include "votca/xtp/logger.h"
#include "votca/xtp/memorybudget.h"
#include "votca/xtp/orbitals.h"
#include "votca/xtp/rpa_uks.h"
#include "votca/xtp/screening_kernels.h"
#include "votca/xtp/screening_update.h"
#include "votca/xtp/vxc_grid.h"
#include "votca/xtp/vxc_potential.h"
 
using std::flush;
namespace votca {
namespace xtp {
 
Index GWBSE::CountCoreLevels() {
  Index ignored_corelevels = 0;
  if (!orbitals_.hasECPName()) {
    ECPBasisSet basis;
    basis.Load("corelevels");
    Index coreElectrons = 0;
    for (const auto& atom : orbitals_.QMAtoms()) {
      coreElectrons += basis.getElement(atom.getElement()).getNcore();
    }
    ignored_corelevels = coreElectrons / 2;
  }
  return ignored_corelevels;
}
 
void GWBSE::Initialize(tools::Property& options) {
 
  // getting level ranges
  Index rpamax = 0;
  Index rpamin = 0;  // never changes
  Index qpmin = 0;
  Index qpmax = 0;
  Index bse_vmin = 0;
  Index bse_cmax = 0;
 
  const bool is_uks = orbitals_.hasUnrestrictedOrbitals();
  Index homo = orbitals_.getHomo();  // indexed from 0
  if (is_uks) {
    homo = std::max(orbitals_.getHomoAlpha(), orbitals_.getHomoBeta());
  }
  Index num_of_levels = orbitals_.getBasisSetSize();
  Index num_of_occlevels = orbitals_.getNumberOfAlphaElectrons();
  if (is_uks) {
    num_of_occlevels = std::max(orbitals_.getNumberOfAlphaElectrons(),
                                orbitals_.getNumberOfBetaElectrons());
  }
 
  std::string ranges = options.get(".ranges").as<std::string>();
 
  // now check validity, and get rpa, qp, and bse level ranges accordingly
 
  if (ranges == "factor") {
 
    double rpamaxfactor = options.get(".rpamax").as<double>();
    rpamax = Index(rpamaxfactor * double(num_of_levels)) -
             1;  // total number of levels
 
    double qpminfactor = options.get(".qpmin").as<double>();
    qpmin =
        num_of_occlevels - Index(qpminfactor * double(num_of_occlevels)) - 1;
 
    double qpmaxfactor = options.get(".qpmax").as<double>();
    qpmax =
        num_of_occlevels + Index(qpmaxfactor * double(num_of_occlevels)) - 1;
 
    double bseminfactor = options.get(".bsemin").as<double>();
    bse_vmin =
        num_of_occlevels - Index(bseminfactor * double(num_of_occlevels)) - 1;
 
    double bsemaxfactor = options.get(".bsemax").as<double>();
    bse_cmax =
        num_of_occlevels + Index(bsemaxfactor * double(num_of_occlevels)) - 1;
 
  } else if (ranges == "explicit") {
    // get explicit numbers
    rpamax = options.get(".rpamax").as<Index>();
    qpmin = options.get(".qpmin").as<Index>();
    qpmax = options.get(".qpmax").as<Index>();
    bse_vmin = options.get(".bsemin").as<Index>();
    bse_cmax = options.get(".bsemax").as<Index>();
  } else if (ranges == "default") {
    rpamax = num_of_levels - 1;
    qpmin = 0;
    qpmax = 3 * homo + 1;
    bse_vmin = 0;
    bse_cmax = 3 * homo + 1;
  } else if (ranges == "full") {
    rpamax = num_of_levels - 1;
    qpmin = 0;
    qpmax = num_of_levels - 1;
    bse_vmin = 0;
    bse_cmax = num_of_levels - 1;
  }
  std::string ignore_corelevels =
      options.get(".ignore_corelevels").as<std::string>();
 
  if (ignore_corelevels == "RPA" || ignore_corelevels == "GW" ||
      ignore_corelevels == "BSE") {
    Index ignored_corelevels = CountCoreLevels();
    if (ignore_corelevels == "RPA") {
      rpamin = ignored_corelevels;
    }
    if (ignore_corelevels == "GW" || ignore_corelevels == "RPA") {
      if (qpmin < ignored_corelevels) {
        qpmin = ignored_corelevels;
      }
    }
    if (ignore_corelevels == "GW" || ignore_corelevels == "RPA" ||
        ignore_corelevels == "BSE") {
      if (bse_vmin < ignored_corelevels) {
        bse_vmin = ignored_corelevels;
      }
    }
 
    XTP_LOG(Log::error, *pLog_)
        << TimeStamp() << " Ignoring " << ignored_corelevels
        << " core levels for " << ignore_corelevels << " and beyond." << flush;
  }
 
  // check maximum and minimum sizes
  if (rpamax >= num_of_levels) {
    rpamax = num_of_levels - 1;
  }
  if (qpmax >= num_of_levels) {
    qpmax = num_of_levels - 1;
  }
  if (bse_cmax >= num_of_levels) {
    bse_cmax = num_of_levels - 1;
  }
  if (bse_vmin < 0) {
    bse_vmin = 0;
  }
  if (qpmin < 0) {
    qpmin = 0;
  }
 
  Index bse_vmax = homo;
  Index bse_cmin = homo + 1;
 
  // Energy caps on the GW and BSE windows (eV above the DFT LUMO / below the
  // DFT HOMO; <= 0: off). They only shrink the windows set above, and never
  // cut a (near-)degenerate set of levels.
  {
    const double qp_emax =
        options.ifExistsReturnElseReturnDefault<double>(".qp_emax", 0.0);
    const double qp_emin =
        options.ifExistsReturnElseReturnDefault<double>(".qp_emin", 0.0);
    const double bse_emax =
        options.ifExistsReturnElseReturnDefault<double>(".bse_emax", 0.0);
    const double bse_emin =
        options.ifExistsReturnElseReturnDefault<double>(".bse_emin", 0.0);
    std::vector<const Eigen::VectorXd*> spins{&orbitals_.MOs().eigenvalues()};
    std::vector<Index> homos{is_uks ? orbitals_.getHomoAlpha() : homo};
    if (is_uks) {
      spins.push_back(&orbitals_.MOs_beta().eigenvalues());
      homos.push_back(orbitals_.getHomoBeta());
    }
    // levels closer than this count as degenerate and stay together
    constexpr double degenerate = 5e-4;  // Ha
    // highest level (over the spins) within cap_ev above the LUMO
    auto upper = [&](double cap_ev) {
      Index last = homo + 1;
      for (std::size_t s = 0; s < spins.size(); ++s) {
        const Eigen::VectorXd& e = *spins[s];
        const double limit = e(homos[s] + 1) + cap_ev * tools::conv::ev2hrt;
        Index i = homos[s] + 1;
        while (i + 1 < e.size() && e(i + 1) <= limit) {
          ++i;
        }
        const double edge = e(i);  // keep the set degenerate with it
        while (i + 1 < e.size() && e(i + 1) - edge < degenerate) {
          ++i;
        }
        last = std::max(last, i);
      }
      return last;
    };
    // lowest level (over the spins) within cap_ev below the HOMO
    auto lower = [&](double cap_ev) {
      Index first = homo;
      for (std::size_t s = 0; s < spins.size(); ++s) {
        const Eigen::VectorXd& e = *spins[s];
        const double limit = e(homos[s]) - cap_ev * tools::conv::ev2hrt;
        Index i = homos[s];
        while (i - 1 >= 0 && e(i - 1) >= limit) {
          --i;
        }
        const double edge = e(i);
        while (i - 1 >= 0 && edge - e(i - 1) < degenerate) {
          --i;
        }
        first = std::min(first, i);
      }
      return first;
    };
    auto report = [&](const std::string& what, const std::string& option,
                      double cap, Index before, Index after) {
      XTP_LOG(Log::error, *pLog_)
          << TimeStamp() << " " << what << " capped by " << option << " = "
          << cap << " eV: " << before << " -> " << after << " ("
          << std::abs(before - after) << " levels removed)" << flush;
    };
    if (qp_emax > 0.0) {
      const Index cap = std::min(qpmax, upper(qp_emax));
      report("GW window top", "qp_emax", qp_emax, qpmax, cap);
      qpmax = cap;
    }
    if (qp_emin > 0.0) {
      const Index cap = std::max(qpmin, lower(qp_emin));
      report("GW window bottom", "qp_emin", qp_emin, qpmin, cap);
      qpmin = cap;
    }
    if (bse_emax > 0.0) {
      const Index cap = std::min(bse_cmax, upper(bse_emax));
      report("BSE window top", "bse_emax", bse_emax, bse_cmax, cap);
      bse_cmax = cap;
    }
    if (bse_emin > 0.0) {
      const Index cap = std::max(bse_vmin, lower(bse_emin));
      report("BSE window bottom", "bse_emin", bse_emin, bse_vmin, cap);
      bse_vmin = cap;
    }
  }
 
  if (rpamin < 0 || rpamax < 0 || rpamin > rpamax) {
    throw std::runtime_error("Invalid RPA level range after setup/clamping.");
  }
  if (qpmin < 0 || qpmax < 0 || qpmin > qpmax) {
    throw std::runtime_error("Invalid GW level range after setup/clamping.");
  }
  if (bse_vmin < 0 || bse_vmax < 0 || bse_vmin > bse_vmax) {
    throw std::runtime_error(
        "Invalid BSE occupied level range after setup/clamping.");
  }
  if (bse_cmin < 0 || bse_cmax < 0 || bse_cmin > bse_cmax) {
    throw std::runtime_error(
        "Invalid BSE virtual level range after setup/clamping.");
  }
  if (bse_vmax >= num_of_levels || bse_cmax >= num_of_levels) {
    throw std::runtime_error(
        "BSE level range exceeds available orbital indices.");
  }
  if (bse_vmax >= bse_cmin) {
    throw std::runtime_error("BSE occupied and virtual level ranges overlap.");
  }
 
  gwopt_.homo = homo;
  gwopt_.qpmin = qpmin;
  gwopt_.qpmax = qpmax;
  gwopt_.rpamin = rpamin;
  gwopt_.rpamax = rpamax;
 
  bseopt_.vmin = bse_vmin;
  bseopt_.cmax = bse_cmax;
  bseopt_.homo = homo;
  bseopt_.qpmin = qpmin;
  bseopt_.qpmax = qpmax;
  bseopt_.rpamin = rpamin;
  bseopt_.rpamax = rpamax;
 
  orbitals_.setRPAindices(rpamin, rpamax);
  orbitals_.setGWindices(qpmin, qpmax);
  orbitals_.setBSEindices(bse_vmin, bse_cmax);
 
  // Index bse_vmax = homo;
  // Index bse_cmin = homo + 1;
  Index bse_vtotal = bse_vmax - bse_vmin + 1;
  Index bse_ctotal = bse_cmax - bse_cmin + 1;
  Index bse_size = bse_vtotal * bse_ctotal;
 
  XTP_LOG(Log::error, *pLog_) << TimeStamp() << " RPA level range [" << rpamin
                              << ":" << rpamax << "]" << flush;
  XTP_LOG(Log::error, *pLog_) << TimeStamp() << " GW  level range [" << qpmin
                              << ":" << qpmax << "]" << flush;
  XTP_LOG(Log::error, *pLog_)
      << TimeStamp() << " BSE level range occ[" << bse_vmin << ":" << bse_vmax
      << "]  virt[" << bse_cmin << ":" << bse_cmax << "]" << flush;
 
  gwopt_.reset_3c = options.get(".gw.rebuild_3c_freq").as<Index>();
 
  bseopt_.nmax = options.get(".bse.exctotal").as<Index>();
  if (bseopt_.nmax > bse_size || bseopt_.nmax < 0) {
    bseopt_.nmax = bse_size;
  }
 
  bseopt_.davidson_correction =
      options.get("bse.davidson.correction").as<std::string>();
 
  bseopt_.davidson_tolerance =
      options.get("bse.davidson.tolerance").as<std::string>();
 
  bseopt_.davidson_update =
      options.get("bse.davidson.update").as<std::string>();
 
  bseopt_.davidson_maxiter = options.get("bse.davidson.maxiter").as<Index>();
 
  bseopt_.useTDA = options.get("bse.useTDA").as<bool>();
  orbitals_.setTDAApprox(bseopt_.useTDA);
  if (!bseopt_.useTDA) {
    XTP_LOG(Log::error, *pLog_) << " BSE type: full" << flush;
  } else {
    XTP_LOG(Log::error, *pLog_) << " BSE type: TDA" << flush;
  }
 
  Index full_bse_size = (bseopt_.useTDA) ? bse_size : 2 * bse_size;
  XTP_LOG(Log::error, *pLog_) << TimeStamp() << " BSE Hamiltonian has size "
                              << full_bse_size << "x" << full_bse_size << flush;
 
  bseopt_.use_Hqp_offdiag = options.get("bse.use_Hqp_offdiag").as<bool>();
  orbitals_.SetFlagUseHqpOffdiag(bseopt_.use_Hqp_offdiag);
 
  if (!bseopt_.use_Hqp_offdiag) {
    XTP_LOG(Log::error, *pLog_)
        << " BSE without Hqp offdiagonal elements" << flush;
  } else {
    XTP_LOG(Log::error, *pLog_)
        << " BSE with Hqp offdiagonal elements" << flush;
  }
 
  bseopt_.max_dyn_iter = options.get("bse.dyn_screen_max_iter").as<Index>();
  bseopt_.dyn_tolerance = options.get("bse.dyn_screen_tol").as<double>();
  if (bseopt_.max_dyn_iter > 0) {
    do_dynamical_screening_bse_ = true;
  }
 
  functional_ = orbitals_.getXCFunctionalName();
  grid_ = orbitals_.getXCGrid();
 
  dftbasis_name_ = orbitals_.getDFTbasisName();
  if (orbitals_.hasAuxbasisName()) {
    auxbasis_name_ = orbitals_.getAuxbasisName();
  } else if (options.exists(".auxbasisset")) {
    auxbasis_name_ = options.get(".auxbasisset").as<std::string>();
  } else {
    auxbasis_name_ = "aux-" + dftbasis_name_;
    try {
      BasisSet b;
      b.Load(auxbasis_name_);
    } catch (std::runtime_error&) {
      throw std::runtime_error(
          "There is no auxbasis from the dftcalculation nor did you specify an "
          "auxbasisset for the gwbse calculation. Also no auxiliary basisset "
          "for basisset " +
          dftbasis_name_ + " could be found!");
    }
    XTP_LOG(Log::error, *pLog_)
        << " No auxbasisset given, using " << auxbasis_name_ << flush;
  }
 
  std::string mode = options.get("gw.mode").as<std::string>();
  if (mode == "G0W0") {
    gwopt_.gw_sc_max_iterations = 1;
  }
 
  XTP_LOG(Log::error, *pLog_) << " Running GW as: " << mode << flush;
  gwopt_.ScaHFX = orbitals_.getScaHFX();
 
  gwopt_.shift = options.get("gw.scissor_shift").as<double>();
  gwopt_.g_sc_limit =
      options.get("gw.qp_sc_limit").as<double>();  // convergence criteria
                                                   // for qp iteration
                                                   // [Hartree]]
  gwopt_.g_sc_max_iterations =
      options.get("gw.qp_sc_max_iter").as<Index>();  // convergence
                                                     // criteria for qp
                                                     // iteration
                                                     // [Hartree]]
 
  if (mode == "evGW") {
    gwopt_.gw_sc_max_iterations = options.get("gw.sc_max_iter").as<Index>();
  }
 
  gwopt_.gw_sc_limit =
      options.get("gw.sc_limit").as<double>();  // convergence criteria
                                                // for shift it
  XTP_LOG(Log::error, *pLog_)
      << " qp_sc_limit [Hartree]: " << gwopt_.g_sc_limit << flush;
  if (gwopt_.gw_sc_max_iterations > 1) {
    XTP_LOG(Log::error, *pLog_)
        << " gw_sc_limit [Hartree]: " << gwopt_.gw_sc_limit << flush;
  }
  bseopt_.min_print_weight = options.get("bse.print_weight").as<double>();
  // print exciton WF composition weight larger than minimum
 
  // possible tasks
  std::string tasks_string = options.get(".tasks").as<std::string>();
  boost::algorithm::to_lower(tasks_string);
 
  if (tasks_string.find("gw") != std::string::npos) {
    do_gw_ = true;
  }
 
  if (is_uks) {
    if (tasks_string.find("excitons") != std::string::npos ||
        tasks_string.find("exciton_uks") != std::string::npos) {
      do_gw_ = true;
      do_bse_exciton_uks_ = true;
    }
 
    if (tasks_string.find("singlets") != std::string::npos ||
        tasks_string.find("triplets") != std::string::npos) {
      throw std::runtime_error(
          "Invalid gwbse task for UKS reference: 'singlets' and 'triplets' "
          "are not defined for open-shell systems.\n"
          "Use 'exciton_uks' (or 'excitons') instead.");
    }
  } else {
    if (tasks_string.find("all") != std::string::npos) {
      if (is_uks) {
        do_gw_ = true;
        do_bse_exciton_uks_ = true;
      } else {
        do_gw_ = true;
        do_bse_singlets_ = true;
        do_bse_triplets_ = true;
      }
    }
    if (tasks_string.find("singlets") != std::string::npos) {
      do_bse_singlets_ = true;
    }
    if (tasks_string.find("triplets") != std::string::npos) {
      do_bse_triplets_ = true;
    }
  }
 
  XTP_LOG(Log::error, *pLog_) << " Tasks: " << flush;
  if (do_gw_) {
    XTP_LOG(Log::error, *pLog_) << " GW " << flush;
  }
  if (do_bse_singlets_) {
    XTP_LOG(Log::error, *pLog_) << " singlets " << flush;
  }
  if (do_bse_triplets_) {
    XTP_LOG(Log::error, *pLog_) << " triplets " << flush;
  }
  if (do_bse_exciton_uks_) {
    XTP_LOG(Log::error, *pLog_) << " exciton_uks " << flush;
  }
 
  if (options.exists("bse.fragments")) {
    std::vector<tools::Property*> prop_region =
        options.Select("bse.fragments.fragment");
    Index index = 0;
    for (tools::Property* prop : prop_region) {
      std::string indices = prop->get("indices").as<std::string>();
      fragments_.push_back(QMFragment<BSE_Population>(index, indices));
      index++;
    }
  }
 
  gwopt_.sigma_integration =
      options.get("gw.sigma_integrator").as<std::string>();
  XTP_LOG(Log::error, *pLog_)
      << " Sigma integration: " << gwopt_.sigma_integration << flush;
  gwopt_.eta = options.get("gw.eta").as<double>();
  XTP_LOG(Log::error, *pLog_) << " eta: " << gwopt_.eta << flush;
  if (gwopt_.sigma_integration == "exact") {
    XTP_LOG(Log::error, *pLog_)
        << " RPA Hamiltonian size: " << (homo + 1 - rpamin) * (rpamax - homo)
        << flush;
  }
  if (gwopt_.sigma_integration == "cda") {
    gwopt_.order = options.get("gw.quadrature_order").as<Index>();
    XTP_LOG(Log::error, *pLog_)
        << " Quadrature integration order : " << gwopt_.order << flush;
    gwopt_.quadrature_scheme =
        options.get("gw.quadrature_scheme").as<std::string>();
    XTP_LOG(Log::error, *pLog_)
        << " Quadrature integration scheme : " << gwopt_.quadrature_scheme
        << flush;
    gwopt_.alpha = options.get("gw.alpha").as<double>();
    XTP_LOG(Log::error, *pLog_)
        << " Alpha smoothing parameter : " << gwopt_.alpha << flush;
  }
  gwopt_.qp_solver = options.get("gw.qp_solver").as<std::string>();
 
  XTP_LOG(Log::error, *pLog_) << " QP solver: " << gwopt_.qp_solver << flush;
  if (gwopt_.qp_solver == "grid") {
    // Grid-based QP solving now exposes the full search extent, dense scan,
    // and adaptive shell scan as separate controls. This avoids the old
    // overloading of qp_grid_steps / qp_grid_spacing, where one pair of values
    // simultaneously determined the window width and both scan resolutions.
    //
    // New-style options are read first. Deprecated legacy aliases are then
    // translated only for values that are still unset.
    // New decoupled QP search options
    if (options.exists("gw.qp_full_window_half_width")) {
      gwopt_.qp_full_window_half_width =
          options.get("gw.qp_full_window_half_width").as<double>();
    }
    if (options.exists("gw.qp_dense_spacing")) {
      gwopt_.qp_dense_spacing = options.get("gw.qp_dense_spacing").as<double>();
    }
    if (options.exists("gw.qp_adaptive_shell_width")) {
      gwopt_.qp_adaptive_shell_width =
          options.get("gw.qp_adaptive_shell_width").as<double>();
    }
    if (options.exists("gw.qp_adaptive_shell_count")) {
      gwopt_.qp_adaptive_shell_count =
          options.get("gw.qp_adaptive_shell_count").as<Index>();
    }
 
    // Deprecated legacy aliases. They are accepted for backward
    // compatibility and mapped onto the canonical controls below.
    const bool has_legacy_steps = options.exists("gw.qp_grid_steps");
    const bool has_legacy_spacing = options.exists("gw.qp_grid_spacing");
 
    if (has_legacy_steps != has_legacy_spacing) {
      throw std::runtime_error(
          "Deprecated gw.qp_grid_steps and gw.qp_grid_spacing must be given "
          "together if either is used.");
    }
 
    if (has_legacy_steps && has_legacy_spacing) {
      gwopt_.qp_grid_steps = options.get("gw.qp_grid_steps").as<Index>();
      gwopt_.qp_grid_spacing = options.get("gw.qp_grid_spacing").as<double>();
 
      const double legacy_half_width =
          qp_solver::LegacyFullWindowHalfWidth(gwopt_);
      const double legacy_shell_width =
          qp_solver::LegacyAdaptiveShellWidth(gwopt_);
 
      if (gwopt_.qp_full_window_half_width <= 0.0) {
        gwopt_.qp_full_window_half_width = legacy_half_width;
      }
      if (gwopt_.qp_dense_spacing <= 0.0) {
        gwopt_.qp_dense_spacing = gwopt_.qp_grid_spacing;
      }
      if (gwopt_.qp_adaptive_shell_count <= 0 &&
          gwopt_.qp_adaptive_shell_width <= 0.0) {
        gwopt_.qp_adaptive_shell_width = legacy_shell_width;
      }
 
      XTP_LOG(Log::error, *pLog_)
          << " Deprecated GW QP options detected: " << "qp_grid_steps="
          << gwopt_.qp_grid_steps
          << " qp_grid_spacing=" << gwopt_.qp_grid_spacing
          << " -> mapped to qp_full_window_half_width="
          << gwopt_.qp_full_window_half_width
          << " qp_dense_spacing=" << gwopt_.qp_dense_spacing
          << " qp_adaptive_shell_width=" << gwopt_.qp_adaptive_shell_width
          << flush;
    }
 
    // Final normalization produces one canonical option set used by both
    // GW and GW_UKS implementations.
    qp_solver::NormalizeGridSearchOptions(gwopt_);
 
    XTP_LOG(Log::error, *pLog_)
        << " QP full window half-width: " << gwopt_.qp_full_window_half_width
        << flush;
    XTP_LOG(Log::error, *pLog_)
        << " QP dense spacing: " << gwopt_.qp_dense_spacing << flush;
    XTP_LOG(Log::error, *pLog_)
        << " QP adaptive shell width: " << gwopt_.qp_adaptive_shell_width
        << flush;
    XTP_LOG(Log::error, *pLog_)
        << " QP adaptive shell count: " << gwopt_.qp_adaptive_shell_count
        << flush;
  }
  gwopt_.qp_root_finder = options.get("gw.qp_root_finder").as<std::string>();
  XTP_LOG(Log::error, *pLog_)
      << " QP root finder: " << gwopt_.qp_root_finder << flush;
 
  gwopt_.gw_mixing_order =
      options.get("gw.mixing_order").as<Index>();  // max history in
                                                   // mixing (0: plain,
                                                   // 1: linear, >1
                                                   // Anderson)
 
  gwopt_.gw_mixing_alpha = options.get("gw.mixing_alpha").as<double>();
  gwopt_.qp_grid_search_mode =
      options.get("gw.qp_grid_search_mode").as<std::string>();
  gwopt_.qp_restrict_search = options.get("gw.qp_restrict_search").as<bool>();
  gwopt_.qp_root_continuity = options.ifExistsReturnElseReturnDefault<bool>(
      "gw.qp_root_continuity", true);
  gwopt_.qp_root_tracking = options.ifExistsReturnElseReturnDefault<bool>(
      "gw.qp_root_tracking", false);
  core_exchange_ =
      options.ifExistsReturnElseReturnDefault<bool>("gw.core_exchange", true);
  gwopt_.screening_update =
      options.ifExistsReturnElseReturnDefault<std::string>(
          "gw.screening_update", "adaptive");
  ScreeningUpdate::Parse(gwopt_.screening_update);  // validates
  gwopt_.screening_update_ratio =
      options.ifExistsReturnElseReturnDefault<double>(
          "gw.screening_update_ratio", 0.1);
  gwopt_.screening_update_max_inner =
      options.ifExistsReturnElseReturnDefault<Index>(
          "gw.screening_update_max_inner", 10);
  gwopt_.qp_zero_margin = options.get("gw.qp_zero_margin").as<double>();
  gwopt_.qp_virtual_min_energy =
      options.get("gw.qp_virtual_min_energy").as<double>();
 
  // QSGW options
  gwopt_.do_qsgw =
      options.ifExistsReturnElseReturnDefault<bool>("gw.do_qsgw", false);
  gwopt_.qsgw_max_iterations = options.ifExistsReturnElseReturnDefault<Index>(
      "gw.qsgw_max_iterations", 50);
  gwopt_.qsgw_sc_limit =
      options.ifExistsReturnElseReturnDefault<double>("gw.qsgw_sc_limit", 1e-5);
  gwopt_.qsgw_max_virt_correction =
      options.ifExistsReturnElseReturnDefault<double>(
          "gw.qsgw_max_virt_correction", 0.5);
  gwopt_.qsgw_hartree_update = options.ifExistsReturnElseReturnDefault<bool>(
      "gw.qsgw_hartree_update", true);
  gwopt_.qsgw_hartree_screened = options.ifExistsReturnElseReturnDefault<bool>(
      "gw.qsgw_hartree_screened", true);
  gwopt_.qsgw_regularization =
      options.ifExistsReturnElseReturnDefault<std::string>(
          "gw.qsgw_regularization", "eta");
  if (gwopt_.qsgw_regularization != "eta" &&
      gwopt_.qsgw_regularization != "srg") {
    throw std::runtime_error("gw.qsgw_regularization must be eta or srg, got " +
                             gwopt_.qsgw_regularization);
  }
  gwopt_.qsgw_srg_s =
      options.ifExistsReturnElseReturnDefault<double>("gw.qsgw_srg_s", 500.0);
  if (!(gwopt_.qsgw_srg_s > 0.0)) {
    throw std::runtime_error("gw.qsgw_srg_s must be positive");
  }
  gwopt_.out_of_window_shift.mode = OutOfWindowShift::Parse(
      options.ifExistsReturnElseReturnDefault<std::string>(
          "gw.out_of_window_shift", "max"));
  gwopt_.out_of_window_shift.fit_fraction =
      options.ifExistsReturnElseReturnDefault<double>(
          "gw.out_of_window_fit_fraction", 0.3);
  if (gwopt_.out_of_window_shift.mode != OutOfWindowShift::Mode::Max) {
    XTP_LOG(Log::error, *pLog_)
        << " Levels outside the GW window shifted by: "
        << OutOfWindowShift::Name(gwopt_.out_of_window_shift.mode)
        << ((gwopt_.out_of_window_shift.mode == OutOfWindowShift::Mode::Linear)
                ? " (fit fraction " +
                      std::to_string(gwopt_.out_of_window_shift.fit_fraction) +
                      ")"
                : std::string())
        << flush;
  }
  if (gwopt_.do_qsgw) {
    XTP_LOG(Log::error, *pLog_)
        << " QSGW enabled: max_iter=" << gwopt_.qsgw_max_iterations
        << " sc_limit=" << gwopt_.qsgw_sc_limit << " Ha"
        << " max_virt_correction=" << gwopt_.qsgw_max_virt_correction << " Ha ("
        << gwopt_.qsgw_max_virt_correction * 27.2114 << " eV)" << std::flush;
  }
 
  if (mode == "evGW") {
    if (gwopt_.gw_mixing_order == 0) {
      XTP_LOG(Log::error, *pLog_) << " evGW with plain update " << std::flush;
    } else if (gwopt_.gw_mixing_order == 1) {
      XTP_LOG(Log::error, *pLog_) << " evGW with linear update using alpha "
                                  << gwopt_.gw_mixing_alpha << std::flush;
    } else {
      XTP_LOG(Log::error, *pLog_) << " evGW with Anderson update with history "
                                  << gwopt_.gw_mixing_order << " using alpha "
                                  << gwopt_.gw_mixing_alpha << std::flush;
    }
    if (gwopt_.screening_update == "adaptive") {
      XTP_LOG(Log::error, *pLog_)
          << " evGW screening update: adaptive (ratio "
          << gwopt_.screening_update_ratio << ", at most "
          << gwopt_.screening_update_max_inner << " iterations per W)"
          << std::flush;
    } else {
      XTP_LOG(Log::error, *pLog_)
          << " evGW screening update: every iteration" << std::flush;
    }
  }
 
  if (options.exists("gw.sigma_plot")) {
    sigma_plot_states_ = options.get("gw.sigma_plot.states").as<std::string>();
    sigma_plot_steps_ = options.get("gw.sigma_plot.steps").as<Index>();
    sigma_plot_spacing_ = options.get("gw.sigma_plot.spacing").as<double>();
    sigma_plot_filename_ =
        options.get("gw.sigma_plot.filename").as<std::string>();
 
    XTP_LOG(Log::error, *pLog_)
        << " Sigma plot states: " << sigma_plot_states_ << flush;
    XTP_LOG(Log::error, *pLog_)
        << " Sigma plot steps: " << sigma_plot_steps_ << flush;
    XTP_LOG(Log::error, *pLog_)
        << " Sigma plot spacing: " << sigma_plot_spacing_ << flush;
    XTP_LOG(Log::error, *pLog_)
        << " Sigma plot filename: " << sigma_plot_filename_ << flush;
  }
 
  if (options.exists("gw.sigma_dump")) {
    if (is_uks) {
      throw std::runtime_error("gw.sigma_dump is not implemented for UKS");
    }
    if (gwopt_.sigma_integration != "ppm" &&
        gwopt_.sigma_integration != "exact") {
      throw std::runtime_error(
          "gw.sigma_dump needs sigma_integrator ppm or exact");
    }
    if (gwopt_.do_qsgw) {
      throw std::runtime_error("gw.sigma_dump is not implemented for QSGW");
    }
    do_sigma_dump_ = true;
    sigma_dump_opt_.filename =
        options.get("gw.sigma_dump.filename").as<std::string>();
    sigma_dump_opt_.levels_emax_ev =
        options.get("gw.sigma_dump.levels_emax").as<double>();
    sigma_dump_opt_.imag_points =
        options.get("gw.sigma_dump.imag_points").as<Index>();
    sigma_dump_opt_.imag_scale =
        options.get("gw.sigma_dump.imag_scale").as<double>();
    sigma_dump_opt_.spectral_min =
        options.get("gw.sigma_dump.spectral_min").as<double>();
    sigma_dump_opt_.spectral_max =
        options.get("gw.sigma_dump.spectral_max").as<double>();
    sigma_dump_opt_.spectral_binwidth =
        options.get("gw.sigma_dump.spectral_binwidth").as<double>();
    sigma_dump_opt_.plot_steps =
        options.get("gw.sigma_dump.plot_steps").as<Index>();
    sigma_dump_opt_.plot_spacing =
        options.get("gw.sigma_dump.plot_spacing").as<double>();
    XTP_LOG(Log::error, *pLog_)
        << " Sigma dump filename: " << sigma_dump_opt_.filename << flush;
  }
}
 
void GWBSE::addoutput(tools::Property& summary) {
 
  const double hrt2ev = tools::conv::hrt2ev;
  tools::Property& gwbse_summary = summary.add("GWBSE", "");
  if (do_gw_) {
    gwbse_summary.setAttribute("units", "eV");
    gwbse_summary.setAttribute(
        "DFTEnergy",
        (boost::format("%1$+1.6f ") % (orbitals_.getDFTTotalEnergy() * hrt2ev))
            .str());
 
    if (orbitals_.hasUnrestrictedOrbitals()) {
      gwbse_summary.add("dft_alpha", "");
      gwbse_summary.add("dft_beta", "");
 
      tools::Property& alpha_summary = gwbse_summary.get("dft_alpha");
      tools::Property& beta_summary = gwbse_summary.get("dft_beta");
 
      alpha_summary.setAttribute("HOMO", orbitals_.getHomoAlpha());
      alpha_summary.setAttribute("LUMO", orbitals_.getLumoAlpha());
      beta_summary.setAttribute("HOMO", orbitals_.getHomoBeta());
      beta_summary.setAttribute("LUMO", orbitals_.getLumoBeta());
      for (Index state = 0; state < gwopt_.qpmax + 1 - gwopt_.qpmin; state++) {
        tools::Property& level_alpha = alpha_summary.add("level", "");
        level_alpha.setAttribute("number", state + gwopt_.qpmin);
        level_alpha.add(
            "dft_energy",
            (boost::format("%1$+1.6f ") %
             (orbitals_.MOs().eigenvalues()(state + gwopt_.qpmin) * hrt2ev))
                .str());
        level_alpha.add("gw_energy",
                        (boost::format("%1$+1.6f ") %
                         (orbitals_.QPpertEnergiesAlpha()(state) * hrt2ev))
                            .str());
        level_alpha.add(
            "qp_energy",
            (boost::format("%1$+1.6f ") %
             (orbitals_.QPdiagAlpha().eigenvalues()(state) * hrt2ev))
                .str());
 
        tools::Property& level_beta = beta_summary.add("level", "");
        level_beta.setAttribute("number", state + gwopt_.qpmin);
        level_beta.add(
            "dft_energy",
            (boost::format("%1$+1.6f ") %
             (orbitals_.MOs_beta().eigenvalues()(state + gwopt_.qpmin) *
              hrt2ev))
                .str());
        level_beta.add("gw_energy",
                       (boost::format("%1$+1.6f ") %
                        (orbitals_.QPpertEnergiesBeta()(state) * hrt2ev))
                           .str());
        level_beta.add("qp_energy",
                       (boost::format("%1$+1.6f ") %
                        (orbitals_.QPdiagBeta().eigenvalues()(state) * hrt2ev))
                           .str());
      }
    } else {
      tools::Property& dft_summary = gwbse_summary.add("dft", "");
      dft_summary.setAttribute("HOMO", gwopt_.homo);
      dft_summary.setAttribute("LUMO", gwopt_.homo + 1);
 
      for (Index state = 0; state < gwopt_.qpmax + 1 - gwopt_.qpmin; state++) {
        tools::Property& level_summary = dft_summary.add("level", "");
        level_summary.setAttribute("number", state + gwopt_.qpmin);
        level_summary.add(
            "dft_energy",
            (boost::format("%1$+1.6f ") %
             (orbitals_.MOs().eigenvalues()(state + gwopt_.qpmin) * hrt2ev))
                .str());
        level_summary.add("gw_energy",
                          (boost::format("%1$+1.6f ") %
                           (orbitals_.QPpertEnergies()(state) * hrt2ev))
                              .str());
        level_summary.add("qp_energy",
                          (boost::format("%1$+1.6f ") %
                           (orbitals_.QPdiag().eigenvalues()(state) * hrt2ev))
                              .str());
      }
    }
  }
  if (do_bse_singlets_) {
    tools::Property& singlet_summary = gwbse_summary.add("singlets", "");
    for (Index state = 0; state < bseopt_.nmax; ++state) {
      tools::Property& level_summary = singlet_summary.add("level", "");
      level_summary.setAttribute("number", state + 1);
      level_summary.add(
          "omega", (boost::format("%1$+1.6f ") %
                    (orbitals_.BSESinglets().eigenvalues()(state) * hrt2ev))
                       .str());
      if (orbitals_.hasTransitionDipoles()) {
 
        const Eigen::Vector3d& dipoles = (orbitals_.TransitionDipoles())[state];
        double f = 2 * dipoles.squaredNorm() *
                   orbitals_.BSESinglets().eigenvalues()(state) / 3.0;
 
        level_summary.add("f", (boost::format("%1$+1.6f ") % f).str());
        tools::Property& dipol_summary = level_summary.add(
            "Trdipole", (boost::format("%1$+1.4f %2$+1.4f %3$+1.4f") %
                         dipoles.x() % dipoles.y() % dipoles.z())
                            .str());
        dipol_summary.setAttribute("unit", "e*bohr");
        dipol_summary.setAttribute("gauge", "length");
      }
    }
  }
  if (do_bse_triplets_) {
    tools::Property& triplet_summary = gwbse_summary.add("triplets", "");
    for (Index state = 0; state < bseopt_.nmax; ++state) {
      tools::Property& level_summary = triplet_summary.add("level", "");
      level_summary.setAttribute("number", state + 1);
      level_summary.add(
          "omega", (boost::format("%1$+1.6f ") %
                    (orbitals_.BSETriplets().eigenvalues()(state) * hrt2ev))
                       .str());
    }
  }
  if (do_bse_exciton_uks_) {
    tools::Property& exciton_uks_summary = gwbse_summary.add("exciton_uks", "");
 
    const bool has_dipoles = orbitals_.hasTransitionDipoles();
    Eigen::VectorXd oscs = Eigen::VectorXd::Zero(0);
    if (has_dipoles) {
      oscs =
          orbitals_.Oscillatorstrengths(QMStateType(QMStateType::ExcitonUKS));
    }
 
    for (Index state = 0;
         state <
         std::min<Index>(bseopt_.nmax, orbitals_.BSEUKS().eigenvalues().size());
         ++state) {
      tools::Property& level_summary = exciton_uks_summary.add("level", "");
      level_summary.setAttribute("number", state + 1);
      level_summary.add("omega",
                        (boost::format("%1$+1.6f ") %
                         (orbitals_.BSEUKS().eigenvalues()(state) * hrt2ev))
                            .str());
      const Index ndip =
          static_cast<Index>(orbitals_.TransitionDipoles().size());
      const Index nosc = static_cast<Index>(oscs.size());
 
      if (has_dipoles && state < ndip && state < nosc) {
        const Eigen::Vector3d& dipoles = orbitals_.TransitionDipoles()[state];
 
        level_summary.add("f",
                          (boost::format("%1$+1.6f ") % oscs(state)).str());
 
        tools::Property& dipol_summary = level_summary.add(
            "Trdipole", (boost::format("%1$+1.4f %2$+1.4f %3$+1.4f") %
                         dipoles.x() % dipoles.y() % dipoles.z())
                            .str());
        dipol_summary.setAttribute("unit", "e*bohr");
        dipol_summary.setAttribute("gauge", "length");
      }
    }
  }
 
  return;
}
 
/*
 *    Many-body Green's fuctions theory implementation
 *
 *  data required from orbitals file
 *  - atomic coordinates
 *  - DFT molecular orbitals (energies and coeffcients)
 *  - DFT exchange-correlation potential matrix in atomic orbitals
 *  - number of electrons, number of levels
 */
 
Eigen::MatrixXd GWBSE::CalculateVXC(const AOBasis& dftbasis) {
  if (orbitals_.getXCFunctionalName().empty()) {
    orbitals_.setXCFunctionalName(functional_);
  } else {
    if (!(functional_ == orbitals_.getXCFunctionalName())) {
      throw std::runtime_error("Functionals from DFT " +
                               orbitals_.getXCFunctionalName() + " GWBSE " +
                               functional_ + " differ!");
    }
  }
 
  Vxc_Grid grid;
  grid.GridSetup(grid_, orbitals_.QMAtoms(), dftbasis);
  XTP_LOG(Log::info, *pLog_)
      << TimeStamp() << " Setup grid for integration with gridsize: " << grid_
      << " with " << grid.getGridSize() << " points, divided into "
      << grid.getBoxesSize() << " boxes" << flush;
  Vxc_Potential<Vxc_Grid> vxcpotential(grid);
  vxcpotential.setXCfunctional(functional_);
  XTP_LOG(Log::error, *pLog_)
      << TimeStamp() << " Integrating Vxc with functional " << functional_
      << flush;
  Eigen::MatrixXd DMAT = orbitals_.DensityMatrixGroundState();
  Mat_p_Energy e_vxc_ao = vxcpotential.IntegrateVXC(DMAT);
  XTP_LOG(Log::info, *pLog_) << TimeStamp() << " Calculated Vxc" << flush;
  XTP_LOG(Log::error, *pLog_)
      << TimeStamp() << " Set hybrid exchange factor: " << orbitals_.getScaHFX()
      << flush;
  Index qptotal = gwopt_.qpmax - gwopt_.qpmin + 1;
  Eigen::MatrixXd mos =
      orbitals_.MOs().eigenvectors().middleCols(gwopt_.qpmin, qptotal);
 
  Eigen::MatrixXd vxc = mos.transpose() * e_vxc_ao.matrix() * mos;
  XTP_LOG(Log::error, *pLog_)
      << TimeStamp() << " Calculated exchange-correlation expectation values "
      << flush;
 
  return vxc;
}
 
std::pair<Eigen::MatrixXd, Eigen::MatrixXd> GWBSE::CalculateVXCSpinResolved(
    const AOBasis& dftbasis) {
  if (orbitals_.getXCFunctionalName().empty()) {
    orbitals_.setXCFunctionalName(functional_);
  } else if (!(functional_ == orbitals_.getXCFunctionalName())) {
    throw std::runtime_error("Functionals from DFT " +
                             orbitals_.getXCFunctionalName() + " GWBSE " +
                             functional_ + " differ!");
  }
 
  Vxc_Grid grid;
  grid.GridSetup(grid_, orbitals_.QMAtoms(), dftbasis);
  Vxc_Potential<Vxc_Grid> vxcpotential(grid);
  vxcpotential.setXCfunctional(functional_);
 
  auto dmats = orbitals_.DensityMatrixGroundStateSpinResolved();
  auto e_vxc_ao = vxcpotential.IntegrateVXCSpin(dmats[0], dmats[1]);
 
  Index qptotal = gwopt_.qpmax - gwopt_.qpmin + 1;
  Eigen::MatrixXd mos_alpha =
      orbitals_.MOs().eigenvectors().middleCols(gwopt_.qpmin, qptotal);
  Eigen::MatrixXd mos_beta =
      orbitals_.MOs_beta().eigenvectors().middleCols(gwopt_.qpmin, qptotal);
 
  Eigen::MatrixXd vxc_alpha =
      mos_alpha.transpose() * e_vxc_ao.vxc_alpha * mos_alpha;
  Eigen::MatrixXd vxc_beta =
      mos_beta.transpose() * e_vxc_ao.vxc_beta * mos_beta;
 
  return std::make_pair(vxc_alpha, vxc_beta);
}
 
bool GWBSE::Evaluate() {
  citations::Cite("Wehner:2018");
  citations::Cite("Tirimbo:2020a");
  if (gwopt_.do_qsgw) {
    citations::Cite("vanSchilfgaarde:2006");
  }
 
  // set the parallelization
  XTP_LOG(Log::error, *pLog_) << TimeStamp() << " Using "
                              << OPENMP::getMaxThreads() << " threads" << flush;
 
  XTP_LOG(Log::error, *pLog_)
      << TimeStamp() << " Using " << EigenBackendDescription() << flush;
  if (accelerate::LapackAvailable()) {
    XTP_LOG(Log::error, *pLog_) << TimeStamp()
                                << " Screening eigensolvers and inverses call "
                                   "Accelerate LAPACK directly"
                                << flush;
  }
  XTP_LOG(Log::error, *pLog_)
      << TimeStamp() << " Molecule Coordinates [A] " << flush;
  for (QMAtom& atom : orbitals_.QMAtoms()) {
    std::string output = (boost::format("%5d"
                                        "%5s"
                                        "   %1.4f %1.4f %1.4f") %
                          atom.getId() % atom.getElement() %
                          (atom.getPos().x() * tools::conv::bohr2ang) %
                          (atom.getPos().y() * tools::conv::bohr2ang) %
                          (atom.getPos().z() * tools::conv::bohr2ang))
                             .str();
 
    XTP_LOG(Log::error, *pLog_) << output << flush;
  }
 
  std::string dft_package = orbitals_.getQMpackage();
  XTP_LOG(Log::error, *pLog_)
      << TimeStamp() << " DFT data was created by " << dft_package << flush;
 
  BasisSet dftbs;
  dftbs.Load(dftbasis_name_);
 
  XTP_LOG(Log::error, *pLog_)
      << TimeStamp() << " Loaded DFT Basis Set " << dftbasis_name_ << flush;
 
  AOBasis dftbasis = orbitals_.getDftBasis();
  XTP_LOG(Log::error, *pLog_) << TimeStamp() << " Filled DFT Basis of size "
                              << dftbasis.AOBasisSize() << flush;
  XTP_LOG(Log::error, *pLog_)
      << TimeStamp() << " Loaded Auxbasis Set " << auxbasis_name_ << flush;
 
  orbitals_.SetupAuxBasis(auxbasis_name_);
  AOBasis auxbasis = orbitals_.getAuxBasis();
  XTP_LOG(Log::error, *pLog_) << TimeStamp() << " Filled Auxbasis of size "
                              << auxbasis.AOBasisSize() << flush;
 
  if ((do_bse_singlets_ || do_bse_triplets_ || do_bse_exciton_uks_) &&
      fragments_.size() > 0) {
    for (const auto& frag : fragments_) {
      XTP_LOG(Log::error, *pLog_) << TimeStamp() << " Fragment " << frag.getId()
                                  << " size:" << frag.size() << flush;
    }
  }
 
  if (!do_gw_) {
    if ((!orbitals_.hasUnrestrictedOrbitals() && !orbitals_.hasQPdiag()) ||
        (orbitals_.hasUnrestrictedOrbitals() &&
         (!orbitals_.hasQPdiagAlpha() || !orbitals_.hasQPdiagBeta()))) {
      throw std::runtime_error(
          "You want no GW calculation but the orb file has no matching QP "
          "coefficients.");
    }
  }
  const bool is_uks = orbitals_.hasUnrestrictedOrbitals();
  TCMatrix_gwbse Mmn;
  TCMatrix_gwbse_spin Mmn_spin;
  // rpamin here, because RPA needs till rpamin
  Index max_3c = std::max(bseopt_.cmax, gwopt_.qpmax);
  if (is_uks) {
    Mmn_spin.alpha.Initialize(auxbasis.AOBasisSize(), gwopt_.rpamin, max_3c,
                              gwopt_.rpamin, gwopt_.rpamax);
    Mmn_spin.beta.Initialize(auxbasis.AOBasisSize(), gwopt_.rpamin, max_3c,
                             gwopt_.rpamin, gwopt_.rpamax);
    XTP_LOG(Log::error, *pLog_)
        << TimeStamp() << " Calculating alpha spin Mmn " << flush;
    Mmn_spin.alpha.Fill(auxbasis, dftbasis, orbitals_.MOs().eigenvectors());
    XTP_LOG(Log::error, *pLog_)
        << TimeStamp() << " Calculating beta spin Mmn " << flush;
    Mmn_spin.beta.Fill(auxbasis, dftbasis, orbitals_.MOs_beta().eigenvectors());
  } else {
    Mmn.Initialize(auxbasis.AOBasisSize(), gwopt_.rpamin, max_3c, gwopt_.rpamin,
                   gwopt_.rpamax);
    XTP_LOG(Log::error, *pLog_)
        << TimeStamp() << " Calculating Mmn (3-center-repulsion x orbitals)  "
        << flush;
    Mmn.Fill(auxbasis, dftbasis, orbitals_.MOs().eigenvectors());
    XTP_LOG(Log::info, *pLog_)
        << TimeStamp() << " Removed " << Mmn.Removedfunctions()
        << " functions from Aux Coulomb matrix to avoid near linear "
           "dependencies"
        << flush;
    XTP_LOG(Log::error, *pLog_)
        << TimeStamp() << " Calculated Mmn (3-center-repulsion x orbitals)  "
        << flush;
  }
  if (const std::string usage = MemoryBudget::Usage(); !usage.empty()) {
    XTP_LOG(Log::error, *pLog_)
        << TimeStamp() << " After Mmn: " << usage << flush;
  }
 
  // The environment's reaction field in the metric of Mmn. Needs only the
  // auxiliary basis and its metric, so it stays valid however Mmn is later
  // rotated, dressed or refilled (QSGW) -- all of it on this basis.
  Eigen::MatrixXd reaction_field;
  if (!environment_.empty()) {
    if (is_uks) {
      throw std::runtime_error(
          "GWBSE: environment screening is implemented for closed-shell "
          "systems only.");
    }
    std::chrono::time_point<std::chrono::system_clock> start =
        std::chrono::system_clock::now();
    Index n_explicit = 0;
    for (const PolarSegment& seg : environment_.explicit_segments) {
      n_explicit += seg.size();
    }
    Index n_shell = 0;
    for (const PolarSegment& seg : environment_.shell_segments) {
      n_shell += seg.size();
    }
    XTP_LOG(Log::error, *pLog_)
        << TimeStamp() << " Environment screening: " << n_explicit
        << " explicit Thole sites (exp_damp " << environment_.exp_damp << "), "
        << n_shell << " shell sites (epsilon " << environment_.shell_dielectric
        << ")" << flush;
    const Eigen::MatrixXd B =
        EnvironmentScreening::Kernel(auxbasis, environment_);
    reaction_field =
        EnvironmentScreening::SymmetrizedReactionField(B, Mmn.InvSqrt());
    std::chrono::duration<double> elapsed_time =
        std::chrono::system_clock::now() - start;
    XTP_LOG(Log::error, *pLog_)
        << TimeStamp() << " Built environment reaction field in "
        << elapsed_time.count() << " seconds." << flush;
  }
 
  Eigen::MatrixXd Hqp;
  Eigen::MatrixXd Hqp_alpha;
  Eigen::MatrixXd Hqp_beta;
  if (do_gw_) {
 
    std::chrono::time_point<std::chrono::system_clock> start =
        std::chrono::system_clock::now();
    if (is_uks) {
      if (gwopt_.do_qsgw) {
        throw std::runtime_error(
            "QSGW (gw.do_qsgw) is not implemented for open-shell (UKS) "
            "references.");
      }
      auto vxc = CalculateVXCSpinResolved(dftbasis);
      GW_UKS::options gwopt_uks;
      gwopt_uks.homo_alpha = orbitals_.getHomoAlpha();
      gwopt_uks.homo_beta = orbitals_.getHomoBeta();
      gwopt_uks.qpmin = gwopt_.qpmin;
      gwopt_uks.qpmax = gwopt_.qpmax;
      gwopt_uks.rpamin = gwopt_.rpamin;
      gwopt_uks.rpamax = gwopt_.rpamax;
      gwopt_uks.eta = gwopt_.eta;
      gwopt_uks.g_sc_limit = gwopt_.g_sc_limit;
      gwopt_uks.g_sc_max_iterations = gwopt_.g_sc_max_iterations;
      gwopt_uks.gw_sc_limit = gwopt_.gw_sc_limit;
      gwopt_uks.gw_sc_max_iterations = gwopt_.gw_sc_max_iterations;
      gwopt_uks.shift = gwopt_.shift;
      gwopt_uks.ScaHFX = gwopt_.ScaHFX;
      gwopt_uks.sigma_integration = gwopt_.sigma_integration;
      gwopt_uks.reset_3c = gwopt_.reset_3c;
      gwopt_uks.qp_solver = gwopt_.qp_solver;
      gwopt_uks.qp_solver_alpha = gwopt_.qp_solver_alpha;
      gwopt_uks.qp_grid_steps = gwopt_.qp_grid_steps;
      gwopt_uks.qp_grid_spacing = gwopt_.qp_grid_spacing;
 
      // Forward the already-normalized canonical grid-search controls so that
      // RKS and UKS use the same search design and only differ in the
      // spin-dependent sigma evaluation.
      gwopt_uks.qp_full_window_half_width = gwopt_.qp_full_window_half_width;
      gwopt_uks.qp_dense_spacing = gwopt_.qp_dense_spacing;
      gwopt_uks.qp_adaptive_shell_width = gwopt_.qp_adaptive_shell_width;
      gwopt_uks.qp_adaptive_shell_count = gwopt_.qp_adaptive_shell_count;
      gwopt_uks.gw_mixing_order = gwopt_.gw_mixing_order;
      gwopt_uks.gw_mixing_alpha = gwopt_.gw_mixing_alpha;
      gwopt_uks.quadrature_scheme = gwopt_.quadrature_scheme;
      gwopt_uks.order = gwopt_.order;
      gwopt_uks.alpha = gwopt_.alpha;
      gwopt_uks.out_of_window_shift = gwopt_.out_of_window_shift;
      gwopt_uks.qp_restrict_search = gwopt_.qp_restrict_search;
      gwopt_uks.qp_root_continuity = gwopt_.qp_root_continuity;
      gwopt_uks.screening_update = gwopt_.screening_update;
      gwopt_uks.qp_root_tracking = gwopt_.qp_root_tracking;
      gwopt_uks.screening_update_ratio = gwopt_.screening_update_ratio;
      gwopt_uks.screening_update_max_inner = gwopt_.screening_update_max_inner;
      gwopt_uks.qp_zero_margin = gwopt_.qp_zero_margin;
      gwopt_uks.qp_virtual_min_energy = gwopt_.qp_virtual_min_energy;
      gwopt_uks.qp_root_finder = gwopt_.qp_root_finder;
      gwopt_uks.qp_grid_search_mode = gwopt_.qp_grid_search_mode;
 
      GW_UKS gw = GW_UKS(*pLog_, Mmn_spin, vxc.first, vxc.second,
                         orbitals_.MOs().eigenvalues(),
                         orbitals_.MOs_beta().eigenvalues());
      gw.configure(gwopt_uks);
      if (gwopt_.rpamin > 0 && core_exchange_) {
        gw.setCoreExchange(
            TCMatrix_gwbse::CoreExchange(
                auxbasis, dftbasis, orbitals_.MOs().eigenvectors(),
                gwopt_.rpamin, gwopt_.qpmin, gwopt_.qpmax),
            TCMatrix_gwbse::CoreExchange(
                auxbasis, dftbasis, orbitals_.MOs_beta().eigenvectors(),
                gwopt_.rpamin, gwopt_.qpmin, gwopt_.qpmax));
        XTP_LOG(Log::error, *pLog_)
            << TimeStamp() << " Sigma_x includes the exchange with the "
            << gwopt_.rpamin << " frozen core levels" << flush;
      }
      gw.CalculateGWPerturbation();
      orbitals_.QPpertEnergiesAlpha() = gw.getGWAResultsAlpha();
      orbitals_.QPpertEnergiesBeta() = gw.getGWAResultsBeta();
      orbitals_.RPAInputEnergiesAlpha() = gw.RPAInputEnergiesAlpha();
      orbitals_.RPAInputEnergiesBeta() = gw.RPAInputEnergiesBeta();
      gw.CalculateHQP();
      Hqp_alpha = gw.getHQPAlpha();
      Hqp_beta = gw.getHQPBeta();
      Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> es_alpha =
          gw.DiagonalizeQPHamiltonianAlpha();
      Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> es_beta =
          gw.DiagonalizeQPHamiltonianBeta();
      orbitals_.QPdiagAlpha().eigenvectors() = es_alpha.eigenvectors();
      orbitals_.QPdiagAlpha().eigenvalues() = es_alpha.eigenvalues();
      orbitals_.QPdiagBeta().eigenvectors() = es_beta.eigenvectors();
      orbitals_.QPdiagBeta().eigenvalues() = es_beta.eigenvalues();
      std::chrono::duration<double> elapsed_time =
          std::chrono::system_clock::now() - start;
      XTP_LOG(Log::error, *pLog_)
          << TimeStamp() << " UKS GW calculation took " << elapsed_time.count()
          << " seconds." << flush;
    } else {
      Eigen::MatrixXd vxc = CalculateVXC(dftbasis);
      GW gw = GW(*pLog_, Mmn, vxc, orbitals_.MOs().eigenvalues());
      gw.configure(gwopt_);
      gw.setKeepScreeningData(do_sigma_dump_);
      gw.setReactionField(reaction_field);
      if (gwopt_.rpamin > 0 && core_exchange_) {
        gw.setCoreExchange(TCMatrix_gwbse::CoreExchange(
            auxbasis, dftbasis, orbitals_.MOs().eigenvectors(), gwopt_.rpamin,
            gwopt_.qpmin, gwopt_.qpmax));
        XTP_LOG(Log::error, *pLog_)
            << TimeStamp() << " Sigma_x includes the exchange with the "
            << gwopt_.rpamin << " frozen core levels" << flush;
      }
 
      gw.CalculateGWPerturbation();
 
      if (!sigma_plot_states_.empty()) {
        gw.PlotSigma(sigma_plot_filename_, sigma_plot_steps_,
                     sigma_plot_spacing_, sigma_plot_states_);
      }
 
      orbitals_.QPpertEnergies() = gw.getGWAResults();
      orbitals_.RPAInputEnergies() = gw.RPAInputEnergies();
 
      XTP_LOG(Log::info, *pLog_)
          << TimeStamp() << " Calculating offdiagonal part of Sigma  " << flush;
      if (gwopt_.do_qsgw) {
        // QSGW: iterate rotation of Mmn until QP energies converge.
        gw.CalculateQSGW();
 
        // Print seed vs QSGW comparison. Label the seed column by what
        // CalculateGWPerturbation ran: G0W0 if one iteration, evGW otherwise.
        const std::string seed_label =
            (gwopt_.gw_sc_max_iterations == 1) ? "G0W0" : "evGW";
        Eigen::VectorXd qsgw_energies = gw.getGWAResults();
        gw.PrintQSGW_Energies(seed_label, gw.getQSGWSeedEnergies(),
                              qsgw_energies);
        gw.PrintQSGW_Composition();
 
        // The QSGW orbitals and energies: QPdiag holds U (DFT MOs -> QSGW
        // orbitals, columns) and the energies, so that BSE-only runs from the
        // .orb file and everything built from the BSE vectors (transition
        // dipoles, densities) use C_qp = C_dft U (Orbitals::BSEOrbitals).
        // QPpertEnergies() keeps the G0W0/evGW seed. The RPA energies are
        // the QSGW ones in the window.
        orbitals_.QPdiag().eigenvalues() = qsgw_energies;
        orbitals_.QPdiag().eigenvectors() = gw.getQSGWRotation();
        orbitals_.setQSGW(true);
        orbitals_.RPAInputEnergies() = gw.RPAInputEnergies();
 
        // The BSE in the QSGW orbitals: integrals refilled with C_qp (levels
        // outside the GW window stay DFT MOs, scissor-shifted in the RPA
        // energies and in AdjustHqpSize), and H_qp is diagonal.
        XTP_LOG(Log::error, *pLog_)
            << TimeStamp() << " Rebuilding Mmn in QSGW QP wavefunction basis"
            << flush;
        Mmn.Fill(auxbasis, dftbasis, orbitals_.BSEOrbitals());
        XTP_LOG(Log::error, *pLog_)
            << TimeStamp() << " Rebuilt Mmn (3-center-repulsion x QP orbitals)"
            << flush;
        Hqp = qsgw_energies.asDiagonal();
      } else {
        orbitals_.setQSGW(false);
        gw.CalculateHQP();
        XTP_LOG(Log::error, *pLog_)
            << TimeStamp() << " Calculated offdiagonal part of Sigma  "
            << flush;
 
        Hqp = gw.getHQP();
 
        if (do_sigma_dump_) {
          gw.DumpSigma(sigma_dump_opt_,
                       (gwopt_.gw_sc_max_iterations > 1) ? "evGW" : "G0W0",
                       votca::tools::ToolsVersionStr());
        }
 
        Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> es =
            gw.DiagonalizeQPHamiltonian();
        if (es.info() == Eigen::ComputationInfo::Success) {
          XTP_LOG(Log::error, *pLog_)
              << TimeStamp() << " Diagonalized QP Hamiltonian  " << flush;
        }
 
        orbitals_.QPdiag().eigenvectors() = es.eigenvectors();
        orbitals_.QPdiag().eigenvalues() = es.eigenvalues();
      }
      std::chrono::duration<double> elapsed_time =
          std::chrono::system_clock::now() - start;
      XTP_LOG(Log::error, *pLog_)
          << TimeStamp() << " GW calculation took " << elapsed_time.count()
          << " seconds." << flush;
    }
 
  } else {
    if (orbitals_.getGWAmax() != gwopt_.qpmax ||
        orbitals_.getGWAmin() != gwopt_.qpmin ||
        orbitals_.getRPAmax() != gwopt_.rpamax ||
        orbitals_.getRPAmin() != gwopt_.rpamin) {
      throw std::runtime_error(
          "The ranges for GW and RPA do not agree with the ranges from the "
          ".orb file, rerun your GW calculation");
    }
 
    if (is_uks) {
      const Eigen::MatrixXd& qpcoeff_alpha =
          orbitals_.QPdiagAlpha().eigenvectors();
      const Eigen::MatrixXd& qpcoeff_beta =
          orbitals_.QPdiagBeta().eigenvectors();
 
      Hqp_alpha = qpcoeff_alpha *
                  orbitals_.QPdiagAlpha().eigenvalues().asDiagonal() *
                  qpcoeff_alpha.transpose();
      Hqp_beta = qpcoeff_beta *
                 orbitals_.QPdiagBeta().eigenvalues().asDiagonal() *
                 qpcoeff_beta.transpose();
    } else if (orbitals_.isQSGW()) {
      // QSGW BSE-only run: rebuild Mmn_ in the QSGW orbitals stored in
      // QPdiag. Hqp is diagonal in that basis.
      XTP_LOG(Log::error, *pLog_)
          << TimeStamp()
          << " Rebuilding Mmn in QSGW QP wavefunction basis (BSE-only)"
          << flush;
      Mmn.Fill(auxbasis, dftbasis, orbitals_.BSEOrbitals());
      XTP_LOG(Log::error, *pLog_)
          << TimeStamp() << " Rebuilt Mmn (3-center-repulsion x QP orbitals)"
          << flush;
      Hqp = orbitals_.QPdiag().eigenvalues().asDiagonal();
    } else {
      const Eigen::MatrixXd& qpcoeff = orbitals_.QPdiag().eigenvectors();
 
      Hqp = qpcoeff * orbitals_.QPdiag().eigenvalues().asDiagonal() *
            qpcoeff.transpose();
    }
  }
 
  // proceed only if BSE requested
  if (do_bse_singlets_ || do_bse_triplets_ || do_bse_exciton_uks_) {
 
    std::chrono::time_point<std::chrono::system_clock> start =
        std::chrono::system_clock::now();
 
    if (is_uks) {
 
      // Build a single spin-summed dielectric screening from the unrestricted
      // RPA response and reuse it for both exciton spin channels.
      RPA_UKS rpa_uks_bse(*pLog_, Mmn_spin);
      rpa_uks_bse.configure(orbitals_.getHomoAlpha(), orbitals_.getHomoBeta(),
                            bseopt_.rpamin, bseopt_.rpamax);
      rpa_uks_bse.setRPAInputEnergies(orbitals_.RPAInputEnergiesAlpha(),
                                      orbitals_.RPAInputEnergiesBeta());
 
      const SymmetricEigenSystem es_bse =
          SymmetricEigen(rpa_uks_bse.calculate_epsilon_r(0.0));
 
      Eigen::VectorXd epsilon_0_inv_bse =
          Eigen::VectorXd::Zero(es_bse.values.size());
      for (Index i = 0; i < es_bse.values.size(); ++i) {
        if (es_bse.values(i) > 1e-8) {
          epsilon_0_inv_bse(i) = 1.0 / es_bse.values(i);
        }
      }
 
      if (do_bse_exciton_uks_) {
        BSE_UKS::options bseopt_uks;
        bseopt_uks.useTDA = bseopt_.useTDA;
        bseopt_uks.rpamin = bseopt_.rpamin;
        bseopt_uks.rpamax = bseopt_.rpamax;
        bseopt_uks.qpmin = bseopt_.qpmin;
        bseopt_uks.qpmax = bseopt_.qpmax;
        bseopt_uks.vmin = bseopt_.vmin;
        bseopt_uks.cmax = bseopt_.cmax;
        bseopt_uks.nmax = bseopt_.nmax;
        bseopt_uks.davidson_correction = bseopt_.davidson_correction;
        bseopt_uks.davidson_tolerance = bseopt_.davidson_tolerance;
        bseopt_uks.davidson_update = bseopt_.davidson_update;
        bseopt_uks.davidson_maxiter = bseopt_.davidson_maxiter;
        bseopt_uks.min_print_weight = bseopt_.min_print_weight;
        bseopt_uks.use_Hqp_offdiag = bseopt_.use_Hqp_offdiag;
        bseopt_uks.max_dyn_iter = bseopt_.max_dyn_iter;
        bseopt_uks.dyn_tolerance = bseopt_.dyn_tolerance;
 
        BSE_UKS bse_uks(*pLog_, Mmn_spin);
        bse_uks.configure_with_precomputed_screening(
            bseopt_uks, orbitals_.getHomoAlpha(), orbitals_.getHomoBeta(),
            orbitals_.RPAInputEnergiesAlpha(), orbitals_.RPAInputEnergiesBeta(),
            Hqp_alpha, Hqp_beta, epsilon_0_inv_bse, es_bse.vectors);
 
        bse_uks.Solve_excitons_uks(orbitals_);
        XTP_LOG(Log::error, *pLog_)
            << TimeStamp() << " Solved combined UKS BSE exciton problem "
            << flush;
        bse_uks.Analyze_excitons_uks(fragments_, orbitals_);
 
        if (do_dynamical_screening_bse_) {
          bse_uks.Perturbative_DynamicalScreening(orbitals_);
        }
      }
    } else {
      BSE bse = BSE(*pLog_, Mmn);
      bse.setReactionField(reaction_field, environment_.include_kreac);
      bse.configure(bseopt_, orbitals_.RPAInputEnergies(), Hqp);
 
      if (do_bse_triplets_) {
        bse.Solve_triplets(orbitals_);
        XTP_LOG(Log::error, *pLog_)
            << TimeStamp() << " Solved BSE for triplets " << flush;
        bse.Analyze_triplets(fragments_, orbitals_);
      }
 
      if (do_bse_singlets_) {
        bse.Solve_singlets(orbitals_);
        XTP_LOG(Log::error, *pLog_)
            << TimeStamp() << " Solved BSE for singlets " << flush;
        bse.Analyze_singlets(fragments_, orbitals_);
      }
 
      if (do_dynamical_screening_bse_) {
        if (do_bse_triplets_) {
          bse.Perturbative_DynamicalScreening(QMStateType(QMStateType::Triplet),
                                              orbitals_);
        }
 
        if (do_bse_singlets_) {
          bse.Perturbative_DynamicalScreening(QMStateType(QMStateType::Singlet),
                                              orbitals_);
        }
      }
    }
 
    std::chrono::duration<double> elapsed_time =
        std::chrono::system_clock::now() - start;
    XTP_LOG(Log::error, *pLog_) << TimeStamp() << " BSE calculation took "
                                << elapsed_time.count() << " seconds." << flush;
  }
  if (const std::string usage = MemoryBudget::Usage(); !usage.empty()) {
    XTP_LOG(Log::error, *pLog_)
        << TimeStamp() << " End of GWBSE: " << usage << flush;
  }
  XTP_LOG(Log::error, *pLog_)
      << TimeStamp() << " GWBSE calculation finished " << flush;
  return true;
}
 
}  // namespace xtp
}  // namespace votca