Code Reference

Common

Common.Simulations

A placeholder for Simulation in the Common module. This module gather all simulations common things for TwoD, ThreeD, TwoDShape, models (and maybe others added afterwards).

class Common.Simulations.GenericSimulation(terrain=None, gravity=9.8, name=None, project=None, enable_forest=False, random_seed=None)

Bases: object

Generic Simulation, parent of all simulations from PlatRock main modules (TwoD, ThreeD, TwoDShape, …). It contains common attributes and functions. A Simulation object contains all informations concerning PlatRock simulations. Its child type defines the simulation model, its attributes stores the simulation setup and outputs. The run() method is used to launch the simulation (loops on rocks) via a set of generic methods.

Parameters:

random_seed (int, optional) – if given the random generator will be sed with this value, making simulation reproductible.

name

the simulation name, useful for GUIs

Type:

string

terrain

binds a terrain to this simulation, must be compatible with the Simulation type.

Type:

compatible Terrain

gravity

positive gravity value

Type:

float

project

the project that contains this simulation, useful for GUIs

Type:

Common.Projects.Project

enable_forest

whether to enable the forest or not

Type:

bool

status

reflects the simulation state, will be modified internally

Type:

string

use_retro_compatibility

whether this simulation was loaded by RetroCompatibility or not

Type:

bool

forest_impact_model

a bounce model that will handle rock-tree contacts, defaults to Common.BounceModels.Toe_Tree_2022

Type:

Common.BounceModels subclass

nb_rocks

how many rocks to launch, will be set internally

Type:

int

current_rock

points to the current simulated rock, will be set internally

Type:

compatible Rock

benchmark

whether to enable yappi profiling tool or not

Type:

bool

checkpoints

the list of compatible checkpoints, will be set internally

Type:

list of compatible Checkpoint

output

binds to the output instance, useful to retrieve simulation results

Type:

Common.Outputs.Output

current_rock_number

how many rocks have already propagated, will be set internally

Type:

int

random_generator

set internally

Type:

numpy.random.RandomState

override_forest_params

whether to globally override all forest parameters or not

Type:

bool

override_rebound_params

whether to globally override all soil parameters or not

Type:

bool

override_[param_name]

where [param_name] are the soil/forest parameter to override (ex: override_R_n)

Type:

various

abort()

If this simulation is launched via a GUI, this will abord its subprocess according to the process name, which sould be set to get_full_path().

after_all_tasks(queue=None)

Task method called after all rocks propagations are finished.

Parameters:

queue (multiprocessing.Queue, optional) – if given, communicates a dict with status, rocks_done, nb_rocks.

after_failed_run_tasks()

Task method called if an error occurs.

after_rock_propagation_tasks(queue=None)

Task method called after each single rock propagation is finished.

Parameters:

queue (multiprocessing.Queue, optional) – if given, communicates a dict with status, rocks_done, nb_rocks after each rock propagation.

after_successful_run_tasks()

Task method called after all the rocks are propagated, if everything went right.

before_rock_launch_tasks()

Task method called before each rock propagation.

before_run_tasks()

Task method called right after a simulation is launched.

get_dir()

Get the path corresponding to the simulation, its the basepath of setup.json.

Returns:

string

get_full_path()

Get the full path of the simulation pickle file, composed of: “/the_project_path/simulation_name/setup.json”

Returns:

string

classmethod get_parent_module()

get_setup_lock()

static get_setup_lock_from_path(setup_path)

get_terrain_cls()

rock_propagation_tasks()

Here is the science, this task method must do the propagation main loops for a single rock.

run(GUI=False, queue=None)

Actually launch the simulation, contains the main loop on rocks and the calls to all other task methods.

Parameters:

• GUI (bool) – enables the ThreeD 3D view

• queue (multiprocessing.Queue, optional) – this queue will be passed to other methods to communicate.

save_to_file()

This method will write the simulation into a json file located at get_full_path() with jsonpickle.

Note

This method is not intented to be used as it, rather call it from the simulation subclass as we must before remove the unwanted heavy attributes.

vel_stop_condition()

Common.BounceModels

This module is the placeholder for all BounceModel of PlatRock physical models. It is used by TwoD and ThreeD (non-siconos).

class Common.BounceModels.Azzoni_Roll(vel, mu_r, slope, gravity, start_pos=None, tan_slope=None, A=None, mass=None, radius=None, I=None)

Bases: object

Class capable of performing rocks roll on slopes, based on [Azzoni 1995]. The constructor will compute the stop distance (and optionally the stop position) on a supposed infinite slope. After that, you can retrieve the rock velocity at a given position with get_vel().

Parameters:

• mass (float, optional) – if A is not given, give the rock mass

• radius (float, optional) – if A is not given, give the rock radius

• I (float, optional) – if A is not given, give the rock inertia

vel

the input rock velocity

Type:

Vector2

mu_r

the rolling friction, this is tan_roll_phi in Azzoni paper

Type:

float

slope

the slope in radians

Type:

float

gravity

the gravity

Type:

float

start_pos

the rock input position, to compute the rock final position

Type:

Vector2, optional

tan_slope

stores the tangent of the slope, use in constructor only if you don’t want the code to compute it from the slope

Type:

float, optional

A

you can manually set this intermediate result, so you don’t have to give the rock mass, radius and I (see [Azzoni 1995]).

Type:

float, optional

delta_tan_angles

the difference between the two tangents of angles (slope and mu).

Type:

float

dist_stop

the resulting distance at which the rock will stop

Type:

float

stop_pos

the resulting position of the rock, if start_pos is given

Type:

Vector2

direction

stores the rock velocity direction along x: -1 or +1

Type:

int

v_square

stores the square of the rock velocity norm

Type:

float

compute_dist()

Computes the distance at which the rock will stop if it were on an infinite slope, and store it into dist_stop. If start_pos is set, also compute the stop_pos.

Note

If the rock does an accelerated roll, dist_stop will be set to \(+\infty\) and stop_pos will be set to [\(\pm\infty\), \(\pm\infty\)]

get_vel(arrival_point)

Get the arrival velocity from an initiated instance of Azzoni_Roll and an arrival point.

Parameters:

arrival_point (Vector2) – the precomputed arrival point

Returns:

the arrival velocity

Return type:

Vector2

class Common.BounceModels.BounceModel(simulation=None)

Bases: object

The parent class of every rock-soil bounce models. The table below represents the bounce-models dependency to the soil parameters. The soil parameters of the terrain elements (segments or faces) must be set according to this table. Similarly, the input files (csv or geojson) must be consistent with this table. Note that the parameters are case-sensitive.

	bounce_model_number	roughness	mu_r	R_n	R_t	v_half	phi
