PyPartMC 2.1.2__cp315-cp315-win_amd64.whl

PyPartMC/__generate_si.py

@@ -0,0 +1,37 @@
+from collections import namedtuple
+
+
+def __generate_si():
+    prefixes = {
+        "T": 1e12,
+        "G": 1e9,
+        "M": 1e6,
+        "k": 1e3,
+        "h": 1e2,
+        "da": 1e1,
+        "": 1e0,
+        "d": 1e-1,
+        "c": 1e-2,
+        "m": 1e-3,
+        "u": 1e-6,
+        "n": 1e-9,
+        "p": 1e-12,
+    }
+    units = {
+        "m": 1e0,
+        "g": 1e-3,
+        "s": 1e0,
+        "K": 1e0,
+        "Pa": 1e0,
+        "mol": 1e0,
+        "W": 1e0,
+        "J": 1e0,
+        "N": 1e0,
+    }
+    return namedtuple("SI", [prefix + unit for prefix in prefixes for unit in units])(
+        **{
+            prefix_k + unit_k: prefix_v * unit_v
+            for prefix_k, prefix_v in prefixes.items()
+            for unit_k, unit_v in units.items()
+        }
+    )

PyPartMC/__init__.py

@@ -0,0 +1,78 @@
+"""
+.. include::../../README.md
+"""
+
+#  pylint: disable=invalid-name
+import importlib.metadata
+import inspect
+
+# pylint: disable=invalid-name,wrong-import-position
+import os
+from contextlib import contextmanager
+from pathlib import Path
+
+import nanobind
+
+
+# https://github.com/diegoferigo/cmake-build-extension/blob/master/src/cmake_build_extension/__init__.py
+@contextmanager
+def __build_extension_env():
+    cookies = []
+    # https://docs.python.org/3/whatsnew/3.8.html#bpo-36085-whatsnew
+    if hasattr(os, "add_dll_directory"):
+        basepath = os.path.dirname(os.path.abspath(__file__))
+        dllspath = os.path.join(basepath, "..")
+        os.environ["PATH"] = dllspath + os.pathsep + os.environ["PATH"]
+        for path in os.environ.get("PATH", "").split(os.pathsep):
+            if path and Path(path).is_absolute() and Path(path).is_dir():
+                cookies.append(os.add_dll_directory(path))
+    try:
+        yield
+    finally:
+        for cookie in cookies:
+            cookie.close()
+
+
+from .__generate_si import __generate_si
+
+si = __generate_si()
+""" a utility namedtuple aimed at clrifying physics-related code by providing
+    SI-prefix-aware unit multipliers, resulting in e.g.: `p = 1000 * si.hPa`
+    notation. Note: no dimensional analysis is done! """
+
+from ._PyPartMC import *  # pylint: disable=import-error
+from ._PyPartMC import (  # pylint: disable=import-error
+    __versions_of_build_time_dependencies__,
+)
+
+# Hacky workaround for missing docs in pdoc auto-generated documentation.
+# After the switch to nanobind, the docs became empty despite "__doc__" being
+# accessible in all of PyPartMC's objects. The code below manually populates
+# the "__all__" atrribute of the package. Additionally, functions in the generated
+# docs would be listed as nanobind objects with no additional documentation.
+# To solve that, dummy functions of the same name are created, and their "__doc__"
+# attribute is manually set to the "original" objects' "__doc__"
+if os.getenv("PDOC_GENERATE_PYPARTMC_DOCS") == "1":
+    all_items = []
+    for name, obj in inspect.getmembers(
+        _PyPartMC  # pylint: disable=undefined-variable
+    ):
+        if callable(obj):
+            if not inspect.isclass(obj):
+                exec(name + " = lambda : 0")  # pylint: disable=exec-used
+                temp = "_PyPartMC." + name + ".__doc__"
+                setattr(eval(name), "__doc__", eval(temp))  # pylint: disable=eval-used
+            all_items.append(name)
+
+    __all__ = tuple([*all_items, "si"])
+
+__version__ = importlib.metadata.version(__package__)
+
+# workaround for MATLAB bindings
+# pylint: disable=undefined-variable
+setattr(nanobind, "nb_type_0", type(_PyPartMC.AeroData))
+
+
+# Function that returns cmakes config file location
+def cmake_dir() -> str:
+    return os.path.join(os.path.dirname(__file__), "cmake")

