occpy 0.7.5__cp311-cp311-macosx_10_15_universal2.whl → 0.7.6__cp311-cp311-macosx_10_15_universal2.whl

include/occ/dma/add_qlm.h

@@ -0,0 +1,13 @@
+#pragma once
+#include <occ/core/linear_algebra.h>
+#include <occ/dma/mult.h>
+
+namespace occ::dma {
+void addqlm(int l, int lmax, double f, Eigen::Ref<const Vec> gx,
+            Eigen::Ref<const Vec> gy, Eigen::Ref<const Vec> gz, Mult &out);
+
+void addql0(int l, double f, Eigen::Ref<const Vec> gx,
+            Eigen::Ref<const Vec> gy, Eigen::Ref<const Vec> gz,
+            Mult& out);
+
+} // namespace occ::dma

include/occ/dma/binomial.h

@@ -0,0 +1,51 @@
+#pragma once
+#include <occ/core/linear_algebra.h>
+
+namespace occ::dma {
+
+/**
+ * @brief Class to compute and store binomial coefficients
+ */
+class BinomialCoefficients {
+public:
+  /**
+   * @brief Constructor
+   * @param max_order Maximum order of binomial coefficients to compute
+   */
+  BinomialCoefficients(int max_order = 20);
+
+  /**
+   * @brief Get binomial coefficient (n choose k)
+   * @param k First parameter
+   * @param m Second parameter
+   * @return Binomial coefficient
+   */
+  double binomial(int k, int m) const;
+
+  /**
+   * @brief Get square root of binomial coefficient
+   * @param k First parameter
+   * @param m Second parameter
+   * @return Square root of binomial coefficient
+   */
+  double sqrt_binomial(int k, int m) const;
+
+  /**
+   * @brief Get matrix of all binomial coefficients
+   * @return Reference to matrix of binomial coefficients
+   */
+  const Mat &binomial_matrix() const;
+
+  /**
+   * @brief Get matrix of all square roots of binomial coefficients
+   * @return Reference to matrix of square roots of binomial coefficients
+   */
+  const Mat &sqrt_binomial_matrix() const;
+
+private:
+  int m_max_order{20};
+  Mat m_binomial;
+  Mat m_sqrt_binomial;
+};
+
+} // namespace occ::dma

include/occ/dma/dma.h

@@ -0,0 +1,57 @@
+#pragma once
+#include <occ/core/atom.h>
+#include <occ/core/linear_algebra.h>
+#include <occ/core/molecule.h>
+#include <occ/core/timings.h>
+#include <occ/dma/mult.h>
+#include <occ/qm/integral_engine.h>
+#include <occ/qm/wavefunction.h>
+#include <string>
+#include <vector>
+
+namespace occ::dma {
+
+struct DMASettings {
+  int max_rank{4};
+  double big_exponent{4.0};
+  bool include_nuclei{true};
+};
+
+struct DMAResult {
+  int max_rank{4};
+  std::vector<Mult> multipoles;
+};
+
+struct DMASites {
+  inline auto size() const { return positions.cols(); }
+  inline auto num_atoms() const { return atoms.size(); }
+
+  std::vector<occ::core::Atom> atoms;
+  std::vector<std::string> name;
+  Mat3N positions;
+  IVec atom_indices;
+  Vec radii;
+  IVec limits;
+};
+
+class DMACalculator {
+public:
+  DMACalculator(const qm::Wavefunction &wfn);
+  void update_settings(const DMASettings &settings);
+  inline const auto &settings() const { return m_settings; }
+  void set_radius_for_element(int atomic_number, double radius_angs);
+  void set_limit_for_element(int atomic_number, int limit);
+
+  inline const auto &sites() const { return m_sites; }
+
+  DMAResult compute_multipoles();
+  Mult compute_total_multipoles(const DMAResult &result) const;
+
+private:
+  DMASites m_sites;
+  qm::AOBasis m_basis;
+  qm::MolecularOrbitals m_mo;
+  DMASettings m_settings;
+};
+
+} // namespace occ::dma

include/occ/dma/gauss_hermite.h

@@ -0,0 +1,9 @@
+#include <array>
+#include <occ/core/linear_algebra.h>
+
+namespace occ::dma {
+
+Vec gauss_hermite_points(int n);
+Vec gauss_hermite_weights(int n);
+
+} // namespace occ::dma

include/occ/dma/linear_multipole_calculator.h

