qupled 1.3.3__cp313-cp313-macosx_13_0_x86_64.whl

qupled/hf.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+import numpy as np
+
+from . import database
+from . import mpi
+from . import native
+
+
+class HF:
+    """
+    Class used to solve the HF scheme.
+    """
+
+    def __init__(self):
+        self.inputs: Input = None
+        """The inputs used to solve the scheme. Default = ``None``"""
+        self.results: Result = Result()
+        """The results obtained by solving the scheme"""
+        # Undocumented properties
+        self.db_handler = database.DataBaseHandler()
+        self.native_scheme_cls = native.HF
+        self.native_inputs_cls = native.Input
+        self.native_scheme_status = None
+
+    @property
+    def run_id(self):
+        """
+        Property that retrieves the run ID from the database handler.
+
+        Returns:
+            str: The run ID associated with the current database handler.
+        """
+        return self.db_handler.run_id
+
+    @mpi.MPI.record_time
+    @mpi.MPI.synchronize_ranks
+    def compute(self, inputs: Input):
+        """
+        Solves the scheme and saves the results.
+
+        Args:
+            inputs: Input parameters.
+        """
+        self.inputs = inputs
+        self._add_run_to_database()
+        self._compute_native()
+        self._save()
+
+    @mpi.MPI.run_only_on_root
+    def compute_rdf(self, rdf_grid: np.ndarray = None):
+        """
+        Computes the radial distribution function (RDF) using the provided RDF grid.
+        If results are available, this method computes the RDF and stores the results
+        in the database.
+
+        Args:
+            rdf_grid: A numpy array representing the RDF grid.
+                If not provided, a default grid will be used.
+        """
+        if self.results is not None:
+            self.results.compute_rdf(rdf_grid)
+            self.db_handler.insert_results(
+                {"rdf": self.results.rdf, "rdf_grid": self.results.rdf_grid}
+            )
+
+    def _add_run_to_database(self):
+        """
+        Adds the current run information to the database.
+
+        This method inserts the run details stored in `self.inputs` into the database
+        using the `db_handler`. It also updates the `database_info` attribute of
+        `self.inputs` with the current `run_id`.
+        """
+        self.db_handler.insert_run(self.inputs)
+        self.inputs.database_info.run_id = self.run_id
+
+    def _compute_native(self):
+        """
+        Computes the native representation of the inputs and processes the results.
+
+        This method performs the following steps:
+        1. Converts the current inputs to their native representation.
+        2. Initializes a native scheme object using the native inputs.
+        3. Computes the native scheme and stores its status.
+        4. Converts the results from the native scheme back to the desired format.
+        """
+        native_inputs = self.native_inputs_cls()
+        self.inputs.to_native(native_inputs)
+        scheme = self.native_scheme_cls(native_inputs)
+        self.native_scheme_status = scheme.compute()
+        self.results.from_native(scheme)
+
+    @mpi.MPI.run_only_on_root
+    def _save(self):
+        """
+        Saves the current state and results to the database.
+
+        This method updates the run status in the database using the current
+        native scheme status and inserts the results into the database.
+        """
+        self.db_handler.update_run_status(self.native_scheme_status)
+        self.db_handler.insert_results(self.results.__dict__)
+
+
+class Input:
+    """
+    Class used to store the inputs for the :obj:`qupled.hf.HF` class.
+    """
+
+    def __init__(self, coupling: float, degeneracy: float):
+        """
+        Initialize the base class with the given parameters.
+
+        Parameters:
+            coupling (float): Coupling parameter.
+            degeneracy (float): Degeneracy parameter.
+        """
+        self.chemical_potential: list[float] = [-10.0, 10.0]
+        """Initial guess for the chemical potential. Default = ``[-10, 10]``"""
+        self.coupling: float = coupling
+        """Coupling parameter."""
+        self.cutoff: float = 10.0
+        """Cutoff for the wave-vector grid. Default =  ``10.0``"""
+        self.degeneracy: float = degeneracy
+        """Degeneracy parameter."""
+        self.frequency_cutoff: float = 10.0
+        """Cutoff for the frequency (applies only in the ground state). Default =  ``10.0``"""
+        self.integral_error: float = 1.0e-5
+        """Accuracy (relative error) in the computation of integrals. Default = ``1.0e-5``"""
+        self.integral_strategy: str = "full"
+        """
+        Scheme used to solve two-dimensional integrals
+        allowed options include:
+
+        - full: the inner integral is evaluated at arbitrary points selected automatically by the quadrature rule
+
+        - segregated: the inner integral is evaluated on a fixed grid that depends on the integrand that is being processed
+
+        Segregated is usually faster than full but it could become
+        less accurate if the fixed points are not chosen correctly. Default =  ``'full'``
+        """
+        self.matsubara: int = 128
+        """Number of Matsubara frequencies. Default = ``128``"""
+        self.resolution: float = 0.1
+        """Resolution of the wave-vector grid. Default =  ``0.1``"""
+        self.threads: int = 1
+        """Number of OMP threads for parallel calculations. Default =  ``1``"""
+        # Undocumented default values
+        self.theory: str = "HF"
+        self.database_info: DatabaseInfo = DatabaseInfo()
+
+    def to_native(self, native_input: any):
+        """
+        Converts the attributes of the current object to their native representations
+        and sets them on the provided `native_input` object.
+
+        This method iterates through the attributes of the current object and checks
+        if the `native_input` object has a corresponding attribute. If it does, the
+        method attempts to convert the attribute's value to its native representation
+        using a `to_native` method, if available. Otherwise, it directly assigns the
+        attribute's value to the `native_input` object.
+
+        Args:
+            native_input (any): The object to which the native representations of the
+                current object's attributes will be assigned.
+        """
+        name = Input.to_native.__name__
+        for attr, value in self.__dict__.items():
+            if hasattr(native_input, attr) and value is not None:
+                value_to_set = (
+                    tonative()
+                    if callable(tonative := getattr(value, name, None))
+                    else value
+                )
+                setattr(native_input, attr, value_to_set)
+
+
+class Result:
+    """
+    Class used to store the results for the :obj:`qupled.hf.HF` class.
+    """
+
+    def __init__(self):
+        self.idr: np.ndarray = None
+        """Ideal density response"""
+        self.lfc: np.ndarray = None
+        """Local field correction"""
+        self.rdf: np.ndarray = None
+        """Radial distribution function"""
+        self.rdf_grid: np.ndarray = None
+        """Radial distribution function grid"""
+        self.sdr: np.ndarray = None
+        """Static density response"""
+        self.ssf: np.ndarray = None
+        """Static structure factor"""
+        self.uint: float = None
+        """Internal energy"""
+        self.wvg: np.ndarray = None
+        """Wave-vector grid"""
+
+    def from_native(self, native_scheme: any):
+        """
+        Updates the attributes of the current object based on the attributes of a given native scheme object.
+
+        Args:
+            native_scheme (any): An object containing attributes to update the current object with.
+
+        Notes:
+            - Only attributes that exist in both the current object and the native_scheme object will be updated.
+            - Attributes with a value of `None` in the native_scheme object will not overwrite the current object's attributes.
+        """
+        for attr in self.__dict__.keys():
+            if hasattr(native_scheme, attr):
+                value = getattr(native_scheme, attr)
+                setattr(self, attr, value) if value is not None else None
+
+    def compute_rdf(self, rdf_grid: np.ndarray | None = None):
+        """
+        Compute the radial distribution function (RDF) for the system.
+
+        Args:
+            rdf_grid (np.ndarray | None, optional): A 1D array specifying the grid points
+                at which the RDF is computed. If None, a default grid ranging from 0.0
+                to 10.0 with a step size of 0.01 is used.
+
+        Returns:
+            None: The computed RDF is stored in the `self.rdf` attribute.
+        """
+        if self.wvg is not None and self.ssf is not None:
+            self.rdf_grid = (
+                rdf_grid if rdf_grid is not None else np.arange(0.0, 10.0, 0.01)
+            )
+            self.rdf = native.compute_rdf(self.rdf_grid, self.wvg, self.ssf)
+
+
+class DatabaseInfo:
+    """
+    Class used to store the database information passed to the native code.
+    """
+
+    def __init__(self):
+        self.name: str = database.DataBaseHandler.DEFAULT_DATABASE_NAME
+        """Database name"""
+        self.run_id: int = None
+        """ID of the run in the database"""
+        self.run_table_name: str = database.DataBaseHandler.RUN_TABLE_NAME
+        """Name of the table used to store the runs in the database"""
+
+    def to_native(self) -> native.DatabaseInfo:
+        """
+        Converts the current object to a native `DatabaseInfo` instance.
+        This method creates a new instance of `native.DatabaseInfo` and copies
+        all non-None attributes from the current object to the new instance.
+        Returns:
+            native.DatabaseInfo: A new instance of `native.DatabaseInfo` with
+            attributes copied from the current object.
+        """
+        native_database_info = native.DatabaseInfo()
+        for attr, value in self.__dict__.items():
+            if value is not None:
+                setattr(native_database_info, attr, value)
+        return native_database_info