Classical
Pfeiffer
Bourrier

updated_normal

the segment (2D) or face (3D) rotated normal used to emulate roughness.

Type:

Vector2 || Vector3

simulation

the parent simulation, as the bounce models needs it to get its type and random generator. It should be a child class of GenericSimulation.

Type:

a child of GenericSimulation, optional

check_output_vel_2D(r, f)

Checks whether the rock velocity after rebound is valid, and the rocks doens’t go down inside the terrain.

Parameters:

• r (TwoD.Objects.Rock) – the current rock

• f (TwoD.Objects.Segment) – the segment on which the rock bounces

check_output_vel_3D(r, f)

Warning

Not implemented.

get_velocity_decomposed(v)

From the rock velocity in GCS, get the decomposed velocity in local CS (\(v_{n}\), \(v_t\)).

Parameters:

v (Vector2 || Vector3) – input velocity

Returns:

the normal and tangential velocities in local CS.

Return type:

list[\(v_n\), \(v_t\)]

set_updated_normal(*args, **kwargs)

Set updated_normal from the soil element normal, the rock velocity and the soil roughness.

Note

This method is self-overriden by set_updated_normal2D() or set_updated_normal3D() at its first call, depending on the simulation type. On previous implementations the binding was made in “__init__” but it caused jsonpickle to don’t load “set_updated_normal” function at all. Reason:Jsonpickle doesn’t run __init__ on load, but rather : - restore attributes from json file - “restore” methods from the existing class in memory

So in the previous implementation “set_updated_normal” was not an attribute, and neither a member function of BounceModel.

Parameters:

• *args – see set_updated_normal2D() or set_updated_normal3D()

• **kwargs – see set_updated_normal2D() or set_updated_normal3D()

set_updated_normal2D(rock, normal, roughness)

Set updated_normal from the segment normal, the rock propagation direction and the soil roughness.

Parameters:

• rock (Rock) – the current rock

• normal (Vector2) – the current segment normal

• roughness (float) – the current segment roughness

set_updated_normal3D(rock, normal, roughness)

Set updated_normal from the face normal, the rock propagation direction and the soil roughness.

Parameters:

• rock (Rock) – the current rock

• normal (Vector3) – the current segment normal

• roughness (float) – the current segment roughness

valid_input_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

The set of parameters needed by all bounce models.

class Common.BounceModels.Bourrier(*args)

Bases: BounceModel

Bourrier bounce model type (see [Bourrier2011]).

run(r, f, disable_roughness=False)

See [Bourrier2011].

valid_input_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

The set of parameters needed by the Bourrier bounce model.

class Common.BounceModels.Classical(*args)

Bases: BounceModel

Classical \(R_n, R_t\) bounce model type.

run(r, f, disable_roughness=False)

Runs the bounce model:

1. randomly compute the local slope angle

2. compute the rock velocity in the local slope coordinate system

3. apply \(R_n\) and \(R_t\) to the local velocity

4. finally rotate back the velocity into the global coordinates and set it to the rock.

Parameters:

• r (TwoD.Objects.Rock || ThreeD.Objects.Rock) – the rock that bounces

• f (TwoD.Objects.Segment || ThreeD.Objects.Face) – the terrain element on which the rock bounces

• disable_roughness (bool, optional) – disables the set_updated_normal() function

valid_input_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

The set of parameters needed by the Classical bounce model.

class Common.BounceModels.Pfeiffer(*args)

Bases: BounceModel

Pfeiffer bounce model type (see [Pfeiffer1989]).

run(r, f, disable_roughness=False)

Runs the bounce model:

1. randomly compute the local slope angle

2. compute the rock velocity in the local slope coordinate system

3. compute the friction function and the scaling factor

4. modify the velocity

5. finally rotate back the velocity into the global coordinates and set it to the rock.

Parameters:

• r (TwoD.Objects.Rock || ThreeD.Objects.Rock) – the rock that bounces

• f (TwoD.Objects.Segment || ThreeD.Objects.Face) – the terrain element on which the rock bounces

• disable_roughness (bool, optional) – disables the set_updated_normal() function

valid_input_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

The set of parameters needed by the Pfeiffer bounce model.

class Common.BounceModels.Toe_Tree

Bases: object

get_output_vel(vel=None, vol=None, ecc=None, dbh=None, ang=None)

Search in the abacus data array and retuns the nearest value.

Parameters:

• vel (float) – the input rock velocity norm

• vol (float) – the volume of the rock

• ecc (float) – the input rock eccentricity

• dbh (float) – the tree diameter

• ang (float) – the angle formed by the rock velocity and the horizontal plane

Returns:

the rock output velocities \(v_x, v_y, v_z\).

Return type:

numpy.ndarray

run_3D(r, t, xy_contact_point)

valid_input_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

The set of parameters needed by the Toe rock-tree bounce model.

input_sequence

the ordered list of parameters in Toe dem abacus output

Type:

list

weight_sequence

the priority of the parameters when searching a value in the abacus, higher to lower

Type:

list

toe_array

stores the abacus data in a numpy array for fast multi-dimensional search

Type:

numpy.ndarray

last_computed_data

stores the last computed output properties for access from the outside

Type:

dict

class Common.BounceModels.Toe_Tree_2022

Bases: object

cKDTree = None

conv_tab = None

data_file_url = 'https://entrepot.recherche.data.gouv.fr/api/access/datafile/:persistentId?persistentId=doi:10.57745/FY4IZI'

get_index(inputs)

get_output_vel(vel=None, vol=None, ecc=None, dbh=None, ang=None, hi=None)

max_dist = 10000

params_weights = [1, 1, 1, 1, 1, 1]

raw_data = None

raw_data_col_offset = 1

run_2D(rock, hi, dhp, ecc, rolling=False)

run_3D(rock, hi, tree, xy_contact_point)

valid_input_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

The set of parameters needed by the Toe rock-tree bounce model.

Common.BounceModels.number_to_model_correspondance = {0: <class 'Common.BounceModels.Classical'>, 1: <class 'Common.BounceModels.Pfeiffer'>, 2: <class 'Common.BounceModels.Bourrier'>}

A dictionnary that allows to link between the rebound model numbers and the corresponding class.

0: Classical 1: Pfeiffer 2: Bourrier

Common.Outputs

This module is used to store output data in an optimized hdf5 file.

Common.Outputs.FLY = 7