@@ -0,0 +1,158 @@
+#pragma once
+#include <occ/core/linear_algebra.h>
+#include <occ/dma/mult.h>
+#include <occ/qm/wavefunction.h>
+#include <unsupported/Eigen/CXX11/Tensor>
+#include <vector>
+
+namespace occ::dma {
+
+/**
+ * @brief Settings for linear multipole analysis
+ */
+struct LinearDMASettings {
+  int max_rank = 4;
+  bool include_nuclei = true;
+  bool use_slices = false;
+  double tolerance = 2.30258 * 18; // Threshold for numerical significance
+  double default_radius = 0.5;     // Default site radius in Å
+  double hydrogen_radius = 0.325;  // Hydrogen site radius in Å
+};
+
+/**
+ * @brief Calculator for distributed multipole analysis of linear molecules
+ *
+ * This class encapsulates the functionality of the dmaql0 function,
+ * providing a cleaner interface for calculating multipole moments
+ * for linear molecules where only Qlm with m=0 are non-zero.
+ */
+class LinearMultipoleCalculator {
+public:
+  /**
+   * @brief Constructor for linear multipole calculator
+   *
+   * @param wfn Wavefunction containing basis set and density matrix
+   * @param settings Settings for the DMA calculation
+   */
+  LinearMultipoleCalculator(
+      const occ::qm::Wavefunction &wfn,
+      const LinearDMASettings &settings = LinearDMASettings{});
+
+  /**
+   * @brief Calculate all multipole moments for the linear molecule
+   *
+   * @return std::vector<Mult> Multipole moments for each site
+   */
+  std::vector<Mult> calculate();
+
+private:
+  /**
+   * @brief Setup sites and their properties based on molecule atoms
+   */
+  void setup_sites();
+
+  /**
+   * @brief Setup slice information for slice-based calculations
+   */
+  void setup_slices();
+
+  /**
+   * @brief Process nuclear contributions to multipoles
+   *
+   * @param site_multipoles Vector to store multipole contributions
+   */
+  void process_nuclear_contributions(std::vector<Mult> &site_multipoles);
+
+  /**
+   * @brief Process electronic contributions from density matrix
+   *
+   * @param site_multipoles Vector to store multipole contributions
+   */
+  void process_electronic_contributions(std::vector<Mult> &site_multipoles);
+
+  /**
+   * @brief Process a shell pair for electronic contributions
+   *
+   * @param shell_i First shell
+   * @param shell_j Second shell
+   * @param i_shell_idx Index of first shell
+   * @param j_shell_idx Index of second shell
+   * @param atom_i Index of first atom
+   * @param atom_j Index of second atom
+   * @param site_multipoles Vector to store multipole contributions
+   */
+  void process_shell_pair(const occ::qm::Shell &shell_i,
+                          const occ::qm::Shell &shell_j, int i_shell_idx,
+                          int j_shell_idx, int atom_i, int atom_j,
+                          std::vector<Mult> &site_multipoles);
+
+  /**
+   * @brief Process a primitive pair within shells
+   *
+   * @param shell_i First shell
+   * @param shell_j Second shell
+   * @param i_prim Index of primitive in first shell
+   * @param j_prim Index of primitive in second shell
+   * @param d_block Density matrix block for this shell pair
+   * @param atom_i Index of first atom
+   * @param atom_j Index of second atom
+   * @param site_multipoles Vector to store multipole contributions
+   */
+  void process_primitive_pair(const occ::qm::Shell &shell_i,
+                              const occ::qm::Shell &shell_j, int i_prim,
+                              int j_prim, const Mat &d_block, int atom_i,
+                              int atom_j, std::vector<Mult> &site_multipoles);
+
+  /**
+   * @brief Calculate error function integrals for slices
+   *
+   * @param aa Sum of gaussian exponents
+   * @param la Angular momentum of first function
+   * @param lb Angular momentum of second function
+   * @param za Z-coordinate of first center relative to product center
+   * @param zb Z-coordinate of second center relative to product center
+   * @param z1 Lower bound of slice
+   * @param z2 Upper bound of slice
+   * @param gz Output tensor for integrals
+   * @param skip Flag set to true if all integrals are negligible
+   */
+  void calculate_slice_integrals(double aa, int la, int lb, double za,
+                                 double zb, double z1, double z2,
+                                 Eigen::Tensor<double, 3> &gz,
+                                 bool &skip) const;
+
+  /**
+   * @brief Get cartesian powers for a basis function
+   *
+   * @param bf_idx Basis function index within shell
+   * @param l Angular momentum of shell
+   * @param powers Output array for x,y,z powers
+   */
+  void get_cartesian_powers(int bf_idx, int l, int powers[3]) const;
+
+  /**
+   * @brief Apply scaling factors for higher angular momentum functions
+   *
+   * @param d_block Density matrix block to scale
+   * @param l Angular momentum
+   * @param size Size of shell
+   * @param is_row Whether to scale rows (true) or columns (false)
+   */
+  void apply_angular_scaling(Mat &d_block, int l, int size, bool is_row) const;
+
+  // Member variables
+  const occ::qm::Wavefunction &m_wfn;
+  const LinearDMASettings m_settings;
+
+  // Cached data from wavefunction
+  Mat3N m_sites;      // Site positions (same as atom positions initially)
+  Vec m_site_radii;   // Site radii
+  IVec m_site_limits; // Site multipole rank limits
+  std::vector<int> m_sort_indices; // Sorting indices for z-ordering
+  Vec m_slice_separations;         // Separation planes for slices
+
+  // Density matrix (factor of 2 applied)
+  Mat m_density_matrix;
+};
+
+} // namespace occ::dma

include/occ/dma/linear_multipole_shifter.h