PyPartMC/cmake/PyPartMCConfig.cmake

@@ -0,0 +1,65 @@
+if(TARGET PyPartMC::PyPartMC)
+    return()
+endif()
+
+find_package(Python 3.8 REQUIRED COMPONENTS Interpreter Development)
+
+set(PyPartMC_RUNTIME_LIBRARY "${PYPARTMC_LIB_FILE}")
+
+execute_process(
+    COMMAND ${Python_EXECUTABLE} -c "import nanobind, PyPartMC, os; from PyPartMC import _PyPartMC; print(f'{os.path.dirname(PyPartMC.__file__)};{nanobind.include_dir()};{_PyPartMC.__file__}')"
+    OUTPUT_VARIABLE PY_PATHS
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    RESULT_VARIABLE res
+)
+
+if(res)
+    message(FATAL_ERROR "filed to find PyPartMC libraries")
+endif()
+
+list(GET PY_PATHS 0 PYPARTMC_DIR)
+list(GET PY_PATHS 1 NANOBIND_INCLUDE_DIR)
+list(GET PY_PATHS 2 PYPARTMC_LIB_FILE)
+
+get_filename_component(VENV_PYPARTMC_DIR "${PYPARTMC_LIB_FILE}" DIRECTORY)
+
+add_library(PyPartMC::PyPartMC INTERFACE IMPORTED)
+
+add_library(PyPartMC::RuntimeCore UNKNOWN IMPORTED)
+set_target_properties(PyPartMC::RuntimeCore PROPERTIES IMPORTED_LOCATION "${PYPARTMC_LIB_FILE}")
+
+set(POTENTIAL_INCLUDE_DIRS 
+    "${PYPARTMC_DIR}/include"
+    "${VENV_PYPARTMC_DIR}/include"
+    "${NANOBIND_INCLUDE_DIR}"
+)
+
+set(ACTUAL_INCLUDE_DIRS "")
+foreach(DIR IN LISTS POTENTIAL_INCLUDE_DIRS)
+    if(EXISTS "${DIR}")
+        list(APPEND ACTUAL_INCLUDE_DIRS "${DIR}")
+    endif()
+endforeach()
+
+target_include_directories(PyPartMC::PyPartMC INTERFACE 
+    ${ACTUAL_INCLUDE_DIRS}
+    ${Python_INCLUDE_DIRS}
+)
+
+target_link_libraries(PyPartMC::PyPartMC INTERFACE 
+    "${VENV_PYPARTMC_DIR}/lib/libpartmclib.a"
+    PyPartMC::RuntimeCore
+    ${Python_LIBRARIES}
+)
+
+function(pypartmc_setup_runtime TARGET_NAME)
+    if(WIN32)
+        add_custom_command(TARGET ${TARGET_NAME} POST_BUILD
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                "${PYPARTMC_LIB_FILE}"
+                $<TARGET_FILE_DIR:${TARGET_NAME}>
+        )
+    endif()
+endfunction()
+
+message(STATUS "Found PyPartMC: ${PYPARTMC_DIR}")

PyPartMC/include/PyPartMC/aero_binned.hpp

