diff --git a/src/aero_data.hpp b/src/aero_data.hpp
index b57a22f2..87a039a6 100644
--- a/src/aero_data.hpp
+++ b/src/aero_data.hpp
@@ -8,6 +8,7 @@
 
 #include "pmc_resource.hpp"
 #include "json_resource.hpp"
+#include "getters.hpp"
 #include "camp_core.hpp"
 #include "aero_data_parameters.hpp"
 #include "nanobind/nanobind.h"
@@ -78,44 +79,23 @@ struct AeroData {
     }
 
     static std::size_t __len__(const AeroData &self) {
-        int len;
-        f_aero_data_len(
-            self.ptr.f_arg(),
-            &len
-        );
-        return len;
+        return pypartmc::get_value<int>(self, f_aero_data_len);
     }
 
     static void set_frac_dim(AeroData &self, const double value) {
-        f_aero_data_set_frac_dim( 
-            self.ptr.f_arg_non_const(),
-            &value
-        );
+        pypartmc::set_value(self, f_aero_data_set_frac_dim, value);
     }
 
     static auto get_frac_dim(const AeroData &self) {
-        double value;
-        f_aero_data_get_frac_dim(
-            self.ptr.f_arg(),
-            &value
-        );
-        return value;
+        return pypartmc::get_value(self, f_aero_data_get_frac_dim);
     }
 
     static void set_vol_fill_factor(AeroData &self, const double value) {
-        f_aero_data_set_vol_fill_factor(
-            self.ptr.f_arg_non_const(),
-            &value
-        );
+        pypartmc::set_value(self, f_aero_data_set_vol_fill_factor, value);
     }
 
     static auto get_prime_radius(AeroData &self) {
-        double value;
-        f_aero_data_get_prime_radius(
-            self.ptr.f_arg(),
-            &value
-        );
-        return value;
+        return pypartmc::get_value(self, f_aero_data_get_prime_radius);
     }
 
     static void set_prime_radius(AeroData &self, const double value) {
@@ -126,12 +106,7 @@ struct AeroData {
     }
 
     static auto get_vol_fill_factor(const AeroData &self) {
-        double value;
-        f_aero_data_get_vol_fill_factor(
-            self.ptr.f_arg(),
-            &value
-        );
-        return value;
+        return pypartmc::get_value(self, f_aero_data_get_vol_fill_factor);
     }
 
     static auto rad2vol(const AeroData &self, const double radius) {
@@ -219,11 +194,7 @@ struct AeroData {
     }
 
     static std::size_t n_source(const AeroData &self) {
-        int len;
-        f_aero_data_n_source(
-            self.ptr.f_arg(),
-            &len
-        );
+        int len = pypartmc::get_value<int>(self, f_aero_data_n_source);
         if (len == -1)
             throw std::runtime_error("No sources defined.");
         return len;
diff --git a/src/aero_mode.hpp b/src/aero_mode.hpp
index 46f98cbc..092b8957 100644
--- a/src/aero_mode.hpp
+++ b/src/aero_mode.hpp
@@ -9,6 +9,7 @@
 #include "pmc_resource.hpp"
 #include "aero_data.hpp"
 #include "bin_grid.hpp"
+#include "getters.hpp"
 
 extern "C" void f_aero_mode_ctor(
     void *ptr
@@ -204,7 +205,7 @@ struct AeroMode {
            &len
        );
 
-       return data; 
+       return data;
     }
 
     static void set_vol_frac(AeroMode &self, const std::valarray<double>&data)
@@ -223,11 +224,9 @@ struct AeroMode {
 
     static auto get_vol_frac(const AeroMode &self)
     {
-       int len;
-       f_aero_mode_get_n_spec(self.ptr.f_arg(), &len); 
-       std::valarray<double> data(len);
-       f_aero_mode_get_vol_frac(self.ptr.f_arg(), begin(data), &len);
-       return data;
+        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)
@@ -246,17 +245,13 @@ struct AeroMode {
 
     static auto get_vol_frac_std(const AeroMode &self)
     {
-       int len;
-       f_aero_mode_get_n_spec(self.ptr.f_arg(), &len);
-       std::valarray<double> data(len);
-       f_aero_mode_get_vol_frac_std(self.ptr.f_arg(), begin(data), &len);
-       return data;
+        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){
-       double val;
-       f_aero_mode_get_char_radius(self.ptr.f_arg(), &val);
-       return val;
+       return pypartmc::get_value(self, f_aero_mode_get_char_radius);
     }
 
     static void set_char_radius(AeroMode &self, const double &val){
@@ -264,9 +259,7 @@ struct AeroMode {
     }
 
     static auto get_gsd(const AeroMode &self){
-       double val;
-       f_aero_mode_get_gsd(self.ptr.f_arg(), &val);
-       return val;
+       return pypartmc::get_value(self, f_aero_mode_get_gsd);
     }
 
     static void set_gsd(AeroMode &self, const double &val) {
@@ -359,14 +352,8 @@ struct AeroMode {
     }
 
     static auto get_sample_num_conc(const AeroMode &self) {
-       int len;
-       f_aero_mode_get_sample_bins(self.ptr.f_arg(), &len);
-       std::valarray<double> sample_num_conc(len);
-       f_aero_mode_get_sample_num_conc(
-           self.ptr.f_arg(),
-           begin(sample_num_conc),
-           &len
-       );
-       return sample_num_conc;
+        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);
     }
 };
diff --git a/src/aero_particle.F90 b/src/aero_particle.F90
index ea00442b..2822f8ef 100644
--- a/src/aero_particle.F90
+++ b/src/aero_particle.F90
@@ -165,8 +165,8 @@ subroutine f_aero_particle_species_mass( &
   subroutine f_aero_particle_species_masses( &
       aero_particle_ptr_c, &
       aero_data_ptr_c, &
-      size_masses, &
-      masses &
+      masses, &
+      size_masses &
     ) bind(C)
 
     type(aero_particle_t), pointer :: aero_particle_ptr_f => null()
diff --git a/src/aero_particle.hpp b/src/aero_particle.hpp
index 3f7d176f..a3764099 100644
--- a/src/aero_particle.hpp
+++ b/src/aero_particle.hpp
@@ -24,7 +24,7 @@ extern "C" void f_aero_particle_diameter(const void *aero_particle_ptr, const vo
 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, const int *size_masses, void *masses) 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;
@@ -71,213 +71,109 @@ struct AeroParticle {
     static auto volumes(const AeroParticle &self)
     {
         int len = AeroData::__len__(*self.aero_data);
-        std::valarray<double> data(len);
-        f_aero_particle_volumes(
-            self.ptr.f_arg(),
-            begin(data),
-            &len
-        );
-        return data;
+        auto fn = f_aero_particle_volumes;
+        auto aero_data_ptr = self.aero_data->ptr.f_arg();
+        return pypartmc::get_array_values_set_len(self, fn, len);
     }
 
     static auto volume(const AeroParticle &self) {
-        double vol;
-        f_aero_particle_volume(
-            self.ptr.f_arg(),
-            &vol
-        );
-        return vol;
+        return pypartmc::get_value<double>(self, f_aero_particle_volume);
     }
 
     static auto species_volume(const AeroParticle &self, const int &i_spec) {
-        double vol;
-        f_aero_particle_species_volume(
-            self.ptr.f_arg(),
-            &i_spec,
-            &vol
-        );
-        return vol;
+        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) {
-        double vol;
         const int i_spec = AeroData::spec_by_name(*self.aero_data, name);
-
-        f_aero_particle_species_volume(
-            self.ptr.f_arg(),
-            &i_spec,
-            &vol
-        );
-        return vol;
+        auto fn = f_aero_particle_species_volume;
+        return pypartmc::get_derived_value(self, fn, &i_spec);
     }
 
     static auto dry_volume(const AeroParticle &self) {
-        double vol;
-        f_aero_particle_dry_volume(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            &vol
-        );
-        return vol;
+        return pypartmc::get_derived_value(self, f_aero_particle_dry_volume, self.aero_data.get());
     }
 
     static auto radius(const AeroParticle &self) {
-        double radius;
-        f_aero_particle_radius(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            &radius
-        );
-        return radius;
+        return pypartmc::get_derived_value(self, f_aero_particle_radius, self.aero_data.get());
     }
 
     static auto dry_radius(const AeroParticle &self) {
-        double radius;
-        f_aero_particle_dry_radius(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            &radius
-        );
-        return radius;
+        return pypartmc::get_derived_value(self, f_aero_particle_dry_radius, self.aero_data.get());
     }
 
     static auto diameter(const AeroParticle &self) {
-        double diameter;
-        f_aero_particle_diameter(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            &diameter
-        );
-        return diameter;
+        return pypartmc::get_derived_value(self, f_aero_particle_diameter, self.aero_data.get());
     }
 
     static auto dry_diameter(const AeroParticle &self) {
-        double diameter;
-        f_aero_particle_dry_diameter(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            &diameter
-        );
-        return diameter;
+        return pypartmc::get_derived_value(self, f_aero_particle_dry_diameter, self.aero_data.get());
     }
 
     static auto mass(const AeroParticle &self) {
-        double mass;
-        f_aero_particle_mass(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            &mass
-        );
-        return mass;
+        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) {
-        double mass;
-        f_aero_particle_species_mass(
-            self.ptr.f_arg(),
-            &i_spec,
-            self.aero_data.get(),
-            &mass
-        );
-        return mass;
+        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) {
-        double mass;
-        const int i_spec = AeroData::spec_by_name(*self.aero_data, name);
-        f_aero_particle_species_mass(
-            self.ptr.f_arg(),
-            &i_spec,
-            self.aero_data.get(),
-            &mass
-        );
-        return mass;
+        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);
-        std::valarray<double> masses(len);
-        f_aero_particle_species_masses(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            &len,
-            begin(masses)
-        );
-        return masses;
+        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) {
-        double kappa;
-        f_aero_particle_solute_kappa(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            &kappa
-        );
-        return kappa;
+        return pypartmc::get_derived_value(self, f_aero_particle_solute_kappa, self.aero_data.get());
     }
 
     static auto moles(const AeroParticle &self) {
-        double moles;
-        f_aero_particle_moles(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            &moles
-        );
-        return moles;
+        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) {
-        double mobility_diameter;
-        f_aero_particle_mobility_diameter(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            env_state.ptr.f_arg(),
-            &mobility_diameter
-        );
-        return mobility_diameter;
+        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) {
-        double density;
-        f_aero_particle_density(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            &density
-        );
-        return density;
+        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) {
-        double approx_crit_rel_humid;
-        f_aero_particle_approx_crit_rel_humid(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            env_state.ptr.f_arg(),
-            &approx_crit_rel_humid
-        );
-        return approx_crit_rel_humid;
+        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) {
-        double crit_rel_humid;
-        f_aero_particle_crit_rel_humid(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            env_state.ptr.f_arg(),
-            &crit_rel_humid
-        );
-        return crit_rel_humid;
+        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) {
-        double crit_diameter;
-        f_aero_particle_crit_diameter(
-            self.ptr.f_arg(),
-            self.aero_data.get(),
-            env_state.ptr.f_arg(),
-            &crit_diameter
-        );
-        return crit_diameter;
+        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) {
@@ -345,51 +241,25 @@ struct AeroParticle {
     }
 
     static auto sources(const AeroParticle &self) {
-        int len = AeroData::n_source(*self.aero_data);
-        std::valarray<int> data(len);
-
-        f_aero_particle_get_component_sources(
-            self.ptr.f_arg(),
-            begin(data),
-            &len
-        );
-        return data;
+        int len = AeroData::__len__(*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) {
-        double val;
-        f_aero_particle_least_create_time(
-            self.ptr.f_arg(),
-            &val
-        );
-        return val;
+        return pypartmc::get_value(self, f_aero_particle_least_create_time);
     }
 
     static auto greatest_create_time(const AeroParticle &self) {
-        double val;
-        f_aero_particle_greatest_create_time(
-            self.ptr.f_arg(),
-            &val
-        );
-        return val;
+        return pypartmc::get_value(self, f_aero_particle_greatest_create_time);
     }
 
     static auto id(const AeroParticle &self) {
-        int64_t val;
-        f_aero_particle_id(
-            self.ptr.f_arg(),
-            &val
-        );
-        return val;
+        return pypartmc::get_value<int64_t>(self, f_aero_particle_id);
     }
 
     static auto is_frozen(const AeroParticle &self) {
-        int val;
-        f_aero_particle_frozen(
-            self.ptr.f_arg(),
-            &val
-        );
-        return val;
+        return pypartmc::get_value<int>(self, f_aero_particle_frozen);
     }
 
     static auto refract_shell(const AeroParticle &self) {
@@ -414,42 +284,23 @@ struct AeroParticle {
         return refract_core;
     }
 
-    static void set_weight_class(AeroParticle &self, const int weight_class) {
-        f_aero_particle_set_weight_class(
-            self.ptr.f_arg_non_const(),
-            &weight_class
-        );
-    }
-
     static auto get_weight_class(const AeroParticle &self) {
-        int weight_class;
-
-        f_aero_particle_get_weight_class(
-            self.ptr.f_arg(),
-            &weight_class
-        );
-        return weight_class;
+        return pypartmc::get_value<int>(self, f_aero_particle_get_weight_class);
     }
 
-    static void set_weight_group(AeroParticle &self, const int weight_group) {
-        f_aero_particle_set_weight_group(
-            self.ptr.f_arg_non_const(),
-            &weight_group
-        );
+    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) {
-        int weight_group;
+        return pypartmc::get_value<int>(self, f_aero_particle_get_weight_group);
+    }
 
-        f_aero_particle_get_weight_group(
-            self.ptr.f_arg(),
-            &weight_group
-        );
-        return 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());
     }
 };
diff --git a/src/aero_state.hpp b/src/aero_state.hpp
index 68365c39..f7c1af71 100644
--- a/src/aero_state.hpp
+++ b/src/aero_state.hpp
@@ -335,21 +335,10 @@ struct AeroState {
     }
 
     static auto num_concs(const AeroState &self) {
-        int len;
-        f_aero_state_len(
-            self.ptr.f_arg(),
-            &len
-        );
-        std::valarray<double> num_concs(len);
-
-        f_aero_state_num_concs(
-            self.ptr.f_arg(),
-            self.aero_data->ptr.f_arg(),
-            begin(num_concs),
-            &len
-        );
-
-        return num_concs;
+        auto fn = f_aero_state_num_concs;
+        auto len_fn =  f_aero_state_len;
+        auto aero_data_ptr = self.aero_data->ptr.f_arg();
+        return pypartmc::get_array_values(self, fn, len_fn, aero_data_ptr);
     }
 
     static auto masses(
@@ -396,40 +385,18 @@ struct AeroState {
     }
 
     static auto dry_diameters(const AeroState &self) {
-        int len;
-        f_aero_state_len(
-            self.ptr.f_arg(),
-            &len
-        );
-        std::valarray<double> dry_diameters(len);
-
-        f_aero_state_dry_diameters(
-            self.ptr.f_arg(),
-            self.aero_data->ptr.f_arg(),
-            begin(dry_diameters),
-            &len
-        );
-
-        return dry_diameters;
+        auto fn = f_aero_state_dry_diameters;
+        auto len_fn = f_aero_state_len;
+        auto aero_data_ptr = self.aero_data->ptr.f_arg();
+        return pypartmc::get_array_values(self, fn, len_fn, aero_data_ptr);
     }
 
     static auto mobility_diameters(const AeroState &self, const EnvState &env_state) {
-        int len;
-        f_aero_state_len(
-            self.ptr.f_arg(),
-            &len
-        );
-        std::valarray<double> mobility_diameters(len);
-
-        f_aero_state_mobility_diameters(
-            self.ptr.f_arg(),
-            self.aero_data->ptr.f_arg(),
-            env_state.ptr.f_arg(),
-            begin(mobility_diameters),
-            &len
-        );
-
-        return mobility_diameters;
+        auto fn = f_aero_state_mobility_diameters;
+        auto len_fn = f_aero_state_len;
+        auto aero_data_ptr = self.aero_data->ptr.f_arg();
+        auto env_state_ptr = env_state.ptr.f_arg();
+        return pypartmc::get_array_values(self, fn, len_fn, aero_data_ptr, env_state_ptr);
     }
 
     static auto diameters(
@@ -502,22 +469,11 @@ struct AeroState {
         const AeroState &self,
         const EnvState &env_state
     ) {
-        int len;
-        f_aero_state_len(
-            self.ptr.f_arg(),
-            &len
-        );
-        std::valarray<double> crit_rel_humids(len);
-
-        f_aero_state_crit_rel_humids(
-            self.ptr.f_arg(),
-            self.aero_data->ptr.f_arg(),
-            env_state.ptr.f_arg(), 
-            begin(crit_rel_humids),
-            &len
-        );
-
-        return crit_rel_humids;
+        auto fn = f_aero_state_crit_rel_humids;
+        auto len_fn = f_aero_state_len;
+        auto aero_data_ptr = self.aero_data->ptr.f_arg();
+        auto env_state_ptr = env_state.ptr.f_arg();
+        return pypartmc::get_array_values(self, fn, len_fn, aero_data_ptr, env_state_ptr);
     }
 
     static void make_dry(
@@ -530,20 +486,9 @@ struct AeroState {
     }
 
     static auto ids(const AeroState &self) {
-        int len;
-        f_aero_state_len(
-            self.ptr.f_arg(),
-            &len
-        );
-        std::valarray<int64_t> ids(len);
-
-        f_aero_state_ids(
-            self.ptr.f_arg(),
-            begin(ids),
-            &len
-        );
-
-        return ids;
+        auto fn = f_aero_state_ids;
+        auto len_fn = f_aero_state_len;
+        return pypartmc::get_array_values<int64_t>(self, fn, len_fn);
     }
 
     static auto mixing_state(
diff --git a/src/bin_grid.hpp b/src/bin_grid.hpp
index f22060ac..92110062 100644
--- a/src/bin_grid.hpp
+++ b/src/bin_grid.hpp
@@ -7,6 +7,7 @@
 #pragma once
 
 #include "pmc_resource.hpp"
+#include "getters.hpp"
 #include <valarray>
 #include <vector>
 #include "nanobind/stl/string.h"
@@ -107,49 +108,22 @@ struct BinGrid {
             self.ptr.f_arg(),
             &len
         );
-        len++;
-        std::valarray<double> data(len);
-        f_bin_grid_edges(
-            self.ptr.f_arg(),
-            begin(data),
-            &len
-        );
-
-        return data;
+        auto fn = f_bin_grid_edges;
+        return pypartmc::get_array_values_set_len(self, fn, len + 1);
     }
 
     static auto centers(const BinGrid &self) 
     {
-        int len;
-        f_bin_grid_size(
-            self.ptr.f_arg(),
-            &len
-        );
-        std::valarray<double> data(len);
-
-        f_bin_grid_centers(
-            self.ptr.f_arg(),
-            begin(data),
-            &len
-        );
-        
-        return data;
+        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)
     {
-        int len;
-        f_bin_grid_size(
-            self.ptr.f_arg(),
-            &len
-        );
-        std::valarray<double> data(len);
-        f_bin_grid_widths(
-            self.ptr.f_arg(),
-            begin(data),
-            &len
-        );
-        return data;
+        auto len_fn = f_bin_grid_size;
+        auto fn = f_bin_grid_widths;
+        return pypartmc::get_array_values(self, fn, len_fn);
     }
 
 };
diff --git a/src/env_state.hpp b/src/env_state.hpp
index e8e9799e..6eec4e60 100644
--- a/src/env_state.hpp
+++ b/src/env_state.hpp
@@ -8,6 +8,7 @@
 
 #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;
@@ -50,173 +51,85 @@ struct EnvState {
         ptr(f_env_state_ctor, f_env_state_dtor)
     {}
 
-    static void set_temperature(const EnvState &self, double &temperature) {
-        f_env_state_set_temperature(
-            self.ptr.f_arg(),
-            &temperature
-        );
+    static double temp(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_temperature);
     }
 
-    static auto temp(const EnvState &self) {
-        double temperature;
-
-        f_env_state_get_temperature(
-            self.ptr.f_arg(),
-            &temperature
-        );
-        return 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) {
-        double rel_humid;
-
-        f_env_state_get_rel_humid(
-            self.ptr.f_arg(),
-            &rel_humid
-        );
-        return rel_humid;
+        return pypartmc::get_value(self, f_env_state_get_rel_humid);
     }
-    
-    static void set_height(const EnvState &self, const double height) {
-        f_env_state_set_height(
-            self.ptr.f_arg(),
-            &height
-        );
-    }
-
-    static auto get_height(const EnvState &self) {
-        double height;
 
-        f_env_state_get_height(
-            self.ptr.f_arg(),
-            &height
-        );
-        return height;
+    static void set_height(EnvState &self, const double height) {
+        pypartmc::set_value(self, f_env_state_set_height, height);
     }
 
-    static void set_additive_kernel_coefficient(const EnvState &self, const double additive_kernel_coefficient) {
-        f_env_state_set_additive_kernel_coefficient(
-            self.ptr.f_arg(),
-            &additive_kernel_coefficient
-        );
+    static double get_height(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_height);
     }
 
-    static auto get_additive_kernel_coefficient(const EnvState &self) {
-        double additive_kernel_coefficient;
-
-        f_env_state_get_additive_kernel_coefficient(
-            self.ptr.f_arg(),
-            &additive_kernel_coefficient
-        );
-        return additive_kernel_coefficient;
+    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 void set_pressure(const EnvState &self, const double pressure) {
-        f_env_state_set_pressure(
-            self.ptr.f_arg(),
-            &pressure
-        );
+    static double get_additive_kernel_coefficient(const EnvState &self) {
+        return pypartmc::get_value(self, f_env_state_get_additive_kernel_coefficient);
     }
 
-    static auto get_pressure(const EnvState &self) {
-        double pressure;
+    static void set_pressure(EnvState &self, const double pressure) {
+        pypartmc::set_value(self, f_env_state_set_pressure, pressure);
+    }
 
-        f_env_state_get_pressure(
-            self.ptr.f_arg(),
-            &pressure
-        );
-        return 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) {
-        double elapsed_time;
-
-        f_env_state_get_elapsed_time(
-            self.ptr.f_arg(),
-            &elapsed_time
-        );
-        return elapsed_time;
+        return pypartmc::get_value(self, f_env_state_get_elapsed_time);
     }
 
     static auto get_start_time(const EnvState &self) {
-        double start_time;
-
-        f_env_state_get_start_time(
-            self.ptr.f_arg(),
-            &start_time
-        );
-        return start_time;
+        return pypartmc::get_value(self, f_env_state_get_start_time);
     }
 
     static auto air_density(const EnvState &self) {
-        double air_density;
-
-        f_env_state_air_dens(
-            self.ptr.f_arg(),
-            &air_density
-        );
-        return air_density;
+        return pypartmc::get_value(self, f_env_state_air_dens);
     }
 
     static auto air_molar_density(const EnvState &self) {
-        double air_molar_density;
-
-        f_env_state_air_molar_dens(
-            self.ptr.f_arg(),
-            &air_molar_density
-        );
-        return air_molar_density;
-    }
-
-    static void set_latitude(const EnvState &self, const double latitude) {
-        f_env_state_set_latitude(
-            self.ptr.f_arg(),
-            &latitude
-        );
+        return pypartmc::get_value(self, f_env_state_air_molar_dens);
     }
 
     static auto get_latitude(const EnvState &self) {
-        double latitude;
-
-        f_env_state_get_latitude(
-            self.ptr.f_arg(),
-            &latitude
-        );
-        return latitude;
+        return pypartmc::get_value(self, f_env_state_get_latitude);
     }
 
-    static void set_longitude(const EnvState &self, const double longitude) {
-        f_env_state_set_longitude(
-            self.ptr.f_arg(),
-            &longitude
-        );
+    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) {
-        double longitude;
-
-        f_env_state_get_longitude(
-            self.ptr.f_arg(),
-            &longitude
-        );
-        return longitude;
+        return pypartmc::get_value(self, f_env_state_get_longitude);
     }
 
-    static void set_altitude(const EnvState &self, const double altitude) {
-        f_env_state_set_altitude(
-            self.ptr.f_arg(),
-            &altitude
-        );
+    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) {
-        double altitude;
+        return pypartmc::get_value(self, f_env_state_get_altitude);
+    }
 
-        f_env_state_get_altitude(
-            self.ptr.f_arg(),
-            &altitude
-        );
-        return 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) {
@@ -242,13 +155,7 @@ struct EnvState {
     }
 
     static auto sat_vapor_pressure(const EnvState &self) {
-        double sat_vapor_pressure;
-
-        f_env_state_sat_vapor_pressure(
-            self.ptr.f_arg(),
-            &sat_vapor_pressure
-        );
-        return sat_vapor_pressure;
+        return pypartmc::get_value(self, f_env_state_sat_vapor_pressure);
     }
 
 };
diff --git a/src/getters.hpp b/src/getters.hpp
new file mode 100644
index 00000000..8f1a0950
--- /dev/null
+++ b/src/getters.hpp
@@ -0,0 +1,50 @@
+/*##################################################################################################
+# 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 { // possible namespace to avoid name conflicts
+
+template <typename T = double, typename SelfType, typename Func>
+inline T get_value(const SelfType &self, Func func) { // inline to keep it header-only
+    T value{};
+    func(self.ptr.f_arg(), &value);
+    return value;
+}
+
+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);
+}
+
+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;
+}
+
+template<typename T = double, typename SelfType, typename Func, typename LenF, typename... ExtraArgs>
+static 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;
+    }
+
+template<typename T = double, typename SelfType, typename Func, typename... ExtraArgs>
+static 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;
+    }
+}
diff --git a/src/scenario.hpp b/src/scenario.hpp
index 7e0596d6..1b8b6bb4 100644
--- a/src/scenario.hpp
+++ b/src/scenario.hpp
@@ -165,31 +165,15 @@ struct Scenario {
     }
 
     static auto emission_rate_scale(const Scenario &self) {
-        int len;
-
-        f_scenario_aero_emission_n_times(self.ptr.f_arg(), &len);
-        std::valarray<double> rates(len);
-        f_scenario_emission_rates(
-            self.ptr.f_arg(),
-            begin(rates),
-            &len
-        );
-
-        return rates;
+        auto fn = f_scenario_emission_rates;
+        auto len_fn = f_scenario_aero_emission_n_times;
+        return pypartmc::get_array_values(self, fn, len_fn);
     }
 
     static auto emission_time(const Scenario &self) {
-        int len;
-
-        f_scenario_aero_emission_n_times(self.ptr.f_arg(), &len);
-        std::valarray<double> times(len);
-        f_scenario_emission_time(
-            self.ptr.f_arg(),
-            begin(times),
-            &len
-        );
-
-        return times;
+        auto fn = f_scenario_emission_time;
+        auto len_fn = f_scenario_aero_emission_n_times;
+        return pypartmc::get_array_values(self, fn, len_fn);
     }
 
     static AeroDist* get_aero_background_dist(const Scenario &self, const AeroData &aero_data, const int &idx) {
@@ -207,31 +191,15 @@ struct Scenario {
     }
 
     static auto aero_dilution_rate(const Scenario &self) {
-        int len;
-
-        f_scenario_aero_background_n_times(self.ptr.f_arg(), &len);
-        std::valarray<double> rates(len);
-        f_scenario_aero_background_rate_scale(
-            self.ptr.f_arg(),
-            begin(rates),
-            &len
-        );
-
-        return rates;
+        auto fn = f_scenario_aero_background_rate_scale;
+        auto len_fn = f_scenario_aero_background_n_times;
+        return pypartmc::get_array_values(self, fn, len_fn);
     }
 
     static auto aero_dilution_time(const Scenario &self) {
-        int len;
-
-        f_scenario_aero_background_n_times(self.ptr.f_arg(), &len);
-        std::valarray<double> times(len);
-        f_scenario_aero_background_time(
-            self.ptr.f_arg(),
-            begin(times),
-            &len
-        );
-
-        return times;
+        auto fn = f_scenario_aero_background_time;
+        auto len_fn = f_scenario_aero_background_n_times;
+        return pypartmc::get_array_values(self, fn, len_fn);
     }
 
 };
diff --git a/tests/test_env_state.py b/tests/test_env_state.py
index eef85fcb..7085f42e 100644
--- a/tests/test_env_state.py
+++ b/tests/test_env_state.py
@@ -129,6 +129,18 @@ def test_humidity_ctor():
         # assert
         assert ENV_STATE_CTOR_ARG_MINIMAL["rel_humidity"] == sut.rh
 
+    @staticmethod
+    def test_temp():
+        # arrange
+        gas_data = ppmc.GasData(GAS_DATA_CTOR_ARG_MINIMAL)
+        aero_data = ppmc.AeroData(AERO_DATA_CTOR_ARG_MINIMAL)
+        scenario = ppmc.Scenario(gas_data, aero_data, SCENARIO_CTOR_ARG_MINIMAL)
+        sut = ppmc.EnvState(ENV_STATE_CTOR_ARG_MINIMAL)
+        scenario.init_env_state(sut, 0.0)
+
+        # assert
+        assert sut.temp == SCENARIO_CTOR_ARG_MINIMAL["temp_profile"][1]["temp"][0]
+
     @staticmethod
     def test_elapsed_time():
         # arrange and act