PyPartMC 2.1.2__cp315-cp315-win_amd64.whl

PyPartMC/include/PyPartMC/bin_grid.hpp

@@ -0,0 +1,143 @@
+/*##################################################################################################
+# This file is a part of PyPartMC licensed under the GNU General Public License v3 (LICENSE file)  #
+# Copyright (C) 2022-2025 University of Illinois Urbana-Champaign                                  #
+# Authors: https://github.com/open-atmos/PyPartMC/graphs/contributors                              #
+##################################################################################################*/
+
+#pragma once
+
+#include "pmc_resource.hpp"
+#include "getters.hpp"
+#include <valarray>
+#include <vector>
+#include "nanobind/stl/string.h"
+
+extern "C" void f_bin_grid_ctor(void *ptr) noexcept;
+
+extern "C" void f_bin_grid_dtor(void *ptr) noexcept;
+
+extern "C" void f_bin_grid_init(
+    const void *ptr,
+    const int *n_bin,
+    const int *type,
+    const double *min,
+    const double *max
+) noexcept;
+
+extern "C" void f_bin_grid_size(
+    const void *ptr,
+    int *val
+) noexcept;
+
+extern "C" void f_bin_grid_edges(
+    const void *ptr,
+    void *arr_data,
+    const int *arr_size
+) noexcept;
+
+extern "C" void f_bin_grid_centers(
+    const void *ptr,
+    void *arr_data,
+    const int *arr_size
+) noexcept;
+
+extern "C" void f_bin_grid_widths(
+    const void *ptr,
+    void *arr_data,
+    const int *arr_size
+) noexcept;
+
+extern "C" void f_bin_grid_histogram_1d(
+    const void *x_bin_grid_ptr_c,
+    const void *x_data,
+    const void *weight_data,
+    const int *arr_size,
+    void *output_data,
+    const int *grid_size
+) noexcept;
+
+extern "C" void f_bin_grid_histogram_2d(
+    const void *x_bin_grid_ptr_c,
+    const void *x_data,
+    const void *y_bin_grid_ptr_c,
+    const void *y_data,
+    const void *weight_data,
+    const int *arr_size,
+    void *output_data,
+    const int *x_grid_size,
+    const int *y_grid_size
+) noexcept;
+
+namespace nb = nanobind;
+
+struct BinGrid {
+    PMCResource ptr;
+
+    BinGrid(const int &n_bin, const nb::str &grid_type, const double &min, const double &max) :
+        ptr(f_bin_grid_ctor, f_bin_grid_dtor)
+    {
+        const std::string grid_type_str {grid_type.c_str()}; 
+
+        int type = 0;
+        if (grid_type_str == "log") type = 1;
+        if (grid_type_str == "linear") type = 2;
+        if (type == 0)
+            throw std::invalid_argument( "Invalid grid spacing." );
+
+        f_bin_grid_init(ptr.f_arg(), &n_bin, &type, &min, &max);
+    }
+
+    BinGrid():
+        ptr(f_bin_grid_ctor, f_bin_grid_dtor)
+    {
+    }
+
+    static std::size_t __len__(const BinGrid &self) {
+        int len;
+        f_bin_grid_size(
+            self.ptr.f_arg(),
+            &len
+        );
+        return len;
+    }
+
+    static auto edges(const BinGrid &self)
+    {
+        int len;
+        f_bin_grid_size(
+            self.ptr.f_arg(),
+            &len
+        );
+        auto fn = f_bin_grid_edges;
+        return pypartmc::get_array_values_set_len(self, fn, len + 1);
+    }
+
+    static auto centers(const BinGrid &self) 
+    {
+        auto len_fn = f_bin_grid_size;
+        auto fn = f_bin_grid_centers;
+        return pypartmc::get_array_values(self, fn, len_fn);
+    }
+
+    static auto widths(const BinGrid &self)
+    {
+        auto len_fn = f_bin_grid_size;
+        auto fn = f_bin_grid_widths;
+        return pypartmc::get_array_values(self, fn, len_fn);
+    }
+
+};
+
+std::valarray<double> histogram_1d(
+    const BinGrid &bin_grid,
+    std::valarray<double> values,
+    std::valarray<double> weights
+);
+
+std::vector<std::vector<double>> histogram_2d(
+    const BinGrid &x_bin_grid,
+    std::valarray<double> x_values,
+    const BinGrid &y_bin_grid,
+    std::valarray<double> y_values,
+    std::valarray<double> weights
+);

