Module particle_array¶

The ParticleArray class itself is documented as below.

A ParticleArray represents a collection of particles.

class pysph.base.particle_array.ParticleArray(str name='', default_particle_tag=Local, constants=None, **props)¶

Bases: object

Class to represent a collection of particles.

name¶

str

name of this particle array.

properties¶

dict

dictionary of {prop_name:carray}.

constants¶

dict

dictionary of {const_name: carray}

Examples

There are many ways to create a ParticleArray:

>>> p = ParticleArray(name='fluid', x=[1.,2., 3., 4.])
>>> p.name
'fluid'
>>> p.x, p.tag, p.pid, p.gid

For a full specification of properties with their type etc.:

>>> p = ParticleArray(name='fluid',
...                   x=dict(data=[1,2], type='int', default=1))
>>> p.get_carray('x').get_c_type()
'int'

The default value is what is used to set the default value when a new particle is added and the arrays auto-resized.

To create constants that are not resized with added/removed particles:

>>> p = ParticleArray(name='f', x=[1,2], constants={'c':[0.,0.,0.]})

Constructor

Parameters:	name (str) – name of this particle array. default_particle_tag (int) – one of Local, Remote or Ghost constants (dict) – dictionary of constant arrays for the entire particle array. These must be arrays and are not resized when particles are added or removed. These are stored as CArrays internally. props – any additional keyword arguments are taken to be properties, one for each property.

Receive(self, int send_proc)¶

Send(self, int recv_proc, props=None)¶

__delattr__¶

x.__delattr__(‘name’) <==> del x.name

__getattr__()¶

Convenience, to access particle property arrays as an attribute

A numpy array is returned. Look at the get() functions documentation for care on using this numpy array.

__getattribute__¶

x.__getattribute__(‘name’) <==> x.name

__reduce__(self)¶

Implemented to facilitate pickling of extension types

__setattr__¶

Convenience, to set particle property arrays as an attribute

__setstate__(self, d)¶

Load the particle array object from the saved dictionary

add_constant(self, str name, data)¶

Add a constant property to the particle array.

A constant property is an array but has a fixed size in that it is never resized as particles are added or removed. These properties are always stored internally as CArrays.

An example of where this is useful is if you need to calculate the center of mass of a solid body or the net force on the body.

Parameters:	name (str) – name of the constant data (array-like) – the value for the data.

add_output_arrays(self, list props)¶

Append props to the existing list of output arrays

Parameters:	props (list) – The additional list of property arrays to save

add_particles(self, **particle_props)¶

Add particles in particle_array to self.

Parameters:	particle_props (dict) – a dictionary containing numpy arrays for various particle properties.

Notes

• all properties should have same length arrays.
• all properties should already be present in this particles array. if new properties are seen, an exception will be raised. properties.

add_property(self, str name, str type='double', default=None, data=None)¶

Add a new property to the particle array.

If a default is not supplied 0 is assumed.

Parameters:	name (str) – compulsory name of property. type (str) – specifying the data type of this property (‘double’, ‘int’ etc.) default (value) – specifying the default value of this property. data (ndarray) – specifying the data associated with each particle.

Notes

If there are no particles currently in the particle array, and a new property with some particles is added, all the remaining properties will be resized to the size of the newly added array.

If there are some particles in the particle array, and a new property is added without any particles, then this new property will be resized according to the current size.

If there are some particles in the particle array and a new property is added with a different number of particles, then an error will be raised.

Warning

• it is best not to add properties with data when you already have particles in the particle array. Reason is that, the particles in the particle array will be stored so that the ‘Real’ particles are in the top of the list and later the dummy ones. The data in your property array should be matched to the particles appropriately. This may not always be possible when there are particles of different type in the particle array.
• Properties without any values can be added anytime.
• While initializing particle arrays only using the add_property function, you will have to call align_particles manually to make sure particles are aligned properly.

align_particles(self) → int¶

Moves all ‘Local’ particles to the beginning of the array

This makes retrieving numpy slices of properties of ‘Local’ particles possible. This facility will be required frequently.

Notes

Pseudo-code:

index_arr = LongArray(n)

next_insert = 0
for i from 0 to n
    p <- ith particle
    if p is Local
        if i != next_insert
            tmp = index_arr[next_insert]
            index_arr[next_insert] = i
            index_arr[i] = tmp
            next_insert += 1
        else
            index_arr[i] = i
            next_insert += 1
    else
        index_arr[i] = i

 # we now have the new index assignment.
 # swap the required values as needed.
 for every property array:
     for i from 0 to n:
         if index_arr[i] != i:
             tmp = prop[i]
             prop[i] = prop[index_arr[i]]
             prop[index_arr[i]] = tmp

append_parray(self, ParticleArray parray) → int¶

Add particles from a particle array

properties that are not there in self will be added

cl_properties¶

cl_properties: dict

cl_setup_done¶

cl_setup_done: ‘bool’

clear(self)¶

Clear all data held by this array

constants

constants: dict

copy_over_properties(self, dict props)¶

Copy the properties from one set to another.

Parameters:	props (dict) – A mapping between the properties to be copied.

Examples