For ThreeD.Postprocessings.Postprocessing only, to describe a fly-over-raster-cell

Common.Outputs.MOTION = 8

For ShapedSimulations only, to track the motion of the rocks (don’t really track contacts)

Common.Outputs.OUT = 6

Rock out of terrain

class Common.Outputs.Output(s)

Bases: object

Captures rocks contacts data for a whole simulation and organize them in a structured way. Getters functions helps to retrieve and select data from the strucure. Hdf5 file export is also supported.

Parameters:

s (a Simulation instance) – will be _s attribute.

_s

binds to the simulation to retrieve informations from it.

Type:

a Simulation instance

contacts_slices

helper dict that links fields name to the corresponding columns in the contacts output array

Type:

dict of slices

checkpoints

the list of checkpoints, binded to the simulations checkpoints.

Type:

list of checkpoint

volumes

the 1D array of rocks volumes

Type:

numpy.ndarray

densities

the 1D array of rocks densities

Type:

numpy.ndarray

inertias

the 1D or 3D array of rocks inertias

Type:

numpy.ndarray

contacts

the list of contacts for all rocks, each rock is a numpy array with first dimension length equals the number of contacts, second dimension equals the number of fields recorded (see contact_slices).

Type:

list of numpy.ndarray

add_contact(r, normal, type_)

Add a contact to the last rock added to the output. This is triggered by the rock_propagation_tasks() functions at each contact. It will store contact-related infos, such as position, velocity…

Parameters:

• r (Rock)

• normal (platrock.Common.Math.Vector2 | Common.Math.Vector3) the contact normal (branch vector)

• type (int) – one of the contact type (ex: SOIL)

add_rock(r)

Add a rock with no contacts to the output. This is triggered by the before_rock_launch_tasks() functions. Stores rock quantities such a volume, density, inertia…

Parameters:

r (Rock) – instanciated rock

del_contact(rock_id, contact_id)

Sometimes a contact must be deleted for a given rock.

Parameters:

• rock_id (int) – the rock index in contacts from which to remove a contact

• contact_id (int) – if equals -1, remove the last contact, else remove the contact at this index in contacts

get_contacts_angVels(rock_id)

From a rock number, retrive all contacts angVels.

Parameters:

rock_id (int) – the rock index in contacts from which to retrieve infos

Returns:

numpy.ndarray

get_contacts_field(rock_id, field)

From a rock number, retrive all contact data corresponding to the field name (see contacts_slices)

Parameters:

• rock_id (int) – the rock index in contacts from which to retrieve infos

• field (string) – the data to retrieve (see keys of contacts_slices)

Returns:

numpy.ndarray

get_contacts_normals(rock_id)

From a rock number, retrive all contacts normals.

Parameters:

rock_id (int) – the rock index in contacts from which to retrieve infos

Returns:

numpy.ndarray

get_contacts_pos(rock_id)

From a rock number, retrive all contacts positions.

Parameters:

rock_id (int) – the rock index in contacts from which to retrieve infos

Returns:

numpy.ndarray

get_contacts_types(rock_id)

From a rock number, retrive all contacts types.

Parameters:

rock_id (int) – the rock index in contacts from which to retrieve infos

Returns:

numpy.ndarray

get_contacts_vels(rock_id)

From a rock number, retrive all contacts velocities.

Parameters:

rock_id (int) – the rock index in contacts from which to retrieve infos

Returns:

numpy.ndarray

write_to_h5(filename)

Export this output to a hdf5 file.

Note

It is advised to use hdf-compass to read hdf5 files. Use sudo apt install hdf-compass on debian-based distros such as Ubuntu.

Note

Here is the hdf5 file structure created:

# hdf5-file/
# ├── rocks/
# |   ├── start_data
# |   └── contacts/
# |       ├── 0 (contacts of rock n°0)
# |       ├── ..
# |       └── nb_rocks
# └── checkpoints/
#     ├── x_0 (x position of checkpoint 0)
#     ├── x_1
#     └── x_N

Common.Outputs.ROLL = 4

Rolling-friction

Common.Outputs.ROLL_TREE = 3

Contact with a tree while rolling

Common.Outputs.SOIL = 1

Rock-soil contact

Common.Outputs.START = 0

The rock initial position

Common.Outputs.STOP = 5

Rock stop position

Common.Outputs.TREE = 2

Rock-tree contact

Common.OneDTreeGenerator

Module that handles the generation of trees.

class Common.TreesGenerators.OneDTreeGenerator(sim, treesDensity=0.1, trees_dhp=0.3, dRock=0.5)

Bases: object

Computes the (1D) distance before the next tree impact from the trees/rock properties and a probability law. Instanciate then launch getOneRandomTreeImpactDistance() to get the next distance.

Note

The cdf follow an exponential law which parameter is a function of basal area (treesDensity*trees_dhp), trees_dhp and dRock.

sim

the parent simulation

Type:

GenericSimulation, optional

treesDensity

the trees density, in trees/m²

Type:

float

trees_dhp

the trees mean diameter, in meters

Type:

float, optional

dRock

the rock equivalent diameter, in meters

Type:

float, optional

coef

the computed parameters of the cdf exponential law

Type:

float

prob0

the probability to hit a tree immediately

Type:

float

random_generator

copied from simulation or numpy.random

getOneRandomTreeImpactDistance()

Get the next impact distance from the instanciated object (pick a value from the previously computed PDF function).

Returns:

float

Common.Math

Cython module intented to do mathematical operations as fast as possible.

class platrock.Common.Math.Vector1(input=0.0)

Bases: ndarray

Mainly for defining angular velocity in 2D models, and still allows for computations while sharing bounce models between 2D and 3D models. Instanciation follows numpy.ndarray directives.

dot(B)

Get the dot product of this Vector1 by B, equivalent to regular scalar product.

Parameters:

B (Vector1)

Returns:

float

norm()

Get the norm of this Vector1, equivalent to absolute value.

Returns:

float

normalized()

Get the corresponding normalized Vector1.

Returns:

Vector1

class platrock.Common.Math.Vector2(input=[0, 0])

Bases: ndarray

Two components vector with fast operations, also allows for computations while sharing bounce models between 2D and 3D models. Instanciation follows numpy.ndarray directives.

cross(B)

Get the cross product of this Vector2 by B.

Parameters:

B (Vector2)

Returns:

Vector1

dot(B)

Get the dot product of this Vector2 by B.

Parameters:

B (Vector2)

Returns:

float

norm()

Get the norm of this Vector2.

Returns:

float

normalized()

Get the corresponding normalized Vector2.