@@ -0,0 +1,117 @@
+/*##################################################################################################
+# This file is a part of PyPartMC licensed under the GNU General Public License v3 (LICENSE file)  #
+# Copyright (C) 2025 University of Illinois Urbana-Champaign                                       #
+# Authors: https://github.com/open-atmos/PyPartMC/graphs/contributors                              #
+##################################################################################################*/
+
+#pragma once
+
+#include "pmc_resource.hpp"
+#include "aero_data.hpp"
+#include "bin_grid.hpp"
+#include "aero_dist.hpp"
+
+extern "C" void f_aero_binned_ctor(void *ptr) noexcept;
+extern "C" void f_aero_binned_dtor(void *ptr) noexcept;
+extern "C" void f_aero_binned_len(
+    const void *ptr, int *len
+) noexcept;
+extern "C" void f_aero_binned_add_aero_dist(
+    void *ptr,
+    const void *aero_data,
+    const void *bin_grid,
+    const void *aero_dist
+) noexcept;
+extern "C" void f_aero_binned_set_sizes(
+    void *ptr,
+    const void *aero_data,
+    const void *aero_binned
+) noexcept;
+extern "C" void f_aero_binned_num_conc(
+    const void *ptr,
+    double *num_conc,
+    const int *len
+) noexcept;
+extern "C" void f_aero_binned_species_vol_conc(
+    const void *ptr,
+    double *data,
+    const int *n_bins,
+    const int *i_spec
+) noexcept;
+    
+struct AeroBinned {
+    PMCResource ptr;
+    std::shared_ptr<AeroData> aero_data;
+    AeroBinned(std::shared_ptr<AeroData> aero_data) : 
+        ptr(f_aero_binned_ctor, f_aero_binned_dtor),
+        aero_data(aero_data)
+    {
+    }
+
+    AeroBinned(std::shared_ptr<AeroData> aero_data, const BinGrid &bin_grid) : 
+        ptr(f_aero_binned_ctor, f_aero_binned_dtor),
+        aero_data(aero_data)
+    {
+        f_aero_binned_set_sizes(
+            ptr.f_arg_non_const(),
+            aero_data->ptr.f_arg(),
+            bin_grid.ptr.f_arg()
+        );
+    }
+
+    static auto num_conc(const AeroBinned &self) {
+        int len;
+        f_aero_binned_len(
+            self.ptr.f_arg(),
+            &len
+        );
+        std::valarray<double> num_conc(len);
+
+        f_aero_binned_num_conc(
+            self.ptr.f_arg(),
+            begin(num_conc),
+            &len
+        );
+
+        return num_conc;
+    }
+
+    static auto vol_conc(const AeroBinned &self){
+
+        int len;
+        f_aero_binned_len(
+            self.ptr.f_arg(),
+            &len
+        );
+
+        int cols = len;
+        int rows;
+        f_aero_data_len(self.aero_data->ptr.f_arg(), &rows);
+
+        std::valarray<std::valarray<double>> vol_conc(rows);
+        std::valarray<double> vol_species(cols);
+        for (int i = 0; i < rows; i++) {
+           vol_conc[i] = std::valarray<double>(cols);
+           f_aero_binned_species_vol_conc(self.ptr.f_arg(), begin(vol_species), &cols, &i);
+           for (int j = 0; j < cols; ++j) {
+                vol_conc[i][j] = vol_species[j];
+           } 
+       }
+  
+       return vol_conc;
+
+    }
+
+    static void add_aero_dist(AeroBinned &self, 
+         const BinGrid &bin_grid, const AeroDist &aero_dist)
+    {
+         f_aero_binned_add_aero_dist(
+             self.ptr.f_arg_non_const(),
+             bin_grid.ptr.f_arg(),
+             self.aero_data->ptr.f_arg(),
+             aero_dist.ptr.f_arg()
+         );
+    }
+
+};
+

PyPartMC/include/PyPartMC/aero_data.hpp

