Merge pull request #626 from slayoo/cleanup

rename particulator.particles -> particulator.attributes

PySDM/backends/numba/test_helpers/bdf.py

@@ -26,21 +26,21 @@ def _bdf_condensation(particulator, rtol_x, rtol_thd, counters, RH_max, success,
         solver=particulator.condensation_solver,
         n_threads=1,
         n_cell=particulator.mesh.n_cell,
-        cell_start_arg=particulator.particles.cell_start.data,
-        v=particulator.particles["volume"].data,
+        cell_start_arg=particulator.attributes.cell_start.data,
+        v=particulator.attributes["volume"].data,
         v_cr=None,
-        n=particulator.particles['n'].data,
-        vdry=particulator.particles["dry volume"].data,
-        idx=particulator.particles._Particles__idx.data,
+        n=particulator.attributes['n'].data,
+        vdry=particulator.attributes["dry volume"].data,
+        idx=particulator.attributes._Particles__idx.data,
         rhod=particulator.env["rhod"].data,
         thd=particulator.env["thd"].data,
         qv=particulator.env["qv"].data,
         dv_mean=particulator.env.dv,
         prhod=particulator.env.get_predicted("rhod").data,
         pthd=particulator.env.get_predicted("thd").data,
         pqv=particulator.env.get_predicted("qv").data,
-        kappa=particulator.particles["kappa"].data,
-        f_org=particulator.particles["dry volume organic fraction"].data,
+        kappa=particulator.attributes["kappa"].data,
+        f_org=particulator.attributes["dry volume organic fraction"].data,
         rtol_x=rtol_x,
         rtol_thd=rtol_thd,
         dt=particulator.dt,

PySDM/builder.py

@@ -70,7 +70,7 @@ def build(self, attributes: dict, products: list = (), int_caster=discretise_n):
         attributes['n'] = int_caster(attributes['n'])
         if self.particulator.mesh.dimension == 0:
             attributes['cell id'] = np.zeros_like(attributes['n'], dtype=np.int64)
-        self.particulator.particles = ParticlesFactory.attributes(self.particulator, self.req_attr, attributes)
+        self.particulator.attributes = ParticlesFactory.attributes(self.particulator, self.req_attr, attributes)
 
         for key in self.particulator.dynamics.keys():
             self.particulator.timers[key] = WallTimer()

PySDM/dynamics/aqueous_chemistry.py

@@ -67,28 +67,28 @@ def register(self, builder):
         self.do_chemistry_flag = self.particulator.Storage.empty(self.particulator.n_sd, dtype=bool)
 
     def __call__(self):
-        self.particulator.particles.chem_recalculate_cell_data(
+        self.particulator.attributes.chem_recalculate_cell_data(
             equilibrium_consts=self.equilibrium_consts,
             kinetic_consts=self.kinetic_consts
         )
         for _ in range(self.n_substep):
-            self.particulator.particles.chem_recalculate_drop_data(
+            self.particulator.attributes.chem_recalculate_drop_data(
                 equilibrium_consts=self.equilibrium_consts,
                 dissociation_factors=self.dissociation_factors
             )
-            self.particulator.particles.dissolution(
+            self.particulator.attributes.dissolution(
                 gaseous_compounds=GASEOUS_COMPOUNDS,
                 system_type=self.system_type,
                 dissociation_factors=self.dissociation_factors,
                 environment_mixing_ratios=self.environment_mixing_ratios,
                 dt=self.particulator.dt / self.n_substep,
                 do_chemistry_flag=self.do_chemistry_flag
             )
-            self.particulator.particles.chem_recalculate_drop_data(
+            self.particulator.attributes.chem_recalculate_drop_data(
                 equilibrium_consts=self.equilibrium_consts,
                 dissociation_factors=self.dissociation_factors
             )
-            self.particulator.particles.oxidation(
+            self.particulator.attributes.oxidation(
                 kinetic_consts=self.kinetic_consts,
                 equilibrium_consts=self.equilibrium_consts,
                 dissociation_factors=self.dissociation_factors,

PySDM/dynamics/coalescence.py

@@ -85,35 +85,35 @@ def __call__(self):
             else:
                 self.dt_left[:] = self.particulator.dt
 
-                while self.particulator.particles.get_working_length() != 0:
-                    self.particulator.particles.cell_idx.sort_by_key(self.dt_left)
+                while self.particulator.attributes.get_working_length() != 0:
+                    self.particulator.attributes.cell_idx.sort_by_key(self.dt_left)
                     self.step()
 
-                self.particulator.particles.reset_working_length()
-                self.particulator.particles.reset_cell_idx()
+                self.particulator.attributes.reset_working_length()
+                self.particulator.attributes.reset_cell_idx()
             self.rnd_opt.reset()
 
     def step(self):
         pairs_rand, rand = self.rnd_opt.get_random_arrays()
         self.toss_pairs(self.is_first_in_pair, pairs_rand)
         self.compute_probability(self.prob, self.is_first_in_pair)
         self.compute_gamma(self.prob, rand, self.is_first_in_pair)
-        self.particulator.particles.coalescence(gamma=self.prob, is_first_in_pair=self.is_first_in_pair)
+        self.particulator.attributes.coalescence(gamma=self.prob, is_first_in_pair=self.is_first_in_pair)
         if self.adaptive:
-            self.particulator.particles.cut_working_length(self.particulator.particles.adaptive_sdm_end(self.dt_left))
+            self.particulator.attributes.cut_working_length(self.particulator.attributes.adaptive_sdm_end(self.dt_left))
 
     def toss_pairs(self, is_first_in_pair, u01):
-        self.particulator.particles.permutation(u01, self.croupier == 'local')
+        self.particulator.attributes.permutation(u01, self.croupier == 'local')
         is_first_in_pair.update(
-            self.particulator.particles.cell_start,
-            self.particulator.particles.cell_idx,
-            self.particulator.particles['cell id']
+            self.particulator.attributes.cell_start,
+            self.particulator.attributes.cell_idx,
+            self.particulator.attributes['cell id']
         )
-        self.particulator.particles.sort_within_pair_by_attr(is_first_in_pair, attr_name="n")
+        self.particulator.attributes.sort_within_pair_by_attr(is_first_in_pair, attr_name="n")
 
     def compute_probability(self, prob, is_first_in_pair):
         self.kernel(self.kernel_temp, is_first_in_pair)
-        prob.max(self.particulator.particles['n'], is_first_in_pair)
+        prob.max(self.particulator.attributes['n'], is_first_in_pair)
         prob *= self.kernel_temp
 
         self.particulator.normalize(prob, self.norm_factor_temp)
@@ -122,8 +122,8 @@ def compute_gamma(self, prob, rand, is_first_in_pair):
         if self.adaptive:
             self.particulator.backend.adaptive_sdm_gamma(
                 prob,
-                self.particulator.particles['n'],
-                self.particulator.particles["cell id"],
+                self.particulator.attributes['n'],
+                self.particulator.attributes["cell id"],
                 self.dt_left,
                 self.particulator.dt,
                 self.dt_coal_range,
@@ -139,8 +139,8 @@ def compute_gamma(self, prob, rand, is_first_in_pair):
         self.particulator.backend.compute_gamma(
             prob,
             rand,
-            self.particulator.particles['n'],
-            self.particulator.particles["cell id"],
+            self.particulator.attributes['n'],
+            self.particulator.attributes["cell id"],
             self.collision_rate_deficit,
             self.collision_rate,
             is_first_in_pair

PySDM/dynamics/condensation.py

@@ -88,4 +88,4 @@ def __call__(self):
                 self.counters['n_substeps'][:] = np.maximum(self.counters['n_substeps'][:], int(self.particulator.dt / self.dt_cond_range[1]))
                 if self.dt_cond_range[0] != 0:
                     self.counters['n_substeps'][:] = np.minimum(self.counters['n_substeps'][:], int(self.particulator.dt / self.dt_cond_range[0]))
-            self.particulator.particles.attributes['volume'].mark_updated()
+            self.particulator.attributes.attributes['volume'].mark_updated()

PySDM/dynamics/displacement.py

@@ -39,21 +39,21 @@ def upload_courant_field(self, courant_field):
 
     def __call__(self):
         # TIP: not need all array only [idx[:sd_num]]
-        cell_origin = self.particulator.particles['cell origin']
-        position_in_cell = self.particulator.particles['position in cell']
+        cell_origin = self.particulator.attributes['cell origin']
+        position_in_cell = self.particulator.attributes['position in cell']
 
         self.calculate_displacement(self.displacement, self.courant, cell_origin, position_in_cell)
         self.update_position(position_in_cell, self.displacement)
         if self.enable_sedimentation:
-            self.precipitation_in_last_step = self.particulator.particles.remove_precipitated()
+            self.precipitation_in_last_step = self.particulator.attributes.remove_precipitated()
         self.update_cell_origin(cell_origin, position_in_cell)
         self.boundary_condition(cell_origin)
-        self.particulator.particles.recalculate_cell_id()
+        self.particulator.attributes.recalculate_cell_id()
 
         # TODO #443
-        self.particulator.particles.attributes['position in cell'].mark_updated()
-        self.particulator.particles.attributes['cell origin'].mark_updated()
-        self.particulator.particles.attributes['cell id'].mark_updated()
+        self.particulator.attributes.attributes['position in cell'].mark_updated()
+        self.particulator.attributes.attributes['cell origin'].mark_updated()
+        self.particulator.attributes.attributes['cell id'].mark_updated()
 
     def calculate_displacement(self, displacement, courant, cell_origin, position_in_cell):
         for dim in range(self.dimension):
@@ -63,7 +63,7 @@ def calculate_displacement(self, displacement, courant, cell_origin, position_in
             displacement_z = displacement[self.dimension - 1, :]
             dt_over_dz = self.particulator.dt / self.particulator.mesh.dz
             displacement_z *= 1 / dt_over_dz
-            displacement_z -= self.particulator.particles['terminal velocity']
+            displacement_z -= self.particulator.attributes['terminal velocity']
             displacement_z *= dt_over_dz
 
     def update_position(self, position_in_cell, displacement):

PySDM/dynamics/freezing.py

@@ -28,20 +28,20 @@ def __call__(self):
 
         if self.singular:
             self.particulator.bck.freeze_singular(
-                T_fz=self.particulator.particles['freezing temperature'],
-                v_wet=self.particulator.particles['volume'],
+                T_fz=self.particulator.attributes['freezing temperature'],
+                v_wet=self.particulator.attributes['volume'],
                 T=self.particulator.environment['T'],
                 RH=self.particulator.environment['RH'],
-                cell=self.particulator.particles['cell id']
+                cell=self.particulator.attributes['cell id']
             )
         else:
             self.rand.urand(self.rng)
             self.particulator.bck.freeze_time_dependent(
                 rand=self.rand,
-                immersed_surface_area=self.particulator.particles['immersed surface area'],
-                volume=self.particulator.particles['volume'],
+                immersed_surface_area=self.particulator.attributes['immersed surface area'],
+                volume=self.particulator.attributes['volume'],
                 J_het=self.J_het,
                 dt=self.particulator.dt
             )
 
-        self.particulator.particles.attributes['volume'].mark_updated()
+        self.particulator.attributes.attributes['volume'].mark_updated()

PySDM/exporters/vtk_exporter.py

@@ -42,15 +42,14 @@ def export_particles(self, particulator):
             print("Exporting Particles to vtk, path: " + path)
         payload = {}
 
-        particles = particulator.particles
-        for k in particles.attributes.keys():
-            if len(particles[k].shape) != 1:
-                tmp = particles[k].to_ndarray(raw=True)
-                tmp_dict = {k + '[' + str(i) + ']' : tmp[i] for i in range(len(particles[k].shape))}
+        for k in particulator.attributes.keys():
+            if len(particulator.attributes[k].shape) != 1:
+                tmp = particulator.attributes[k].to_ndarray(raw=True)
+                tmp_dict = {k + '[' + str(i) + ']' : tmp[i] for i in range(len(particulator.attributes[k].shape))}
 
                 payload.update(tmp_dict)
             else:
-                payload[k] = particles[k].to_ndarray(raw=True)
+                payload[k] = particulator.attributes[k].to_ndarray(raw=True)
 
         payload.update({k: np.array(v) for k, v in payload.items() if not (v.flags['C_CONTIGUOUS'] or v.flags['F_CONTIGUOUS'])})
 

PySDM/particulator.py

@@ -17,7 +17,7 @@ def __init__(self, n_sd, backend):
         self.backend = backend
         self.formulae = backend.formulae
         self.environment = None
-        self.particles: (Particles, None) = None
+        self.attributes: (Particles, None) = None
         self.dynamics = {}
         self.products = {}
         self.observers = []
@@ -67,8 +67,8 @@ def mesh(self):
 
     def normalize(self, prob, norm_factor):
         self.backend.normalize(
-            prob, self.particles['cell id'], self.particles.cell_idx,
-            self.particles.cell_start, norm_factor, self.dt, self.mesh.dv)
+            prob, self.attributes['cell id'], self.attributes.cell_idx,
+            self.attributes.cell_start, norm_factor, self.dt, self.mesh.dv)
 
     def update_TpRH(self):
         self.backend.temperature_pressure_RH(
@@ -87,29 +87,29 @@ def condensation(self, rtol_x, rtol_thd, counters, RH_max, success, cell_order):
         self.backend.condensation(
             solver=self.condensation_solver,
             n_cell=self.mesh.n_cell,
-            cell_start_arg=self.particles.cell_start,
-            v=self.particles["volume"],
-            n=self.particles['n'],
-            vdry=self.particles["dry volume"],
-            idx=self.particles._Particles__idx,
+            cell_start_arg=self.attributes.cell_start,
+            v=self.attributes["volume"],
+            n=self.attributes['n'],
+            vdry=self.attributes["dry volume"],
+            idx=self.attributes._Particles__idx,
             rhod=self.env["rhod"],
             thd=self.env["thd"],
             qv=self.env["qv"],
             dv=self.env.dv,
             prhod=self.env.get_predicted("rhod"),
             pthd=self.env.get_predicted("thd"),
             pqv=self.env.get_predicted("qv"),
-            kappa=self.particles["kappa"],
-            f_org=self.particles["dry volume organic fraction"],
+            kappa=self.attributes["kappa"],
+            f_org=self.attributes["dry volume organic fraction"],
             rtol_x=rtol_x,
             rtol_thd=rtol_thd,
-            v_cr=self.particles["critical volume"],
+            v_cr=self.attributes["critical volume"],
             dt=self.dt,
             counters=counters,
             cell_order=cell_order,
             RH_max=RH_max,
             success=success,
-            cell_id=self.particles['cell id']
+            cell_id=self.attributes['cell id']
         )
 
     def run(self, steps):

PySDM/physics/coalescence_kernels/_parameterized.py

@@ -10,12 +10,12 @@ def __init__(self, params):
 
     def __call__(self, output, is_first_in_pair):
         self.particulator.backend.linear_collection_efficiency(
-            self.params, output, self.particulator.particles['radius'], is_first_in_pair, const.si.um)
+            self.params, output, self.particulator.attributes['radius'], is_first_in_pair, const.si.um)
         output **= 2
         output *= const.pi
-        self.pair_tmp.max(self.particulator.particles['radius'], is_first_in_pair)
+        self.pair_tmp.max(self.particulator.attributes['radius'], is_first_in_pair)
         self.pair_tmp **= 2
         output *= self.pair_tmp
 
-        self.pair_tmp.distance(self.particulator.particles['terminal velocity'], is_first_in_pair)
+        self.pair_tmp.distance(self.particulator.attributes['terminal velocity'], is_first_in_pair)
         output *= self.pair_tmp

PySDM/physics/coalescence_kernels/geometric.py

@@ -11,8 +11,8 @@ def __init__(self, collection_efficiency=1, x='volume'):
         self.x = x
 
     def __call__(self, output, is_first_in_pair):
-        output.sum(self.particulator.particles['radius'], is_first_in_pair)
+        output.sum(self.particulator.attributes['radius'], is_first_in_pair)
         output **= 2
         output *= const.pi * self.collection_efficiency
-        self.pair_tmp.distance(self.particulator.particles['terminal velocity'], is_first_in_pair)
+        self.pair_tmp.distance(self.particulator.attributes['terminal velocity'], is_first_in_pair)
         output *= self.pair_tmp

PySDM/physics/coalescence_kernels/golovin.py

@@ -9,7 +9,7 @@ def __init__(self, b):
         self.particulator = None
 
     def __call__(self, output, is_first_in_pair):
-        output.sum(self.particulator.particles['volume'], is_first_in_pair)
+        output.sum(self.particulator.attributes['volume'], is_first_in_pair)
         output *= self.b
 
     def register(self, builder):

PySDM/products/product.py

@@ -36,9 +36,9 @@ def register(self, builder):
 
     def download_moment_to_buffer(self, attr, rank, filter_attr='volume', filter_range=(-np.inf, np.inf),
                                   weighting_attribute='volume', weighting_rank=0):
-        self.particulator.particles.moments(self.moment_0, self.moments, {attr: (rank,)},
-                                    attr_name=filter_attr, attr_range=filter_range,
-                                    weighting_attribute=weighting_attribute, weighting_rank=weighting_rank)
+        self.particulator.attributes.moments(self.moment_0, self.moments, {attr: (rank,)},
+                                             attr_name=filter_attr, attr_range=filter_range,
+                                             weighting_attribute=weighting_attribute, weighting_rank=weighting_rank)
         if rank == 0:  # TODO #217
             self.download_to_buffer(self.moment_0)
         else:
@@ -59,9 +59,9 @@ def register(self, builder):
 
     def recalculate_spectrum_moment(self, attr, rank, filter_attr='volume',
                                             weighting_attribute='volume', weighting_rank=0):
-        self.particulator.particles.spectrum_moments(self.moment_0, self.moments, attr, rank, self.attr_bins_edges,
-                                             attr_name=filter_attr,
-                                             weighting_attribute=weighting_attribute, weighting_rank=weighting_rank)
+        self.particulator.attributes.spectrum_moments(self.moment_0, self.moments, attr, rank, self.attr_bins_edges,
+                                                      attr_name=filter_attr,
+                                                      weighting_attribute=weighting_attribute, weighting_rank=weighting_rank)
 
     def download_spectrum_moment_to_buffer(self, rank, bin_number):
         if rank == 0:  # TODO #217

PySDM/products/state/super_droplet_count.py

@@ -11,7 +11,7 @@ def __init__(self):
         )
 
     def get(self):
-        cell_start = self.particulator.particles.cell_start
+        cell_start = self.particulator.attributes.cell_start
         n_cell = cell_start.shape[0] - 1
         for i in range(n_cell):
             self.buffer.ravel()[i] = cell_start[i + 1] - cell_start[i]

PySDM/state/particles.py

@@ -70,6 +70,9 @@ def reset_cell_idx(self):
         self.cell_idx.reset_index()
         self.__sort_by_cell_id()
 
+    def keys(self):
+        return self.attributes.keys()
+
     def __getitem__(self, item):
         return self.attributes[item].get()
 
@@ -158,14 +161,14 @@ def coalescence(self, gamma, is_first_in_pair):
                                           is_first_in_pair=is_first_in_pair
                                           )
         self.healthy = bool(self.__healthy_memory)
-        self.particulator.particles.sanitize()
+        self.particulator.attributes.sanitize()
         self.attributes['n'].mark_updated()
         for attr in self.attributes.values():
             if isinstance(attr, ExtensiveAttribute):
                 attr.mark_updated()
 
     def adaptive_sdm_end(self, dt_left):
-        return self.particulator.bck.adaptive_sdm_end(dt_left, self.particulator.particles.cell_start)
+        return self.particulator.bck.adaptive_sdm_end(dt_left, self.particulator.attributes.cell_start)
 
     def has_attribute(self, attr):
         return attr in self.attributes