Returns:

Vector2

rotated(ang, ax=None)

Get a rotated version of this Vector2.

Parameters:

• ang (float) – the amount (angle) of rotation in radians.

• ax (None) – not used, just here for compatibility with Vector3 operations

Returns:

Vector2

class platrock.Common.Math.Vector3(input=[0, 0, 0])

Bases: ndarray

3 components vector with fast operations, also allows for computations while sharing bounce models between 2D and 3D models. Instanciation follows numpy.ndarray directives.

cross(B)

Get the cross product of this Vector3 by B.

Parameters:

B (Vector3)

Returns:

Vector3

dot(B)

Get the dot product of this Vector3 by B.

Parameters:

B (Vector3)

Returns:

float

norm()

Get the norm of this Vector3.

Returns:

float

normalized()

Get the corresponding normalized Vector3.

Returns:

Vector3

rotated(ang, ax)

Get a rotated version of this Vector3.

Parameters:

• ang (float) – the amount (angle) of rotation in radians.

• ax (Vector3) – the axis to turn around.

Returns:

Vector3

platrock.Common.Math.atan2_unsigned(y, x)

Returns atan2, but shifted in the interval [\(0\), \(2\pi\)].

Parameters:

• y (float)

• x (float)

Returns:

float

platrock.Common.Math.center_2d_polygon_vertices(points)

Move in place a 2D array of points forming a polygon to set its COG to [0,0].

Parameters:

points (numpy.ndarray) – the array of points forming the polygon in the form [[x0, y0], [x1, y1], …]

platrock.Common.Math.cross2(A, B)

Get the cross product of this Vector2 by B.

Parameters:

B (Vector2)

Returns:

Vector1

platrock.Common.Math.cross3(A, B)

Get the cross product of this Vector3 by B.

Parameters:

B (Vector3)

Returns:

Vector3

platrock.Common.Math.dot1(A, B)

Get the dot product of this Vector1 by B, equivalent to regular scalar product.

Parameters:

B (Vector1)

Returns:

float

platrock.Common.Math.dot2(A, B)

Get the dot product of this Vector2 by B.

Parameters:

B (Vector2)

Returns:

float

platrock.Common.Math.dot3(A, B)

Get the dot product of this Vector3 by B.

Parameters:

B (Vector3)

Returns:

float

platrock.Common.Math.get_2D_polygon_area_inertia(points, density, cog_centered=False)

From a 2D array of points forming a polygon, get its area and inertia.

Parameters:

• points (numpy.ndarray) – the array of points forming the polygon in the form [[x0, y0], [x1, y1], …]

• density (float) – the 2D polygon density, used to compute inertia

• cog_centered (bool, optional) – whether the polygon COG in also at coordinates [0,0] or not.

Returns:

the area and inertia, \([A, I]\).

Return type:

list

platrock.Common.Math.get_2D_polygon_center_of_mass(points)

From a 2D array of points forming a polygon, get its center of mass.

Note

Taken from http://math.15873.pagesperso-orange.fr/page9.htm

Parameters:

points (numpy.ndarray) – the array of points forming the polygon in the form [[x0, y0], [x1, y1], …]

Returns:

the center of mass coordinates \([G_x, G_y]\)

Return type:

list

platrock.Common.Math.get_random_convex_polygon(n, Lx, Ly)

Get a random convex 2D array of points forming a polygon.

Note

Valtr’s algorithm is used, it can be found here : https://cglab.ca/~sander/misc/ConvexGeneration/convex.html

Parameters:

• n (int) – the number of vertices

• Lx (float) – the polygon size in the \(x\) direction

• Ly (float) – the polygon size in the \(y\) direction

Returns:

2D array of points forming the polygon

Return type:

numpy.ndarray

platrock.Common.Math.get_random_value_from_gamma_distribution(mean, std, rand_gen=None)

Get a random value from a given gamma distribution. Uses scipy.stats.

Parameters:

• mean (float) – the desired distribution mean

• std (float) – the desired distribution standard deviation

• rand_gen (numpy.random.RandomState, optional) – the random generator, useful for simulations reproductibility.

Returns:

float

platrock.Common.Math.norm1(A)

Get the norm of this Vector1, equivalent to absolute value.

Returns:

float

platrock.Common.Math.norm2(A)

Get the norm of this Vector2.

Returns:

float

platrock.Common.Math.norm3(A)

Get the norm of this Vector3.

Returns:

float

platrock.Common.Math.normalized1(A)

Get the corresponding normalized Vector1.

Returns:

Vector1

platrock.Common.Math.normalized2(A)

Get the corresponding normalized Vector2.

Returns:

Vector2

platrock.Common.Math.normalized3(A)

Get the corresponding normalized Vector3.

Returns:

Vector3

platrock.Common.Math.rotate_points_around_origin(points, radians)

Rotate in place a 2D array of points around [0,0].

Parameters:

• points (numpy.ndarray) – the array of points in the form [[x0, y0], [x1, y1], …]

• radians (float) – the amount of rotation, (angle in radians)

platrock.Common.Math.rotate_vector(q, A)

Get a rotated quaternion from an input quaternion q with a rotation vector A.

Parameters:

• q (quaternion) – the quaternion to turn

• A (Vector3) – the rotation vector

Returns:

quaternion

platrock.Common.Math.rotated2(A, ang, ax=None)

Get a rotated version of this Vector2.

Parameters:

• ang (float) – the amount (angle) of rotation in radians.

• ax (None) – not used, just here for compatibility with Vector3 operations

Returns:

Vector2

platrock.Common.Math.rotated3(A, ang, ax)

Get a rotated version of this Vector3.

Parameters:

• ang (float) – the amount (angle) of rotation in radians.

• ax (Vector3) – the axis to turn around.

Returns:

Vector3

platrock.Common.Math.sort_2d_polygon_vertices(points)

Sort in place a 2D array of points to form a polygon.

Parameters:

points (numpy.ndarray) – the array of points in the form [[x0, y0], [x1, y1], …]

Common.Utils

Some handy classes and functions used everywhere in PlatRock. FIXME: DOC

class Common.Utils.BoolParameterDescriptor(input_names, inst_name, human_name, default_value=None)

Bases: ParameterDescriptor

TYPE = 'Bool'

class Common.Utils.FreeNumberParameterDescriptor(input_names, inst_name, human_name, type_, min_value=None, max_value=None, default_value=None)

Bases: ParameterDescriptor

TYPE = 'FreeNumber'

class Common.Utils.FreeStringParameterDescriptor(input_names, inst_name, human_name, default_value='', hint=False)