PyPartMC/include/PyPartMC/camp_core.hpp

@@ -0,0 +1,31 @@
+/*##################################################################################################
+# 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 "json_resource.hpp"
+#include "pmc_resource.hpp"
+
+extern "C" void f_camp_core_ctor(void *ptr) noexcept;
+extern "C" void f_camp_core_dtor(void *ptr) noexcept;
+extern "C" void f_camp_core_initialize(void *ptr, const char *prefix,
+    const int *prefix_size) noexcept;
+
+struct CampCore {
+    PMCResource ptr;
+
+    CampCore() :
+        ptr(f_camp_core_ctor, f_camp_core_dtor)
+    {
+    }
+
+    CampCore(const std::string &config_name) :
+        ptr(f_camp_core_ctor, f_camp_core_dtor)
+    {
+        const int config_name_size = config_name.size();
+        f_camp_core_initialize(ptr.f_arg_non_const(), config_name.c_str(), &config_name_size);
+    }
+};

PyPartMC/include/PyPartMC/condense.hpp

@@ -0,0 +1,35 @@
+/*##################################################################################################
+# 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 "aero_data.hpp"
+#include "aero_state.hpp"
+#include "env_state.hpp"
+#include "aero_particle.hpp"
+
+extern "C" void f_condense_equilib_particle(
+    const void*,
+    const void*,
+    const void*
+) noexcept;
+
+extern "C" void f_condense_equilib_particles(
+    const void*,
+    const void*,
+    const void*
+) noexcept;
+
+void condense_equilib_particle(
+    const EnvState &env_state,
+    const AeroData &aero_data,
+    const AeroParticle &aero_particle
+);
+
+void condense_equilib_particles(
+    const EnvState &env_state,
+    const AeroData &aero_data,
+    const AeroState &aero_state
+);

PyPartMC/include/PyPartMC/env_state.hpp

@@ -0,0 +1,161 @@
+/*##################################################################################################
+# 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 "json_resource.hpp"
+#include "pmc_resource.hpp"
+#include "getters.hpp"
+
+extern "C" void f_env_state_ctor(void *ptr) noexcept;
+extern "C" void f_env_state_dtor(void *ptr) noexcept;
+extern "C" void f_env_state_from_json(const void *ptr) noexcept;
+extern "C" void f_env_state_set_temperature(const void *ptr, const double *temperature) noexcept;
+extern "C" void f_env_state_get_temperature(const void *ptr, double *temperature) noexcept;
+extern "C" void f_env_state_set_additive_kernel_coefficient(const void *ptr, const double *additive_kernel_coefficient) noexcept;
+extern "C" void f_env_state_get_additive_kernel_coefficient(const void *ptr, double *additive_kernel_coefficient) noexcept;
+extern "C" void f_env_state_get_rel_humid(const void *ptr, double *rel_humid) noexcept;
+extern "C" void f_env_state_set_height(const void *ptr, const double *height) noexcept;
+extern "C" void f_env_state_get_height(const void *ptr, double *height) noexcept;
+extern "C" void f_env_state_set_pressure(const void *ptr, const double *pressure) noexcept;
+extern "C" void f_env_state_get_pressure(const void *ptr, double *pressure) noexcept;
+extern "C" void f_env_state_get_elapsed_time(const void *ptr, double *elapsed_time) noexcept;
+extern "C" void f_env_state_get_start_time(const void *ptr, double *start_time) noexcept;
+extern "C" void f_env_state_air_dens(const void *ptr, double *air_density) noexcept;
+extern "C" void f_env_state_air_molar_dens(const void *ptr, double *air_molar_density) noexcept;
+extern "C" void f_env_state_set_latitude(const void *ptr, const double *latitude) noexcept;
+extern "C" void f_env_state_get_latitude(const void *ptr, double *latitude) noexcept;
+extern "C" void f_env_state_set_longitude(const void *ptr, const double *longitude) noexcept;
+extern "C" void f_env_state_get_longitude(const void *ptr, double *longitude) noexcept;
+extern "C" void f_env_state_set_altitude(const void *ptr, const double *altitude) noexcept;
+extern "C" void f_env_state_get_altitude(const void *ptr, double *altitude) noexcept;
+extern "C" void f_env_state_ppb_to_conc(const void *ptr, const double *ppb, double *conc) noexcept;
+extern "C" void f_env_state_conc_to_ppb(const void *ptr, const double *conc, double *ppb) noexcept;
+extern "C" void f_env_state_sat_vapor_pressure(const void *ptr, double *sat_vapor_pressure) noexcept;
+
+struct EnvState {
+    PMCResource ptr;
+
+    EnvState(const nlohmann::ordered_json &json) :
+        ptr(f_env_state_ctor, f_env_state_dtor)
+    {
+        JSONResourceGuard<InputJSONResource> guard(json);
+        f_env_state_from_json(this->ptr.f_arg());
+        guard.check_parameters();
+    }
+
+    EnvState() :
+        ptr(f_env_state_ctor, f_env_state_dtor)
+    {}
+
+    static double temp(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_temperature);
+    }
+
+    static void set_temperature(EnvState &self, double temperature) {
+        pypartmc::set_value(self, f_env_state_set_temperature, temperature);
+    }
+
+    static auto rh(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_rel_humid);
+    }
+
+    static void set_height(EnvState &self, const double height) {
+        pypartmc::set_value(self, f_env_state_set_height, height);
+    }
+
+    static double get_height(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_height);
+    }
+
+    static void set_additive_kernel_coefficient(
+        EnvState &self,
+        const double additive_kernel_coefficient)
+    {
+        pypartmc::set_value(
+            self,
+            f_env_state_set_additive_kernel_coefficient,
+            additive_kernel_coefficient);
+    }
+    static double get_additive_kernel_coefficient(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_additive_kernel_coefficient);
+    }
+
+    static void set_pressure(EnvState &self, const double pressure) {
+        pypartmc::set_value(self, f_env_state_set_pressure, pressure);
+    }
+
+    static double get_pressure(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_pressure);
+    }
+
+    static auto get_elapsed_time(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_elapsed_time);
+    }
+
+    static auto get_start_time(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_start_time);
+    }
+
+    static auto air_density(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_air_dens);
+    }
+
+    static auto air_molar_density(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_air_molar_dens);
+    }
+
+    static auto get_latitude(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_latitude);
+    }
+
+    static void set_latitude(EnvState &self, const double latitude) {
+        pypartmc::set_value(self, f_env_state_set_latitude, latitude);
+    }
+
+    static auto get_longitude(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_longitude);
+    }
+
+    static void set_longitude(EnvState &self, const double longitude) {
+        pypartmc::set_value(self, f_env_state_set_longitude, longitude);
+    }
+
+    static auto get_altitude(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_altitude);
+    }
+
+    static void set_altitude(EnvState &self, const double altitude) {
+        pypartmc::set_value(self, f_env_state_set_altitude, altitude);
+    }
+
+    static auto ppb_to_conc(const EnvState &self, const double ppb) {
+        double conc;
+
+        f_env_state_ppb_to_conc(
+            self.ptr.f_arg(),
+            &ppb,
+            &conc
+        );
+        return conc;
+    }
+
+    static auto conc_to_ppb(const EnvState &self, const double conc) {
+        double ppb;
+
+        f_env_state_conc_to_ppb(
+            self.ptr.f_arg(),
+            &conc,
+            &ppb
+        );
+        return ppb;
+    }
+
+    static auto sat_vapor_pressure(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_sat_vapor_pressure);
+    }
+
+};

PyPartMC/include/PyPartMC/gas_data.hpp

@@ -0,0 +1,105 @@
+/*##################################################################################################
+# 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 "json_resource.hpp"
+#include "pmc_resource.hpp"
+#include "gas_data_parameters.hpp"
+#include "camp_core.hpp"
+#include "nanobind/nanobind.h"
+#include "nanobind_json/nanobind_json.h"
+
+extern "C" void f_gas_data_ctor(void *ptr) noexcept;
+extern "C" void f_gas_data_dtor(void *ptr) noexcept;
+extern "C" void f_gas_data_len(const void *ptr, int *len) noexcept;
+extern "C" void f_gas_data_from_json(const void *ptr) noexcept;
+extern "C" void f_gas_data_from_camp(const void *ptr, const void *camp_core_ptr) noexcept;
+extern "C" void f_gas_data_to_json(const void *ptr) noexcept;
+extern "C" void f_gas_data_spec_by_name(const void *ptr, int *value, const char *name_data,
+    const int *name_size) noexcept;
+extern "C" void f_gas_data_spec_name_by_index(const void *ptr, const int *i_spec,
+    char *name_data) noexcept;
+
+struct GasData {
+    PMCResource ptr;
+    const nlohmann::ordered_json json;
+
+    GasData(const CampCore &CampCore) :
+        ptr(f_gas_data_ctor, f_gas_data_dtor)
+    {
+        f_gas_data_from_camp(this->ptr.f_arg(), CampCore.ptr.f_arg());
+    }
+
+    GasData(const nanobind::tuple &tpl) :
+        ptr(f_gas_data_ctor, f_gas_data_dtor),
+        json(tpl)
+    {
+        auto json_array = nlohmann::ordered_json::array();
+        for (const auto item : tpl)
+            json_array.push_back(nlohmann::ordered_json::object({{
+                nanobind::cast<std::string>(item),
+                nlohmann::ordered_json::array()
+            }}));
+
+        JSONResourceGuard<InputJSONResource> guard(json_array);
+        f_gas_data_from_json(this->ptr.f_arg());
+        guard.check_parameters();
+    }
+
+    GasData() :
+        ptr(f_gas_data_ctor, f_gas_data_dtor)
+    {}
+
+    static auto __str__(const GasData &self) {
+        return self.json.dump();
+    }   
+
+    static std::size_t __len__(const GasData &self) {
+        int len;
+        f_gas_data_len(
+            self.ptr.f_arg(),
+            &len
+        );
+        return len;
+    }
+
+    static auto spec_by_name(const GasData &self, const std::string &name) {
+        int value;
+        const int name_size = name.size();
+        f_gas_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 auto names(const GasData &self) {
+
+        int len;
+        f_gas_data_len(
+            self.ptr.f_arg(),
+            &len
+        );
+
+        char name[GAS_NAME_LEN];
+        nanobind::list names;
+        for (int idx = 0; idx < len; idx++) {
+             f_gas_data_spec_name_by_index(
+                 self.ptr.f_arg(),
+                 &idx,
+                 name
+            );
+            names.append(nanobind::str(name));
+        }
+        return nanobind::tuple(names);
+    }
+};
+

PyPartMC/include/PyPartMC/gas_state.hpp

@@ -0,0 +1,129 @@
+/*##################################################################################################
+# 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 <string>
+#include "nlohmann/json.hpp"
+#include "json_resource.hpp"
+#include "pmc_resource.hpp"
+#include "gas_data.hpp"
+
+extern "C" void f_gas_state_ctor(void *ptr) noexcept;
+extern "C" void f_gas_state_dtor(void *ptr) noexcept;
+extern "C" void f_gas_state_set_item(const void *ptr, const int *idx, const double *val) noexcept;
+extern "C" void f_gas_state_get_item(const void *ptr, const int *idx, double *val) noexcept;
+extern "C" void f_gas_state_len(const void *ptr, int *len) noexcept;
+extern "C" void f_gas_state_to_json(const void *ptr) noexcept;
+extern "C" void f_gas_state_from_json(const void *ptr, const void *gasdata_ptr) noexcept;
+extern "C" void f_gas_state_set_size(const void *ptr, const void *gasdata_ptr) noexcept;
+extern "C" void f_gas_state_mix_rats(const void *ptr, const double *data, const int *len);
+
+struct GasState {
+    PMCResource ptr;
+    std::shared_ptr<GasData> gas_data;
+
+    GasState(std::shared_ptr<GasData> gas_data):
+        ptr(f_gas_state_ctor, f_gas_state_dtor),
+        gas_data(gas_data)
+    {
+        f_gas_state_set_size(
+            this->ptr.f_arg(),
+            gas_data->ptr.f_arg()
+        );
+    }
+
+    static void set_item(const GasState &self, const int &idx, const double &val) {
+        if (idx < 0 || idx >= (int)__len__(self))
+            throw std::out_of_range("TODO #118");
+        f_gas_state_set_item(
+            self.ptr.f_arg(),
+            &idx,
+            &val
+        );
+    }
+
+    static auto get_item(const GasState &self, const int &idx) {
+        if (idx < 0 || idx >= (int)__len__(self))
+            throw std::out_of_range("TODO #118");
+        double value;
+        f_gas_state_get_item(
+            self.ptr.f_arg(),
+            &idx,
+            &value
+        );
+        return value;
+    }
+
+    static auto __str__(const GasState &self) {
+        JSONResourceGuard<OutputJSONResource> guard;
+
+        f_gas_state_to_json(self.ptr.f_arg());
+        auto str = json_resource_ptr()->str();
+
+        return str;
+    }
+
+    static std::size_t __len__(const GasState &self) {
+        int len;
+        f_gas_state_len(self.ptr.f_arg(), &len);
+        return len;
+    }
+
+    static auto mix_rat(
+        const GasState &self,
+        const std::string &name
+    ) {
+        int value;
+        const int name_size = name.size();
+
+        f_gas_data_spec_by_name(
+            self.gas_data->ptr.f_arg(),
+            &value,
+            name.c_str(),
+            &name_size
+        );
+        if (value == 0)
+            throw std::runtime_error("Element not found.");
+        return get_item(self, value - 1);
+    }
+
+    static void set_size(GasState &self) {
+        f_gas_state_set_size(
+            self.ptr.f_arg(),
+            self.gas_data->ptr.f_arg()
+        );
+    }
+
+    static auto mix_rats(const GasState &self) {
+        int len;
+        f_gas_state_len(
+            self.ptr.f_arg(),
+            &len
+        );
+        std::valarray<double> data(len);
+
+        for (int idx = 0; idx < len; idx++) {
+             f_gas_state_get_item(
+                 self.ptr.f_arg(),
+                 &idx,
+                 &data[idx]
+             );
+        }
+        return data;
+    }
+
+    static void set_mix_rats(const GasState &self, const nlohmann::ordered_json &json) {
+        if (json.size() == 0)
+            throw std::runtime_error("Non-empty sequence of mixing ratios expected");
+
+        JSONResourceGuard<InputJSONResource> guard(json);
+        f_gas_state_from_json(
+            self.ptr.f_arg(),
+            self.gas_data->ptr.f_arg()
+        );
+        guard.check_parameters();
+    }
+};

PyPartMC/include/PyPartMC/getters.hpp

@@ -0,0 +1,55 @@
+/*##################################################################################################
+# 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 <utility>
+#include <valarray>
+
+namespace pypartmc {
+
+// Retrieves a single value from a Fortran routine.
+template <typename T = double, typename SelfType, typename Func>
+inline T get_value(const SelfType &self, Func func) {
+    T value{};
+    func(self.ptr.f_arg(), &value);
+    return value;
+}
+
+// Sets a single value through a Fortran routine via input parameter.
+template <typename T = double, typename SelfType, typename Func>
+inline void set_value(SelfType &self, Func func, T value) {
+    func(self.ptr.f_arg_non_const(), &value);
+}
+
+// Retrieves a computed value from a Fortran routine with additional arguments.
+template <typename T = double, typename SelfType, typename Func, typename... Args>
+inline T get_derived_value(const SelfType &self, Func func, Args&&... args) {
+    T value{};
+    func(self.ptr.f_arg(), std::forward<Args>(args)..., &value);
+    return value;
+}
+
+// Retrieves an array from a Fortran routine, querying length dynamically via len_fn.
+template<typename T = double, typename SelfType, typename Func, typename LenF, typename... ExtraArgs>
+inline auto get_array_values(const SelfType &self, Func f, LenF len_fn,
+    ExtraArgs&&... extra) {
+    int len;
+    len_fn(self.ptr.f_arg(), &len);
+    std::valarray<T> arr(len);
+    f(self.ptr.f_arg(), std::forward<ExtraArgs>(extra)..., begin(arr), &len);
+    return arr;
+}
+
+// Retrieves an array from a Fortran routine with a predetermined length.
+template<typename T = double, typename SelfType, typename Func, typename... ExtraArgs>
+inline auto get_array_values_set_len(const SelfType &self, Func f, int len,
+    ExtraArgs&&... extra) {
+    std::valarray<T> arr(len);
+    f(self.ptr.f_arg(), std::forward<ExtraArgs>(extra)..., begin(arr), &len);
+    return arr;
+}
+}