@@ -0,0 +1,146 @@
+#pragma once
+#include <occ/core/linear_algebra.h>
+#include <occ/dma/mult.h>
+#include <vector>
+
+namespace occ::dma {
+
+/**
+ * @brief Handles 1D multipole shifting operations along a single axis
+ *
+ * This class encapsulates the functionality for shifting multipole moments
+ * along a linear axis (typically z-axis) and moving them between sites.
+ * It provides a modern C++ interface for operations that were originally
+ * implemented as separate shiftz/movez functions.
+ */
+class LinearMultipoleShifter {
+public:
+  /**
+   * @brief Construct a shifter for moving multipoles to sites along an axis
+   *
+   * @param position Source position along the axis
+   * @param multipoles Source multipoles to be moved
+   * @param site_positions Matrix of site positions (only z-component used)
+   * @param site_radii Vector of site radii
+   * @param site_limits Vector of maximum multipole ranks for each site
+   * @param site_multipoles Vector of multipoles at each site
+   * @param max_rank Maximum multipole rank to consider
+   */
+  LinearMultipoleShifter(double position, Mult &multipoles,
+                         const Mat3N &site_positions, const Vec &site_radii,
+                         const IVec &site_limits,
+                         std::vector<Mult> &site_multipoles, int max_rank);
+
+  /**
+   * @brief Move multipoles from source position to nearest appropriate sites
+   *
+   * This implements the logic from the original movez function, distributing
+   * multipoles to the nearest sites along the axis based on distance and
+   * site limits.
+   */
+  void move_to_sites();
+
+  /**
+   * @brief Shift multipoles along the axis between two points
+   *
+   * @param source Source multipoles
+   * @param l1 Minimum rank to shift
+   * @param m1 Maximum rank to shift from source
+   * @param destination Destination multipoles
+   * @param m2 Maximum rank to keep at destination
+   * @param displacement Displacement along the axis
+   */
+  static void shift_along_axis(const Mult &source, int l1, int m1,
+                               Mult &destination, int m2, double displacement);
+
+private:
+  /**
+   * @brief Find nearest site with sufficient multipole limit
+   *
+   * @param low Minimum required limit
+   * @param start Starting site index for search
+   * @return Index of nearest suitable site
+   */
+  int find_nearest_site_with_limit(int low, int start) const;
+
+  /**
+   * @brief Find all sites at approximately the same distance
+   *
+   * @param primary_site Index of the primary (nearest) site
+   * @param low Minimum required limit
+   * @param tolerance Distance tolerance for considering sites equivalent
+   * @return Vector of site indices at similar distances
+   */
+  std::vector<int> find_equivalent_sites(int primary_site, int low,
+                                         double tolerance = 1.0e-8) const;
+
+  /**
+   * @brief Process multipoles for a specific rank range
+   *
+   * @param sites Vector of destination site indices
+   * @param low Starting rank
+   * @param high Ending rank
+   */
+  void process_rank_range(const std::vector<int> &sites, int low, int high);
+
+  /**
+   * @brief Calculate scaled distance to a site
+   *
+   * @param site_index Index of the site
+   * @return Scaled distance (distance / radius)
+   */
+  double scaled_distance_to_site(int site_index) const;
+
+  /**
+   * @brief Precompute powers of displacement for efficient shifting
+   *
+   * @param displacement The displacement value
+   * @param max_power Maximum power needed
+   * @return Vector of powers [1, z, z^2, z^3, ...]
+   */
+  static Vec compute_displacement_powers(double displacement, int max_power);
+
+  // Member variables
+  double m_position;
+  Mult &m_multipoles;
+  const Mat3N &m_site_positions;
+  const Vec &m_site_radii;
+  const IVec &m_site_limits;
+  std::vector<Mult> &m_site_multipoles;
+  int m_max_rank;
+  int m_num_sites;
+  int m_site_with_highest_limit;
+
+  // Cached calculations
+  Vec m_scaled_distances;
+};
+
+/**
+ * @brief Convenience function for 1D multipole shifting
+ *
+ * @param source Source multipoles
+ * @param l1 Minimum rank to shift
+ * @param m1 Maximum rank to shift from source
+ * @param destination Destination multipoles
+ * @param m2 Maximum rank to keep at destination
+ * @param displacement Displacement along the axis
+ */
+void shiftz(const Mult &source, int l1, int m1, Mult &destination, int m2,
+            double displacement);
+
+/**
+ * @brief Convenience function for moving multipoles to sites along an axis
+ *
+ * @param multipoles Multipole moments to be moved
+ * @param position Source position along the axis
+ * @param site_positions Matrix of site positions
+ * @param site_radii Vector of site radii
+ * @param site_limits Vector of maximum rank for each site
+ * @param site_multipoles Vector of multipoles at each site
+ * @param max_rank Maximum multipole rank
+ */
+void movez(Mult &multipoles, double position, const Mat3N &site_positions,
+           const Vec &site_radii, const IVec &site_limits,
+           std::vector<Mult> &site_multipoles, int max_rank);
+
+} // namespace occ::dma