Bases: ParameterDescriptor

TYPE = 'FreeString'

class Common.Utils.ParameterDescriptor(input_names, inst_name, human_name, type_, default_value)

Bases: object

Fully describes a parameter, useful for GUIs.

Note

This class doesn’t contain the value of the parameter, only its characteristics. Values are directly stored in instances, GenericSimulation for example.

input_names

when reading platrock input parameters names from files, use this(ese) name(s) to bind to the right parameter. Always store as a list of strings in instances.

Type:

list of strings || string

inst_name

the instance name, name that this parameter will take in platrock source code, objects instances, etc…

Type:

string

human_name

a human-readable and understandable full parameter name, including eventual unity

Type:

string

type_

the python type the parameter should be of

Type:

type

min_value

the minimum acceptable value

Type:

type_

max_value

the maximum acceptable value

Type:

type_

default_value

the default value

Type:

type_

set_to_obj(obj, value=None, inst_name_prefix='', inst_name_suffix='')

Set a value from this parameter descriptor to an object attribute. This will cast to type_ and set the default_value if the value given is None. The attribute name will be inst_name.

Parameters:

• obj (object) – the instance to set the parameter to

• value (anything castable to type_, optional) – the value to set, if None default_value will be used

• inst_name_prefix (string, optional) – a prefix added before inst_name

• inst_name_suffix (string, optional) – a suffix added after inst_name

class Common.Utils.ParametersDescriptorsSet(params_list)

Bases: object

A container of ParameterDescriptor, with helper functions.

Note

ParametersDescriptorsSet are not iterable, use parameters attribute to loop on contained ParameterDescriptor.

Parameters:

params_list (list of ParameterDescriptor || list of list of args to construct ParameterDescriptor) – the input set of ParameterDescriptor

parameters

contains the ParameterDescriptor

Type:

list

instance_names_to_parameters

links ParameterDescriptor.inst_name to ParameterDescriptor

Type:

dict

input_names_to_parameters

links ParameterDescriptor.input_names to ParameterDescriptor

Type:

dict

add_parameter(*args, **kwargs)

Adds a ParameterDescriptor into this set, either by passing a ParametersDescriptorsSet or args/kwargs that satisfies the ParameterDescriptor constructor.

:param A single ParameterDescriptor: :param or a set of arguments compatible with ParameterDescriptor constructor signature.:

Kwargs:

A set of keywords arguments compatible with ParameterDescriptor constructor signature.

get_human_names()

Get all the human names of the ParameterDescriptor contained in this container

Returns:

list of strings

get_input_names()

Get all the input names of the ParameterDescriptor contained in this container

Returns:

list of strings

get_instance_names()

Get all the instance names of the ParameterDescriptor contained in this container

Returns:

list of strings

get_param_by_input_name(input_name)

Get a ParameterDescriptor from its input name.

Parameters:

input_name (string) – the input name to search for

Returns:

returns false if the param input name doesn’t exist.

Return type:

ParameterDescriptor || bool

get_param_by_instance_name(instance_name)

Get a ParameterDescriptor from its instance name.

Parameters:

instance_name (string) – the instance name name to search for

Returns:

returns false if the param instance name doesn’t exist.

Return type:

ParameterDescriptor || bool

class Common.Utils.Report

Bases: object

A report is a handy tool that groups a series of messages with corresponding message type. It is used to check users parameters in WebUI, before they launch a simulation.

nb_of_errors

counts the number of errors contained is this report

Type:

int

messages

contains all the messages in the format [[mess_type, “the message”], …]

Type:

list

add_error(message)

Adds an error (“E”) message to the report. Note that this will increment nb_of_errors.

Parameters:

message (string) – the message

add_info(message)

Adds an info (“I”) message to the report.

Parameters:

message (string) – the message

add_message(_type, message)

Adds a message to the report, should not really be used directly.

Parameters:

• _type (sting) – one of the messages_letters_to_types keys (for example “I”)

• message (string) – the message

add_warning(message)

Adds an warning (“W”) message to the report.

Parameters:

message (string) – the message

check_parameter(param_descriptor, param_value, location_string='')

Checks the validity of a value for a given ParameterDescriptor. The value type and range will be checked, if they are not valid some error messages will be added to this report.

Parameters:

• param_descriptor (ParameterDescriptor) – the parameter descriptor containing the type and range for the value

• param_value (any) – the value to check

• location_string (string) – for the error message to be more explicit, tell where the parameter comes from.

messages_letters_to_types = {'E': 'ERROR', 'I': 'INFO', 'W': 'WARNING'}

Links between the message letter types (_type) and the corresponding human names

class Common.Utils.StringChoiceParameterDescriptor(input_names, inst_name, human_name, default_value='', choices=[''])

Bases: ParameterDescriptor

TYPE = 'StringChoice'

Common.Utils.extract_geojson_to_params_set(filename, destination, validation_params_descriptors_set, colormap)

Get geometries and parameters from a geojson file, and populate the destination list.

Note

The destination should be an instanciated list, for example as an object attribute, as it will be cleared then modified in place. Its format will be:

[
    {
        "shapely_polygon": <the_corresponding_shapely_polygon_instance>,
        "params": {
            "R_n": 0.5,
            "R_t": 0.2,
            ...
        },
        "color": [0.5, 0.5, 0.5]
    }
]

Parameters:

• filename (string) – path to the geojson file

• destination (list) – points to a list that will contains the parameters and geometries

• validation_params_descriptors_set (ParametersDescriptorsSet) – the parameters coming from the geojson file will be validated with this parameter container

• colormap (list) – a (2D) list of rgb colors to set a “color” to each output parameter set

Returns:

0 if extraction is OK, the error message otherwise

Common.Utils.get_geojson_all_properties(filename, unique=True)

Get all available “properties” names for all features of a geojson file.

Parameters:

• filename (string) – path to the geojson file

• unique (bool, optional) – if set to False, all properties names of all features of the file will be output (2D list). If set to True the properties names of all features will be merged, but each parameter will appear once (1D list).

Returns:

list of strings

Common.Utils.get_geojson_all_shapes(filename, unique=True)

Get all available “geometry” types for all features of a geojson file.

Parameters:

• filename (string) – path to the geojson file

• unique (bool, optional) – if set to False, all geometry names of all features of the file will be output (2D list). If set to True the geometry names of all features will be merged, but each geometry will appear once (1D list).

Returns:

list of strings

Common.Utils.parameterDescriptorFactory(*args, **kwargs)

Common.Debug