@@ -0,0 +1,283 @@
+/*##################################################################################################
+# This file is a part of PyPartMC licensed under the GNU General Public License v3 (LICENSE file)  #
+# Copyright (C) 2022 University of Illinois Urbana-Champaign                                       #
+# Authors: https://github.com/open-atmos/PyPartMC/graphs/contributors                              #
+##################################################################################################*/
+
+#pragma once
+
+#include "pmc_resource.hpp"
+#include "json_resource.hpp"
+#include "getters.hpp"
+#include "camp_core.hpp"
+#include "aero_data_parameters.hpp"
+#include "nanobind/nanobind.h"
+
+extern "C" void f_aero_data_ctor(void *ptr) noexcept;
+extern "C" void f_aero_data_dtor(void *ptr) noexcept;
+extern "C" void f_aero_data_from_json(const void *ptr) noexcept;
+extern "C" void f_aero_data_from_camp(const void *ptr, const void *camp_core_ptr) noexcept;
+extern "C" void f_aero_data_spec_by_name(const void *ptr, int *value, const char *name_data, const int *name_size) noexcept;
+extern "C" void f_aero_data_len(const void *ptr, int *len) noexcept;
+extern "C" void f_aero_data_n_source(const void *ptr, int *len) noexcept;
+extern "C" void f_aero_data_set_frac_dim(void *ptr, const double*) noexcept;
+extern "C" void f_aero_data_get_frac_dim(const void *ptr, double*) noexcept;
+extern "C" void f_aero_data_set_vol_fill_factor(void *ptr, const double*) noexcept;
+extern "C" void f_aero_data_get_vol_fill_factor(const void *ptr, double*) noexcept;
+extern "C" void f_aero_data_set_prime_radius(void *ptr, const double*) noexcept;
+extern "C" void f_aero_data_get_prime_radius(const void *ptr, double*) noexcept;
+extern "C" void f_aero_data_rad2vol(const void *ptr, const double*, double*) noexcept;
+extern "C" void f_aero_data_vol2rad(const void *ptr, const double*, double*) noexcept;
+extern "C" void f_aero_data_diam2vol(const void *ptr, const double*, double*) noexcept;
+extern "C" void f_aero_data_vol2diam(const void *ptr, const double*, double*) noexcept;
+extern "C" void f_aero_data_get_species_density(const void *ptr, const int *idx, double *val) noexcept;
+extern "C" void f_aero_data_get_species_kappa(const void *ptr, const int *idx, double *val) noexcept;
+extern "C" void f_aero_data_get_species_molecular_weight(const void *ptr, const int *idx, double *val) noexcept;
+extern "C" void f_aero_data_source_name_by_index(const void *ptr, const int *i_source,
+    char *name_data) noexcept;
+extern "C" void f_aero_data_spec_name_by_index(const void *ptr, const int *i_spec,
+    char *name_data) noexcept;
+
+struct AeroData {
+    PMCResource ptr;
+
+    AeroData(
+        const CampCore &camp_core
+    ) :
+        ptr(f_aero_data_ctor, f_aero_data_dtor)
+    {
+        f_aero_data_from_camp(this->ptr.f_arg(), camp_core.ptr.f_arg());
+    }
+
+    AeroData(const nlohmann::ordered_json &json) :
+        ptr(f_aero_data_ctor, f_aero_data_dtor)
+    {
+        if (!InputJSONResource::unique_keys(json))
+            throw std::runtime_error("Species names must be unique");
+
+        JSONResourceGuard<InputJSONResource> guard(json);
+        f_aero_data_from_json(this->ptr.f_arg());
+        guard.check_parameters();
+    }
+
+    AeroData() :
+        ptr(f_aero_data_ctor, f_aero_data_dtor)
+    {}
+
+    static auto spec_by_name(const AeroData &self, const std::string &name) {
+        int value;
+        const int name_size = name.size();
+        f_aero_data_spec_by_name(
+            self.ptr.f_arg(),
+            &value,
+            name.c_str(),
+            &name_size
+        );
+        if (value==0)
+            throw std::runtime_error("Element not found.");
+        return value - 1;
+    }
+
+    static std::size_t __len__(const AeroData &self) {
+        return pypartmc::get_value<int>(self, f_aero_data_len);
+    }
+
+    static void set_frac_dim(AeroData &self, const double value) {
+        pypartmc::set_value(self, f_aero_data_set_frac_dim, value);
+    }
+
+    static auto get_frac_dim(const AeroData &self) {
+        return pypartmc::get_value(self, f_aero_data_get_frac_dim);
+    }
+
+    static void set_vol_fill_factor(AeroData &self, const double value) {
+        pypartmc::set_value(self, f_aero_data_set_vol_fill_factor, value);
+    }
+
+    static auto get_prime_radius(AeroData &self) {
+        return pypartmc::get_value(self, f_aero_data_get_prime_radius);
+    }
+
+    static void set_prime_radius(AeroData &self, const double value) {
+        f_aero_data_set_prime_radius(
+            self.ptr.f_arg_non_const(),
+            &value
+        );
+    }
+
+    static auto get_vol_fill_factor(const AeroData &self) {
+        return pypartmc::get_value(self, f_aero_data_get_vol_fill_factor);
+    }
+
+    static auto rad2vol(const AeroData &self, const double radius) {
+        double vol;
+        f_aero_data_rad2vol(
+            self.ptr.f_arg(),
+            &radius,
+            &vol
+        );
+        return vol;
+    }
+
+    static auto vol2rad(const AeroData &self, const double vol) {
+        double radius;
+        f_aero_data_vol2rad(
+            self.ptr.f_arg(),
+            &vol,
+            &radius
+        );
+        return radius;
+    }
+
+    static auto diam2vol(const AeroData &self, const double diam) {
+        double vol;
+        f_aero_data_diam2vol(
+            self.ptr.f_arg(),
+            &diam,
+            &vol
+        );
+        return vol;
+    }
+
+    static auto vol2diam(const AeroData &self, const double vol) {
+        double diam;
+        f_aero_data_vol2diam(
+            self.ptr.f_arg(),
+            &vol,
+            &diam
+        );
+        return diam;
+    }
+
+    static auto densities(const AeroData &self) {
+        int len;
+        f_aero_data_len(
+            self.ptr.f_arg(),
+            &len
+        );
+        std::valarray<double> data(len);
+
+        for (int idx = 0; idx < len; idx++) {
+             f_aero_data_get_species_density(
+                 self.ptr.f_arg(),
+                 &idx,
+                 &data[idx]
+            );
+        }
+
+        return data;
+    }
+
+    static auto density(const AeroData &self, const std::string &name) {
+        int idx;
+        double data;
+        const int name_size = name.size();
+
+        f_aero_data_spec_by_name(
+            self.ptr.f_arg(),
+            &idx,
+            name.c_str(),
+            &name_size
+        );
+
+        if (idx==0)
+            throw std::runtime_error("Element not found.");
+
+        idx--;
+        f_aero_data_get_species_density(
+            self.ptr.f_arg(),
+            &idx,
+            &data
+        );
+
+        return data;
+    }
+
+    static std::size_t n_source(const AeroData &self) {
+        int len = pypartmc::get_value<int>(self, f_aero_data_n_source);
+        if (len == -1)
+            throw std::runtime_error("No sources defined.");
+        return len;
+    }
+
+    static auto sources(const AeroData &self) {
+
+        int len;
+        f_aero_data_n_source(
+            self.ptr.f_arg(),
+            &len
+        );
+
+        char name[AERO_SOURCE_NAME_LEN];
+        auto names = nanobind::list();
+        for (int idx = 0; idx < len; idx++) {
+             f_aero_data_source_name_by_index(
+                 self.ptr.f_arg(),
+                 &idx,
+                 name
+            );
+            names.append(std::string(name));
+        }
+        return nanobind::tuple(names);
+    }
+
+    static auto names(const AeroData &self) {
+
+        int len;
+        f_aero_data_len(
+            self.ptr.f_arg(),
+            &len
+        );
+
+        char name[AERO_NAME_LEN];
+        auto names = nanobind::list();
+        for (int idx = 0; idx < len; idx++) {
+             f_aero_data_spec_name_by_index(
+                 self.ptr.f_arg(),
+                 &idx,
+                 name
+            );
+            names.append(std::string(name));
+        }
+        return nanobind::tuple(names);
+    }
+
+    static auto kappa(const AeroData &self) {
+        int len;
+        f_aero_data_len(
+            self.ptr.f_arg(),
+            &len
+        );
+        std::valarray<double> data(len);
+
+        for (int idx = 0; idx < len; idx++) {
+             f_aero_data_get_species_kappa(
+                 self.ptr.f_arg(),
+                 &idx,
+                 &data[idx]
+            );
+        }
+
+        return data;
+    }
+
+    static auto molecular_weights(const AeroData &self) {
+        int len;
+        f_aero_data_len(
+            self.ptr.f_arg(),
+            &len
+        );
+        std::valarray<double> data(len);
+
+        for (int idx = 0; idx < len; idx++) {
+             f_aero_data_get_species_molecular_weight(
+                 self.ptr.f_arg(),
+                 &idx,
+                 &data[idx]
+            );
+        }
+
+        return data;
+    }
+};
+

