PyPartMC 2.1.2__cp315-cp315-win_amd64.whl

PyPartMC/include/PyPartMC/aero_mode.hpp

@@ -0,0 +1,359 @@
+/*##################################################################################################
+# 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_data.hpp"
+#include "bin_grid.hpp"
+#include "getters.hpp"
+
+extern "C" void f_aero_mode_ctor(
+    void *ptr
+) noexcept;
+
+extern "C" void f_aero_mode_dtor(
+    void *ptr
+) noexcept;
+
+extern "C" void f_aero_mode_get_num_conc(
+    const void *ptr,
+    double *val
+) noexcept;
+
+extern "C" void f_aero_mode_set_num_conc(
+    void *ptr,
+    const double *val
+) noexcept;
+
+extern "C" void f_aero_mode_num_conc(
+    const void *ptr,
+    const void *bin_grid_ptr,
+    const void *aero_data_ptr_c,
+    void *arr_data,
+    const int *arr_size
+) noexcept;
+
+extern "C" void f_aero_mode_get_n_spec(
+    const void *ptr,
+    int *len
+) noexcept;
+
+extern "C" void f_aero_mode_get_vol_frac(
+    const void *ptr,
+    void *arr_data,
+    const int *arr_size
+) noexcept;
+
+extern "C" void f_aero_mode_set_vol_frac(
+    void *ptr,
+    const void *arr_data,
+    const int *arr_size
+) noexcept;
+
+extern "C" void f_aero_mode_get_vol_frac_std(
+    const void *ptr,
+    void *arr_data,
+    const int *arr_size
+) noexcept;
+
+extern "C" void f_aero_mode_set_vol_frac_std(
+    void *ptr,
+    const void *arr_data,
+    const int *arr_size
+) noexcept;
+
+extern "C" void f_aero_mode_get_char_radius(
+    const void *ptr,
+    double *val
+) noexcept;
+
+extern "C" void f_aero_mode_set_char_radius(
+    void *ptr,
+    const double *val 
+) noexcept;
+
+extern "C" void f_aero_mode_get_gsd(
+    const void *ptr,
+    double *val
+) noexcept;
+
+extern "C" void f_aero_mode_set_gsd(
+    void *ptr,
+    const double *val
+) noexcept;
+
+extern "C" void f_aero_mode_set_type(
+    void *ptr,
+    const int *val
+) noexcept;
+
+extern "C" void f_aero_mode_get_type(
+    const void *ptr,
+    int *val
+) noexcept;
+
+extern "C" void f_aero_mode_set_name(
+    void *ptr,
+    const char *name_data, const int *name_size
+) noexcept;
+
+extern "C" void f_aero_mode_get_name(
+    const void *ptr,
+    char **name_data, int *name_size
+) noexcept;
+
+extern "C" void f_aero_mode_set_sampled(
+    void *ptr,
+    const void *rad_data,
+    const void *num_conc_data,
+    const int *arr_size
+) noexcept; 
+
+extern "C" void f_aero_mode_from_json(
+    void *ptr,
+    void *aero_data_ptr
+) noexcept;
+
+extern "C" void f_aero_mode_get_sample_num_conc(
+    const void *ptr,
+    void *sample_num_conc_data,
+    const int *sample_num_conc_data_size
+) noexcept;
+
+extern "C" void f_aero_mode_get_sample_radius(
+    const void *ptr,
+    void *sample_radius_data,
+    const int *sample_radius_data_size
+) noexcept;
+
+extern "C" void f_aero_mode_get_sample_bins(const void *ptr, int *n_bins) noexcept;
+
+struct AeroMode {
+    PMCResource ptr;
+
+    AeroMode() :
+        ptr(f_aero_mode_ctor, f_aero_mode_dtor)
+    {}
+
+    AeroMode(AeroData &aero_data, const nlohmann::ordered_json &json) :
+        ptr(f_aero_mode_ctor, f_aero_mode_dtor)
+    {
+        if (json.size() != 1 || !json.is_object() || !json.begin().value().is_object())
+            throw std::runtime_error("Single-element dict expected with mode name as key and mode params dict as value");
+        check_mode_json(json.begin().value());
+        JSONResourceGuard<InputJSONResource> guard(json, "", "mode_name");
+        f_aero_mode_from_json(ptr.f_arg_non_const(), aero_data.ptr.f_arg_non_const());
+        guard.check_parameters();
+    }
+
+    static void check_mode_json(const nlohmann::ordered_json &mode) {
+        for (auto key : std::set<std::string>({"mass_frac", "mode_type"})) // TODO #320: more...
+            if (mode.find(key) == mode.end())
+                throw std::runtime_error("mode parameters dict must include key '" + key + "'");
+        auto mass_frac = mode["mass_frac"];
+            
+        if (!mass_frac.is_array()) // TODO #320: check if all are single-element dicts
+            throw std::runtime_error("mass_frac value must be a list of single-element dicts");
+        if (!InputJSONResource::unique_keys(mass_frac))
+            throw std::runtime_error("mass_frac keys must be unique");
+        if (mode["mode_type"] == "sampled") {
+            if (mode.find("size_dist") == mode.end())
+                throw std::runtime_error("size_dist key must be set for mode_type=sampled");
+            auto sd = mode["size_dist"];
+            if (
+                sd.size() != 2 || 
+                !sd[0].is_object() || 
+                sd[0].size() != 1 || 
+                sd[1].size() != 1 ||
+                sd[0].find("diam") == sd[0].end() ||
+                sd[1].find("num_conc") == sd[1].end()
+            )
+                throw std::runtime_error("size_dist value must be an iterable of two single-element dicts (first with 'diam', second with 'num_conc' as keys)");
+            auto diam = *sd[0].find("diam");
+            auto num_conc = *sd[1].find("num_conc");
+            if (diam.size() != num_conc.size() + 1)
+                throw std::runtime_error("size_dist['num_conc'] must have len(size_dist['diam'])-1 elements");
+        }
+    }
+
+    static auto get_num_conc(const AeroMode &self){
+       double val;
+       f_aero_mode_get_num_conc(self.ptr.f_arg(), &val);
+       return val;
+    }
+
+    static void set_num_conc(AeroMode &self, const double &val){
+       f_aero_mode_set_num_conc(self.ptr.f_arg_non_const(), &val);
+    }
+
+    static auto num_dist(const AeroMode &self, 
+       const BinGrid &bin_grid, const AeroData &aero_data)
+    {
+       int len;
+       f_bin_grid_size(bin_grid.ptr.f_arg(), &len);
+       std::valarray<double> data(len);
+
+       f_aero_mode_num_conc(
+           self.ptr.f_arg(),
+           bin_grid.ptr.f_arg(),
+           aero_data.ptr.f_arg(),
+           begin(data),
+           &len
+       );
+
+       return data;
+    }
+
+    static void set_vol_frac(AeroMode &self, const std::valarray<double>&data)
+    {
+        int len = data.size();
+        int n_spec;
+        f_aero_mode_get_n_spec(self.ptr.f_arg(), &n_spec);
+        if (len!=n_spec)
+            throw std::runtime_error("AeroData size mismatch");
+        f_aero_mode_set_vol_frac(
+            self.ptr.f_arg_non_const(),
+            begin(data),
+            &len
+        );
+    }
+
+    static auto get_vol_frac(const AeroMode &self)
+    {
+        auto fn = f_aero_mode_get_vol_frac;
+        auto len_fn = f_aero_mode_get_n_spec;
+        return pypartmc::get_array_values(self, fn, len_fn);
+    }
+
+    static void set_vol_frac_std(AeroMode &self, const std::valarray<double>&data)
+    {
+        int len = data.size();
+        int n_spec;
+        f_aero_mode_get_n_spec(self.ptr.f_arg(), &n_spec);
+        if (len!=n_spec)
+            throw std::runtime_error("AeroData size mismatch");
+        f_aero_mode_set_vol_frac_std(
+            self.ptr.f_arg_non_const(),
+            begin(data),
+            &len
+        );
+    }
+
+    static auto get_vol_frac_std(const AeroMode &self)
+    {
+        auto fn = f_aero_mode_get_vol_frac_std;
+        auto len_fn = f_aero_mode_get_n_spec;
+        return pypartmc::get_array_values(self, fn, len_fn);
+    }
+
+    static auto get_char_radius(const AeroMode &self){
+       return pypartmc::get_value(self, f_aero_mode_get_char_radius);
+    }
+
+    static void set_char_radius(AeroMode &self, const double &val){
+       f_aero_mode_set_char_radius(self.ptr.f_arg_non_const(), &val);
+    }
+
+    static auto get_gsd(const AeroMode &self){
+       return pypartmc::get_value(self, f_aero_mode_get_gsd);
+    }
+
+    static void set_gsd(AeroMode &self, const double &val) {
+       f_aero_mode_set_gsd(self.ptr.f_arg_non_const(), &val);
+    }
+
+    static void set_sampled(AeroMode &self, const std::valarray<double>&sample_diams,
+         const std::valarray<double>&sample_num_conc) {
+
+        int len = sample_diams.size();
+        {
+            int len_num_conc = sample_num_conc.size();
+            if (len != len_num_conc + 1)
+                throw std::runtime_error("Diameter and number size mismatch");
+        }
+
+        f_aero_mode_set_sampled(
+            self.ptr.f_arg_non_const(),
+            begin(sample_diams),
+            begin(sample_num_conc),
+            &len
+        );
+    }
+
+    static auto types() {
+        static auto vec = std::vector<std::string>{
+            "log_normal",
+            "exp",
+            "mono",
+            "sampled"
+        };
+        return vec;
+    };
+
+    static void set_type(AeroMode &self, const std::string &mode_type) {
+        auto found = false;
+        auto type = 0;
+
+        for (auto el : AeroMode::types()) {
+            ++type;
+            if (el == mode_type) {
+                found = true;
+                break;
+            }
+        }
+        
+        if (!found)
+            throw std::invalid_argument("Invalid mode type.");
+
+        f_aero_mode_set_type(self.ptr.f_arg_non_const(), &type);
+    }
+
+    static auto get_type(const AeroMode &self) {
+        int type;
+        f_aero_mode_get_type(self.ptr.f_arg(), &type);
+
+        if (type <= 0 || (unsigned int)type > AeroMode::types().size())
+            throw std::logic_error("Unknown mode type.");
+
+        return AeroMode::types()[type - 1];
+    }
+
+    static void set_name(AeroMode &self, const std::string &name) {
+        int size = name.size();
+        f_aero_mode_set_name(self.ptr.f_arg_non_const(), name.c_str(), &size);
+    }
+
+    static auto get_name(const AeroMode &self) {
+        std::string name;
+        char* f_ptr = NULL;
+        int size = 0;
+        f_aero_mode_get_name(self.ptr.f_arg(), &f_ptr, &size);
+        name.resize(size);
+        for (int i = 0; i < size; ++i)
+          name[i] = f_ptr[i];
+        return name;
+    }
+
+    static auto get_sample_radius(const AeroMode &self) {
+       int len;
+       f_aero_mode_get_sample_bins(self.ptr.f_arg(), &len);
+       len++;
+       std::valarray<double> sample_radius(len);
+       f_aero_mode_get_sample_radius(
+          self.ptr.f_arg(),
+          begin(sample_radius),
+          &len
+       );
+       return sample_radius;
+    }
+
+    static auto get_sample_num_conc(const AeroMode &self) {
+        auto fn = f_aero_mode_get_sample_num_conc;
+        auto len_fn = f_aero_mode_get_sample_bins;
+        return pypartmc::get_array_values(self, fn, len_fn);
+    }
+};

PyPartMC/include/PyPartMC/aero_particle.hpp

@@ -0,0 +1,275 @@
+/*##################################################################################################
+# 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_data.hpp"
+#include "env_state.hpp"
+#include <complex>
+
+extern "C" void f_aero_particle_ctor(void *ptr) noexcept;
+extern "C" void f_aero_particle_dtor(void *ptr) noexcept;
+extern "C" void f_aero_particle_init(const void *ptr, const void *, const void *arr_data, const int *arr_size) noexcept;
+extern "C" void f_aero_particle_volumes(const void *ptr, void *arr_data, const int *arr_size) noexcept;
+extern "C" void f_aero_particle_volume(const void *ptr, double *vol) noexcept;
+extern "C" void f_aero_particle_species_volume(const void *ptr, const int *i_spec, double *vol) noexcept;
+extern "C" void f_aero_particle_dry_volume(const void *aero_particle_ptr, const void *aero_data_ptr, double *vol) noexcept;
+extern "C" void f_aero_particle_radius(const void *aero_particle_ptr, const void *aero_data_ptr, double *radius) noexcept;
+extern "C" void f_aero_particle_dry_radius(const void *aero_particle_ptr, const void *aero_data_ptr, double *radius) noexcept;
+extern "C" void f_aero_particle_diameter(const void *aero_particle_ptr, const void *aero_data_ptr, double *diameter) noexcept;
+extern "C" void f_aero_particle_dry_diameter(const void *aero_particle_ptr, const void * aero_data_ptr, double *diameter) noexcept;
+extern "C" void f_aero_particle_mass(const void *aero_particle_ptr, const void *aero_data_ptr, double *mass) noexcept;
+extern "C" void f_aero_particle_species_mass(const void *aero_particle_ptr, const int *i_spec, const void *aero_data_ptr, double *mass) noexcept;
+extern "C" void f_aero_particle_species_masses(const void *aero_particle_ptr, const void *aero_data_ptr, void *masses, const int *size_masses) noexcept;
+extern "C" void f_aero_particle_solute_kappa(const void *aero_particle_ptr, const void *aero_data_ptr, void *kappa) noexcept;
+extern "C" void f_aero_particle_moles(const void *aero_particle_ptr, const void *aero_data_ptr, void *moles) noexcept;
+extern "C" void f_aero_particle_mobility_diameter(const void *aero_particle_ptr, const void *aero_data_ptr, const void *env_state_ptr, void *mobility_diameter) noexcept;
+extern "C" void f_aero_particle_density(const void *aero_particle_ptr, const void *aero_data_ptr, void *density) noexcept;
+extern "C" void f_aero_particle_approx_crit_rel_humid(const void *aero_particle_ptr, const void *aero_data_ptr, const void *env_state_ptr, void *approx_crit_rel_humid) noexcept;
+extern "C" void f_aero_particle_crit_rel_humid(const void *aero_particle_ptr, const void *aero_data_ptr, const void *env_state_ptr, void *crit_rel_humid) noexcept;
+extern "C" void f_aero_particle_crit_diameter(const void *aero_particle_ptr, const void *aero_data_ptr, const void *env_state, void *crit_diameter) noexcept;
+extern "C" void f_aero_particle_coagulate(const void *aero_particle_1_ptr, const void *aero_particle_2_ptr, void *new_particle_ptr, const void *aero_data_ptr) noexcept;
+extern "C" void f_aero_particle_zero(void *aero_particle_ptr, const void *aero_data_ptr) noexcept;
+extern "C" void f_aero_particle_set_vols(void *aero_particle_ptr, const int *vol_size, const void *volumes) noexcept;
+extern "C" void f_aero_particle_absorb_cross_sect(const void *aero_particle_ptr, double *val, const int *arr_size) noexcept;
+extern "C" void f_aero_particle_scatter_cross_sect(const void *aero_particle_ptr, double *val, const int *arr_size) noexcept;
+extern "C" void f_aero_particle_asymmetry(const void *aero_particle_ptr, double *val, const int *arr_size) noexcept;
+extern "C" void f_aero_particle_greatest_create_time(const void *aero_particle_ptr, double *val) noexcept;
+extern "C" void f_aero_particle_least_create_time(const void *aero_particle_ptr, double *val) noexcept;
+extern "C" void f_aero_particle_get_component_sources(const void *aero_particle_ptr, void *arr_data, const int *arr_size) noexcept;
+extern "C" void f_aero_particle_id(const void *aero_particle_ptr, int64_t *val) noexcept;
+extern "C" void f_aero_particle_frozen(const void *aero_particle_ptr, bool *val) noexcept;
+extern "C" void f_aero_particle_refract_shell(const void *aero_particle_ptr, std::complex<double> *val, const int *arr_size) noexcept;
+extern "C" void f_aero_particle_refract_core(const void *aero_particle_ptr, std::complex<double> *val, const int *arr_size) noexcept;
+extern "C" void f_aero_particle_set_weight_class(void *ptr, const int *weight_class) noexcept;
+extern "C" void f_aero_particle_get_weight_class(const void *ptr, int *weight_class) noexcept;
+extern "C" void f_aero_particle_set_weight_group(void *ptr, const int *weight_group) noexcept;
+extern "C" void f_aero_particle_get_weight_group(const void *ptr, int *weight_group) noexcept;
+extern "C" void f_aero_particle_new_id(void *ptr) noexcept;
+
+struct AeroParticle {
+    PMCResource ptr;
+    std::shared_ptr<AeroData> aero_data;
+
+    AeroParticle(
+        std::shared_ptr<AeroData> aero_data,
+        const std::valarray<double>&data
+    ) :
+        ptr(f_aero_particle_ctor, f_aero_particle_dtor),
+        aero_data(aero_data)
+    {
+        int len = data.size();
+        f_aero_particle_init(ptr.f_arg(), aero_data->ptr.f_arg(), begin(data), &len);
+        if (size_t(len) != AeroData::__len__(*aero_data))
+            throw std::runtime_error("AeroData size mistmatch");
+    }
+
+    static auto volumes(const AeroParticle &self)
+    {
+        int len = AeroData::__len__(*self.aero_data);
+        auto fn = f_aero_particle_volumes;
+        return pypartmc::get_array_values_set_len(self, fn, len);
+    }
+
+    static auto volume(const AeroParticle &self) {
+        return pypartmc::get_value<double>(self, f_aero_particle_volume);
+    }
+
+    static auto species_volume(const AeroParticle &self, const int &i_spec) {
+        auto fn = f_aero_particle_species_volume;
+        return pypartmc::get_derived_value(self, fn, &i_spec);
+    }
+
+    static auto species_volume_by_name(const AeroParticle &self, const std::string &name) {
+        const int i_spec = AeroData::spec_by_name(*self.aero_data, name);
+        auto fn = f_aero_particle_species_volume;
+        return pypartmc::get_derived_value(self, fn, &i_spec);
+    }
+
+    static auto dry_volume(const AeroParticle &self) {
+        return pypartmc::get_derived_value(self, f_aero_particle_dry_volume, self.aero_data.get());
+    }
+
+    static auto radius(const AeroParticle &self) {
+        return pypartmc::get_derived_value(self, f_aero_particle_radius, self.aero_data.get());
+    }
+
+    static auto dry_radius(const AeroParticle &self) {
+        return pypartmc::get_derived_value(self, f_aero_particle_dry_radius, self.aero_data.get());
+    }
+
+    static auto diameter(const AeroParticle &self) {
+        return pypartmc::get_derived_value(self, f_aero_particle_diameter, self.aero_data.get());
+    }
+
+    static auto dry_diameter(const AeroParticle &self) {
+        return pypartmc::get_derived_value(self, f_aero_particle_dry_diameter, self.aero_data.get());
+    }
+
+    static auto mass(const AeroParticle &self) {
+        return pypartmc::get_derived_value(self, f_aero_particle_mass, self.aero_data.get());
+    }
+
+    static auto species_mass(const AeroParticle &self, const int &i_spec) {
+        auto fn = f_aero_particle_species_mass;
+        return pypartmc::get_derived_value(self, fn, &i_spec, self.aero_data.get());
+    }
+
+    static auto species_mass_by_name(const AeroParticle &self, const std::string &name) {
+        auto fn = f_aero_particle_species_mass;
+        int i_spec = AeroData::spec_by_name(*self.aero_data, name);
+        return pypartmc::get_derived_value(self, fn, &i_spec, self.aero_data.get());
+    }
+
+    static auto species_masses(const AeroParticle &self) {
+        int len = AeroData::__len__(*self.aero_data);
+        auto fn = f_aero_particle_species_masses;
+        return pypartmc::get_array_values_set_len(self, fn, len, self.aero_data.get());
+    }
+
+    static auto solute_kappa(const AeroParticle &self) {
+        return pypartmc::get_derived_value(self, f_aero_particle_solute_kappa, self.aero_data.get());
+    }
+
+    static auto moles(const AeroParticle &self) {
+        return pypartmc::get_derived_value(self, f_aero_particle_moles, self.aero_data.get());
+    }
+
+    static auto mobility_diameter(const AeroParticle &self, const EnvState &env_state) {
+        return pypartmc::get_derived_value(
+             self,
+             f_aero_particle_mobility_diameter,
+             self.aero_data.get(),
+             env_state.ptr.f_arg());
+    }
+
+    static auto density(const AeroParticle &self) {
+        return pypartmc::get_derived_value(self, f_aero_particle_density, self.aero_data.get());
+    }
+
+    static auto approx_crit_rel_humid(const AeroParticle &self, const EnvState &env_state) {
+        return pypartmc::get_derived_value(
+             self,
+             f_aero_particle_approx_crit_rel_humid,
+             self.aero_data.get(),
+             env_state.ptr.f_arg());
+    }
+
+    static auto crit_rel_humid(const AeroParticle &self, const EnvState &env_state) {
+        return pypartmc::get_derived_value(
+             self,
+             f_aero_particle_crit_rel_humid,
+             self.aero_data.get(),
+             env_state.ptr.f_arg());
+    }
+
+    static auto crit_diameter(const AeroParticle &self, const EnvState &env_state) {
+        return pypartmc::get_derived_value(
+             self,
+             f_aero_particle_crit_diameter,
+             self.aero_data.get(),
+             env_state.ptr.f_arg());
+    }
+
+    static auto coagulate(const AeroParticle &self, const AeroParticle &two) {
+        int len = AeroData::__len__(*self.aero_data);
+        std::valarray<double> data(len);
+        AeroParticle* new_ptr = new AeroParticle(self.aero_data, data);
+        f_aero_particle_coagulate(
+            self.ptr.f_arg(),
+            two.ptr.f_arg(),
+            new_ptr,
+            self.aero_data->ptr.f_arg()
+        );
+        return new_ptr;
+    }
+
+    static void zero(AeroParticle &self) {
+        f_aero_particle_zero(
+            self.ptr.f_arg_non_const(),
+            self.aero_data.get()
+        );
+    }
+
+    static void set_vols(AeroParticle &self, const std::valarray<double>&volumes) {
+        int len = AeroData::__len__(*self.aero_data.get());
+        if (volumes.size() != size_t(len))
+            throw std::runtime_error("AeroData size mistmatch");
+        f_aero_particle_set_vols(
+            self.ptr.f_arg_non_const(),
+            &len,
+            begin(volumes)
+        );
+    }
+
+    static auto scatter_cross_sect(const AeroParticle &self) {
+        auto fn = f_aero_particle_scatter_cross_sect;
+        return pypartmc::get_array_values_set_len(self, fn, n_swbands);
+    }
+
+    static auto absorb_cross_sect(const AeroParticle &self) {
+        auto fn = f_aero_particle_absorb_cross_sect;
+        return pypartmc::get_array_values_set_len(self, fn, n_swbands);
+    }
+
+    static auto asymmetry(const AeroParticle &self) {
+        auto fn = f_aero_particle_asymmetry;
+        return pypartmc::get_array_values_set_len(self, fn, n_swbands);
+    }
+
+    static auto sources(const AeroParticle &self) {
+        int len = AeroData::n_source(*self.aero_data);
+        auto fn = f_aero_particle_get_component_sources;
+        return pypartmc::get_array_values_set_len<int>(self, fn, len);
+    }
+
+    static auto least_create_time(const AeroParticle &self) {
+        return pypartmc::get_value(self, f_aero_particle_least_create_time);
+    }
+
+    static auto greatest_create_time(const AeroParticle &self) {
+        return pypartmc::get_value(self, f_aero_particle_greatest_create_time);
+    }
+
+    static auto id(const AeroParticle &self) {
+        return pypartmc::get_value<int64_t>(self, f_aero_particle_id);
+    }
+
+    static auto is_frozen(const AeroParticle &self) {
+        return pypartmc::get_value<bool>(self, f_aero_particle_frozen);
+    }
+
+    static auto refract_shell(const AeroParticle &self) {
+        auto fn = f_aero_particle_refract_shell;
+        return pypartmc::get_array_values_set_len<std::complex<double>>(self, fn, n_swbands);
+    }
+
+    static auto refract_core(const AeroParticle &self) {
+        auto fn = f_aero_particle_refract_core;
+        return pypartmc::get_array_values_set_len<std::complex<double>>(self, fn, n_swbands);
+    }
+
+    static auto get_weight_class(const AeroParticle &self) {
+        return pypartmc::get_value<int>(self, f_aero_particle_get_weight_class);
+    }
+
+    static void set_weight_class(AeroParticle &self, const int weight_class) {
+        pypartmc::set_value<int>(self, f_aero_particle_set_weight_class, weight_class);
+    }
+
+    static auto get_weight_group(const AeroParticle &self) {
+        return pypartmc::get_value<int>(self, f_aero_particle_get_weight_group);
+    }
+
+    static void set_weight_group(AeroParticle &self, const int weight_group) {
+        pypartmc::set_value<int>(self, f_aero_particle_set_weight_group, weight_group);
+    }
+
+    static void new_id(AeroParticle &self) {
+        f_aero_particle_new_id(self.ptr.f_arg_non_const());
+    }
+};