This module is used by PlatRock for logging. Log level can be set with current_level or by launching platrock -ll=info (replace info by the log level you want). It is also used by the WebUI to log to files instead of stdout.

Common.Debug.ERROR = 40

Only log errors

Common.Debug.INFO = 20

The more verbose mode.

Common.Debug.WARNING = 30

Intermediate verbosity.

Common.Debug.add_logger(filename=None)

Get or create a logger based on the process PID, clear its handlers, add a new handler.

Parameters:

filename (string, optional) – the filename to write into, otherwise log will output to stdout.

Common.Debug.args_to_str(*args)

Concatenate stringified variables.

Parameters:

*args (any) – the arguments to be stringified.

Returns:

all args as strings, separated by spaces.

Return type:

str

Common.Debug.current_level = 0

Current log level. This is set by bin/platrock.

Common.Debug.do_nothing(*args)

Common.Debug.error(*args)

Write variables to current logger if the current log level is superior or equal to ERROR.

Parameters:

*args (any) – the variables to log.

Common.Debug.get_logger()

Get the logger corresponding to the current process PID, or create one if it doesn’t exist (this is the behavior of “logging.getLogger”)

Returns:

the python logger to write into.

Return type:

logging.RootLogger

Common.Debug.info(*args)

Write variables to current logger if the current log level is superior or equal to INFO.

Parameters:

*args (any) – the variables to log.

Common.Debug.init(level)

This function sets the current_level and overrides the info(), warning(), error() functions with do_nothing() depending on the level.

Parameters:

level (int) – the log level, should be set to INFO, WARNING or ERROR.

Common.Debug.warning(*args)

Write variables to current logger if the current log level is superior or equal to WARNING.

Parameters:

*args (any) – the variables to log.

TwoD

TwoD.Simulations

class TwoD.Simulations.Simulation(*args, **kwargs)

Bases: GenericTwoDSimulation

A TwoD simulation.

Constructor

Parameters:

checkpoints_x (list [x0, x1, ...]) – all the checkpoints x postions. Checkpoints data are post-computed with update_checkpoints() from all contacts of all rocks.

add_rock()

before_run_tasks()

Task method called right after a simulation is launched.

get_parameters_verification_report()

rock_propagation_tasks()

Here is the science, this task method must do the propagation main loops for a single rock.

setup_rock_kinematics()

webui_typename = 'PlatRock 2D'

TwoD.Objects

This module handles the objects types needed by the TwoD model.

class TwoD.Objects.Checkpoint(_x=None, angle=None, max_height=None)

Bases: GenericTwoDCheckpoint

class TwoD.Objects.Rock(*args, **kwargs)

Bases: GenericTwoDRock

A falling rock.

Parameters:

• x (float) – initial position along the x axis. Note that the coordinates system used is the one after the terrain is eventually cleaned, shifted and reversed.

• height (float) – initial height relative to the terrain

vel

velocity along x,z

Type:

Common.Math.Vector2 [float,float]

angVel

angular velocity

Type:

float

volume

volume

Type:

float

density

density

Type:

float

I

inertia, autocomputed if not given

Type:

float

pos

position along x,z, autocomputed

Type:

Vector2

radius

radius, autocomputed

Type:

float

mass

mass, autocomputed

Type:

float

A

an intermediate result of the Azzoni Roll, automatically precomputed

Type:

float

v_square

an intermediate value computed into the Azzoni Roll

Type:

float

force_roll

a flag set/used into the roll algorithm to handle roll along two colinear segments

Type:

bool

is_stopped

flag triggered when the stopping condition is reached

Type:

boolean

current_segment

the current segment that is vertically under the rock

Type:

Segment

flying_direction

-1 if the rock is moving towards -x, +1 if the rock is moving towards +x

Type:

int

color

the rock RGB color, each compound being between 0. and 1., autocomputed

Type:

list [float,float,float]

out_of_bounds

set to true during the simulation if the rock went out of the terrain

Type:

bool

bounce(s, segment, disable_roughness=False)

Apply a bounce from platrock.Common.BounceModels to the rock, it will update the velocity and angVel of the rock.

Parameters:

• s (Simulation) – the current simulation, needed to access its output

• segment (Segment) – the segment that is vertically under the rock

• disable_roughness (bool) – use this to tell the bounce model not to apply the terrain roughness

fly(arrival_point, s, segment)

Apply a fly movement to the rock, it will update the position and the velocity of the rock.

Parameters:

• arrival_point (Vector2) – the new position along x,z

• s (Simulation) – the current simulation, needed to access its output

• segment (Segment) – the segment that is vertically under the rock after the move

move(arrival_point, s, segment)

Actually move the rock by updating its pos. The current simulation and arrival segment must be given as they are usually already computed at this stage.

Note

This method also handles the rock stop condition, it has in charge to set is_stopped.

Parameters:

• arrival_point (Vector2) – the new position along x,z

• s (Simulation) – the current simulation, needed to access its output

• segment (Segment) – the segment that is vertically under the rock after the move

roll(s, azzoni_roll, arrival_point)

Apply a roll movement to the rock, it will update the position, velocity and angVel of the rock.

Parameters:

• s (Simulation) – the current simulation, needed to access its output

• azzoni_roll (Azzoni_Roll) – the instanciated roll model as it contains necessary attributes and methods

• arrival_point (Vector2) – the new position along x,z

update_flying_direction()

Deduce and update the flying_direction from the velocity.

class TwoD.Objects.Segment(start_point, end_point)

Bases: GenericSegment

A segment of the terrain. Attributes from all bounce models / rolls will be considered as valid, they are stored in valid_input_attrs, with values :

instance name	input name(s)	human name
roughness	roughness	Roughness
bounce_model_number	bounce_model_number || bounce_mod	Rebound model
mu_r	mu_r	μ \(_{r}\)
R_t	R_t	R \(_{t}\)
R_n	R_n	R \(_{n}\)
phi	phi	φ
v_half	v_half	V \(_{1/2}\)
trees_density	trees_density || density	Trees density (trees/ha)
trees_dhp_mean	trees_dhp_mean || dhp_mean	Mean trees ⌀ (cm)
trees_dhp_std	trees_dhp_std || dhp_std	σ(trees ⌀) (cm)

Parameters:

• start_point (Vector2) – start point coordinates of the segment (\([x_{start}, z_{start}]\))

• end_point (Vector2) – end point coordinates of the segment (\([x_{end}, z_{end}]\))

points

start and end points in the form \([ [x_{start}, z_{start}], [x_{end}, z_{end}] ]\)