PyPartMC/include/PyPartMC/aero_dist.hpp

@@ -0,0 +1,85 @@
+/*##################################################################################################
+# This file is a part of PyPartMC licensed under the GNU General Public License v3 (LICENSE file)  #
+# Copyright (C) 2022 University of Illinois Urbana-Champaign                                       #
+# Authors: https://github.com/open-atmos/PyPartMC/graphs/contributors                              #
+##################################################################################################*/
+
+#pragma once
+
+#include "pmc_resource.hpp"
+#include "aero_mode.hpp"
+
+extern "C" void f_aero_dist_ctor(
+    void *ptr
+) noexcept;
+
+extern "C" void f_aero_dist_dtor(
+    void *ptr
+) noexcept;
+
+extern "C" void f_aero_dist_n_mode(
+    const void *ptr,
+    int *n_mode
+) noexcept;
+
+extern "C" void f_aero_dist_from_json(
+    void *ptr,
+    void *aero_data_ptr
+) noexcept;
+
+extern "C" void f_aero_dist_total_num_conc(
+    const void *ptr,
+    double *total_num_conc
+) noexcept;
+
+extern "C" void f_aero_dist_mode(
+    const void *ptr,
+    void *ptr_c,
+    const int *index
+) noexcept;
+
+struct AeroDist {
+    PMCResource ptr;
+    std::shared_ptr<AeroData> aero_data;
+
+    AeroDist(
+        std::shared_ptr<AeroData> aero_data,
+        const nlohmann::ordered_json &json
+    ):
+        ptr(f_aero_dist_ctor, f_aero_dist_dtor),
+        aero_data(aero_data)
+    {
+        for (const auto &mode : json)
+            AeroMode::check_mode_json(mode.begin().value());
+        
+        JSONResourceGuard<InputJSONResource> guard(json, "", "mode_name", 1);
+        f_aero_dist_from_json(ptr.f_arg_non_const(), aero_data->ptr.f_arg_non_const());
+        guard.check_parameters();
+    }
+
+    AeroDist() :
+        ptr(f_aero_dist_ctor, f_aero_dist_dtor)
+    {}
+
+    static auto get_n_mode(const AeroDist &self) {
+        int n_mode;
+        f_aero_dist_n_mode(self.ptr.f_arg(), &n_mode);
+        return n_mode;
+    }
+
+    static auto get_total_num_conc(const AeroDist &self) {
+        double total_num_conc;
+        f_aero_dist_total_num_conc(self.ptr.f_arg(), &total_num_conc);
+        return total_num_conc;
+    }
+
+    static AeroMode* get_mode(const AeroDist &self, const int &idx) {
+        if (idx < 0 || idx >= AeroDist::get_n_mode(self))
+            throw std::out_of_range("Index out of range");
+
+        AeroMode *ptr = new AeroMode();
+        f_aero_dist_mode(self.ptr.f_arg(), ptr, &idx);
+
+        return ptr;
+    }
+};