EigenmodeStrategy.h

Go to the documentation of this file.

/*
** This file is part of eOn.
**
** SPDX-License-Identifier: BSD-3-Clause
**
** Copyright (c) 2010--present, eOn Development Team
** All rights reserved.
**
** Repo:
** https://github.com/TheochemUI/eOn
*/
#pragma once
 
#include "Davidson.h"
#include "Dimer.h"
#include "ImprovedDimer.h"
#include "Lanczos.h"
#include "LowestEigenmode.h"
#include <stdexcept>
#include <variant>
 
#ifdef WITH_GPRD
#include "AtomicGPDimer.h"
#endif
 
namespace eonc {
 
#ifdef WITH_GPRD
using EigenmodeStrategy =
    std::variant<Dimer, ImprovedDimer, Lanczos, Davidson, AtomicGPDimer>;
#else
using EigenmodeStrategy = std::variant<Dimer, ImprovedDimer, Lanczos, Davidson>;
#endif

inline std::shared_ptr<EigenmodeStrategy>
buildEigenmodeStrategy(std::shared_ptr<Matter> matter, const Parameters &params,
                       std::shared_ptr<Potential> pot) {
  if (params.saddle_search_options.minmode_method ==
      LowestEigenmode::MINMODE_DIMER) {
    if (params.dimer_options.improved) {
      return std::make_shared<EigenmodeStrategy>(
          ImprovedDimer(matter, params, pot));
    }
    return std::make_shared<EigenmodeStrategy>(Dimer(matter, params, pot));
  } else if (params.saddle_search_options.minmode_method ==
             LowestEigenmode::MINMODE_LANCZOS) {
    return std::make_shared<EigenmodeStrategy>(Lanczos(matter, params, pot));
  } else if (params.saddle_search_options.minmode_method ==
             LowestEigenmode::MINMODE_DAVIDSON) {
    return std::make_shared<EigenmodeStrategy>(Davidson(matter, params, pot));
  }
#ifdef WITH_GPRD
  else if (params.saddle_search_options.minmode_method ==
           LowestEigenmode::MINMODE_GPRDIMER) {
    // AtomicGPDimer embeds atmd::AtomicDimer (unique_ptr + user dtor → not
    // movable). Construct the alternative in place; do not pass a temporary.
    return std::make_shared<EigenmodeStrategy>(
        std::in_place_type<AtomicGPDimer>, matter, params, pot);
  }
#else
  else if (params.saddle_search_options.minmode_method ==
           LowestEigenmode::MINMODE_GPRDIMER) {
    throw std::runtime_error(
        "min_mode_method=gprdimer requires -Dwith_gprd=true (WITH_GPRD)");
  }
#endif
  // Default to improved dimer
  return std::make_shared<EigenmodeStrategy>(
      ImprovedDimer(matter, params, pot));
}

inline void eigenmodeCompute(EigenmodeStrategy &s,
                             std::shared_ptr<Matter> matter,
                             AtomMatrix direction) {
  std::visit([&](auto &impl) { impl.compute(matter, direction); }, s);
}

inline double eigenmodeGetEigenvalue(EigenmodeStrategy &s) {
  return std::visit([](auto &impl) { return impl.getEigenvalue(); }, s);
}

inline AtomMatrix eigenmodeGetEigenvector(EigenmodeStrategy &s) {
  return std::visit([](auto &impl) { return impl.getEigenvector(); }, s);
}

inline ImprovedDimer *asImprovedDimer(EigenmodeStrategy &s) {
  return std::get_if<ImprovedDimer>(&s);
}

inline long eigenmodeTotalForceCalls(EigenmodeStrategy &s) {
  return std::visit([](auto &impl) { return impl.totalForceCalls; }, s);
}
 
inline double eigenmodeStatsTorque(EigenmodeStrategy &s) {
  return std::visit([](auto &impl) { return impl.statsTorque; }, s);
}
 
inline double eigenmodeStatsAngle(EigenmodeStrategy &s) {
  return std::visit([](auto &impl) { return impl.statsAngle; }, s);
}
 
inline long eigenmodeStatsRotations(EigenmodeStrategy &s) {
  return std::visit([](auto &impl) { return impl.statsRotations; }, s);
}
 
inline long eigenmodeTotalIterations(EigenmodeStrategy &s) {
  return std::visit([](auto &impl) { return impl.totalIterations; }, s);
}
 
} // namespace eonc
 
using eonc::EigenmodeStrategy;