Type:

np.ndarray

index

index of the segment (they are continuously and automatically indexed through the terrain)

Type:

int

branch

the vector connecting start_point to end_point

Type:

Vector2

normal

the segment normal vector

Type:

Vector2

slope_gradient

the gradient of slope (\(\Delta_z / \Delta_x\))

Type:

float

slope

the slope in radians, CCW

Type:

float

valid_input_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

Describes the available soil attributes, they are a concatenation of all bounce models parameters.

class TwoD.Objects.Terrain(*args, **kwargs)

Bases: GenericTwoDTerrain

A 2D terrain made of segments.

Parameters:

file (string)

segments

the successive Segment forming the terrain

Type:

list

rebound_models_available

A list of available bounce models numbers regarding the per-segment input parameters given, automatically filled.

Type:

list

forest_available

whether the forest is available in the terrain regarding the per-segment input parameters given, automatically set.

Type:

bool

check_segments_parameters_consistency()

Analyze the segments parameters and checks their consistency/availability. forest_available and rebound_models_available are here.

valid_input_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

TwoD.Geoms

This module is used by the TwoD model. It describes 2D geometric objects and provide some functions to solve geometric problems.

class TwoD.Geoms.Line(S=None, a=None, b=None, point=None, angle=None)

Bases: object

A line, described by the two constants a and b in \(z=ax + b\). The instanciation can be done with either from:

• a segment S

• a and b constants

• [x, y] of a point and a positive angle in radians

Parameters:

S (TwoD.Objects.Segment, optional) – a segment from which to deduce the line.

a

the rate of increase coefficient.

Type:

float

b

the y-intercept.

Type:

float

EPS = 1e-10

class TwoD.Geoms.Parabola(r=None, pos=None, vel=None, g=None, ABC=None)

Bases: object

A 2D parabola, described by : \(z = Ax^2 + Bx +C\). The instanciation can be done with either from:

• \(g\) and the velocity and position of a TwoD.Objects.Rock,

• \(g\) and an explicit pair of position and velocity,

• directly from an ABC vector/list.

Parameters:

• r (TwoD.Objects.Rock, optional) – a rock from which to deduce the parabola

• pos (iterable, optional) – a position in a list, a vector or an array \([px, pz]\)

• vel (iterable, optional) – a velocity in a list, a vector or an array \([vx, pz]\)

• g (float, optional) – the gravity acceleration

• ABC (iterable, optional) – the A, B and C constants in a list, a vector or an array \([A, B, C]\)

A

the \(A\) square parameter

Type:

float

B

the \(B\) linear parameter

Type:

float

C

the \(C\) constant parameter

Type:

float

get_arrow_x_from_gradient(gradient)

Returns the \(x\) value of the arrow for this parabola and a slope defined by its gradient. If the parabola is a trajectory, the arrow is the highest (vertical) height of the object during its fly over the slope.

Parameters:

gradient (float) – the slope gradient (\(dx/dy\))

Returns:

\(x_{arrow}\)

Return type:

float

get_value_at(x)

Returns the \(z\) value of the parabola at the given \(x\) position.

Parameters:

x (float) – the \(x\) value

Returns:

\(Ax^2 + Bx +C\)

Return type:

float

TwoD.Geoms.find_next_bounce(sim, rock, rock_parabola)

In a given simulation, for a given rock, find the next rebound on the soil. The algorithm works as follows:

1. compute the rock parabola

2. loop on the segments from the TwoD.Objects.Rock.current_segment in the TwoD.Objects.Rock.flying_direction, and try to find a parabola-segment intersection

3. keep the intersection with the soil if it is compatible with the rock flying direction and if it does not correspond to the previous rock rebound point

Parameters:

• sim (TwoD.Simulations.Simulation) – the simulation

• rock (TwoD.Objects.Rock) – the rock

Returns:

(intersection point, corresponding segment)

Return type:

(Vector2 [x_i, z_i], TwoD.Objects.Segment)

TwoD.Geoms.get_line_parabola_intersections(L, P)

Computes the intersections between a line and a parabola. If no solutions, return a NaN-filled array.

Parameters:

• L (TwoD.Geoms.Line) – the line

• P (TwoD.Geoms.Parabola) – the parabola

Returns:

the two solutions [[x_i1,z_i1], [x_i2, z_i2]]:

Return type:

numpy.ndarray

TwoD.Geoms.get_roots(A, B, C)

Gives the roots of the second order equation \(z=Ax^2 + Bx + C\). If there is no solutions, the returned array is empty. If the there is one solution only, it will be duplicated in the output array.

Parameters:

• A (float) – the square coefficient

• B (float) – the linear coefficient

• C (float) – the constant coefficient

Returns:

array containing the two roots \([x_{root1}, x_{root2}]\), or empty array.

Return type:

Vector2

TwoD.Geoms.get_segment_parabola_intersections(S, P)

Computes the intersection(s) between a segment and a parabola. If no solutions, return an empty array.

Parameters:

• S (TwoD.Objects.Segment) – the segment

• P (TwoD.Geoms.Parabola) – the parabola

Returns:

the eventual solutions [[x_i1, z_i1], [x_i2, z_i2]].

Return type:

numpy.ndarray

TwoDShape

TwoDShape.Simulations

TwoDShape.Objects

class TwoDShape.Objects.Checkpoint(_x=None, angle=None, max_height=None)

Bases: GenericTwoDCheckpoint

class TwoDShape.Objects.Ellipse(**kwargs)

Bases: Rock

valid_shape_params = <platrock.Common.Utils.ParametersDescriptorsSet object>

class TwoDShape.Objects.PointsList(points=None, **kwargs)

Bases: Rock

static get_secondary_axis_extents(points)

static input_string_to_points(input_str)

NOTE: input_str can be an xy filepath or a string representing the content of an xy file.

classmethod new_from_points(points)

static points_are_convex(points)

valid_shape_params = <platrock.Common.Utils.ParametersDescriptorsSet object>

static validate_points(points)

static xy_string_to_points(string)

class TwoDShape.Objects.Random(**kwargs)

Bases: Rock

generate()

valid_shape_params = <platrock.Common.Utils.ParametersDescriptorsSet object>

class TwoDShape.Objects.Rectangle(**kwargs)

Bases: Rock

valid_shape_params = <platrock.Common.Utils.ParametersDescriptorsSet object>

class TwoDShape.Objects.Rock(**kwargs)

Bases: GenericTwoDRock

classmethod get_subclass_from_name(name)

classmethod get_subclasses_names()

