gwbse.h

Go to the documentation of this file.

/*
 *            Copyright 2009-2022 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.
 *
 */
 
#pragma once
#ifndef VOTCA_XTP_GWBSE_H
#define VOTCA_XTP_GWBSE_H
 
// Standard includes
#include <fstream>
 
// VOTCA includes
#include <votca/tools/property.h>
 
// Local VOTCA includes
#include "bse.h"
#include "bse_uks.h"
#include "eigen.h"
#include "environmentscreening.h"
#include "gw.h"
#include "gw_uks.h"
#include "logger.h"
#include "qmfragment.h"
 
namespace votca {
namespace xtp {
class Orbitals;
class AOBasis;
 
class GWBSE {
 public:
  GWBSE(Orbitals& orbitals) : orbitals_(orbitals) {};
  void Initialize(tools::Property& options);
 
  std::string Identify() { return "gwbse"; }
 
  void setLogger(Logger* pLog) { pLog_ = pLog; }
 
  // Screen GW and BSE by a static polarizable environment (embedded
  // GW-BSE). R is built in Evaluate, once the auxiliary basis and its
  // metric exist. Closed shell only.
  void setScreeningEnvironment(const ScreeningEnvironment& env) {
    environment_ = env;
  }
 
  bool Evaluate();
 
  void addoutput(tools::Property& summary);
 
 private:
  Eigen::MatrixXd CalculateVXC(const AOBasis& dftbasis);
  std::pair<Eigen::MatrixXd, Eigen::MatrixXd> CalculateVXCSpinResolved(
      const AOBasis& dftbasis);
  Index CountCoreLevels();
  Logger* pLog_;
  Orbitals& orbitals_;
  // program tasks
 
  bool do_gw_ = false;
  bool do_bse_singlets_ = false;
  bool do_bse_triplets_ = false;
  bool do_dynamical_screening_bse_ = false;
  bool do_bse_exciton_uks_ = false;
 
  // options for own Vxc calculation
  std::string functional_;
  std::string grid_;
 
  GW::options gwopt_;
  BSE::options bseopt_;
 
  std::string sigma_plot_states_;
  // frozen-core GW (rpamin > 0): include the exchange with the core levels
  // in Sigma_x (gw.core_exchange)
  bool core_exchange_ = true;
  Index sigma_plot_steps_;
  double sigma_plot_spacing_;
  std::string sigma_plot_filename_;
 
  // basis sets
  std::string auxbasis_name_;
  std::string dftbasis_name_;
 
  std::vector<QMFragment<BSE_Population> > fragments_;
 
  ScreeningEnvironment environment_;
};
}  // namespace xtp
}  // namespace votca
 
#endif  // VOTCA_XTP_GWBSE_H