To save the properties ‘x’ and ‘y’ to say ‘x0’ and ‘y0’:

>>> pa.copy_over_properties(props = {'x':'x0', 'y':'y0'}

copy_properties(self, ParticleArray source, long start_index=-1, long end_index=-1)¶

Copy properties from source to self

Parameters:	source (ParticleArray) – the particle array from where to copy. start_index (long) – the first particle in self which maps to the 0th particle in source end_index (long) – the index of first particle from start_index that is not copied

default_values¶

default_values: dict

extend(self, int num_particles)¶

Increase the total number of particles by the requested amount

New particles are added at the end of the list, you may have to manually call align_particles later.

extract_particles(self, indices, list props=None) → ParticleArray¶

Create new particle array for particles with indices in index_array

Parameters:	indices (list/array/LongArray) – indices of particles to be extracted (can be a LongArray or list/numpy array). props (list) – the list of properties to extract, if None all properties are extracted.

Notes

The algorithm is as follows:

• create a new particle array with the required properties.
• resize the new array to the desired length (index_array.length)
• copy the properties from the existing array to the new array.

get(self, *args, only_real_particles=True)¶

Return the numpy array/constant for the property names in the arguments.

Parameters:	only_real_particles (bool) – indicates if properties of only real particles need to be returned or all particles to be returned. By default only real particles will be returned. args : additional args a list of property names.

Notes

The returned numpy array does NOT own its data. Other operations may be performed.

Returns:
Return type:	Numpy array.

get_carray(self, str prop) → BaseArray¶

Return the c-array for the property or constant.

get_lb_props(self)¶

Return the properties that are to be load balanced. If none are explicitly set by the user, return all of the properties.

get_number_of_particles(self, bool real=False) → int¶

Return the number of particles

get_property_arrays(self, all=True, only_real=True)¶

Return a dictionary of arrays held by the ParticleArray container.

This does not include the constants.

Parameters:	all (bint) – Flag to select all arrays only_real (bint) – Flag to select Local/Remote particles

Notes

The dictionary returned is keyed on the property name and the value is the NumPy array representing the data. If all is set to False, the list of arrays is determined by the output_property_arrays data attribute.

get_property_index(self, prop_name)¶

Get the index of the property in the property array

get_time(self) → double¶

has_array(self, str arr_name)¶

Returns true if the array arr_name is present

indices_invalid¶

indices_invalid: ‘bool’

is_dirty¶

is_dirty: ‘bool’

name

name: str

num_real_particles¶

num_real_particles: ‘long’

output_property_arrays¶

output_property_arrays: list

properties

properties: dict

property_arrays¶

property_arrays: list

remove_particles(self, indices)¶

Remove particles whose indices are given in index_list.

We repeatedly interchange the values of the last element and values from the index_list and reduce the size of the array by one. This is done for every property that is being maintained.

Parameters:	indices (array) – an array of indices, this array can be a list, numpy array or a LongArray.

Notes

Pseudo-code for the implementation:

if index_list.length > number of particles
    raise ValueError

sorted_indices <- index_list sorted in ascending order.

for every every array in property_array
    array.remove(sorted_indices)

remove_property(self, str prop_name)¶

Removes property prop_name from the particle array

remove_tagged_particles(self, int tag)¶

Remove particles that have the given tag.

Parameters:	tag (int) – the type of particles that need to be removed.

resize(self, long size)¶

Resize all arrays to the new size

set(self, **props)¶

Set properties from numpy arrays like objects

Parameters:	props (dict) – a dictionary of properties containing the arrays to be set.

Notes

• the properties being set must already be present in the properties dict.
• the size of the data should match the array already present.

set_dirty(self, bool value)¶

Set the is_dirty variable to given value

set_indices_invalid(self, bool value)¶

Set the indices_invalid to the given value

set_lb_props(self, list lb_props)¶

set_name(self, str name)¶

set_output_arrays(self, list props)¶

Set the list of output arrays for this ParticleArray

Parameters:	props (list) – The list of property arrays

Notes

In PySPH, the solver obtains the list of property arrays to output by calling the ParticleArray.get_property_arrays method. If detailed output is not requested, the output_property_arrays attribute is used to determine the arrays that will be written to file

set_pid(self, int pid)¶

Set the processor id for all particles

set_tag(self, long tag_value, LongArray indices)¶

Set value of tag to tag_value for the particles in indices

set_time(self, double time)¶

set_to_zero(self, list props)¶

time¶

time: ‘double’

update_min_max(self, props=None)¶

Update the min,max values of all properties

update_property(self, BaseArray a, BaseArray a0, BaseArray acc, double dt)¶

Update an array from another array and a scalar.

This situation arises often when we want to update an array from computed accelrations. The scalar in this case will be the the time step.

pysph.base.particle_array.get_ghost_tag() → int¶

pysph.base.particle_array.get_local_tag() → int¶

pysph.base.particle_array.get_remote_tag() → int¶

pysph.base.particle_array.is_ghost(int tag) → bool¶

pysph.base.particle_array.is_local(int tag) → bool¶

pysph.base.particle_array.is_remote(int tag) → bool¶