qupled/include/fmt/args.h

@@ -0,0 +1,235 @@
+// Formatting library for C++ - dynamic argument lists
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_ARGS_H_
+#define FMT_ARGS_H_
+
+#include <functional>  // std::reference_wrapper
+#include <memory>      // std::unique_ptr
+#include <vector>
+
+#include "core.h"
+
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template <typename T> struct is_reference_wrapper : std::false_type {};
+template <typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+
+template <typename T> auto unwrap(const T& v) -> const T& { return v; }
+template <typename T>
+auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
+  return static_cast<const T&>(v);
+}
+
+class dynamic_arg_list {
+  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+  // templates it doesn't complain about inability to deduce single translation
+  // unit for placing vtable. So storage_node_base is made a fake template.
+  template <typename = void> struct node {
+    virtual ~node() = default;
+    std::unique_ptr<node<>> next;
+  };
+
+  template <typename T> struct typed_node : node<> {
+    T value;
+
+    template <typename Arg>
+    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
+
+    template <typename Char>
+    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
+        : value(arg.data(), arg.size()) {}
+  };
+
+  std::unique_ptr<node<>> head_;
+
+ public:
+  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
+    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
+    auto& value = new_node->value;
+    new_node->next = std::move(head_);
+    head_ = std::move(new_node);
+    return value;
+  }
+};
+}  // namespace detail
+
+/**
+  \rst
+  A dynamic version of `fmt::format_arg_store`.
+  It's equipped with a storage to potentially temporary objects which lifetimes
+  could be shorter than the format arguments object.
+
+  It can be implicitly converted into `~fmt::basic_format_args` for passing
+  into type-erased formatting functions such as `~fmt::vformat`.
+  \endrst
+ */
+template <typename Context>
+class dynamic_format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+ private:
+  using char_type = typename Context::char_type;
+
+  template <typename T> struct need_copy {
+    static constexpr detail::type mapped_type =
+        detail::mapped_type_constant<T, Context>::value;
+
+    enum {
+      value = !(detail::is_reference_wrapper<T>::value ||
+                std::is_same<T, basic_string_view<char_type>>::value ||
+                std::is_same<T, detail::std_string_view<char_type>>::value ||
+                (mapped_type != detail::type::cstring_type &&
+                 mapped_type != detail::type::string_type &&
+                 mapped_type != detail::type::custom_type))
+    };
+  };
+
+  template <typename T>
+  using stored_type = conditional_t<
+      std::is_convertible<T, std::basic_string<char_type>>::value &&
+          !detail::is_reference_wrapper<T>::value,
+      std::basic_string<char_type>, T>;
+
+  // Storage of basic_format_arg must be contiguous.
+  std::vector<basic_format_arg<Context>> data_;
+  std::vector<detail::named_arg_info<char_type>> named_info_;
+
+  // Storage of arguments not fitting into basic_format_arg must grow
+  // without relocation because items in data_ refer to it.
+  detail::dynamic_arg_list dynamic_args_;
+
+  friend class basic_format_args<Context>;
+
+  auto get_types() const -> unsigned long long {
+    return detail::is_unpacked_bit | data_.size() |
+           (named_info_.empty()
+                ? 0ULL
+                : static_cast<unsigned long long>(detail::has_named_args_bit));
+  }
+
+  auto data() const -> const basic_format_arg<Context>* {
+    return named_info_.empty() ? data_.data() : data_.data() + 1;
+  }
+
+  template <typename T> void emplace_arg(const T& arg) {
+    data_.emplace_back(detail::make_arg<Context>(arg));
+  }
+
+  template <typename T>
+  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
+    if (named_info_.empty()) {
+      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
+      data_.insert(data_.begin(), {zero_ptr, 0});
+    }
+    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
+    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
+      data->pop_back();
+    };
+    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
+        guard{&data_, pop_one};
+    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
+    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
+    guard.release();
+  }
+
+ public:
+  constexpr dynamic_format_arg_store() = default;
+
+  /**
+    \rst
+    Adds an argument into the dynamic store for later passing to a formatting
+    function.
+
+    Note that custom types and string types (but not string views) are copied
+    into the store dynamically allocating memory if necessary.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      store.push_back(42);
+      store.push_back("abc");
+      store.push_back(1.5f);
+      std::string result = fmt::vformat("{} and {} and {}", store);
+    \endrst
+  */
+  template <typename T> void push_back(const T& arg) {
+    if (detail::const_check(need_copy<T>::value))
+      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
+    else
+      emplace_arg(detail::unwrap(arg));
+  }
+
+  /**
+    \rst
+    Adds a reference to the argument into the dynamic store for later passing to
+    a formatting function.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      char band[] = "Rolling Stones";
+      store.push_back(std::cref(band));
+      band[9] = 'c'; // Changing str affects the output.
+      std::string result = fmt::vformat("{}", store);
+      // result == "Rolling Scones"
+    \endrst
+  */
+  template <typename T> void push_back(std::reference_wrapper<T> arg) {
+    static_assert(
+        need_copy<T>::value,
+        "objects of built-in types and string views are always copied");
+    emplace_arg(arg.get());
+  }
+
+  /**
+    Adds named argument into the dynamic store for later passing to a formatting
+    function. ``std::reference_wrapper`` is supported to avoid copying of the
+    argument. The name is always copied into the store.
+  */
+  template <typename T>
+  void push_back(const detail::named_arg<char_type, T>& arg) {
+    const char_type* arg_name =
+        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
+    if (detail::const_check(need_copy<T>::value)) {
+      emplace_arg(
+          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
+    } else {
+      emplace_arg(fmt::arg(arg_name, arg.value));
+    }
+  }
+
+  /** Erase all elements from the store */
+  void clear() {
+    data_.clear();
+    named_info_.clear();
+    dynamic_args_ = detail::dynamic_arg_list();
+  }
+
+  /**
+    \rst
+    Reserves space to store at least *new_cap* arguments including
+    *new_cap_named* named arguments.
+    \endrst
+  */
+  void reserve(size_t new_cap, size_t new_cap_named) {
+    FMT_ASSERT(new_cap >= new_cap_named,
+               "Set of arguments includes set of named arguments");
+    data_.reserve(new_cap);
+    named_info_.reserve(new_cap_named);
+  }
+};
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_ARGS_H_