screening_update.h

Go to the documentation of this file.

/*
 *            Copyright 2009-2026 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_SCREENING_UPDATE_H
#define VOTCA_XTP_SCREENING_UPDATE_H
 
// Standard includes
#include <stdexcept>
#include <string>
 
// Local VOTCA includes
#include "eigen.h"
 
namespace votca {
namespace xtp {

class ScreeningUpdate {
 public:
  enum class Mode { Every, Adaptive };
  enum class Next { Continue, Rebuild, Converged };
 
  static Mode Parse(const std::string& name) {
    if (name == "every") {
      return Mode::Every;
    } else if (name == "adaptive") {
      return Mode::Adaptive;
    }
    throw std::runtime_error("Unknown gw.screening_update '" + name +
                             "'; choices are every, adaptive");
  }
  static std::string Name(Mode mode) {
    return (mode == Mode::Adaptive) ? "adaptive" : "every";
  }
 
  void Configure(Mode mode, double ratio, Index max_inner) {
    mode_ = mode;
    ratio_ = ratio;
    max_inner_ = max_inner;
  }
  Mode mode() const { return mode_; }

  void Built(const Eigen::VectorXd& energies) {
    built_from_ = energies;
    inner_ = 0;
    ++builds_;
  }
  Index builds() const { return builds_; }
  Index inner() const { return inner_; }

  Next Decide(double residual, const Eigen::VectorXd& new_energies,
              double limit, double* drift_out = nullptr) {
    ++inner_;
    const double step = residual;
    const double drift = (new_energies - built_from_).cwiseAbs().maxCoeff();
    if (drift_out != nullptr) {
      *drift_out = drift;
    }
    if (mode_ == Mode::Every) {
      return (step < limit) ? Next::Converged : Next::Rebuild;
    }
    if (step < limit) {
      return (drift < limit) ? Next::Converged : Next::Rebuild;
    }
    if (step < ratio_ * drift || inner_ >= max_inner_) {
      return Next::Rebuild;
    }
    return Next::Continue;
  }
 
 private:
  Mode mode_ = Mode::Every;
  double ratio_ = 0.25;
  Index max_inner_ = 10;
  Eigen::VectorXd built_from_;
  Index inner_ = 0;
  Index builds_ = 0;
};
 
}  // namespace xtp
}  // namespace votca
 
#endif  // VOTCA_XTP_SCREENING_UPDATE_H