set_volume(dest_vol, modify_base_shape=False)

setup_kinematics(ori=None, **kwargs)

Set the rock kinematics quantities, such as velocity and position.

Parameters:

• x (float) – see Rock constructor.

• height (float) – see Rock constructor.

• vel (Vector2 [float,float]) – see Rock constructor.

• angVel (float) – see Rock constructor.

valid_shape_params = <platrock.Common.Utils.ParametersDescriptorsSet object>

vertices_to_string(points=None)

class TwoDShape.Objects.Segment(start_point, end_point)

Bases: GenericSegment

valid_input_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

class TwoDShape.Objects.Terrain(file=None)

Bases: GenericTwoDTerrain

valid_input_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

ThreeD

ThreeD.Simulations

class ThreeD.Simulations.Simulation(engines=None, dt=0.02, **kwargs)

Bases: GenericThreeDSimulation, GenericTimeSteppedSimulation

A simulation

The table below displays the attributes that have to be set to the polygons of the input geojson rocks_start_params_geojson depending on the sub-model choosen.

	number	z	volume	vz	length	width	height
PlatRock (builtin)
Siconos

Parameters:

• rocks (list [ThreeD.Objects.Rock]) – list of all rocks, created in the launching script (see Examples/3D.py)

• current_rock (ThreeD.Objects.Rock) – the rock currently falling

• terrain (ThreeD.Objects.Terrain) – the terrain of the simulation

• gravity (float) – the — positive — gravity acceleration value

• enable_forest (bool) – whether to take trees into account or not

• engines (list [ThreeD.Engines.Engine]) – list of engines to run at each timestep

• dt (int) – the time-step

• iter (int) – the current iteration (reseted at each new rock)

• running (bool) – whether the simulation is running

• enable_GUI (bool) – enables the 3D view (experimental)

add_rock()

get_parameters_verification_report()

rock_propagation_tasks()

Here is the science, this task method must do the propagation main loops for a single rock.

setup_rock_kinematics()

valid_input_rocks_geojson_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

webui_typename = 'PlatRock 3D'

ThreeD.Objects

class ThreeD.Objects.Bounding_Box

Bases: object

class ThreeD.Objects.Checkpoint(path)

Bases: GenericThreeDCheckpoint

class ThreeD.Objects.Contact

Bases: object

get_storage_copy(r)

class ThreeD.Objects.Rock_terrain_contact(point, face)

Bases: Contact

get_storage_copy(r)

class ThreeD.Objects.Rock_tree_contact(tree)

Bases: Contact

get_storage_copy(r)

class ThreeD.Objects.Sphere(*args, **kwargs)

Bases: GenericThreeDRock

FIXME: DOC

class ThreeD.Objects.Terrain(default_faces_params={'R_n': 0.6, 'R_t': 0.6, 'bounce_model_number': 0, 'e': 0.1, 'mu': 0.8, 'mu_r': 0.5, 'phi': 30, 'roughness': 0.1, 'v_half': 2.5}, *args, **kwargs)

Bases: GenericThreeDTerrain

bounce_class

alias of Bourrier

valid_input_soil_geojson_attrs = <platrock.Common.Utils.ParametersDescriptorsSet object>

ThreeD.Engines

class ThreeD.Engines.Contacts_detector(**kwargs)

Bases: Engine

FIXME:DOC Append (real, geometrical) contacts into ThreeD.Objects.Rock.terrain_active_contacts dict. Rock-Face goes into terrain_active_contacts["terrain"] and Rock-Tree contacts goes into terrain_active_contacts["tree"] .

run(*args, **kwargs)

run_python(s)

class ThreeD.Engines.Engine(iter_every=1, use_cython=True)

Bases: object

“Abstract” class for all engines. Each engine has a run() method which is run at each “iter_every” iteration. Engines instances must be stored in ThreeD.Simulations.Simulation.Engines.

Parameters:

• dead (bool) – if True, the engine will not be ran

• iter_every (int) – run the engine each iter_every timesteps

class ThreeD.Engines.Nscd_integrator(**kwargs)

Bases: Engine

FIXME : doc

run(*args, **kwargs)

run_python(s)

class ThreeD.Engines.Rock_terrain_nscd_basic_contact(**kwargs)

Bases: Engine

FIXME : doc

run(s)

class ThreeD.Engines.Rock_tree_nscd_basic_contact(**kwargs)

Bases: Engine

FIXME : doc

run(s)

class ThreeD.Engines.Snapshooter(filename='snap_', **kwargs)

Bases: Engine

run(s)

class ThreeD.Engines.Time_stepper(safety_coefficient=0.1, **kwargs)

Bases: Engine

run(s)

class ThreeD.Engines.Verlet_update(dist_factor=5, **kwargs)

Bases: Engine

Update the rocks faces (ThreeD.Objects.Rock.verlet_faces_list) and trees (ThreeD.Objects.Rock.verlet_trees_list) neighbours lists.

Parameters:

dist_factor (float) – the verlet distance factor (dist_factor * rock_radius = verlet distance). Values must be >1, but values >5 are highly recommanded.If dist_factor==1, the verlet algorithm will be unefficient.

run(*args, **kwargs)

run_python(s)

Common.RasterTools

class Common.RasterTools.Raster

Bases: object

add_data_grid(name, type, default_value=0)

get_asc_header_string()

get_cell_ll_coords(ix_iy)

get_indices_from_coords(coords)

get_scalar_fields()

get_vector_fields()

is_scalar_type(name)

ix_iy_is_inside(ix_iy)

output_to_asc(output_to_string=False, fields=None)

Common.RasterTools.from_asc(filename, data_name, min_value=None)

Common.RasterTools.from_raster(raster, cell_length=None)

Copy a raster without the data, optionnaly change the cell_length (=remap the raster)

Common.RasterTools.from_terrain(terrain, cell_length, xllcorner=0, yllcorner=0)

Create a new raster from the terrain only. /!if the terrain was generated from an asc, please use “from_asc” then “from_raster” to avoid shifting of the origin.

Common.ThreeDPostprocessings

class Common.ThreeDPostprocessings.ThreeDPostprocessing(simulation, raster_cell_length=None)

Bases: object

add_flights_to_raster_cells_and_contacts(raster_indices, all_c_fields)

delete_overflowing_raster_indices_and_contacts(raster_indices, all_c_fields)

get_indices_cleaned(arr)

get_raster_indices_from_contacts(c_pos, c_types)

insert_fly(arrays_dict, where)

plot()

run()

run_all_rocks()

run_end()

run_init()

run_one_rock()