From 8f3cce5f06d8735d820c7831c548b259dba030c9 Mon Sep 17 00:00:00 2001 From: Kyle Gorkowski Date: Mon, 27 Nov 2023 18:33:23 -0700 Subject: [PATCH 01/11] bench mark Fixes #411 --- .../lagrangian/basic_lagrangian_box.ipynb | 29 ++- docs/examples/lagrangian/testing_times.py | 213 ++++++++++++++++++ 2 files changed, 227 insertions(+), 15 deletions(-) create mode 100644 docs/examples/lagrangian/testing_times.py diff --git a/docs/examples/lagrangian/basic_lagrangian_box.ipynb b/docs/examples/lagrangian/basic_lagrangian_box.ipynb index 00c90915d..eab2e4bd8 100644 --- a/docs/examples/lagrangian/basic_lagrangian_box.ipynb +++ b/docs/examples/lagrangian/basic_lagrangian_box.ipynb @@ -55,11 +55,10 @@ "metadata": {}, "outputs": [], "source": [ - "TOTAL_NUMBER_OF_PARTICLES = 200\n", "# Setting up the Simulation Parameters and Initial Conditions\n", "\n", "# Define fixed parameters\n", - "TOTAL_NUMBER_OF_PARTICLES = 200\n", + "TOTAL_NUMBER_OF_PARTICLES = 2000\n", "TIME_STEP = 0.01\n", "SIMULATION_TIME = 100\n", "MASS = 3\n", @@ -164,22 +163,22 @@ " # Apply boundary conditions for the cube (wrap-around)\n", " position = boundary.wrapped_cube(position=position, cube_side=CUBE_SIDE)\n", "\n", - " # Calculate pairwise distances between particles\n", - " distance_matrix = particle_pairs.calculate_pairwise_distance(\n", - " position=position)\n", + " # # Calculate pairwise distances between particles\n", + " # distance_matrix = particle_pairs.calculate_pairwise_distance(\n", + " # position=position)\n", "\n", - " # Adjust distances for the radius of each particle (surface-to-surface\n", - " # distance)\n", - " radius = particle_property.radius(mass=mass, density=density)\n", - " distance_matrix -= radius.unsqueeze(1) + radius.unsqueeze(0)\n", + " # # Adjust distances for the radius of each particle (surface-to-surface\n", + " # # distance)\n", + " # radius = particle_property.radius(mass=mass, density=density)\n", + " # distance_matrix -= radius.unsqueeze(1) + radius.unsqueeze(0)\n", "\n", - " # Identify pairs of particles that have collided\n", - " valid_collision_indices_pairs = collisions.find_collisions(\n", - " distance_matrix=distance_matrix, indices=indices, mass=mass)\n", + " # # Identify pairs of particles that have collided\n", + " # valid_collision_indices_pairs = collisions.find_collisions(\n", + " # distance_matrix=distance_matrix, indices=indices, mass=mass)\n", "\n", - " # Coalesce particles that have collided and update their velocity and mass\n", - " velocity, mass = collisions.coalescence(\n", - " velocity=velocity, mass=mass, collision_indices_pairs=valid_collision_indices_pairs)\n", + " # # Coalesce particles that have collided and update their velocity and mass\n", + " # velocity, mass = collisions.coalescence(\n", + " # velocity=velocity, mass=mass, collision_indices_pairs=valid_collision_indices_pairs)\n", "\n", " # Calculate the force acting on the particles (e.g., gravity)\n", " force = mass * gravity\n", diff --git a/docs/examples/lagrangian/testing_times.py b/docs/examples/lagrangian/testing_times.py new file mode 100644 index 000000000..ea12d11ce --- /dev/null +++ b/docs/examples/lagrangian/testing_times.py @@ -0,0 +1,213 @@ + +# %% +# Code Section: Importing Necessary Libraries and Initializing Variables + +import torch +import numpy as np +import matplotlib.pyplot as plt +from tqdm import tqdm +from particula.lagrangian import boundary, integration, collisions, particle_property, particle_pairs + +# Initializing the Torch Generator and setting the data type +t_gen = torch.Generator() +t_type = torch.float32 + +# %% +# Setting up the Simulation Parameters and Initial Conditions + +# Define fixed parameters +TOTAL_NUMBER_OF_PARTICLES = 500 +TIME_STEP = 0.01 +SIMULATION_TIME = 1000 +MASS = 3 +CUBE_SIDE = 500 +speed = 1 +save_points = 50 + +# Initialize particle positions randomly within the cube +position = torch.rand( + 3, + TOTAL_NUMBER_OF_PARTICLES, + dtype=t_type) * CUBE_SIDE - CUBE_SIDE / 2 + +# Initialize particle velocities randomly +velocity = torch.rand(3, TOTAL_NUMBER_OF_PARTICLES, + dtype=t_type) * speed - speed / 2 + +# Initialize force as zero for all particles +force = torch.zeros(3, TOTAL_NUMBER_OF_PARTICLES, dtype=t_type) + +# Set constant mass and density for all particles +mass = torch.ones(TOTAL_NUMBER_OF_PARTICLES, dtype=t_type) * MASS +density = torch.ones(TOTAL_NUMBER_OF_PARTICLES, dtype=t_type) * 1 + +# Generate indices for particles, could be integer type +indices = torch.arange(TOTAL_NUMBER_OF_PARTICLES, dtype=t_type) # could be int + +# Calculate the total number of iterations for the simulation +total_iterations = int(SIMULATION_TIME / TIME_STEP) + +# Initialize a tensor to track the total mass over iterations +total_mass = torch.zeros(total_iterations, dtype=t_type) + +# Define gravity acting on all particles +gravity = torch.tensor( + [0, -9.81, 0]).repeat(TOTAL_NUMBER_OF_PARTICLES, 1).transpose(0, 1) + +# %% +# Initializing Arrays for Saving Position and Mass Data + +# Create arrays to store position and mass data at each save point +save_position = np.zeros((3, TOTAL_NUMBER_OF_PARTICLES, save_points)) +save_mass = np.zeros((TOTAL_NUMBER_OF_PARTICLES, save_points)) + +# Determine which iterations will correspond to the save points +save_iterations = np.linspace(0, total_iterations, save_points, dtype=int) + +# %% +# Initialize counter for saving data +save_counter = 0 + +# Start the simulation +for i in tqdm(range(total_iterations), desc='Simulation'): + + # Apply boundary conditions for the cube (wrap-around) + position = boundary.wrapped_cube(position=position, cube_side=CUBE_SIDE) + + # # Calculate pairwise distances between particles + # distance_matrix = particle_pairs.calculate_pairwise_distance( + # position=position) + + # # Adjust distances for the radius of each particle (surface-to-surface + # # distance) + # radius = particle_property.radius(mass=mass, density=density) + # distance_matrix -= radius.unsqueeze(1) + radius.unsqueeze(0) + + # # Identify pairs of particles that have collided + # valid_collision_indices_pairs = collisions.find_collisions( + # distance_matrix=distance_matrix, indices=indices, mass=mass) + + # # Coalesce particles that have collided and update their velocity and mass + # velocity, mass = collisions.coalescence( + # velocity=velocity, mass=mass, + # collision_indices_pairs=valid_collision_indices_pairs) + + # Calculate the force acting on the particles (e.g., gravity) + force = mass * gravity + + # Integrate the equations of motion to update position and velocity + position, velocity = integration.leapfrog( + position=position, velocity=velocity, force=force, mass=mass, time_step=TIME_STEP) + + # Save the position and mass data at designated save points + if i == save_iterations[save_counter]: + save_position[:, :, save_counter] = position.detach().numpy() + save_mass[:, save_counter] = mass.detach().numpy() + save_counter += 1 + +# Perform a final save of the position and mass data +save_position[:, :, -1] = position.detach().numpy() +save_mass[:, -1] = mass.detach().numpy() + +# %% +# Processing the Final Data for Visualization + +# Select the final time index for the data +time_index = -1 +position_final = save_position[:, :, time_index] +mass_final = save_mass[:, time_index] + +# Filter out particles with zero mass +filter_zero_mass = mass_final > 0 + +# Calculate the radius and area of each particle +radius_final = particle_property.radius(mass=mass_final, density=density) +particle_area = np.pi * radius_final**2 + +# Display the number of remaining particles +print(f"Number of particles at the end: {filter_zero_mass.sum()}") + +# Creating a 3D Plot for Visualization +fig = plt.figure() +ax = fig.add_subplot(projection='3d') + +# Choose a color map for the scatter plot +cmap = plt.cm.viridis + +# Plot the final positions of particles with non-zero mass +scatter_plot = ax.scatter( + position_final[0, filter_zero_mass], + position_final[1, filter_zero_mass], + position_final[2, filter_zero_mass], + c=mass_final[filter_zero_mass], + cmap=cmap, + s=particle_area[filter_zero_mass] # Particle size based on area +) + +# Set axis limits based on cube dimensions +ax.set_xlim(-CUBE_SIDE / 2, CUBE_SIDE / 2) +ax.set_ylim(-CUBE_SIDE / 2, CUBE_SIDE / 2) +ax.set_zlim(-CUBE_SIDE / 2, CUBE_SIDE / 2) + +# Add a color bar indicating particle mass +color_bar = plt.colorbar(scatter_plot, ax=ax) +color_bar.set_label('Mass') + +# Show the plot with optimized layout +plt.show() +fig.tight_layout() + +# %% [markdown] +# ## Analyzing the Mass Distribution of Particles +# +# Next, we turn our attention to understanding how the mass distribution of the particles has evolved over the course of the simulation. To achieve this, we will analyze the mass data normalized by the initial MASS value. This normalization allows us to observe changes in the mass distribution as multiples of the initial mass, providing insights into the extent of coalescence and mass variation among the particles. +# + +# %% +# Visualizing the Mass Distribution at Different Stages + +# Create a new figure for the histogram +fig = plt.figure() +ax = fig.add_subplot() + +# Plot histograms of mass distribution at different stages +# Normalizing by initial MASS to observe distribution changes +ax.hist(save_mass[filter_zero_mass, 0] / MASS, bins=25, + alpha=0.8, label='Initial', range=(0, 40)) +ax.hist(save_mass[filter_zero_mass, 24] / MASS, bins=25, + alpha=0.6, label='Middle', range=(0, 40)) +ax.hist(save_mass[filter_zero_mass, -1] / MASS, bins=25, + alpha=0.5, label='Final', range=(0, 40)) + +# Setting labels and title for the plot +ax.set_xlabel('Mass / Initial MASS') +ax.set_ylabel('Number of Particles') + +# Add a legend to the plot +ax.legend() + +# Display the plot +plt.show() + +# Adjust layout for optimal visualization +fig.tight_layout() + +# %% [markdown] +# ## Summary of the Lagrangian Particle Simulation +# +# In this Jupyter Notebook, we have explored the dynamics of a Lagrangian particle system within a defined cubic space. Our focus has been on simulating and analyzing the interactions and evolution of particles under a set of initial conditions and physical laws. Here is a brief overview of what we covered: +# +# ### System Definition and Initialization +# - We began by defining the simulation space and initial conditions for our particle system. This included setting parameters such as the number of particles, mass, and dimensions of the cubic space, as well as initializing the positions and velocities of the particles. +# +# ### Simulation Process +# - The core of our simulation involved a series of iterative steps to simulate particle dynamics. These steps included checking boundary conditions, calculating distances, detecting and handling collisions, coalescing particles, applying forces, and integrating the equations of motion. +# +# ### Data Saving and Analysis +# - Throughout the simulation, we saved key data points, such as the position and mass of particles at specified intervals. This allowed us to track and analyze the changes in the system over time. +# +# ### Visualization and Interpretation +# - We utilized various visualization techniques to interpret the simulation results. This included creating 3D plots to visualize the final positions of particles and histograms to analyze the distribution of mass at different stages of the simulation. +# +# ### Insights Gained +# - The simulation provided valuable insights into the behavior of particles in a Lagrangian framework. We observed how particles interact, coalesce, and evolve over time under the influence of set physical parameters and forces. From 81057d542b8cc2be6ec2bc192ad9f0200fb5f2af Mon Sep 17 00:00:00 2001 From: Kyle Gorkowski Date: Tue, 28 Nov 2023 20:35:53 -0700 Subject: [PATCH 02/11] sweep and prune speed up --- docs/examples/lagrangian/testing_times.py | 136 +++++++++++++++++++++- 1 file changed, 131 insertions(+), 5 deletions(-) diff --git a/docs/examples/lagrangian/testing_times.py b/docs/examples/lagrangian/testing_times.py index ea12d11ce..8c7d7a9bc 100644 --- a/docs/examples/lagrangian/testing_times.py +++ b/docs/examples/lagrangian/testing_times.py @@ -1,7 +1,7 @@ # %% # Code Section: Importing Necessary Libraries and Initializing Variables - +from typing import Tuple import torch import numpy as np import matplotlib.pyplot as plt @@ -63,6 +63,125 @@ # Determine which iterations will correspond to the save points save_iterations = np.linspace(0, total_iterations, save_points, dtype=int) +radius = particle_property.radius(mass=mass, density=density) + + +def single_axis_sweep_and_prune( + position_axis: torch.Tensor, + radius: torch.Tensor +) -> Tuple[torch.Tensor, torch.Tensor]: + """Sweep and prune algorithm for collision detection, + along a single axis, repeated for each axis. + + Args: + position_axis (torch.Tensor): The position of particles along a single + axis. + mass (torch.Tensor): The mass of particles. + density (torch.Tensor): The density of particles. + + Returns: + torch.Tensor: The indices of particles that are close + enough to collide. + """ + # fast return if there are no particles + if position_axis.shape[0] == 0: + return torch.tensor([]), torch.tensor([]) + # apply sweep and prune to find pairs of particles that are close enough + # to collide + sweep = torch.sort(position_axis) + + # gap + sweep_diff = torch.diff(sweep.values) + radius_sum = radius[sweep.indices[:-1]] + radius[sweep.indices[1:]] + + # select indices of particles that are close enough to collide + prune_bool = sweep_diff < radius_sum + # select left particle indices + left_overlap_indices = sweep.indices[ + torch.cat([prune_bool, torch.tensor([False])])] + # select right particle indices + right_overlap_indices = sweep.indices[ + torch.cat([torch.tensor([False]), prune_bool])] + return left_overlap_indices, right_overlap_indices + + +def full_sweep_and_prune( + position: torch.Tensor, + radius: torch.Tensor +) -> torch.Tensor: + """Sweep and prune algorithm for collision detection, + along all axes. + + Args: + position (torch.Tensor): The position of particles. + mass (torch.Tensor): The mass of particles. + density (torch.Tensor): The density of particles. + + Returns: + torch.Tensor: The indices of particles that are close + enough to collide. + """ + # select only particles with positive radius + valid_radius = radius > 0 + valid_radius_indices = torch.arange(radius.shape[0])[valid_radius] + # sweep x axis + left_x_overlap_shifted, right_x_overlap_shifted = single_axis_sweep_and_prune( + position_axis=position[0, valid_radius_indices], + radius=radius[valid_radius_indices] + ) + # fast return if there are no particles overlapping in x + if left_x_overlap_shifted.shape[0] == 0: + return torch.tensor([]) + # unshift from relative valid radius to position index + left_x_overlap_indices = valid_radius_indices[left_x_overlap_shifted] + right_x_overlap_indices = valid_radius_indices[right_x_overlap_shifted] + + # cobine left and right indices for next step + all_overlaps_x = torch.cat( + [left_x_overlap_indices, right_x_overlap_indices]) + # select unique indices + indices_x_unique = torch.unique(all_overlaps_x) + + # sweep y axis + left_y_overlap_shifted, right_y_overlap_shifted = single_axis_sweep_and_prune( + position_axis=position[1][indices_x_unique], + radius=radius[indices_x_unique] + ) + # fast return if there are no particles overlapping in y + if left_y_overlap_shifted.shape[0] == 0: + return torch.tensor([]) + # unshift from x relative index to position index + left_y_overlap_indices = indices_x_unique[left_y_overlap_shifted] + right_y_overlap_indices = indices_x_unique[right_y_overlap_shifted] + + # combine left and right indices for next step + all_overlaps_y = torch.cat( + [left_y_overlap_indices, right_y_overlap_indices]) + # select unique indices + indices_y_unique = torch.unique(all_overlaps_y) + + # sweep z axis + left_z_overlap_shifted, right_z_overlap_shifted = single_axis_sweep_and_prune( + position_axis=position[2][indices_y_unique], + radius=radius[indices_y_unique] + ) + # fast return if there are no particles overlapping in z + if left_z_overlap_shifted.shape[0] == 0: + return torch.tensor([]) + # unshift from y relative index to position index + left_z_overlap_indices = indices_y_unique[left_z_overlap_shifted] + right_z_overlap_indices = indices_y_unique[right_z_overlap_shifted] + + # Combine indices to form collision pairs, may still have duplicates + collision_indices_pairs = torch.cat( + [left_z_overlap_indices.unsqueeze(1), + right_z_overlap_indices.unsqueeze(1)], dim=1) + + return collision_indices_pairs + + +collision_pairs = full_sweep_and_prune(position=position, radius=radius) + # %% # Initialize counter for saving data @@ -74,6 +193,12 @@ # Apply boundary conditions for the cube (wrap-around) position = boundary.wrapped_cube(position=position, cube_side=CUBE_SIDE) + + # calculate sweep and prune collision pairs + radius = particle_property.radius(mass=mass, density=density) + valid_collision_indices_pairs = full_sweep_and_prune( + position=position, radius=radius) + # # Calculate pairwise distances between particles # distance_matrix = particle_pairs.calculate_pairwise_distance( # position=position) @@ -87,10 +212,11 @@ # valid_collision_indices_pairs = collisions.find_collisions( # distance_matrix=distance_matrix, indices=indices, mass=mass) - # # Coalesce particles that have collided and update their velocity and mass - # velocity, mass = collisions.coalescence( - # velocity=velocity, mass=mass, - # collision_indices_pairs=valid_collision_indices_pairs) + if valid_collision_indices_pairs.shape[0] > 0: + # Coalesce particles that have collided and update their velocity and mass + velocity, mass = collisions.coalescence( + velocity=velocity, mass=mass, + collision_indices_pairs=valid_collision_indices_pairs) # Calculate the force acting on the particles (e.g., gravity) force = mass * gravity From 14141172dee43ac8b94fce3d6c97138a046013b0 Mon Sep 17 00:00:00 2001 From: Kyle Gorkowski Date: Wed, 29 Nov 2023 19:16:17 -0700 Subject: [PATCH 03/11] moved sweep, and tested --- docs/examples/lagrangian/testing_times.py | 161 ++-------------- particula/lagrangian/particle_pairs.py | 179 ++++++++++++++++++ .../lagrangian/tests/particle_pairs_test.py | 20 ++ 3 files changed, 217 insertions(+), 143 deletions(-) diff --git a/docs/examples/lagrangian/testing_times.py b/docs/examples/lagrangian/testing_times.py index 8c7d7a9bc..730bf2a0e 100644 --- a/docs/examples/lagrangian/testing_times.py +++ b/docs/examples/lagrangian/testing_times.py @@ -1,7 +1,6 @@ # %% # Code Section: Importing Necessary Libraries and Initializing Variables -from typing import Tuple import torch import numpy as np import matplotlib.pyplot as plt @@ -14,13 +13,13 @@ # %% # Setting up the Simulation Parameters and Initial Conditions - +progress_bar = True # Define fixed parameters -TOTAL_NUMBER_OF_PARTICLES = 500 +TOTAL_NUMBER_OF_PARTICLES = 100 TIME_STEP = 0.01 SIMULATION_TIME = 1000 MASS = 3 -CUBE_SIDE = 500 +CUBE_SIDE = 1000 speed = 1 save_points = 50 @@ -66,152 +65,20 @@ radius = particle_property.radius(mass=mass, density=density) -def single_axis_sweep_and_prune( - position_axis: torch.Tensor, - radius: torch.Tensor -) -> Tuple[torch.Tensor, torch.Tensor]: - """Sweep and prune algorithm for collision detection, - along a single axis, repeated for each axis. - - Args: - position_axis (torch.Tensor): The position of particles along a single - axis. - mass (torch.Tensor): The mass of particles. - density (torch.Tensor): The density of particles. - - Returns: - torch.Tensor: The indices of particles that are close - enough to collide. - """ - # fast return if there are no particles - if position_axis.shape[0] == 0: - return torch.tensor([]), torch.tensor([]) - # apply sweep and prune to find pairs of particles that are close enough - # to collide - sweep = torch.sort(position_axis) - - # gap - sweep_diff = torch.diff(sweep.values) - radius_sum = radius[sweep.indices[:-1]] + radius[sweep.indices[1:]] - - # select indices of particles that are close enough to collide - prune_bool = sweep_diff < radius_sum - # select left particle indices - left_overlap_indices = sweep.indices[ - torch.cat([prune_bool, torch.tensor([False])])] - # select right particle indices - right_overlap_indices = sweep.indices[ - torch.cat([torch.tensor([False]), prune_bool])] - return left_overlap_indices, right_overlap_indices - - -def full_sweep_and_prune( - position: torch.Tensor, - radius: torch.Tensor -) -> torch.Tensor: - """Sweep and prune algorithm for collision detection, - along all axes. - - Args: - position (torch.Tensor): The position of particles. - mass (torch.Tensor): The mass of particles. - density (torch.Tensor): The density of particles. - - Returns: - torch.Tensor: The indices of particles that are close - enough to collide. - """ - # select only particles with positive radius - valid_radius = radius > 0 - valid_radius_indices = torch.arange(radius.shape[0])[valid_radius] - # sweep x axis - left_x_overlap_shifted, right_x_overlap_shifted = single_axis_sweep_and_prune( - position_axis=position[0, valid_radius_indices], - radius=radius[valid_radius_indices] - ) - # fast return if there are no particles overlapping in x - if left_x_overlap_shifted.shape[0] == 0: - return torch.tensor([]) - # unshift from relative valid radius to position index - left_x_overlap_indices = valid_radius_indices[left_x_overlap_shifted] - right_x_overlap_indices = valid_radius_indices[right_x_overlap_shifted] - - # cobine left and right indices for next step - all_overlaps_x = torch.cat( - [left_x_overlap_indices, right_x_overlap_indices]) - # select unique indices - indices_x_unique = torch.unique(all_overlaps_x) - - # sweep y axis - left_y_overlap_shifted, right_y_overlap_shifted = single_axis_sweep_and_prune( - position_axis=position[1][indices_x_unique], - radius=radius[indices_x_unique] - ) - # fast return if there are no particles overlapping in y - if left_y_overlap_shifted.shape[0] == 0: - return torch.tensor([]) - # unshift from x relative index to position index - left_y_overlap_indices = indices_x_unique[left_y_overlap_shifted] - right_y_overlap_indices = indices_x_unique[right_y_overlap_shifted] - - # combine left and right indices for next step - all_overlaps_y = torch.cat( - [left_y_overlap_indices, right_y_overlap_indices]) - # select unique indices - indices_y_unique = torch.unique(all_overlaps_y) - - # sweep z axis - left_z_overlap_shifted, right_z_overlap_shifted = single_axis_sweep_and_prune( - position_axis=position[2][indices_y_unique], - radius=radius[indices_y_unique] - ) - # fast return if there are no particles overlapping in z - if left_z_overlap_shifted.shape[0] == 0: - return torch.tensor([]) - # unshift from y relative index to position index - left_z_overlap_indices = indices_y_unique[left_z_overlap_shifted] - right_z_overlap_indices = indices_y_unique[right_z_overlap_shifted] - - # Combine indices to form collision pairs, may still have duplicates - collision_indices_pairs = torch.cat( - [left_z_overlap_indices.unsqueeze(1), - right_z_overlap_indices.unsqueeze(1)], dim=1) - - return collision_indices_pairs - - -collision_pairs = full_sweep_and_prune(position=position, radius=radius) - - # %% # Initialize counter for saving data save_counter = 0 # Start the simulation -for i in tqdm(range(total_iterations), desc='Simulation'): - - # Apply boundary conditions for the cube (wrap-around) - position = boundary.wrapped_cube(position=position, cube_side=CUBE_SIDE) - +if progress_bar is True: + timer = tqdm(total=total_iterations, desc='Simulation') +for i in range(total_iterations): # calculate sweep and prune collision pairs radius = particle_property.radius(mass=mass, density=density) - valid_collision_indices_pairs = full_sweep_and_prune( + valid_collision_indices_pairs = particle_pairs.full_sweep_and_prune( position=position, radius=radius) - # # Calculate pairwise distances between particles - # distance_matrix = particle_pairs.calculate_pairwise_distance( - # position=position) - - # # Adjust distances for the radius of each particle (surface-to-surface - # # distance) - # radius = particle_property.radius(mass=mass, density=density) - # distance_matrix -= radius.unsqueeze(1) + radius.unsqueeze(0) - - # # Identify pairs of particles that have collided - # valid_collision_indices_pairs = collisions.find_collisions( - # distance_matrix=distance_matrix, indices=indices, mass=mass) - if valid_collision_indices_pairs.shape[0] > 0: # Coalesce particles that have collided and update their velocity and mass velocity, mass = collisions.coalescence( @@ -225,11 +92,19 @@ def full_sweep_and_prune( position, velocity = integration.leapfrog( position=position, velocity=velocity, force=force, mass=mass, time_step=TIME_STEP) + # Apply boundary conditions for the cube (wrap-around) + position = boundary.wrapped_cube(position=position, cube_side=CUBE_SIDE) + # Save the position and mass data at designated save points if i == save_iterations[save_counter]: save_position[:, :, save_counter] = position.detach().numpy() save_mass[:, save_counter] = mass.detach().numpy() save_counter += 1 + if progress_bar is True: + timer.update(save_iterations[1]-save_iterations[0]) + +if progress_bar is True: + timer.close # Perform a final save of the position and mass data save_position[:, :, -1] = position.detach().numpy() @@ -299,11 +174,11 @@ def full_sweep_and_prune( # Plot histograms of mass distribution at different stages # Normalizing by initial MASS to observe distribution changes ax.hist(save_mass[filter_zero_mass, 0] / MASS, bins=25, - alpha=0.8, label='Initial', range=(0, 40)) + alpha=0.8, label='Initial', range=(0, 60)) ax.hist(save_mass[filter_zero_mass, 24] / MASS, bins=25, - alpha=0.6, label='Middle', range=(0, 40)) + alpha=0.6, label='Middle', range=(0, 60)) ax.hist(save_mass[filter_zero_mass, -1] / MASS, bins=25, - alpha=0.5, label='Final', range=(0, 40)) + alpha=0.5, label='Final', range=(0, 60)) # Setting labels and title for the plot ax.set_xlabel('Mass / Initial MASS') diff --git a/particula/lagrangian/particle_pairs.py b/particula/lagrangian/particle_pairs.py index baae3891f..1dac117d2 100644 --- a/particula/lagrangian/particle_pairs.py +++ b/particula/lagrangian/particle_pairs.py @@ -1,5 +1,6 @@ """Lagrangian particle pairwise distances and pairwise operations.""" +from typing import Tuple import torch @@ -73,3 +74,181 @@ def calculate_pairwise_distance(position: torch.Tensor) -> torch.Tensor: detla_position = position.unsqueeze(2) - position.unsqueeze(1) # Compute pairwise Euclidean distances return torch.sqrt(torch.sum(detla_position**2, dim=0)) + + +def single_axis_sweep_and_prune( + position_axis: torch.Tensor, + radius: torch.Tensor +) -> Tuple[torch.Tensor, torch.Tensor]: + """ + Sweep and prune algorithm for collision detection along a single axis. + This function identifies pairs of particles that are close enough to + potentially collide. + + Args: + position_axis (torch.Tensor): The position of particles along a single + axis. + radius (torch.Tensor): The radius of particles. + + Returns: + Tuple[torch.Tensor, torch.Tensor]: Two tensors containing the indices + of potentially colliding particles. + """ + + # Fast return if there are no particles + if position_axis.shape[0] == 0: + return torch.tensor([], dtype=torch.int64), torch.tensor( + [], dtype=torch.int64) + + # Apply sweep and prune to find pairs of particles that are close enough + # to collide + sweep = torch.sort(position_axis) + sweep_diff = torch.diff(sweep.values) + radius_sum = radius[sweep.indices[:-1]] + radius[sweep.indices[1:]] + + # Select indices of particles that are close enough to collide + prune_bool = sweep_diff < radius_sum + left_overlap_indices = sweep.indices[torch.cat( + [prune_bool, torch.tensor([False], dtype=torch.bool)])] + right_overlap_indices = sweep.indices[torch.cat( + [torch.tensor([False], dtype=torch.bool), prune_bool])] + + return left_overlap_indices, right_overlap_indices + + +# pylint: disable=too-many-locals +def full_sweep_and_prune( + position: torch.Tensor, + radius: torch.Tensor +) -> torch.Tensor: + """ + Sweep and prune algorithm for collision detection along all three axes + (x, y, z). This function identifies pairs of particles that are close + enough to potentially collide in 3D space. + + Args: + position (torch.Tensor): The 2D tensor of particle positions, + where each row represents an axis (x, y, z). + radius (torch.Tensor): The radius of particles. + + Returns: + torch.Tensor: A tensor containing pairs of indices of potentially + colliding particles. + """ + # select only particles with positive radius + valid_radius = radius > 0 + valid_radius_indices = torch.arange(radius.shape[0])[valid_radius] + # sweep x axis + left_x_overlap_shifted, right_x_overlap_shifted = \ + single_axis_sweep_and_prune( + position_axis=position[0, valid_radius_indices], + radius=radius[valid_radius_indices] + ) + # fast return if there are no particles overlapping in x + if left_x_overlap_shifted.shape[0] == 0: + return torch.tensor([]) + # unshift from relative valid radius to position index + left_x_overlap_indices = valid_radius_indices[left_x_overlap_shifted] + right_x_overlap_indices = valid_radius_indices[right_x_overlap_shifted] + + # cobine left and right indices for next step + all_overlaps_x = torch.cat( + [left_x_overlap_indices, right_x_overlap_indices]) + # select unique indices + indices_x_unique = torch.unique(all_overlaps_x) + + # sweep y axis + left_y_overlap_shifted, right_y_overlap_shifted = \ + single_axis_sweep_and_prune( + position_axis=position[1][indices_x_unique], + radius=radius[indices_x_unique] + ) + # fast return if there are no particles overlapping in y + if left_y_overlap_shifted.shape[0] == 0: + return torch.tensor([]) + # unshift from x relative index to position index + left_y_overlap_indices = indices_x_unique[left_y_overlap_shifted] + right_y_overlap_indices = indices_x_unique[right_y_overlap_shifted] + + # combine left and right indices for next step + all_overlaps_y = torch.cat( + [left_y_overlap_indices, right_y_overlap_indices]) + # select unique indices + indices_y_unique = torch.unique(all_overlaps_y) + + # sweep z axis + left_z_overlap_shifted, right_z_overlap_shifted = \ + single_axis_sweep_and_prune( + position_axis=position[2][indices_y_unique], + radius=radius[indices_y_unique] + ) + # fast return if there are no particles overlapping in z + if left_z_overlap_shifted.shape[0] == 0: + return torch.tensor([]) + # unshift from y relative index to position index + left_z_overlap_indices = indices_y_unique[left_z_overlap_shifted] + right_z_overlap_indices = indices_y_unique[right_z_overlap_shifted] + + # Combine indices to form collision pairs, may still have duplicates + collision_indices_pairs = torch.cat( + [left_z_overlap_indices.unsqueeze(1), + right_z_overlap_indices.unsqueeze(1)], dim=1) + + return collision_indices_pairs + + +def full_sweep_and_prune_simplified( + position: torch.Tensor, + radius: torch.Tensor +) -> torch.Tensor: + """ + A simplified version of the full sweep and prune algorithm for collision + written above, it is not working yet. there is an error in the update of + the indices in the y and z axis. + + Sweep and prune algorithm for collision detection along all three axes + (x, y, z). This function identifies pairs of particles that are close + enough to potentially collide in 3D space. + + Args: + position (torch.Tensor): The 2D tensor of particle positions, + where each row represents an axis (x, y, z). + radius (torch.Tensor): The radius of particles. + + Returns: + torch.Tensor: A tensor containing pairs of indices of potentially + colliding particles. + """ + if radius.shape[0] == 0: + return torch.tensor([]) + + valid_indices = torch.arange(radius.shape[0])[radius > 0] + unique_indices = valid_indices + + for axis in range(position.shape[0]): + if unique_indices.shape[0] == 0: + break + + left_overlap_indices, right_overlap_indices = \ + single_axis_sweep_and_prune( + position_axis=position[axis, unique_indices], + radius=radius[unique_indices] + ) + + if left_overlap_indices.shape[0] == 0: + return torch.tensor([]) + + # Combine indices to form collision pairs, may still have duplicates + all_overlaps = torch.cat( + [unique_indices[left_overlap_indices], + unique_indices[right_overlap_indices]]) + if axis < position.shape[0]: # not last axis + unique_indices = torch.unique(all_overlaps) # remove duplicates + + # Forming collision pairs + # Combine indices to form collision pairs, may still have duplicates + collision_indices_pairs = torch.cat( + [unique_indices[left_overlap_indices].unsqueeze(1), + unique_indices[right_overlap_indices].unsqueeze(1)], dim=1) + + return collision_indices_pairs diff --git a/particula/lagrangian/tests/particle_pairs_test.py b/particula/lagrangian/tests/particle_pairs_test.py index 1e1a15707..0c48d27bf 100644 --- a/particula/lagrangian/tests/particle_pairs_test.py +++ b/particula/lagrangian/tests/particle_pairs_test.py @@ -21,3 +21,23 @@ def test_calculate_pairwise_distance(): [2.2361, 1.0, 0.0]]) result = particle_pairs.calculate_pairwise_distance(position) assert torch.allclose(result, expected_output, atol=1e-4) + + +def test_single_axis_sweep_and_prune(): + # Test case with some overlapping particles + position_axis = torch.tensor([1.0, 2.0, 4.0, 5.0]) + radius = torch.tensor([0.5, 1.5, 0.2, 0.2]) + left_indices, right_indices = particle_pairs.single_axis_sweep_and_prune( + position_axis, radius) + + assert torch.equal(left_indices, torch.tensor([0])) + assert torch.equal(right_indices, torch.tensor([1])) + + # Test case with no particles + position_axis = torch.tensor([]) + radius = torch.tensor([]) + left_indices, right_indices = particle_pairs.single_axis_sweep_and_prune( + position_axis, radius) + + assert torch.equal(left_indices, torch.tensor([])) + assert torch.equal(right_indices, torch.tensor([])) From ad5d4bf22f662e18ce682c1913a2068b902d9859 Mon Sep 17 00:00:00 2001 From: "sourcery-ai[bot]" <58596630+sourcery-ai[bot]@users.noreply.github.com> Date: Wed, 29 Nov 2023 19:20:00 -0700 Subject: [PATCH 04/11] 'Refactored by Sourcery' (#413) Co-authored-by: Sourcery AI <> --- docs/examples/lagrangian/testing_times.py | 6 ++--- particula/lagrangian/particle_pairs.py | 27 ++++++++++++----------- 2 files changed, 17 insertions(+), 16 deletions(-) diff --git a/docs/examples/lagrangian/testing_times.py b/docs/examples/lagrangian/testing_times.py index 730bf2a0e..9451ebe97 100644 --- a/docs/examples/lagrangian/testing_times.py +++ b/docs/examples/lagrangian/testing_times.py @@ -70,7 +70,7 @@ save_counter = 0 # Start the simulation -if progress_bar is True: +if progress_bar: timer = tqdm(total=total_iterations, desc='Simulation') for i in range(total_iterations): @@ -100,10 +100,10 @@ save_position[:, :, save_counter] = position.detach().numpy() save_mass[:, save_counter] = mass.detach().numpy() save_counter += 1 - if progress_bar is True: + if progress_bar: timer.update(save_iterations[1]-save_iterations[0]) -if progress_bar is True: +if progress_bar: timer.close # Perform a final save of the position and mass data diff --git a/particula/lagrangian/particle_pairs.py b/particula/lagrangian/particle_pairs.py index 1dac117d2..69a4bd26a 100644 --- a/particula/lagrangian/particle_pairs.py +++ b/particula/lagrangian/particle_pairs.py @@ -189,12 +189,13 @@ def full_sweep_and_prune( left_z_overlap_indices = indices_y_unique[left_z_overlap_shifted] right_z_overlap_indices = indices_y_unique[right_z_overlap_shifted] - # Combine indices to form collision pairs, may still have duplicates - collision_indices_pairs = torch.cat( - [left_z_overlap_indices.unsqueeze(1), - right_z_overlap_indices.unsqueeze(1)], dim=1) - - return collision_indices_pairs + return torch.cat( + [ + left_z_overlap_indices.unsqueeze(1), + right_z_overlap_indices.unsqueeze(1), + ], + dim=1, + ) def full_sweep_and_prune_simplified( @@ -245,10 +246,10 @@ def full_sweep_and_prune_simplified( if axis < position.shape[0]: # not last axis unique_indices = torch.unique(all_overlaps) # remove duplicates - # Forming collision pairs - # Combine indices to form collision pairs, may still have duplicates - collision_indices_pairs = torch.cat( - [unique_indices[left_overlap_indices].unsqueeze(1), - unique_indices[right_overlap_indices].unsqueeze(1)], dim=1) - - return collision_indices_pairs + return torch.cat( + [ + unique_indices[left_overlap_indices].unsqueeze(1), + unique_indices[right_overlap_indices].unsqueeze(1), + ], + dim=1, + ) From d6dced01420f051618bdbc2ff41fc84caad364c4 Mon Sep 17 00:00:00 2001 From: Kyle Gorkowski Date: Wed, 29 Nov 2023 19:31:23 -0700 Subject: [PATCH 05/11] updated basic example --- .../lagrangian/basic_lagrangian_box.ipynb | 102 +++++++----------- docs/examples/lagrangian/testing_times.py | 41 ++----- 2 files changed, 50 insertions(+), 93 deletions(-) diff --git a/docs/examples/lagrangian/basic_lagrangian_box.ipynb b/docs/examples/lagrangian/basic_lagrangian_box.ipynb index eab2e4bd8..b720baa41 100644 --- a/docs/examples/lagrangian/basic_lagrangian_box.ipynb +++ b/docs/examples/lagrangian/basic_lagrangian_box.ipynb @@ -23,16 +23,15 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# Code Section: Importing Necessary Libraries and Initializing Variables\n", - "\n", + "import time\n", "import torch\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from tqdm import tqdm\n", "from particula.lagrangian import boundary, integration, collisions, particle_property, particle_pairs\n", "\n", "# Initializing the Torch Generator and setting the data type\n", @@ -51,19 +50,19 @@ }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# Setting up the Simulation Parameters and Initial Conditions\n", "\n", "# Define fixed parameters\n", - "TOTAL_NUMBER_OF_PARTICLES = 2000\n", + "TOTAL_NUMBER_OF_PARTICLES = 500\n", "TIME_STEP = 0.01\n", "SIMULATION_TIME = 100\n", "MASS = 3\n", "CUBE_SIDE = 50\n", - "speed = 10\n", + "speed = 1\n", "save_points = 50\n", "\n", "# Initialize particle positions randomly within the cube\n", @@ -108,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 77, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -142,43 +141,48 @@ }, { "cell_type": "code", - "execution_count": 78, + "execution_count": 14, "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "Simulation: 100%|██████████| 10000/10000 [00:13<00:00, 767.82it/s]\n" + "ename": "KeyboardInterrupt", + "evalue": "", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mc:\\Users\\kkgor\\OneDrive\\Areas\\GitHub\\particula\\docs\\examples\\lagrangian\\basic_lagrangian_box.ipynb Cell 8\u001b[0m line \u001b[0;36m1\n\u001b[0;32m 8\u001b[0m position \u001b[39m=\u001b[39m boundary\u001b[39m.\u001b[39mwrapped_cube(position\u001b[39m=\u001b[39mposition, cube_side\u001b[39m=\u001b[39mCUBE_SIDE)\n\u001b[0;32m 10\u001b[0m \u001b[39m# Calculate pairwise distances between particles\u001b[39;00m\n\u001b[1;32m---> 11\u001b[0m distance_matrix \u001b[39m=\u001b[39m particle_pairs\u001b[39m.\u001b[39;49mcalculate_pairwise_distance(\n\u001b[0;32m 12\u001b[0m position\u001b[39m=\u001b[39;49mposition)\n\u001b[0;32m 14\u001b[0m \u001b[39m# Adjust distances for the radius of each particle (surface-to-surface\u001b[39;00m\n\u001b[0;32m 15\u001b[0m \u001b[39m# distance)\u001b[39;00m\n\u001b[0;32m 16\u001b[0m radius \u001b[39m=\u001b[39m particle_property\u001b[39m.\u001b[39mradius(mass\u001b[39m=\u001b[39mmass, density\u001b[39m=\u001b[39mdensity)\n", + "File \u001b[1;32m~\\OneDrive\\Areas\\GitHub\\particula\\particula\\lagrangian\\particle_pairs.py:74\u001b[0m, in \u001b[0;36mcalculate_pairwise_distance\u001b[1;34m(position)\u001b[0m\n\u001b[0;32m 49\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 50\u001b[0m \u001b[39mneed to test this:\u001b[39;00m\n\u001b[0;32m 51\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 71\u001b[0m \u001b[39m3 points.\u001b[39;00m\n\u001b[0;32m 72\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 73\u001b[0m \u001b[39m# Expand position tensor to compute pairwise differences\u001b[39;00m\n\u001b[1;32m---> 74\u001b[0m detla_position \u001b[39m=\u001b[39m position\u001b[39m.\u001b[39;49munsqueeze(\u001b[39m2\u001b[39;49m) \u001b[39m-\u001b[39;49m position\u001b[39m.\u001b[39;49munsqueeze(\u001b[39m1\u001b[39;49m)\n\u001b[0;32m 75\u001b[0m \u001b[39m# Compute pairwise Euclidean distances\u001b[39;00m\n\u001b[0;32m 76\u001b[0m \u001b[39mreturn\u001b[39;00m torch\u001b[39m.\u001b[39msqrt(torch\u001b[39m.\u001b[39msum(detla_position\u001b[39m*\u001b[39m\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m, dim\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m))\n", + "\u001b[1;31mKeyboardInterrupt\u001b[0m: " ] } ], "source": [ "# Initialize counter for saving data\n", "save_counter = 0\n", - "\n", + "start_time = time.time()\n", "# Start the simulation\n", - "for i in tqdm(range(total_iterations), desc='Simulation'):\n", + "for i in range(total_iterations):\n", "\n", " # Apply boundary conditions for the cube (wrap-around)\n", " position = boundary.wrapped_cube(position=position, cube_side=CUBE_SIDE)\n", "\n", - " # # Calculate pairwise distances between particles\n", - " # distance_matrix = particle_pairs.calculate_pairwise_distance(\n", - " # position=position)\n", + " # Calculate pairwise distances between particles\n", + " distance_matrix = particle_pairs.calculate_pairwise_distance(\n", + " position=position)\n", "\n", - " # # Adjust distances for the radius of each particle (surface-to-surface\n", - " # # distance)\n", - " # radius = particle_property.radius(mass=mass, density=density)\n", - " # distance_matrix -= radius.unsqueeze(1) + radius.unsqueeze(0)\n", + " # Adjust distances for the radius of each particle (surface-to-surface\n", + " # distance)\n", + " radius = particle_property.radius(mass=mass, density=density)\n", + " distance_matrix -= radius.unsqueeze(1) + radius.unsqueeze(0)\n", "\n", - " # # Identify pairs of particles that have collided\n", - " # valid_collision_indices_pairs = collisions.find_collisions(\n", - " # distance_matrix=distance_matrix, indices=indices, mass=mass)\n", + " # Identify pairs of particles that have collided\n", + " valid_collision_indices_pairs = collisions.find_collisions(\n", + " distance_matrix=distance_matrix, indices=indices, mass=mass)\n", "\n", - " # # Coalesce particles that have collided and update their velocity and mass\n", - " # velocity, mass = collisions.coalescence(\n", - " # velocity=velocity, mass=mass, collision_indices_pairs=valid_collision_indices_pairs)\n", + " # Coalesce particles that have collided and update their velocity and mass\n", + " velocity, mass = collisions.coalescence(\n", + " velocity=velocity, mass=mass, collision_indices_pairs=valid_collision_indices_pairs)\n", "\n", " # Calculate the force acting on the particles (e.g., gravity)\n", " force = mass * gravity\n", @@ -195,7 +199,12 @@ "\n", "# Perform a final save of the position and mass data\n", "save_position[:, :, -1] = position.detach().numpy()\n", - "save_mass[:, -1] = mass.detach().numpy()" + "save_mass[:, -1] = mass.detach().numpy()\n", + "\n", + "# Calculate the total simulation time\n", + "end_time = time.time()\n", + "print(f\"Total wall time: {end_time - start_time} seconds\")\n", + "print(f\"Ratio of wall time to simulation time: {(end_time - start_time) / SIMULATION_TIME}\")" ] }, { @@ -209,27 +218,9 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of particles at the end: 32\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Processing the Final Data for Visualization\n", "\n", @@ -290,20 +281,9 @@ }, { "cell_type": "code", - "execution_count": 80, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAGwCAYAAACzXI8XAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA7vUlEQVR4nO3deVhV9aL/8c8GmZRJFAQSEecUcSoNpygttaJST5lliZoNYg40qJ0cT4nZbbJQTx4FO2mUhZbejqakmKaWJplppBzUuqKUJigKKqzfHz3uX8QgGzduFr5fz8PzsNf67u/+LFbn+rlr2hbDMAwBAACYkJOjAwAAAFQVRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJhWHUcHqG7FxcU6evSovLy8ZLFYHB0HAABUgmEYOn36tIKDg+XkVP5xl1pfZI4ePaqQkBBHxwAAAFXw888/q3HjxuWur/VFxsvLS9Iffwhvb28HpwEAAJWRl5enkJAQ67/j5an1RebS6SRvb2+KDAAAJnO5y0K42BcAAJgWRQYAAJgWRQYAAJhWrb9GBgCAyigqKtKFCxccHeOa4eLiImdn5yuehyIDALimGYahY8eO6dSpU46Ocs3x9fVVYGDgFT3njSIDALimXSoxAQEBqlu3Lg9PvQoMw9DZs2eVk5MjSQoKCqryXBQZAMA1q6ioyFpiGjRo4Og41xQPDw9JUk5OjgICAqp8momLfQEA16xL18TUrVvXwUmuTZf+7ldybRJFBgBwzeN0kmPY4+9OkQEAAKZFkQEAAKbl0It9FyxYoAULFujQoUOSpHbt2mnatGkaMGCAJKmgoEBPP/20kpOTVVhYqH79+mn+/Plq1KiRA1MDAK4F0W9tuWqftfqpntX+GRaLRStXrtS9995b7piYmBidOnVKq1atqtSchw4dUlhYmHbv3q2OHTvaJaetHHpEpnHjxpozZ4527dqlnTt36tZbb9U999yjH374QZI0ceJErV69WitWrFBaWpqOHj2qQYMGOTIyAAA1QkxMTIWl5K+ys7OtBwoOHToki8Wi9PT0EmPefPNNJSUl2S/kVeDQIzLR0dElXr/00ktasGCBtm/frsaNG2vx4sVavny5br31VklSYmKirr/+em3fvl033XSTIyIDAGBKgYGBlx3j4+NzFZLYV425RqaoqEjJycnKz89XZGSkdu3apQsXLqhv377WMW3atFGTJk20bdu2cucpLCxUXl5eiR8AAGqzqKgojRs3Ts8995z8/PwUGBioGTNmlBhjsVisp4zCwsIkSZ06dZLFYlFUVJSk0kd51q5dq549e8rX11cNGjTQXXfdpczMzKuwRZXn8Afiff/994qMjFRBQYE8PT21cuVKtW3bVunp6XJ1dZWvr2+J8Y0aNdKxY8fKnS8+Pl4zZ86s5tR/sNf506txbhQAULstXbpUcXFx2rFjh7Zt26aYmBj16NFDt912W6mxX3/9tbp27aoNGzaoXbt2cnV1LXPO/Px8xcXFKSIiQmfOnNG0adM0cOBApaeny8mpZhwLcXiRad26tdLT05Wbm6uPPvpIw4cPV1paWpXnmzJliuLi4qyv8/LyFBISYo+oAADUWBEREZo+fbokqWXLlnr77beVmppaZpHx9/eXJDVo0KDCU06DBw8u8XrJkiXy9/fXvn37FB4ebsf0VefwIuPq6qoWLVpIkrp06aJvvvlGb775poYMGaLz58/r1KlTJY7KHD9+vMI/upubm9zc3Ko7NgAANUpERESJ10FBQdbvMqqqAwcOaNq0adqxY4d+++03FRcXS5KOHDlSY4pMzTgu9CfFxcUqLCxUly5d5OLiotTUVOu6jIwMHTlyRJGRkQ5MCABAzePi4lLitcVisRaPqoqOjtbJkye1aNEi7dixQzt27JAknT9//ormtSeHHpGZMmWKBgwYoCZNmuj06dNavny5Nm3apHXr1snHx0ejRo1SXFyc/Pz85O3traeeekqRkZHcsQQAwBW4dE1MUVFRuWNOnDihjIwMLVq0SL169ZIkbdly9Z6tU1kOLTI5OTl65JFHlJ2dLR8fH0VERGjdunXW83mvv/66nJycNHjw4BIPxAMAAFUXEBAgDw8PrV27Vo0bN5a7u3upW6/r16+vBg0a6J133lFQUJCOHDmiyZMnOyhx+RxaZBYvXlzhend3dyUkJCghIeEqJQIA4A+1+Y7SOnXqaN68eZo1a5amTZumXr16adOmTSXGODk5KTk5WePGjVN4eLhat26tefPmWW/VrikshmEYjg5RnfLy8uTj46Pc3Fx5e3vbdW5uvwYAcysoKFBWVpbCwsLk7u7u6DjXnIr+/pX997vGXewLAABQWRQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABquaioKE2YMKHCMU2bNtUbb7xR4RiLxaJVq1ZJkg4dOiSLxaL09HS7ZKwqh35FAQAANdbq8Vfvs6LftPktMTExWrp0qR5//HEtXLiwxLrY2FjNnz9fw4cPV1JSklJSUkp9O3ZtwREZAABMKiQkRMnJyTp37px1WUFBgZYvX64mTZpYl/n5+cnLy8sREasdRQYAAJPq3LmzQkJClJKSYl2WkpKiJk2aqFOnTtZlfz21lJOTo+joaHl4eCgsLEzLli0rNfeBAwfUu3dvubu7q23btlq/fv1l8+zdu1cDBgyQp6enGjVqpIcffli//fbblW3kZVBkAAAwsZEjRyoxMdH6esmSJRoxYkSF74mJidHPP/+sjRs36qOPPtL8+fOVk5NjXV9cXKxBgwbJ1dVVO3bs0MKFCzVp0qQK5zx16pRuvfVWderUSTt37tTatWt1/Phx3X///Ve2gZfBNTIAAJjYsGHDNGXKFB0+fFiStHXrViUnJ2vTpk1ljv/pp5/0n//8R19//bVuvPFGSdLixYt1/fXXW8ds2LBBP/74o9atW6fg4GBJ0uzZszVgwIByc7z99tvq1KmTZs+ebV22ZMkShYSE6KefflKrVq2udFPLRJEBAMDE/P39deeddyopKUmGYejOO+9Uw4YNyx2/f/9+1alTR126dLEua9OmjXx9fUuMCQkJsZYYSYqMjKwwx3fffaeNGzfK09Oz1LrMzEyKDAAAKNvIkSM1duxYSVJCQoJDMpw5c0bR0dF6+eWXS60LCgqqts+lyAAAYHL9+/fX+fPnZbFY1K9fvwrHtmnTRhcvXtSuXbusp5YyMjJ06tQp65jrr79eP//8s7Kzs60lZPv27RXO27lzZ3388cdq2rSp6tS5evWCi30BADA5Z2dn7d+/X/v27ZOzs3OFY1u3bq3+/fvr8ccf144dO7Rr1y49+uij8vDwsI7p27evWrVqpeHDh+u7777Tl19+qb///e8VzhsbG6uTJ09q6NCh+uabb5SZmal169ZpxIgRKioqsst2loUiAwBALeDt7S1vb+9KjU1MTFRwcLBuvvlmDRo0SI899pgCAgKs652cnLRy5UqdO3dOXbt21aOPPqqXXnqpwjmDg4O1detWFRUV6fbbb1f79u01YcIE+fr6ysmp+uqGxTAMo9pmrwHy8vLk4+Oj3NzcSu/gyop+a4td5ln9VE+7zAMAsE1BQYGysrIUFhYmd3d3R8e55lT096/sv98ckQEAAKZFkQEAAKZFkQEAAKZFkQEAAKZFkQEAAKZFkQEAAKZFkQEAAKZFkQEAAKZFkQEAAKZFkQEAoBaJiorShAkT7DrnjBkz1LFjR7vOaS98+zUAAGWYnz7/qn3WmI5jbH5PTEyMli5dWmr5jh07dP3119sjlilQZAAAMKn+/fsrMTGxxDJ/f//LfgN2bcKpJQAATMrNzU2BgYElfvr06VPi1FLTpk01e/ZsjRw5Ul5eXmrSpIneeeedEvNMmjRJrVq1Ut26ddWsWTNNnTpVFy5cuMpbUzUUGQAAarlXX31VN9xwg3bv3q0xY8boySefVEZGhnW9l5eXkpKStG/fPr355ptatGiRXn/9dQcmrjyKDAAAJrVmzRp5enpaf+67774yx91xxx0aM2aMWrRooUmTJqlhw4bauHGjdf0LL7yg7t27q2nTpoqOjtYzzzyjDz/88GptxhXhGhkAAEzqlltu0YIFC6yv69Wrp6FDh5YaFxERYf3dYrEoMDBQOTk51mUffPCB5s2bp8zMTJ05c0YXL16Ut7d39Ya3E4oMAAAmVa9ePbVo0eKy41xcXEq8tlgsKi4uliRt27ZNDz30kGbOnKl+/frJx8dHycnJevXVV6sls71RZAAAuIZ99dVXCg0N1d///nfrssOHDzswkW0oMgAAXMNatmypI0eOKDk5WTfeeKP+93//VytXrnR0rErjYl8AAK5hd999tyZOnKixY8eqY8eO+uqrrzR16lRHx6o0i2EYhqNDVKe8vDz5+PgoNzfX7hcuRb+1xS7zrH6qp13mAQDYpqCgQFlZWQoLC5O7u7uj41xzKvr7V/bfb47IAAAA06LIAAAA06LIAAAA06LIAAAA06LIAACuebX8vpcayx5/d4oMAOCademJt2fPnnVwkmvTpb/7X588bAuHPhAvPj5eKSkp+vHHH+Xh4aHu3bvr5ZdfVuvWra1joqKilJaWVuJ9jz/+uBYuXHi14wIAahlnZ2f5+vpav3eobt26slgsDk5V+xmGobNnzyonJ0e+vr5ydnau8lwOLTJpaWmKjY3VjTfeqIsXL+r555/X7bffrn379qlevXrWcaNHj9asWbOsr+vWreuIuACAWigwMFCSSnyJIq4OX19f69+/qhxaZNauXVvidVJSkgICArRr1y717t3burxu3bqV3tDCwkIVFhZaX+fl5dknLACgVrJYLAoKClJAQIAuXLjg6DjXDBcXlys6EnNJjfqupdzcXEmSn59fieXLli3Te++9p8DAQEVHR2vq1KnlHpWJj4/XzJkzqz0rAKB2cXZ2tss/rLi6asxXFBQXF+vuu+/WqVOntGXL/3/0/zvvvKPQ0FAFBwdrz549mjRpkrp27aqUlJQy5ynriExISAhfUQAAgIlU9isKaswRmdjYWO3du7dEiZGkxx57zPp7+/btFRQUpD59+igzM1PNmzcvNY+bm5vc3NyqPS8AAHC8GnH79dixY7VmzRpt3LhRjRs3rnBst27dJEkHDx68GtEAAEAN5tAjMoZh6KmnntLKlSu1adMmhYWFXfY96enpkqSgoKBqTgcAAGo6hxaZ2NhYLV++XJ988om8vLx07NgxSZKPj488PDyUmZmp5cuX64477lCDBg20Z88eTZw4Ub1791ZERIQjowMAgBrAoUVmwYIFkv546N2fJSYmKiYmRq6urtqwYYPeeOMN5efnKyQkRIMHD9YLL7zggLQAAKCmcfippYqEhISUeqovAADAJTXiYl8AAICqoMgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTosgAAADTsrnILF26VP/7v/9rff3cc8/J19dX3bt31+HDh+0aDgAAoCI2F5nZs2fLw8NDkrRt2zYlJCRo7ty5atiwoSZOnGj3gAAAAOWpY+sbfv75Z7Vo0UKStGrVKg0ePFiPPfaYevTooaioKHvnAwAAKJfNR2Q8PT114sQJSdLnn3+u2267TZLk7u6uc+fO2TcdAABABWw+InPbbbfp0UcfVadOnfTTTz/pjjvukCT98MMPatq0qb3zAQAAlMvmIzIJCQmKjIzUr7/+qo8//lgNGjSQJO3atUtDhw61e0AAAIDy2HxExtfXV2+//Xap5TNnzrRLIAAAgMqq0nNkvvzySw0bNkzdu3fX//3f/0mS/v3vf2vLli12DQcAAFARm4vMxx9/rH79+snDw0PffvutCgsLJUm5ubmaPXu23QMCAACUx+Yi8+KLL2rhwoVatGiRXFxcrMt79Oihb7/91q7hAAAAKmJzkcnIyFDv3r1LLffx8dGpU6fskQkAAKBSbC4ygYGBOnjwYKnlW7ZsUbNmzewSCgAAoDJsLjKjR4/W+PHjtWPHDlksFh09elTLli3TM888oyeffNKmueLj43XjjTfKy8tLAQEBuvfee5WRkVFiTEFBgWJjY9WgQQN5enpq8ODBOn78uK2xAQBALWRzkZk8ebIefPBB9enTR2fOnFHv3r316KOP6vHHH9dTTz1l01xpaWmKjY3V9u3btX79el24cEG333678vPzrWMmTpyo1atXa8WKFUpLS9PRo0c1aNAgW2MDAIBayGIYhlGVN54/f14HDx7UmTNn1LZtW3l6el5xmF9//VUBAQFKS0tT7969lZubK39/fy1fvlx/+9vfJEk//vijrr/+em3btk033XTTZefMy8uTj4+PcnNz5e3tfcUZ/yz6Lfvcbr76qZ52mQcAgNqisv9+2/xAvEtcXV3Vtm3bqr69TLm5uZIkPz8/SX88LfjChQvq27evdUybNm3UpEmTcotMYWGh9ZZw6Y8/BAAAqJ0qVWRsOZWTkpJSpSDFxcWaMGGCevToofDwcEnSsWPH5OrqKl9f3xJjGzVqpGPHjpU5T3x8PE8ZBgDgGlGpIuPj41PdORQbG6u9e/de8dOBp0yZori4OOvrvLw8hYSEXGk8AABQA1WqyCQmJlZriLFjx2rNmjXavHmzGjdubF0eGBio8+fP69SpUyWOyhw/flyBgYFlzuXm5iY3N7dqzQsAAGoGm+9aysrK0oEDB0otP3DggA4dOmTTXIZhaOzYsVq5cqW++OILhYWFlVjfpUsXubi4KDU11bosIyNDR44cUWRkpK3RAQBALWNzkYmJidFXX31VavmOHTsUExNj01yxsbF67733tHz5cnl5eenYsWM6duyYzp07J+mPU1qjRo1SXFycNm7cqF27dmnEiBGKjIys1B1LAACgdrO5yOzevVs9evQotfymm25Senq6TXMtWLBAubm5ioqKUlBQkPXngw8+sI55/fXXddddd2nw4MHq3bu3AgMDq3xBMQAAqF1svv3aYrHo9OnTpZbn5uaqqKjIprkq8wgbd3d3JSQkKCEhwaa5AQBA7WfzEZnevXsrPj6+RGkpKipSfHy8evbkwW4AAODqsfmIzMsvv6zevXurdevW6tWrlyTpyy+/VF5enr744gu7BwQAACiPzUdk2rZtqz179uj+++9XTk6OTp8+rUceeUQ//vij9UF2AAAAV0OVvqIgODhYs2fPtncWAAAAm1SqyOzZs0fh4eFycnLSnj17KhwbERFhl2AAAACXU6ki07FjRx07dkwBAQHq2LGjLBZLmXccWSwWm+9cAgAAqKpKFZmsrCz5+/tbfwcAAKgJKlVkQkNDrb8fPnxY3bt3V506Jd968eJFffXVVyXGAgAAVCeb71q65ZZbdPLkyVLLc3Nzdcstt9glFAAAQGXYXGQMw5DFYim1/MSJE6pXr55dQgEAAFRGpW+/HjRokKQ/LuiNiYmRm5ubdV1RUZH27Nmj7t272z8hAABAOSpdZHx8fCT9cUTGy8tLHh4e1nWurq666aabNHr0aPsnBAAAKEeli0xiYqL1luu33npLnp6e1RYKAACgMmy6RsYwDC1btkzZ2dnVlQcAAKDSbCoyTk5OatmypU6cOFFdeQAAACrN5ruW5syZo2effVZ79+6tjjwAAACVZvOXRj7yyCM6e/asOnToIFdX1xIX/Uoq8xkzAAAA1cHmIvPGG29UQwwAAADb2Vxkhg8fXh05AAAAbGZzkfmzgoICnT9/vsQyb2/vKwoEAABQWTZf7Jufn6+xY8cqICBA9erVU/369Uv8AAAAXC02F5nnnntOX3zxhRYsWCA3Nzf961//0syZMxUcHKx33323OjICAACUyeZTS6tXr9a7776rqKgojRgxQr169VKLFi0UGhqqZcuW6aGHHqqOnAAAAKXYfETm5MmTatasmaQ/roe5dLt1z549tXnzZvumAwAAqIDNRaZZs2bKysqSJLVp00YffvihpD+O1Pj6+to1HAAAQEVsLjIjRozQd999J0maPHmyEhIS5O7urokTJ+rZZ5+1e0AAAIDy2HyNzMSJE62/9+3bVz/++KN27dqlFi1aKCIiwq7hAAAAKlLpIlNcXKxXXnlFn376qc6fP68+ffpo+vTpCg0NVWhoaHVmBAAAKFOlTy299NJLev755+Xp6anrrrtOb775pmJjY6szGwAAQIUqXWTeffddzZ8/X+vWrdOqVau0evVqLVu2TMXFxdWZDwAAoFyVLjJHjhzRHXfcYX3dt29fWSwWHT16tFqCAQAAXE6li8zFixfl7u5eYpmLi4suXLhg91AAAACVUemLfQ3DUExMjNzc3KzLCgoK9MQTT6hevXrWZSkpKfZNCAAAUI5KF5nhw4eXWjZs2DC7hgEAALBFpYtMYmJideYAAACwmc1P9gUAAKgpKDIAAMC0KDIAAMC0KDIAAMC0KlVkOnfurN9//12SNGvWLJ09e7ZaQwEAAFRGpYrM/v37lZ+fL0maOXOmzpw5U62hAAAAKqNSt1937NhRI0aMUM+ePWUYhv7nf/5Hnp6eZY6dNm2aXQMCAACUp1JFJikpSdOnT9eaNWtksVj0n//8R3XqlH6rxWKhyAAAgKumUkWmdevWSk5OliQ5OTkpNTVVAQEB1RoMAADgcir9ZN9LiouLqyMHAACAzWwuMpKUmZmpN954Q/v375cktW3bVuPHj1fz5s3tGg4AAKAiNj9HZt26dWrbtq2+/vprRUREKCIiQjt27FC7du20fv366sgIAABQJpuPyEyePFkTJ07UnDlzSi2fNGmSbrvtNruFAwAAqIjNR2T279+vUaNGlVo+cuRI7du3z6a5Nm/erOjoaAUHB8tisWjVqlUl1sfExMhisZT46d+/v62RAQBALWVzkfH391d6enqp5enp6TbfyZSfn68OHTooISGh3DH9+/dXdna29ef999+3NTIAAKilbD61NHr0aD322GP673//q+7du0uStm7dqpdffllxcXE2zTVgwAANGDCgwjFubm4KDAy0NSYAALgG2Fxkpk6dKi8vL7366quaMmWKJCk4OFgzZszQuHHj7B5w06ZNCggIUP369XXrrbfqxRdfVIMGDcodX1hYqMLCQuvrvLw8u2cCAAA1g81FxmKxaOLEiZo4caJOnz4tSfLy8rJ7MOmP00qDBg1SWFiYMjMz9fzzz2vAgAHatm2bnJ2dy3xPfHy8Zs6cWS15AABAzVKl58hcUl0F5pIHHnjA+nv79u0VERGh5s2ba9OmTerTp0+Z75kyZUqJU1x5eXkKCQmp1pwAAMAxbL7Y15GaNWumhg0b6uDBg+WOcXNzk7e3d4kfAABQO5mqyPzyyy86ceKEgoKCHB0FAADUAFd0aulKnTlzpsTRlaysLKWnp8vPz09+fn6aOXOmBg8erMDAQGVmZuq5555TixYt1K9fPwemBgAANYVNR2QuXLigPn366MCBA3b58J07d6pTp07q1KmTJCkuLk6dOnXStGnT5OzsrD179ujuu+9Wq1atNGrUKHXp0kVffvml3Nzc7PL5AADA3Gw6IuPi4qI9e/bY7cOjoqJkGEa569etW2e3zwIAALWPzdfIDBs2TIsXL66OLAAAADax+RqZixcvasmSJdqwYYO6dOmievXqlVj/2muv2S0cAABARWwuMnv37lXnzp0lST/99FOJdRaLxT6pAAAAKsHmIrNx48bqyAEAAGCzKt9+ffDgQWVmZqp3797y8PCQYRgckamq1ePtN1f0m/abCwCAGs7mi31PnDihPn36qFWrVrrjjjuUnZ0tSRo1apSefvppuwcEAAAoj81FZuLEiXJxcdGRI0dUt25d6/IhQ4Zo7dq1dg0HAABQEZtPLX3++edat26dGjduXGJ5y5YtdfjwYbsFAwAAuBybj8jk5+eXOBJzycmTJ3niLgAAuKpsLjK9evXSu+++a31tsVhUXFysuXPn6pZbbrFrOAAAgIrYfGpp7ty56tOnj3bu3Knz58/rueee0w8//KCTJ09q69at1ZERAACgTDYfkQkPD9dPP/2knj176p577lF+fr4GDRqk3bt3q3nz5tWREQAAoExVeo6Mj4+P/v73v9s7CwAAgE2qVGR+//13LV68WPv375cktW3bViNGjJCfn59dwwEAAFTE5lNLmzdvVtOmTTVv3jz9/vvv+v333zVv3jyFhYVp8+bN1ZERAACgTDYfkYmNjdWQIUO0YMECOTs7S5KKioo0ZswYxcbG6vvvv7d7SAAAgLLYfETm4MGDevrpp60lRpKcnZ0VFxengwcP2jUcAABARWwuMp07d7ZeG/Nn+/fvV4cOHewSCgAAoDIqdWppz5491t/HjRun8ePH6+DBg7rpppskSdu3b1dCQoLmzJlTPSkBAADKYDEMw7jcICcnJ1ksFl1uqMViUVFRkd3C2UNeXp58fHyUm5srb29vu84d/dYWu8yzuukKu8wjSYp+035zAQDgIJX997tSR2SysrLsFgwAAMBeKlVkQkNDqzsHAACAzar0QLyjR49qy5YtysnJUXFxcYl148aNs0swAACAy7G5yCQlJenxxx+Xq6urGjRoIIvFYl1nsVgoMgAA4KqxuchMnTpV06ZN05QpU+TkZPPd2wAAAHZjcxM5e/asHnjgAUoMAABwOJvbyKhRo7RihR1vFwYAAKgim08txcfH66677tLatWvVvn17ubi4lFj/2muv2S0cAABARapUZNatW6fWrVtLUqmLfQEAAK4Wm4vMq6++qiVLligmJqYa4gAAAFSezdfIuLm5qUePHtWRBQAAwCY2F5nx48frrbfeqo4sAAAANrH51NLXX3+tL774QmvWrFG7du1KXeybkpJit3AAAAAVsbnI+Pr6atCgQdWRBQAAwCY2F5nExMTqyAEAAGAzHs8LAABMy+YjMmFhYRU+L+a///3vFQUCAACoLJuLzIQJE0q8vnDhgnbv3q21a9fq2WeftVcuAACAy7K5yIwfP77M5QkJCdq5c+cVBwIAAKgsu10jM2DAAH388cf2mg4AAOCy7FZkPvroI/n5+dlrOgAAgMuy+dRSp06dSlzsaxiGjh07pl9//VXz58+3azgAAICK2Fxk7r333hKvnZyc5O/vr6ioKLVp08ZeuQAAAC7L5iIzffr06sgBAABgMx6IBwAATKvSR2ScnJwqfBCeJFksFl28ePGKQwEAAFRGpYvMypUry123bds2zZs3T8XFxXYJBQAAUBmVLjL33HNPqWUZGRmaPHmyVq9erYceekizZs2yazgAAICKVOkamaNHj2r06NFq3769Ll68qPT0dC1dulShoaE2zbN582ZFR0crODhYFotFq1atKrHeMAxNmzZNQUFB8vDwUN++fXXgwIGqRAYAALWQTUUmNzdXkyZNUosWLfTDDz8oNTVVq1evVnh4eJU+PD8/Xx06dFBCQkKZ6+fOnat58+Zp4cKF2rFjh+rVq6d+/fqpoKCgSp8HAABql0qfWpo7d65efvllBQYG6v333y/zVJOtBgwYoAEDBpS5zjAMvfHGG3rhhResn/Xuu++qUaNGWrVqlR544IEy31dYWKjCwkLr67y8vCvOCQAAaqZKF5nJkyfLw8NDLVq00NKlS7V06dIyx6WkpNglWFZWlo4dO6a+fftal/n4+Khbt27atm1buUUmPj5eM2fOtEsGAABQs1W6yDzyyCOXvf3ano4dOyZJatSoUYnljRo1sq4ry5QpUxQXF2d9nZeXp5CQkOoJCQAAHKrSRSYpKakaY9iPm5ub3NzcHB0DAABcBTX2yb6BgYGSpOPHj5dYfvz4ces6AABwbauxRSYsLEyBgYFKTU21LsvLy9OOHTsUGRnpwGQAAKCmsPlLI+3pzJkzOnjwoPV1VlaW0tPT5efnpyZNmmjChAl68cUX1bJlS4WFhWnq1KkKDg4u9Q3cAADg2uTQIrNz507dcsst1teXLtIdPny4kpKS9Nxzzyk/P1+PPfaYTp06pZ49e2rt2rVyd3d3VGQAAFCDOLTIREVFyTCMctdbLBbNmjWLrz4AAABlqrHXyAAAAFwORQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJgWRQYAAJhWHUcHgDT/7H/tNtcYu80EAEDNxxEZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWjW6yMyYMUMWi6XET5s2bRwdCwAA1BB1HB3gctq1a6cNGzZYX9epU+MjAwCAq6TGt4I6deooMDDQ0TEAAEANVKNPLUnSgQMHFBwcrGbNmumhhx7SkSNHKhxfWFiovLy8Ej8AAKB2qtFHZLp166akpCS1bt1a2dnZmjlzpnr16qW9e/fKy8urzPfEx8dr5syZVyVfS8tUO83kaad57Gf+B9F2mWfMkNV2mQcAgLLU6CMyAwYM0H333aeIiAj169dPn332mU6dOqUPP/yw3PdMmTJFubm51p+ff/75KiYGAABXU40+IvNXvr6+atWqlQ4ePFjuGDc3N7m5uV3FVAAAwFFq9BGZvzpz5owyMzMVFBTk6CgAAKAGqNFF5plnnlFaWpoOHTqkr776SgMHDpSzs7OGDh3q6GgAAKAGqNGnln755RcNHTpUJ06ckL+/v3r27Knt27fL39/f0dEAAEANUKOLTHJysqMjAACAGqxGn1oCAACoCEUGAACYFkUGAACYFkUGAACYFkUGAACYVo2+awnmNz99vl3mGdNxjF3mqWl5AABXhiMyAADAtCgyAADAtCgyAADAtCgyAADAtCgyAADAtCgyAADAtCgyAADAtCgyAADAtCgyAADAtCgyAADAtCgyAADAtPiuJZjD6vH2mSektX3mAQDUCByRAQAApkWRAQAApkWRAQAApkWRAQAApkWRAQAApkWRAQAApkWRAQAApkWRAQAApkWRAQAApkWRAQAApsVXFNQAB389Y7e55qfPt9tcNcn8s/+100y19CsK7PUVDtFv2mUae/13OKbjGLvMA6D24ogMAAAwLYoMAAAwLYoMAAAwLYoMAAAwLYoMAAAwLYoMAAAwLYoMAAAwLYoMAAAwLYoMAAAwLYoMAAAwLYoMAAAwLb5rqbbJ+I+jE5RU0/KgQnb7ri577Xe+awnAZXBEBgAAmBZFBgAAmBZFBgAAmBZFBgAAmBZFBgAAmBZFBgAAmBZFBgAAmJYpikxCQoKaNm0qd3d3devWTV9//bWjIwEAgBqgxheZDz74QHFxcZo+fbq+/fZbdejQQf369VNOTo6jowEAAAer8UXmtdde0+jRozVixAi1bdtWCxcuVN26dbVkyRJHRwMAAA5Wo7+i4Pz589q1a5emTJliXebk5KS+fftq27ZtZb6nsLBQhYWF1te5ubmSpLy8PLvnKzx30e5zXqlzZy84OkLNduacXaapjv+ersjZwsuPqYRzdvr7yE7/Hda4vzOAq+bS//4Nw6hwXI0uMr/99puKiorUqFGjEssbNWqkH3/8scz3xMfHa+bMmaWWh4SEVEtGmM06u8zyjJ6xyzyo2DMjfRwdAYCDnT59Wj4+5f/fghpdZKpiypQpiouLs74uLi7WyZMn1aBBA1ksFrt9Tl5enkJCQvTzzz/L29vbbvPWJLV9G2v79km1fxvZPvOr7dvI9lWdYRg6ffq0goODKxxXo4tMw4YN5ezsrOPHj5dYfvz4cQUGBpb5Hjc3N7m5uZVY5uvrW10R5e3tXSv/4/yz2r6NtX37pNq/jWyf+dX2bWT7qqaiIzGX1OiLfV1dXdWlSxelpqZalxUXFys1NVWRkZEOTAYAAGqCGn1ERpLi4uI0fPhw3XDDDerataveeOMN5efna8SIEY6OBgAAHKzGF5khQ4bo119/1bRp03Ts2DF17NhRa9euLXUB8NXm5uam6dOnlzqNVZvU9m2s7dsn1f5tZPvMr7ZvI9tX/SzG5e5rAgAAqKFq9DUyAAAAFaHIAAAA06LIAAAA06LIAAAA06LIVFFCQoKaNm0qd3d3devWTV9//bWjI9nFjBkzZLFYSvy0adPG0bGuyObNmxUdHa3g4GBZLBatWrWqxHrDMDRt2jQFBQXJw8NDffv21YEDBxwTtgout30xMTGl9mn//v0dE7YK4uPjdeONN8rLy0sBAQG69957lZGRUWJMQUGBYmNj1aBBA3l6emrw4MGlHqRZk1VmG6OiokrtxyeeeMJBiW2zYMECRUREWB+aFhkZqf/85z/W9Wbff5fbPjPvu7LMmTNHFotFEyZMsC5z5D6kyFTBBx98oLi4OE2fPl3ffvutOnTooH79+iknJ8fR0eyiXbt2ys7Otv5s2bLF0ZGuSH5+vjp06KCEhIQy18+dO1fz5s3TwoULtWPHDtWrV0/9+vVTQUHBVU5aNZfbPknq379/iX36/vvvX8WEVyYtLU2xsbHavn271q9frwsXLuj2229Xfn6+dczEiRO1evVqrVixQmlpaTp69KgGDRrkwNS2qcw2StLo0aNL7Me5c+c6KLFtGjdurDlz5mjXrl3auXOnbr31Vt1zzz364YcfJJl//11u+yTz7ru/+uabb/TPf/5TERERJZY7dB8asFnXrl2N2NhY6+uioiIjODjYiI+Pd2Aq+5g+fbrRoUMHR8eoNpKMlStXWl8XFxcbgYGBxiuvvGJddurUKcPNzc14//33HZDwyvx1+wzDMIYPH27cc889DslTHXJycgxJRlpammEYf+wvFxcXY8WKFdYx+/fvNyQZ27Ztc1TMK/LXbTQMw7j55puN8ePHOy6UndWvX9/417/+VSv3n2H8/+0zjNqz706fPm20bNnSWL9+fYltcvQ+5IiMjc6fP69du3apb9++1mVOTk7q27evtm3b5sBk9nPgwAEFBwerWbNmeuihh3TkyBFHR6o2WVlZOnbsWIn96ePjo27dutWa/SlJmzZtUkBAgFq3bq0nn3xSJ06ccHSkKsvNzZUk+fn5SZJ27dqlCxculNiHbdq0UZMmTUy7D/+6jZcsW7ZMDRs2VHh4uKZMmaKzZ886It4VKSoqUnJysvLz8xUZGVnr9t9ft++S2rDvYmNjdeedd5bYV5Lj/zdY45/sW9P89ttvKioqKvVk4UaNGunHH390UCr76datm5KSktS6dWtlZ2dr5syZ6tWrl/bu3SsvLy9Hx7O7Y8eOSVKZ+/PSOrPr37+/Bg0apLCwMGVmZur555/XgAEDtG3bNjk7Ozs6nk2Ki4s1YcIE9ejRQ+Hh4ZL+2Ieurq6lvhzWrPuwrG2UpAcffFChoaEKDg7Wnj17NGnSJGVkZCglJcWBaSvv+++/V2RkpAoKCuTp6amVK1eqbdu2Sk9PrxX7r7ztk8y/7yQpOTlZ3377rb755ptS6xz9v0GKDEoYMGCA9feIiAh169ZNoaGh+vDDDzVq1CgHJkNVPfDAA9bf27dvr4iICDVv3lybNm1Snz59HJjMdrGxsdq7d6/pr9uqSHnb+Nhjj1l/b9++vYKCgtSnTx9lZmaqefPmVzumzVq3bq309HTl5ubqo48+0vDhw5WWluboWHZT3va1bdvW9Pvu559/1vjx47V+/Xq5u7s7Ok4pnFqyUcOGDeXs7Fzqauzjx48rMDDQQamqj6+vr1q1aqWDBw86Okq1uLTPrpX9KUnNmjVTw4YNTbdPx44dqzVr1mjjxo1q3LixdXlgYKDOnz+vU6dOlRhvxn1Y3jaWpVu3bpJkmv3o6uqqFi1aqEuXLoqPj1eHDh305ptv1pr9V972lcVs+27Xrl3KyclR586dVadOHdWpU0dpaWmaN2+e6tSpo0aNGjl0H1JkbOTq6qouXbooNTXVuqy4uFipqaklzofWFmfOnFFmZqaCgoIcHaVahIWFKTAwsMT+zMvL044dO2rl/pSkX375RSdOnDDNPjUMQ2PHjtXKlSv1xRdfKCwsrMT6Ll26yMXFpcQ+zMjI0JEjR0yzDy+3jWVJT0+XJNPsx78qLi5WYWFhrdh/Zbm0fWUx277r06ePvv/+e6Wnp1t/brjhBj300EPW3x26D6v9cuJaKDk52XBzczOSkpKMffv2GY899pjh6+trHDt2zNHRrtjTTz9tbNq0ycjKyjK2bt1q9O3b12jYsKGRk5Pj6GhVdvr0aWP37t3G7t27DUnGa6+9Zuzevds4fPiwYRiGMWfOHMPX19f45JNPjD179hj33HOPERYWZpw7d87BySunou07ffq08cwzzxjbtm0zsrKyjA0bNhidO3c2WrZsaRQUFDg6eqU8+eSTho+Pj7Fp0yYjOzvb+nP27FnrmCeeeMJo0qSJ8cUXXxg7d+40IiMjjcjISAemts3ltvHgwYPGrFmzjJ07dxpZWVnGJ598YjRr1szo3bu3g5NXzuTJk420tDQjKyvL2LNnjzF58mTDYrEYn3/+uWEY5t9/FW2f2fddef56J5Yj9yFFporeeusto0mTJoarq6vRtWtXY/v27Y6OZBdDhgwxgoKCDFdXV+O6664zhgwZYhw8eNDRsa7Ixo0bDUmlfoYPH24Yxh+3YE+dOtVo1KiR4ebmZvTp08fIyMhwbGgbVLR9Z8+eNW6//XbD39/fcHFxMUJDQ43Ro0ebqnSXtW2SjMTEROuYc+fOGWPGjDHq169v1K1b1xg4cKCRnZ3tuNA2utw2HjlyxOjdu7fh5+dnuLm5GS1atDCeffZZIzc317HBK2nkyJFGaGio4erqavj7+xt9+vSxlhjDMP/+q2j7zL7vyvPXIuPIfWgxDMOo/uM+AAAA9sc1MgAAwLQoMgAAwLQoMgAAwLQoMgAAwLQoMgAAwLQoMgAAwLQoMgAAwLQoMgAAwLQoMgBMJyoqShMmTKhwTFJSknx9fW2at2nTpnrjjTeqnAvA1UeRAUwuJiZGFotFTzzxRKl1sbGxslgsiomJufrB/mTp0qXq2bNnmeuqUjhSUlL0j3/8w/q6rAIyZMgQ/fTTT7ZGrdCMGTNksVjUv3//UuteeeUVWSwWRUVFlVr3yy+/yNXVVeHh4WXOm5aWpltvvVV+fn6qW7euWrZsqeHDh+v8+fPWMYsWLVKHDh3k6ekpX19fderUSfHx8XbbNsCsKDJALRASEqLk5GSdO3fOuqygoEDLly9XkyZNHJjsD5988onuvvtuu83n5+cnLy+vCsd4eHgoICDAbp95SVBQkDZu3KhffvmlxPIlS5aU+7dOSkrS/fffb/1m9T/bt2+f+vfvrxtuuEGbN2/W999/r7feekuurq4qKiqyzj1hwgSNGzdO6enp2rp1q5577jmdOXPG7tsHmA1FBqgFOnfurJCQEKWkpFiXpaSkqEmTJurUqVOJsWvXrlXPnj3l6+urBg0a6K677lJmZqZ1/fnz5zV27FgFBQXJ3d1doaGh1v/P3zAMzZgxQ02aNJGbm5uCg4M1bty4CrMVFBTo888/r3SRmTFjhjp27Kh///vfatq0qXx8fPTAAw/o9OnT1jF/PrUUFRWlw4cPa+LEibJYLLJYLJJKH+nJzMzUPffco0aNGsnT01M33nijNmzYUKlMfxYQEKDbb79dS5cutS776quv9Ntvv+nOO+8sNd4wDCUmJurhhx/Wgw8+qMWLF5dY//nnnyswMFBz585VeHi4mjdvrv79+2vRokXy8PCQJH366ae6//77NWrUKLVo0ULt2rXT0KFD9dJLL9mcH6htKDJALTFy5EglJiZaXy9ZskQjRowoNS4/P19xcXHauXOnUlNT5eTkpIEDB6q4uFiSNG/ePH366af68MMPlZGRoWXLlqlp06aSpI8//livv/66/vnPf+rAgQNatWqV2rdvX2Gu1NRUXXfddWrTpk2ltyUzM1OrVq3SmjVrtGbNGqWlpWnOnDlljk1JSVHjxo01a9YsZWdnKzs7u8xxZ86c0R133KHU1FTt3r1b/fv3V3R0tI4cOVLpXJeMHDlSSUlJ1tdLlizRQw89JFdX11JjN27cqLNnz6pv374aNmyYkpOTlZ+fb10fGBio7Oxsbd68udzPCwwM1Pbt23X48GGbswK1HUUGqCWGDRumLVu26PDhwzp8+LC2bt2qYcOGlRo3ePBgDRo0SC1atFDHjh21ZMkSff/999q3b58k6ciRI2rZsqV69uyp0NBQ9ezZU0OHDrWuCwwMVN++fdWkSRN17dpVo0ePrjBXVU4rFRcXKykpSeHh4erVq5cefvhhpaamljnWz89Pzs7O8vLyUmBgoAIDA8sc16FDBz3++OMKDw9Xy5Yt9Y9//EPNmzfXp59+alM2SbrrrruUl5enzZs3Kz8/Xx9++KFGjhxZ5tjFixfrgQcekLOzs8LDw9WsWTOtWLHCuv6+++7T0KFDdfPNNysoKEgDBw7U22+/rby8POuY6dOny9fXV02bNlXr1q0VExOjDz/80Fo+gWsZRQaoJfz9/XXnnXcqKSlJiYmJuvPOO9WwYcNS4w4cOKChQ4eqWbNm8vb2th5tuXRkIiYmRunp6WrdurXGjRunzz//3Pre++67T+fOnVOzZs00evRorVy5UhcvXiw3k2EYWr16tc1FpmnTpiWugQkKClJOTo5Nc/zVmTNn9Mwzz+j666+Xr6+vPD09tX///iodkXFxcdGwYcOUmJioFStWqFWrVoqIiCg17tSpU0pJSSlRKIcNG1bi9JKzs7MSExP1yy+/aO7cubruuus0e/ZstWvXznp0KSgoSNu2bdP333+v8ePH6+LFixo+fLj69+9PmcE1jyID1CKXTnksXbq03CME0dHROnnypBYtWqQdO3ZYLz69dIdM586dlZWVpX/84x86d+6c7r//fv3tb3+T9MdFxRkZGZo/f748PDw0ZswY9e7dWxcuXCjzs77++mtdvHhR3bt3t2k7XFxcSry2WCxX/A/2M888o5UrV2r27Nn68ssvlZ6ervbt25e4M8gWI0eO1IoVK5SQkFDu33r58uUqKChQt27dVKdOHdWpU0eTJk3Sli1bSt1Rdd111+nhhx/W22+/rR9++EEFBQVauHBhiTHh4eEaM2aM3nvvPa1fv17r169XWlpalfIDtQVFBqhF+vfvr/Pnz+vChQvq169fqfUnTpxQRkaGXnjhBfXp00fXX3+9fv/991LjvL29NWTIEC1atEgffPCBPv74Y508eVLSH3cDRUdHa968edq0aZP1SEFZPvnkE915551ydna274b+xZ/v8CnP1q1bFRMTo4EDB6p9+/YKDAzUoUOHqvyZ7dq1U7t27bR37149+OCDZY5ZvHixnn76aaWnp1t/vvvuO/Xq1UtLliwpd+769esrKCioxLU0f9W2bVtJqnAMcC2o4+gAAOzH2dlZ+/fvt/7+V/Xr11eDBg30zjvvKCgoSEeOHNHkyZNLjHnttdcUFBSkTp06ycnJSStWrFBgYKB8fX2VlJSkoqIidevWTXXr1tV7770nDw8PhYaGlpnn008/1axZs+y/oX/RtGlTbd68WQ888IDc3NzKPKXWsmVLpaSkKDo6WhaLRVOnTr3iozxffPGFLly4UOZzcNLT0/Xtt99q2bJlpS50Hjp0qGbNmqUXX3xRixcvVnp6ugYOHKjmzZuroKBA7777rn744Qe99dZbkqQnn3xSwcHBuvXWW9W4cWNlZ2frxRdflL+/vyIjI69oGwCz44gMUMt4e3vL29u7zHVOTk5KTk7Wrl27FB4erokTJ+qVV14pMcbLy0tz587VDTfcoBtvvFGHDh3SZ599JicnJ/n6+mrRokXq0aOHIiIitGHDBq1evVoNGjQo9VmZmZk6ePBgmUeG7G3WrFk6dOiQmjdvLn9//zLHvPbaa6pfv766d++u6Oho9evXT507d76iz61Xr165D/NbvHix2rZtW+bdWgMHDlROTo4+++wzde3aVWfOnNETTzyhdu3a6eabb9b27du1atUq3XzzzZKkvn37avv27brvvvvUqlUrDR48WO7u7kpNTS3zbw9cSyyGYRiODgGg9nnttde0YcMGffbZZ46OAqAW44gMgGrRuHFjTZkyxdExANRyHJEBAACmxREZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWhQZAABgWv8PzBOjLX5D99AAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Visualizing the Mass Distribution at Different Stages\n", "\n", diff --git a/docs/examples/lagrangian/testing_times.py b/docs/examples/lagrangian/testing_times.py index 9451ebe97..47ee57915 100644 --- a/docs/examples/lagrangian/testing_times.py +++ b/docs/examples/lagrangian/testing_times.py @@ -1,6 +1,7 @@ # %% # Code Section: Importing Necessary Libraries and Initializing Variables +import time import torch import numpy as np import matplotlib.pyplot as plt @@ -15,11 +16,11 @@ # Setting up the Simulation Parameters and Initial Conditions progress_bar = True # Define fixed parameters -TOTAL_NUMBER_OF_PARTICLES = 100 +TOTAL_NUMBER_OF_PARTICLES = 500 TIME_STEP = 0.01 SIMULATION_TIME = 1000 MASS = 3 -CUBE_SIDE = 1000 +CUBE_SIDE = 50 speed = 1 save_points = 50 @@ -53,9 +54,7 @@ gravity = torch.tensor( [0, -9.81, 0]).repeat(TOTAL_NUMBER_OF_PARTICLES, 1).transpose(0, 1) -# %% # Initializing Arrays for Saving Position and Mass Data - # Create arrays to store position and mass data at each save point save_position = np.zeros((3, TOTAL_NUMBER_OF_PARTICLES, save_points)) save_mass = np.zeros((TOTAL_NUMBER_OF_PARTICLES, save_points)) @@ -68,10 +67,8 @@ # %% # Initialize counter for saving data save_counter = 0 +start_time = time.time() -# Start the simulation -if progress_bar: - timer = tqdm(total=total_iterations, desc='Simulation') for i in range(total_iterations): # calculate sweep and prune collision pairs @@ -100,16 +97,16 @@ save_position[:, :, save_counter] = position.detach().numpy() save_mass[:, save_counter] = mass.detach().numpy() save_counter += 1 - if progress_bar: - timer.update(save_iterations[1]-save_iterations[0]) - -if progress_bar: - timer.close # Perform a final save of the position and mass data save_position[:, :, -1] = position.detach().numpy() save_mass[:, -1] = mass.detach().numpy() +# Calculate the total simulation time +end_time = time.time() +print(f"Total wall time: {end_time - start_time} seconds") +print(f"Ratio of wall time to simulation time: {(end_time - start_time) / SIMULATION_TIME}") + # %% # Processing the Final Data for Visualization @@ -160,9 +157,6 @@ # %% [markdown] # ## Analyzing the Mass Distribution of Particles -# -# Next, we turn our attention to understanding how the mass distribution of the particles has evolved over the course of the simulation. To achieve this, we will analyze the mass data normalized by the initial MASS value. This normalization allows us to observe changes in the mass distribution as multiples of the initial mass, providing insights into the extent of coalescence and mass variation among the particles. -# # %% # Visualizing the Mass Distribution at Different Stages @@ -195,20 +189,3 @@ # %% [markdown] # ## Summary of the Lagrangian Particle Simulation -# -# In this Jupyter Notebook, we have explored the dynamics of a Lagrangian particle system within a defined cubic space. Our focus has been on simulating and analyzing the interactions and evolution of particles under a set of initial conditions and physical laws. Here is a brief overview of what we covered: -# -# ### System Definition and Initialization -# - We began by defining the simulation space and initial conditions for our particle system. This included setting parameters such as the number of particles, mass, and dimensions of the cubic space, as well as initializing the positions and velocities of the particles. -# -# ### Simulation Process -# - The core of our simulation involved a series of iterative steps to simulate particle dynamics. These steps included checking boundary conditions, calculating distances, detecting and handling collisions, coalescing particles, applying forces, and integrating the equations of motion. -# -# ### Data Saving and Analysis -# - Throughout the simulation, we saved key data points, such as the position and mass of particles at specified intervals. This allowed us to track and analyze the changes in the system over time. -# -# ### Visualization and Interpretation -# - We utilized various visualization techniques to interpret the simulation results. This included creating 3D plots to visualize the final positions of particles and histograms to analyze the distribution of mass at different stages of the simulation. -# -# ### Insights Gained -# - The simulation provided valuable insights into the behavior of particles in a Lagrangian framework. We observed how particles interact, coalesce, and evolve over time under the influence of set physical parameters and forces. From c2e7cd0f6e28b0c81afa3ed755df261936bb93db Mon Sep 17 00:00:00 2001 From: Kyle Gorkowski Date: Wed, 29 Nov 2023 19:55:05 -0700 Subject: [PATCH 06/11] error in sweep distances --- .../lagrangian/basic_lagrangian_box.ipynb | 2604 ++++++++++++++++- docs/examples/lagrangian/testing_times.py | 11 +- 2 files changed, 2600 insertions(+), 15 deletions(-) diff --git a/docs/examples/lagrangian/basic_lagrangian_box.ipynb b/docs/examples/lagrangian/basic_lagrangian_box.ipynb index b720baa41..b02770d95 100644 --- a/docs/examples/lagrangian/basic_lagrangian_box.ipynb +++ b/docs/examples/lagrangian/basic_lagrangian_box.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -50,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -61,7 +61,7 @@ "TIME_STEP = 0.01\n", "SIMULATION_TIME = 100\n", "MASS = 3\n", - "CUBE_SIDE = 50\n", + "CUBE_SIDE = 100\n", "speed = 1\n", "save_points = 50\n", "\n", @@ -107,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -141,9 +141,2560 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 30, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n", + "Error in collision detection\n" + ] + }, { "ename": "KeyboardInterrupt", "evalue": "", @@ -151,8 +2702,9 @@ "traceback": [ "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[1;32mc:\\Users\\kkgor\\OneDrive\\Areas\\GitHub\\particula\\docs\\examples\\lagrangian\\basic_lagrangian_box.ipynb Cell 8\u001b[0m line \u001b[0;36m1\n\u001b[0;32m 8\u001b[0m position \u001b[39m=\u001b[39m boundary\u001b[39m.\u001b[39mwrapped_cube(position\u001b[39m=\u001b[39mposition, cube_side\u001b[39m=\u001b[39mCUBE_SIDE)\n\u001b[0;32m 10\u001b[0m \u001b[39m# Calculate pairwise distances between particles\u001b[39;00m\n\u001b[1;32m---> 11\u001b[0m distance_matrix \u001b[39m=\u001b[39m particle_pairs\u001b[39m.\u001b[39;49mcalculate_pairwise_distance(\n\u001b[0;32m 12\u001b[0m position\u001b[39m=\u001b[39;49mposition)\n\u001b[0;32m 14\u001b[0m \u001b[39m# Adjust distances for the radius of each particle (surface-to-surface\u001b[39;00m\n\u001b[0;32m 15\u001b[0m \u001b[39m# distance)\u001b[39;00m\n\u001b[0;32m 16\u001b[0m radius \u001b[39m=\u001b[39m particle_property\u001b[39m.\u001b[39mradius(mass\u001b[39m=\u001b[39mmass, density\u001b[39m=\u001b[39mdensity)\n", - "File \u001b[1;32m~\\OneDrive\\Areas\\GitHub\\particula\\particula\\lagrangian\\particle_pairs.py:74\u001b[0m, in \u001b[0;36mcalculate_pairwise_distance\u001b[1;34m(position)\u001b[0m\n\u001b[0;32m 49\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 50\u001b[0m \u001b[39mneed to test this:\u001b[39;00m\n\u001b[0;32m 51\u001b[0m \n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 71\u001b[0m \u001b[39m3 points.\u001b[39;00m\n\u001b[0;32m 72\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 73\u001b[0m \u001b[39m# Expand position tensor to compute pairwise differences\u001b[39;00m\n\u001b[1;32m---> 74\u001b[0m detla_position \u001b[39m=\u001b[39m position\u001b[39m.\u001b[39;49munsqueeze(\u001b[39m2\u001b[39;49m) \u001b[39m-\u001b[39;49m position\u001b[39m.\u001b[39;49munsqueeze(\u001b[39m1\u001b[39;49m)\n\u001b[0;32m 75\u001b[0m \u001b[39m# Compute pairwise Euclidean distances\u001b[39;00m\n\u001b[0;32m 76\u001b[0m \u001b[39mreturn\u001b[39;00m torch\u001b[39m.\u001b[39msqrt(torch\u001b[39m.\u001b[39msum(detla_position\u001b[39m*\u001b[39m\u001b[39m*\u001b[39m\u001b[39m2\u001b[39m, dim\u001b[39m=\u001b[39m\u001b[39m0\u001b[39m))\n", + "\u001b[1;32mc:\\Users\\kkgor\\OneDrive\\Areas\\GitHub\\particula\\docs\\examples\\lagrangian\\basic_lagrangian_box.ipynb Cell 8\u001b[0m line \u001b[0;36m3\n\u001b[0;32m 27\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mError in collision detection\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m 29\u001b[0m \u001b[39m# Coalesce particles that have collided and update their velocity and mass\u001b[39;00m\n\u001b[1;32m---> 30\u001b[0m velocity, mass \u001b[39m=\u001b[39m collisions\u001b[39m.\u001b[39;49mcoalescence(\n\u001b[0;32m 31\u001b[0m velocity\u001b[39m=\u001b[39;49mvelocity, mass\u001b[39m=\u001b[39;49mmass, collision_indices_pairs\u001b[39m=\u001b[39;49mvalid_collision_indices_pairs)\n\u001b[0;32m 33\u001b[0m \u001b[39m# Calculate the force acting on the particles (e.g., gravity)\u001b[39;00m\n\u001b[0;32m 34\u001b[0m force \u001b[39m=\u001b[39m mass \u001b[39m*\u001b[39m gravity\n", + "File \u001b[1;32m~\\OneDrive\\Areas\\GitHub\\particula\\particula\\lagrangian\\collisions.py:104\u001b[0m, in \u001b[0;36mcoalescence\u001b[1;34m(velocity, mass, collision_indices_pairs)\u001b[0m\n\u001b[0;32m 102\u001b[0m sorted_pairs, _ \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39msort(collision_indices_pairs, dim\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m)\n\u001b[0;32m 103\u001b[0m unique_left_indices \u001b[39m=\u001b[39m particle_pairs\u001b[39m.\u001b[39mremove_duplicates(sorted_pairs, \u001b[39m0\u001b[39m)\n\u001b[1;32m--> 104\u001b[0m unique_indices \u001b[39m=\u001b[39m particle_pairs\u001b[39m.\u001b[39;49mremove_duplicates(unique_left_indices, \u001b[39m1\u001b[39;49m)\n\u001b[0;32m 106\u001b[0m \u001b[39m# Update velocities based on conservation of momentum\u001b[39;00m\n\u001b[0;32m 107\u001b[0m total_mass \u001b[39m=\u001b[39m mass[unique_indices[:, \u001b[39m0\u001b[39m]] \u001b[39m+\u001b[39m mass[unique_indices[:, \u001b[39m1\u001b[39m]]\n", + "File \u001b[1;32m~\\OneDrive\\Areas\\GitHub\\particula\\particula\\lagrangian\\particle_pairs.py:36\u001b[0m, in \u001b[0;36mremove_duplicates\u001b[1;34m(index_pairs, index_to_remove)\u001b[0m\n\u001b[0;32m 11\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 12\u001b[0m \u001b[39mRemoves duplicate entries from a specified column in a tensor of index\u001b[39;00m\n\u001b[0;32m 13\u001b[0m \u001b[39mpairs.\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 33\u001b[0m \u001b[39m duplicates.\u001b[39;00m\n\u001b[0;32m 34\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 35\u001b[0m \u001b[39m# Sort index_pairs by the index_to_remove column\u001b[39;00m\n\u001b[1;32m---> 36\u001b[0m sorted_index_pairs, indices_sorted \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39;49msort(\n\u001b[0;32m 37\u001b[0m index_pairs[:, index_to_remove], dim\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m)\n\u001b[0;32m 39\u001b[0m \u001b[39m# Find unique entries in the index_to_remove column\u001b[39;00m\n\u001b[0;32m 40\u001b[0m \u001b[39m# diff_index is True for unique entries\u001b[39;00m\n\u001b[0;32m 41\u001b[0m diff_index \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mdiff(sorted_index_pairs, prepend\u001b[39m=\u001b[39mtorch\u001b[39m.\u001b[39mtensor([\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m])) \u001b[39m>\u001b[39m \u001b[39m0\u001b[39m\n", "\u001b[1;31mKeyboardInterrupt\u001b[0m: " ] } @@ -164,8 +2716,6 @@ "# Start the simulation\n", "for i in range(total_iterations):\n", "\n", - " # Apply boundary conditions for the cube (wrap-around)\n", - " position = boundary.wrapped_cube(position=position, cube_side=CUBE_SIDE)\n", "\n", " # Calculate pairwise distances between particles\n", " distance_matrix = particle_pairs.calculate_pairwise_distance(\n", @@ -191,6 +2741,9 @@ " position, velocity = integration.leapfrog(\n", " position=position, velocity=velocity, force=force, mass=mass, time_step=TIME_STEP)\n", "\n", + " # Apply boundary conditions for the cube (wrap-around)\n", + " position = boundary.wrapped_cube(position=position, cube_side=CUBE_SIDE)\n", + "\n", " # Save the position and mass data at designated save points\n", " if i == save_iterations[save_counter]:\n", " save_position[:, :, save_counter] = position.detach().numpy()\n", @@ -220,7 +2773,25 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of particles at the end: 417\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Processing the Final Data for Visualization\n", "\n", @@ -283,7 +2854,18 @@ "cell_type": "code", "execution_count": null, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABGOElEQVR4nO3de1RVdf7/8dfh6gUBUeFAIl5TEdG0MsrMkkQzv5ZOpXnXsTIslamUmfJWidl0s0xn/KrYd3QsJ7T0W94Vx8QbSZoXUr4k9hOk0QTFAIX9+6PlWZ1A48DBA9vnY6291tn78zmf/f64a/Fa+3YshmEYAgAAMCk3VxcAAABQnQg7AADA1Ag7AADA1Ag7AADA1Ag7AADA1Ag7AADA1Ag7AADA1DxcXUBNUFpaqtOnT6tBgwayWCyuLgcAAFSAYRi6cOGCQkJC5OZ27fM3hB1Jp0+fVmhoqKvLAAAAlXDq1Ck1bdr0mu2EHUkNGjSQ9Ms/lq+vr4urAQAAFZGfn6/Q0FDb3/FrIexItktXvr6+hB0AAGqZ37sFhRuUAQCAqRF2AACAqRF2AACAqXHPDgAAFVBaWqri4mJXl3FT8fT0lLu7e5XHIewAAPA7iouLlZmZqdLSUleXctPx9/eX1Wqt0nvwCDsAAFyHYRjKzs6Wu7u7QkNDr/vyOjiPYRi6dOmScnNzJUnBwcGVHouwAwDAdVy5ckWXLl1SSEiI6tWr5+pybip169aVJOXm5iowMLDSl7SIpwAAXEdJSYkkycvLy8WV3JyuBszLly9XegzCDgAAFcBvJ7qGM/7dCTsAAMDUCDsAAMDUuEEZAIBK6P/+zhu6v7XPda/2fVgsFq1evVqPPPLINfuMGjVK58+f15o1ayo05vfff68WLVrowIED6ty5s1PqdBRhBwAAk3I0mGRnZ6thw4aSrh1S3nvvPRmGUQ3VVh/CDgAAkCRZrdbf7ePn53cDKnEu7tkBAOAm0LNnTz3//PN66aWXFBAQIKvVqhkzZtj1sVgstrNALVq0kCTddtttslgs6tmzp6Rfzhb9+jLX+vXr1b17d/n7+6tRo0Z6+OGHlZGRcQNmVHGc2almzrqmeyOu1QIAzG3ZsmWKi4vTnj17lJKSolGjRumee+7Rgw8+WKbv3r17deedd2rz5s3q0KHDNd8zVFBQoLi4OEVGRurixYuaNm2aHn30UaWlpdWYt00TdgAAuElERkZq+vTpkqQ2bdrogw8+0JYtW8oNO02aNJEkNWrU6LqXtwYNGmS3vmTJEjVp0kRHjhxRRESEE6uvvJoRuQAAQLWLjIy0Ww8ODrb99lRlHT9+XEOGDFHLli3l6+ur5s2bS5KysrKqNK4zcWYHAICbhKenp926xWKp8i+59+/fX2FhYVq0aJFCQkJUWlqqiIgIFRcXV2lcZyLsAACAMq7eo3P1t8HKc/bsWaWnp2vRokW69957JUk7d97Y9w9VBGEHAACUERgYqLp162r9+vVq2rSp6tSpU+ax84YNG6pRo0b6+9//ruDgYGVlZWnq1KkuqvjaCDsAAFSC2Z+S9fDw0Lx58zRr1ixNmzZN9957r7Zv327Xx83NTStXrtTzzz+viIgItW3bVvPmzbM9pl5TWIza9hrEapCfny8/Pz/l5eXJ19fXqWPz6DkA1G6FhYXKzMxUixYtVKdOHVeXc9O53r9/Rf9+15insebMmSOLxaJJkybZthUWFio2NlaNGjWSj4+PBg0apDNnzth9LysrS/369VO9evUUGBioF198UVeuXLnB1QMAgJqqRoSdffv26W9/+1uZR+ImT56stWvXatWqVUpOTtbp06c1cOBAW3tJSYn69eun4uJi7dq1S8uWLVNiYqKmTZt2o6cAAABqKJeHnYsXL2ro0KFatGiR7cfHJCkvL0+LFy/W22+/rQceeEBdu3bV0qVLtWvXLu3evVuStHHjRh05ckT/+Mc/1LlzZ/Xt21evvvqq5s+fX6MeeQMAAK7j8rATGxurfv36KTo62m57amqqLl++bLe9Xbt2atasmVJSUiRJKSkp6tixo4KCgmx9YmJilJ+fr8OHD19zn0VFRcrPz7dbAACAObn0aayVK1fq66+/1r59+8q05eTkyMvLS/7+/nbbg4KClJOTY+vz66Bztf1q27UkJCRo5syZVaweAADUBi47s3Pq1ClNnDhRy5cvv+F3t8fHxysvL8+2nDp16obuHwAA3DguCzupqanKzc1Vly5d5OHhIQ8PDyUnJ2vevHny8PBQUFCQiouLdf78ebvvnTlzxvaDZFartczTWVfXr/ejZd7e3vL19bVbAACAObks7PTq1UuHDh1SWlqabbn99ts1dOhQ22dPT09t2bLF9p309HRlZWUpKipKkhQVFaVDhw7Z/YjZpk2b5Ovrq/Dw8Bs+JwAAUPO4LOw0aNBAERERdkv9+vXVqFEjRUREyM/PT2PHjlVcXJy2bdum1NRUjR49WlFRUbrrrrskSb1791Z4eLiGDx+ub775Rhs2bNDLL7+s2NhYeXt7u2pqAADUOj179rR71115mjdvrnffffe6fSwWi9asWSNJ+v7772WxWJSWluaUGiurRv9cxDvvvCM3NzcNGjRIRUVFiomJ0Ycffmhrd3d317p16zR+/HhFRUWpfv36GjlypGbNmuXCqgEAN4W1E2/s/vq/5/BXRo0apWXLlunpp5/WwoUL7dpiY2P14YcfauTIkUpMTFRSUlKZX0U3ixoVdn77mxt16tTR/PnzNX/+/Gt+JywsTF988UU1VwYAQO0UGhqqlStX6p133lHdunUl/fILBStWrFCzZs1s/QICAlxVYrVz+Xt2AABA9enSpYtCQ0OVlJRk25aUlKRmzZrptttus2377WWs3Nxc9e/fX3Xr1lWLFi20fPnyMmMfP35cPXr0UJ06dRQeHq5Nmzb9bj3ffvut+vbtKx8fHwUFBWn48OH6z3/+U7VJ/g7CDgAAJjdmzBgtXbrUtr5kyRKNHj36ut8ZNWqUTp06pW3btulf//qXPvzwQ7sHgkpLSzVw4EB5eXlpz549WrhwoaZMmXLdMc+fP68HHnhAt912m/bv36/169frzJkzevzxx6s2wd9Roy5jAQAA5xs2bJji4+N18uRJSdJXX32llStXlrl95KrvvvtOX375pfbu3as77rhDkrR48WK1b9/e1mfz5s06duyYNmzYoJCQEEnS7Nmz1bdv32vW8cEHH+i2227T7NmzbduWLFmi0NBQfffdd7r11lurOtVyEXYAADC5Jk2aqF+/fkpMTJRhGOrXr58aN258zf5Hjx6Vh4eHunbtatvWrl07u181OHr0qEJDQ21BR5Lt1TDX8s0332jbtm3y8fEp05aRkUHYAQAAlTdmzBhNmDBBkq774E91unjxovr376833nijTFtwcHC17ZewAwDATaBPnz4qLi6WxWJRTEzMdfu2a9dOV65cUWpqqu0yVnp6ut2vGrRv316nTp1Sdna2Lajs3r37uuN26dJFn376qZo3by4PjxsXQbhBGQCAm4C7u7uOHj2qI0eOyN3d/bp927Ztqz59+ujpp5/Wnj17lJqaqj/+8Y+2R9clKTo6WrfeeqtGjhypb775Rv/+97/1l7/85brjxsbG6ty5cxoyZIj27dunjIwMbdiwQaNHj1ZJSYlT5lkewg4AADcJR34PcunSpQoJCdF9992ngQMH6qmnnlJgYKCt3c3NTatXr9bPP/+sO++8U3/84x/1+uuvX3fMkJAQffXVVyopKVHv3r3VsWNHTZo0Sf7+/nJzq75IYjEMw6i20WuJ/Px8+fn5KS8vz+k/Ctr//Z1OGWftc92dMg4AwDGFhYXKzMxUixYtVKdOHVeXc9O53r9/Rf9+c2YHAACYGmEHAACYGmEHAACYGo+eV7PYi+87aSTu2QEAoDI4swMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAAEyNsAMAwE2mZ8+emjRpklPHnDFjhjp37uzUMZ2FR88BAKiED9M+vKH7e7bzsw5/Z9SoUVq2bFmZ7Xv27FH79u2dUVatQNgBAMDE+vTpo6VLl9pta9Kkye/+8rmZcBkLAAAT8/b2ltVqtVt69epldxmrefPmmj17tsaMGaMGDRqoWbNm+vvf/243zpQpU3TrrbeqXr16atmypV555RVdvnz5Bs+mcgg7AABAb731lm6//XYdOHBAzz77rMaPH6/09HRbe4MGDZSYmKgjR47ovffe06JFi/TOO++4sOKKI+wAAGBi69atk4+Pj2157LHHyu330EMP6dlnn1Xr1q01ZcoUNW7cWNu2bbO1v/zyy7r77rvVvHlz9e/fXy+88II++eSTGzWNKuGeHQAATOz+++/XggULbOv169fXkCFDyvSLjIy0fbZYLLJarcrNzbVt+/jjjzVv3jxlZGTo4sWLunLlinx9fau3eCch7AAAYGL169dX69atf7efp6en3brFYlFpaakkKSUlRUOHDtXMmTMVExMjPz8/rVy5Um+99Va11OxshB0AAHBdu3btUlhYmP7yl7/Ytp08edKFFTmGsAMAAK6rTZs2ysrK0sqVK3XHHXfof//3f7V69WpXl1Vh3KAMAACu67/+6780efJkTZgwQZ07d9auXbv0yiuvuLqsCrMYhmG4ughXy8/Pl5+fn/Ly8px+s9X6hCecMk6f+I+dMg4AwDGFhYXKzMxUixYtVKdOHVeXc9O53r9/Rf9+c2YHAACYGmEHAACYmkvDzoIFCxQZGSlfX1/5+voqKipKX375pa29Z8+eslgsdsszzzxjN0ZWVpb69eunevXqKTAwUC+++KKuXLlyo6cCAABqKJc+jdW0aVPNmTNHbdq0kWEYWrZsmQYMGKADBw6oQ4cOkqRx48Zp1qxZtu/Uq1fP9rmkpET9+vWT1WrVrl27lJ2drREjRsjT01OzZ8++4fMBAAA1j0vDTv/+/e3WX3/9dS1YsEC7d++2hZ169erJarWW+/2NGzfqyJEj2rx5s4KCgtS5c2e9+uqrmjJlimbMmCEvL69yv1dUVKSioiLben5+vpNmVE6NDXJ/v1MF9HHKKACAyuJ5Htdwxr97jblnp6SkRCtXrlRBQYGioqJs25cvX67GjRsrIiJC8fHxunTpkq0tJSVFHTt2VFBQkG1bTEyM8vPzdfjw4WvuKyEhQX5+frYlNDS0eiYFAKj13N3dJUnFxcUuruTmdPXv/m/f8OwIl79U8NChQ4qKilJhYaF8fHy0evVqhYeHS5KefPJJhYWFKSQkRAcPHtSUKVOUnp6upKQkSVJOTo5d0JFkW8/JybnmPuPj4xUXF2dbz8/PJ/AAAMrl4eGhevXq6ccff5Snp6fc3GrMeQJTMwxDly5dUm5urvz9/W2hszJcHnbatm2rtLQ05eXl6V//+pdGjhyp5ORkhYeH66mnnrL169ixo4KDg9WrVy9lZGSoVatWld6nt7e3vL29nVE+AMDkLBaLgoODlZmZWat+IsEs/P39r3k7S0W5POx4eXnZfqCsa9eu2rdvn9577z397W9/K9O3W7dukqQTJ06oVatWslqt2rt3r12fM2fOSFKV/2EAALjKy8tLbdq04VLWDebp6VmlMzpXuTzs/FZpaandzcO/lpaWJkkKDg6WJEVFRen1119Xbm6uAgMDJUmbNm2Sr6+v7VIYAADO4ObmxhuUaymXhp34+Hj17dtXzZo104ULF7RixQpt375dGzZsUEZGhlasWKGHHnpIjRo10sGDBzV58mT16NFDkZGRkqTevXsrPDxcw4cP19y5c5WTk6OXX35ZsbGxXKYCAACSXBx2cnNzNWLECGVnZ8vPz0+RkZHasGGDHnzwQZ06dUqbN2/Wu+++q4KCAoWGhmrQoEF6+eWXbd93d3fXunXrNH78eEVFRal+/foaOXKk3Xt5AADAzc2lYWfx4sXXbAsNDVVycvLvjhEWFqYvvvjCmWUBAAAT4fk5AABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgai4NOwsWLFBkZKR8fX3l6+urqKgoffnll7b2wsJCxcbGqlGjRvLx8dGgQYN05swZuzGysrLUr18/1atXT4GBgXrxxRd15cqVGz0VAABQQ7k07DRt2lRz5sxRamqq9u/frwceeEADBgzQ4cOHJUmTJ0/W2rVrtWrVKiUnJ+v06dMaOHCg7fslJSXq16+fiouLtWvXLi1btkyJiYmaNm2aq6YEAABqGIthGIari/i1gIAAvfnmm/rDH/6gJk2aaMWKFfrDH/4gSTp27Jjat2+vlJQU3XXXXfryyy/18MMP6/Tp0woKCpIkLVy4UFOmTNGPP/4oLy+vCu0zPz9ffn5+ysvLk6+vr1PnE/fB/U4Z5+0J25wyDgAAZlHRv9815p6dkpISrVy5UgUFBYqKilJqaqouX76s6OhoW5927dqpWbNmSklJkSSlpKSoY8eOtqAjSTExMcrPz7edHSpPUVGR8vPz7RYAAGBOLg87hw4dko+Pj7y9vfXMM89o9erVCg8PV05Ojry8vOTv72/XPygoSDk5OZKknJwcu6Bztf1q27UkJCTIz8/PtoSGhjp3UgAAoMZwedhp27at0tLStGfPHo0fP14jR47UkSNHqnWf8fHxysvLsy2nTp2q1v0BAADX8XB1AV5eXmrdurUkqWvXrtq3b5/ee+89PfHEEyouLtb58+ftzu6cOXNGVqtVkmS1WrV371678a4+rXW1T3m8vb3l7e3t5JkAAICayOVndn6rtLRURUVF6tq1qzw9PbVlyxZbW3p6urKyshQVFSVJioqK0qFDh5Sbm2vrs2nTJvn6+io8PPyG1w4AAGoeh8POsmXL9L//+7+29Zdeekn+/v66++67dfLkSYfGio+P144dO/T999/r0KFDio+P1/bt2zV06FD5+flp7NixiouL07Zt25SamqrRo0crKipKd911lySpd+/eCg8P1/Dhw/XNN99ow4YNevnllxUbG8uZGwAAIKkSYWf27NmqW7eupF+ehpo/f77mzp2rxo0ba/LkyQ6NlZubqxEjRqht27bq1auX9u3bpw0bNujBBx+UJL3zzjt6+OGHNWjQIPXo0UNWq1VJSUm277u7u2vdunVyd3dXVFSUhg0bphEjRmjWrFmOTgsAAJiUw+/ZqVevno4dO6ZmzZppypQpys7O1kcffaTDhw+rZ8+e+vHHH6ur1mrDe3YAAKh9qu09Oz4+Pjp79qwkaePGjbazMHXq1NHPP/9cyXIBAACqh8NPYz344IP64x//qNtuu03fffedHnroIUnS4cOH1bx5c2fXBwAAUCUOn9mZP3++oqKi9OOPP+rTTz9Vo0aNJEmpqakaMmSI0wsEAACoCofP7Pj7++uDDz4os33mzJlOKQgAAMCZKvWenX//+98aNmyY7r77bv2///f/JEn/8z//o507dzq1OAAAgKpyOOx8+umniomJUd26dfX111+rqKhIkpSXl6fZs2c7vUAAAICqcDjsvPbaa1q4cKEWLVokT09P2/Z77rlHX3/9tVOLAwAAqCqHw056erp69OhRZrufn5/Onz/vjJoAAACcxuGwY7VadeLEiTLbd+7cqZYtWzqlKAAAAGdxOOyMGzdOEydO1J49e2SxWHT69GktX75cL7zwgsaPH18dNQIAAFSaw4+eT506VaWlperVq5cuXbqkHj16yNvbWy+88IKee+656qgRAACg0hwOOxaLRX/5y1/04osv6sSJE7p48aLCw8Pl4+NTHfUBAABUicNh5yovLy+Fh4c7sxYAAACnq1DYGThwYIUHTEpKqnQxAAAAzlahsOPn51fddQAAAFSLCoWdpUuXVncdAAAA1cLhR88zMzN1/PjxMtuPHz+u77//3hk1AQAAOI3DYWfUqFHatWtXme179uzRqFGjnFETAACA0zgcdg4cOKB77rmnzPa77rpLaWlpzqgJAADAaRwOOxaLRRcuXCizPS8vTyUlJU4pCgAAwFkcDjs9evRQQkKCXbApKSlRQkKCunfv7tTiAAAAqsrhlwq+8cYb6tGjh9q2bat7771XkvTvf/9b+fn52rp1q9MLBAAAqAqHz+yEh4fr4MGDevzxx5Wbm6sLFy5oxIgROnbsmCIiIqqjRgAAgEqr1M9FhISEaPbs2c6uBQAAwOkqFHYOHjyoiIgIubm56eDBg9ftGxkZ6ZTCAAAAnKFCYadz587KyclRYGCgOnfuLIvFIsMwyvSzWCw8kQUAAGqUCoWdzMxMNWnSxPYZAACgtqhQ2AkLC7N9PnnypO6++255eNh/9cqVK9q1a5ddXwAAAFdz+Gms+++/X+fOnSuzPS8vT/fff79TigIAAHAWh8OOYRiyWCxltp89e1b169d3SlEAAADOUuFHzwcOHCjpl5uQR40aJW9vb1tbSUmJDh48qLvvvtv5FQIAAFRBhcOOn5+fpF/O7DRo0EB169a1tXl5eemuu+7SuHHjnF8hAABAFVQ47CxdutT2uPn7778vHx+fKu88ISFBSUlJOnbsmOrWrau7775bb7zxhtq2bWvr07NnTyUnJ9t97+mnn9bChQtt61lZWRo/fry2bdsmHx8fjRw5UgkJCWVuogYAADcfh+7ZMQxDy5cvV3Z2tlN2npycrNjYWO3evVubNm3S5cuX1bt3bxUUFNj1GzdunLKzs23L3LlzbW0lJSXq16+fiouLtWvXLi1btkyJiYmaNm2aU2oEAAC1m0OnPtzc3NSmTRudPXtWbdq0qfLO169fb7eemJiowMBApaamqkePHrbt9erVk9VqLXeMjRs36siRI9q8ebOCgoLUuXNnvfrqq5oyZYpmzJghLy+vMt8pKipSUVGRbT0/P7/KcwEAADWTw09jzZkzRy+++KK+/fZbpxeTl5cnSQoICLDbvnz5cjVu3FgRERGKj4/XpUuXbG0pKSnq2LGjgoKCbNtiYmKUn5+vw4cPl7ufhIQE+fn52ZbQ0FCnzwUAANQMDt/UMmLECF26dEmdOnWSl5eX3Y3Kksp9B09FlJaWatKkSbrnnnvsfj39ySefVFhYmEJCQnTw4EFNmTJF6enpSkpKkiTl5OTYBR1JtvWcnJxy9xUfH6+4uDjben5+PoEHAACTcjjsvPvuu9VQhhQbG6tvv/1WO3futNv+1FNP2T537NhRwcHB6tWrlzIyMtSqVatK7cvb29vu0XkAAGBeDoedkSNHOr2ICRMmaN26ddqxY4eaNm163b7dunWTJJ04cUKtWrWS1WrV3r177fqcOXNGkq55nw8AALh5OHzPzq8VFhYqPz/fbnGEYRiaMGGCVq9era1bt6pFixa/+520tDRJUnBwsCQpKipKhw4dUm5urq3Ppk2b5Ovrq/DwcIfqAQAA5uPwmZ2CggJNmTJFn3zyic6ePVumvaSkpMJjxcbGasWKFfrss8/UoEED2z02fn5+qlu3rjIyMrRixQo99NBDatSokQ4ePKjJkyerR48eioyMlCT17t1b4eHhGj58uObOnaucnBy9/PLLio2N5VIVAABw/MzOSy+9pK1bt2rBggXy9vbWf//3f2vmzJkKCQnRRx995NBYCxYsUF5ennr27Kng4GDb8vHHH0v65c3MmzdvVu/evdWuXTv96U9/0qBBg7R27VrbGO7u7lq3bp3c3d0VFRWlYcOGacSIEZo1a5ajUwMAACbk8JmdtWvX6qOPPlLPnj01evRo3XvvvWrdurXCwsK0fPlyDR06tMJjXX0j87WEhoaWeXtyecLCwvTFF19UeL8AAODm4fCZnXPnzqlly5aSJF9fX9uj5t27d9eOHTucWx0AAEAVORx2WrZsqczMTElSu3bt9Mknn0j65YyPv7+/U4sDAACoKofDzujRo/XNN99IkqZOnar58+erTp06mjx5sl588UWnFwgAAFAVDt+zM3nyZNvn6OhoHTt2TKmpqWrdurXtCSkAAICaosJhp7S0VG+++aY+//xzFRcXq1evXpo+fbrCwsIUFhZWnTUCAABUWoUvY73++uv685//LB8fH91yyy167733FBsbW521AQAAVFmFw85HH32kDz/8UBs2bNCaNWu0du1aLV++XKWlpdVZHwAAQJVUOOxkZWXpoYcesq1HR0fLYrHo9OnT1VIYAACAM1Q47Fy5ckV16tSx2+bp6anLly87vSgAAABnqfANyoZhaNSoUXa/N1VYWKhnnnlG9evXt21LSkpyboUAAABVUOGwM3LkyDLbhg0b5tRiAAAAnK3CYWfp0qXVWQcAAEC1cPgNygAAALUJYQcAAJgaYQcAAJgaYQcAAJhahcJOly5d9NNPP0mSZs2apUuXLlVrUQAAAM5SobBz9OhRFRQUSJJmzpypixcvVmtRAAAAzlKhR887d+6s0aNHq3v37jIMQ3/961/l4+NTbt9p06Y5tUAAAICqqFDYSUxM1PTp07Vu3TpZLBZ9+eWX8vAo+1WLxULYAQAANUqFwk7btm21cuVKSZKbm5u2bNmiwMDAai0MAADAGSr8BuWrSktLq6MOAACAauFw2JGkjIwMvfvuuzp69KgkKTw8XBMnTlSrVq2cWhwAAEBVOfyenQ0bNig8PFx79+5VZGSkIiMjtWfPHnXo0EGbNm2qjhoBAAAqzeEzO1OnTtXkyZM1Z86cMtunTJmiBx980GnFAQAAVJXDZ3aOHj2qsWPHltk+ZswYHTlyxClFAQAAOIvDYadJkyZKS0srsz0tLY0ntAAAQI3j8GWscePG6amnntL//d//6e6775YkffXVV3rjjTcUFxfn9AIBAACqwuGw88orr6hBgwZ66623FB8fL0kKCQnRjBkz9Pzzzzu9QAAAgKpwOOxYLBZNnjxZkydP1oULFyRJDRo0cHphAAAAzlCp9+xcRcgBAAA1ncM3KDtTQkKC7rjjDjVo0ECBgYF65JFHlJ6ebtensLBQsbGxatSokXx8fDRo0CCdOXPGrk9WVpb69eunevXqKTAwUC+++KKuXLlyI6cCAABqKJeGneTkZMXGxmr37t3atGmTLl++rN69e6ugoMDWZ/LkyVq7dq1WrVql5ORknT59WgMHDrS1l5SUqF+/fiouLtauXbu0bNkyJSYm8oOkAABAkmQxDMNwdRFX/fjjjwoMDFRycrJ69OihvLw8NWnSRCtWrNAf/vAHSdKxY8fUvn17paSk6K677tKXX36phx9+WKdPn1ZQUJAkaeHChZoyZYp+/PFHeXl5/e5+8/Pz5efnp7y8PPn6+jp1TnEf3O+Ucd6esM0p4wAAYBYV/fvt0Jmdy5cvq1evXjp+/HiVCyxPXl6eJCkgIECSlJqaqsuXLys6OtrWp127dmrWrJlSUlIkSSkpKerYsaMt6EhSTEyM8vPzdfjw4XL3U1RUpPz8fLsFAACYk0Nhx9PTUwcPHqyWQkpLSzVp0iTdc889ioiIkCTl5OTIy8tL/v7+dn2DgoKUk5Nj6/ProHO1/WpbeRISEuTn52dbQkNDnTwbAABQUzh8z86wYcO0ePFipxcSGxurb7/9VitXrnT62L8VHx+vvLw823Lq1Klq3ycAAHANhx89v3LlipYsWaLNmzera9euql+/vl3722+/7XAREyZM0Lp167Rjxw41bdrUtt1qtaq4uFjnz5+3O7tz5swZWa1WW5+9e/fajXf1aa2rfX7L29tb3t7eDtcJAABqH4fDzrfffqsuXbpIkr777ju7NovF4tBYhmHoueee0+rVq7V9+3a1aNHCrr1r167y9PTUli1bNGjQIElSenq6srKyFBUVJUmKiorS66+/rtzcXNtvc23atEm+vr4KDw93dHoAAMBkHA4727Y576mg2NhYrVixQp999pkaNGhgu8fGz89PdevWlZ+fn8aOHau4uDgFBATI19dXzz33nKKionTXXXdJknr37q3w8HANHz5cc+fOVU5Ojl5++WXFxsZy9gYAAFT+PTsnTpzQhg0b9PPPP0v65SyNoxYsWKC8vDz17NlTwcHBtuXjjz+29XnnnXf08MMPa9CgQerRo4esVquSkpJs7e7u7lq3bp3c3d0VFRWlYcOGacSIEZo1a1ZlpwYAAEzE4ffsnD17Vo8//ri2bdsmi8Wi48ePq2XLlhozZowaNmyot956q7pqrTa8ZwcAgNqnWt6zI/3yRmNPT09lZWWpXr16tu1PPPGE1q9fX7lqAQAAqonD9+xs3LhRGzZssHtqSpLatGmjkydPOq0wAAAAZ3D4zE5BQYHdGZ2rzp07xw3BAACgxnE47Nx777366KOPbOsWi0WlpaWaO3eu7r/fOfenAAAAOIvDl7Hmzp2rXr16af/+/SouLtZLL72kw4cP69y5c/rqq6+qo0YAAIBKc/jMTkREhL777jt1795dAwYMUEFBgQYOHKgDBw6oVatW1VEjAABApTl8Zkf65aV/f/nLX5xdCwAAgNNVKuz89NNPWrx4sY4ePSpJCg8P1+jRoxUQEODU4gAAAKrK4ctYO3bsUPPmzTVv3jz99NNP+umnnzRv3jy1aNFCO3bsqI4aAQAAKs3hMzuxsbF64okntGDBArm7u0uSSkpK9Oyzzyo2NlaHDh1yepEAAACV5fCZnRMnTuhPf/qTLehIv/w+VVxcnE6cOOHU4gAAAKrK4bDTpUsX2706v3b06FF16tTJKUUBAAA4S4UuYx08eND2+fnnn9fEiRN14sQJ3XXXXZKk3bt3a/78+ZozZ071VAkAAFBJFfrVczc3N1ksFv1eV4vFopKSEqcVd6Pwq+cAANQ+Ff37XaEzO5mZmU4rDAAA4EaqUNgJCwur7joAAACqRaVeKnj69Gnt3LlTubm5Ki0ttWt7/vnnnVIYAACAMzgcdhITE/X000/Ly8tLjRo1ksVisbVZLBbCDgAAqFEcDjuvvPKKpk2bpvj4eLm5OfzkOgAAwA3lcFq5dOmSBg8eTNABAAC1gsOJZezYsVq1alV11AIAAOB0Dl/GSkhI0MMPP6z169erY8eO8vT0tGt/++23nVYcAABAVVUq7GzYsEFt27aVpDI3KAMAANQkDoedt956S0uWLNGoUaOqoRwAAADncvieHW9vb91zzz3VUQsAAIDTORx2Jk6cqPfff786agEAAHA6hy9j7d27V1u3btW6devUoUOHMjcoJyUlOa04AACAqnI47Pj7+2vgwIHVUQsAAIDTORx2li5dWh11AAAAVAtegwwAAEzN4TM7LVq0uO77dP7v//6vSgUBAAA4k8NhZ9KkSXbrly9f1oEDB7R+/Xq9+OKLzqoLAADAKRwOOxMnTix3+/z587V//36HxtqxY4fefPNNpaamKjs7W6tXr9Yjjzxiax81apSWLVtm952YmBitX7/etn7u3Dk999xzWrt2rdzc3DRo0CC999578vHxcagWAABgTk67Z6dv37769NNPHfpOQUGBOnXqpPnz51+zT58+fZSdnW1b/vnPf9q1Dx06VIcPH9amTZu0bt067dixQ0899VSl5gAAAMzH4TM71/Kvf/1LAQEBDn2nb9++6tu373X7eHt7y2q1ltt29OhRrV+/Xvv27dPtt98uSXr//ff10EMP6a9//atCQkLK/V5RUZGKiops6/n5+Q7VDQAAag+Hw85tt91md4OyYRjKycnRjz/+qA8//NCpxUnS9u3bFRgYqIYNG+qBBx7Qa6+9pkaNGkmSUlJS5O/vbws6khQdHS03Nzft2bNHjz76aLljJiQkaObMmU6vFQAA1DwOh51f31MjSW5ubmrSpIl69uypdu3aOasuSb9cwho4cKBatGihjIwM/fnPf1bfvn2VkpIid3d35eTkKDAw0O47Hh4eCggIUE5OzjXHjY+PV1xcnG09Pz9foaGhTq0dAADUDA6HnenTp1dHHeUaPHiw7XPHjh0VGRmpVq1aafv27erVq1elx/X29pa3t7czSgQAADVcrXqpYMuWLdW4cWOdOHFCkmS1WpWbm2vX58qVKzp37tw17/MBAAA3lwqHHTc3N7m7u1938fBw2v3O5frhhx909uxZBQcHS5KioqJ0/vx5paam2vps3bpVpaWl6tatW7XWAgAAaocKp5PVq1dfsy0lJUXz5s1TaWmpQzu/ePGi7SyNJGVmZiotLU0BAQEKCAjQzJkzNWjQIFmtVmVkZOill15S69atFRMTI0lq3769+vTpo3HjxmnhwoW6fPmyJkyYoMGDB1/zSSwAAHBzqXDYGTBgQJlt6enpmjp1qtauXauhQ4dq1qxZDu18//79uv/++23rV28aHjlypBYsWKCDBw9q2bJlOn/+vEJCQtS7d2+9+uqrdvfbLF++XBMmTFCvXr1sLxWcN2+eQ3UAAADzqtR1p9OnT2v69OlatmyZYmJilJaWpoiICIfH6dmzpwzDuGb7hg0bfneMgIAArVixwuF9AwCAm4NDNyjn5eVpypQpat26tQ4fPqwtW7Zo7dq1lQo6AAAAN0KFz+zMnTtXb7zxhqxWq/75z3+We1kLAACgpqlw2Jk6darq1q2r1q1ba9myZWV+oPOqpKQkpxUHAABQVRUOOyNGjLD7mQgAAIDaoMJhJzExsRrLAAAAqB616g3KAAAAjiLsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAU3Np2NmxY4f69++vkJAQWSwWrVmzxq7dMAxNmzZNwcHBqlu3rqKjo3X8+HG7PufOndPQoUPl6+srf39/jR07VhcvXryBswAAADWZS8NOQUGBOnXqpPnz55fbPnfuXM2bN08LFy7Unj17VL9+fcXExKiwsNDWZ+jQoTp8+LA2bdqkdevWaceOHXrqqadu1BQAAEAN5+HKnfft21d9+/Ytt80wDL377rt6+eWXNWDAAEnSRx99pKCgIK1Zs0aDBw/W0aNHtX79eu3bt0+33367JOn999/XQw89pL/+9a8KCQm5YXMBAAA1U429ZyczM1M5OTmKjo62bfPz81O3bt2UkpIiSUpJSZG/v78t6EhSdHS03NzctGfPnmuOXVRUpPz8fLsFAACYU40NOzk5OZKkoKAgu+1BQUG2tpycHAUGBtq1e3h4KCAgwNanPAkJCfLz87MtoaGhTq4eAADUFDU27FSn+Ph45eXl2ZZTp065uiQAAFBNamzYsVqtkqQzZ87YbT9z5oytzWq1Kjc31679ypUrOnfunK1Peby9veXr62u3AAAAc6qxYadFixayWq3asmWLbVt+fr727NmjqKgoSVJUVJTOnz+v1NRUW5+tW7eqtLRU3bp1u+E1AwCAmselT2NdvHhRJ06csK1nZmYqLS1NAQEBatasmSZNmqTXXntNbdq0UYsWLfTKK68oJCREjzzyiCSpffv26tOnj8aNG6eFCxfq8uXLmjBhggYPHsyTWAAAQJKLw87+/ft1//3329bj4uIkSSNHjlRiYqJeeuklFRQU6KmnntL58+fVvXt3rV+/XnXq1LF9Z/ny5ZowYYJ69eolNzc3DRo0SPPmzbvhcwEAADWTxTAMw9VFuFp+fr78/PyUl5fn9Pt34j64//c7VcDbE7Y5ZRwAAMyion+/a+w9OwAAAM5A2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKbm4eoCUDEfpn3olHGe7fysU8YBAKC24MwOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwtRoddmbMmCGLxWK3tGvXztZeWFio2NhYNWrUSD4+Pho0aJDOnDnjwooBAEBNU6PDjiR16NBB2dnZtmXnzp22tsmTJ2vt2rVatWqVkpOTdfr0aQ0cONCF1QIAgJqmxr9B2cPDQ1artcz2vLw8LV68WCtWrNADDzwgSVq6dKnat2+v3bt366677rrmmEVFRSoqKrKt5+fnO79wAABQI9T4MzvHjx9XSEiIWrZsqaFDhyorK0uSlJqaqsuXLys6OtrWt127dmrWrJlSUlKuO2ZCQoL8/PxsS2hoaLXOAQAAuE6NDjvdunVTYmKi1q9frwULFigzM1P33nuvLly4oJycHHl5ecnf39/uO0FBQcrJybnuuPHx8crLy7Mtp06dqsZZAAAAV6rRl7H69u1r+xwZGalu3bopLCxMn3zyierWrVvpcb29veXt7e2MEgEAQA1Xo8/s/Ja/v79uvfVWnThxQlarVcXFxTp//rxdnzNnzpR7jw8AALg51aqwc/HiRWVkZCg4OFhdu3aVp6entmzZYmtPT09XVlaWoqKiXFglAACoSWr0ZawXXnhB/fv3V1hYmE6fPq3p06fL3d1dQ4YMkZ+fn8aOHau4uDgFBATI19dXzz33nKKioq77JBYAALi51Oiw88MPP2jIkCE6e/asmjRpou7du2v37t1q0qSJJOmdd96Rm5ubBg0apKKiIsXExOjDDz90cdUAAKAmqdFhZ+XKlddtr1OnjubPn6/58+ffoIoAAEBtU6vu2QEAAHAUYQcAAJhajb6MhV9J/9I543R+1jnjAABQS3BmBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmJppws78+fPVvHlz1alTR926ddPevXtdXRIAAKgBPFxdgDN8/PHHiouL08KFC9WtWze9++67iomJUXp6ugIDA11dnlOc+PGiq0sAAKBWshiGYbi6iKrq1q2b7rjjDn3wwQeSpNLSUoWGhuq5557T1KlTf/f7+fn58vPzU15ennx9fZ1aW9wH9zt1vKpq3f0xp4zzbOdnnTIOAACVVdG/37X+zE5xcbFSU1MVHx9v2+bm5qbo6GilpKSU+52ioiIVFRXZ1vPy8iT98o/mbEU/X3H6mFXx84HPnTJOfsthThln0cFFThlnXOQ4p4wDAKg9rv7d/r3zNrU+7PznP/9RSUmJgoKC7LYHBQXp2LFj5X4nISFBM2fOLLM9NDS0Wmo0oxfG+Lm6BDsv6AVXlwAAcJELFy7Iz+/af5dqfdipjPj4eMXFxdnWS0tLde7cOTVq1EgWi8Vp+8nPz1doaKhOnTrl9MtjNYXZ58j8aj+zz5H51X5mn2N1zs8wDF24cEEhISHX7Vfrw07jxo3l7u6uM2fO2G0/c+aMrFZrud/x9vaWt7e33TZ/f//qKlG+vr6m/A/418w+R+ZX+5l9jsyv9jP7HKtrftc7o3NVrX/03MvLS127dtWWLVts20pLS7VlyxZFRUW5sDIAAFAT1PozO5IUFxenkSNH6vbbb9edd96pd999VwUFBRo9erSrSwMAAC5mirDzxBNP6Mcff9S0adOUk5Ojzp07a/369WVuWr7RvL29NX369DKXzMzE7HNkfrWf2efI/Go/s8+xJszPFO/ZAQAAuJZaf88OAADA9RB2AACAqRF2AACAqRF2AACAqRF2qtH8+fPVvHlz1alTR926ddPevXtdXZJTzJgxQxaLxW5p166dq8uqkh07dqh///4KCQmRxWLRmjVr7NoNw9C0adMUHBysunXrKjo6WsePH3dNsZXwe/MbNWpUmWPap08f1xRbCQkJCbrjjjvUoEEDBQYG6pFHHlF6erpdn8LCQsXGxqpRo0by8fHRoEGDyryMtKaqyPx69uxZ5hg+88wzLqrYcQsWLFBkZKTtxXNRUVH68ssvbe21+fhJvz+/2n78fmvOnDmyWCyaNGmSbZsrjyFhp5p8/PHHiouL0/Tp0/X111+rU6dOiomJUW5urqtLc4oOHTooOzvbtuzcudPVJVVJQUGBOnXqpPnz55fbPnfuXM2bN08LFy7Unj17VL9+fcXExKiwsPAGV1o5vzc/SerTp4/dMf3nP/95AyusmuTkZMXGxmr37t3atGmTLl++rN69e6ugoMDWZ/LkyVq7dq1WrVql5ORknT59WgMHDnRh1RVXkflJ0rhx4+yO4dy5c11UseOaNm2qOXPmKDU1Vfv379cDDzygAQMG6PDhw5Jq9/GTfn9+Uu0+fr+2b98+/e1vf1NkZKTddpceQwPV4s477zRiY2Nt6yUlJUZISIiRkJDgwqqcY/r06UanTp1cXUa1kWSsXr3atl5aWmpYrVbjzTfftG07f/684e3tbfzzn/90QYVV89v5GYZhjBw50hgwYIBL6qkOubm5hiQjOTnZMIxfjpenp6exatUqW5+jR48akoyUlBRXlVlpv52fYRjGfffdZ0ycONF1RVWDhg0bGv/93/9tuuN31dX5GYZ5jt+FCxeMNm3aGJs2bbKbk6uPIWd2qkFxcbFSU1MVHR1t2+bm5qbo6GilpKS4sDLnOX78uEJCQtSyZUsNHTpUWVlZri6p2mRmZionJ8fuePr5+albt26mOZ6StH37dgUGBqpt27YaP368zp496+qSKi0vL0+SFBAQIElKTU3V5cuX7Y5hu3bt1KxZs1p5DH87v6uWL1+uxo0bKyIiQvHx8bp06ZIryquykpISrVy5UgUFBYqKijLd8fvt/K4yw/GLjY1Vv3797I6V5Pr/B03xBuWa5j//+Y9KSkrKvME5KChIx44dc1FVztOtWzclJiaqbdu2ys7O1syZM3Xvvffq22+/VYMGDVxdntPl5ORIUrnH82pbbdenTx8NHDhQLVq0UEZGhv785z+rb9++SklJkbu7u6vLc0hpaakmTZqke+65RxEREZJ+OYZeXl5lfvC3Nh7D8uYnSU8++aTCwsIUEhKigwcPasqUKUpPT1dSUpILq3XMoUOHFBUVpcLCQvn4+Gj16tUKDw9XWlqaKY7fteYnmeP4rVy5Ul9//bX27dtXps3V/w8SduCwvn372j5HRkaqW7duCgsL0yeffKKxY8e6sDJU1uDBg22fO3bsqMjISLVq1Urbt29Xr169XFiZ42JjY/Xtt9/W+vvIruVa83vqqadsnzt27Kjg4GD16tVLGRkZatWq1Y0us1Latm2rtLQ05eXl6V//+pdGjhyp5ORkV5flNNeaX3h4eK0/fqdOndLEiRO1adMm1alTx9XllMFlrGrQuHFjubu7l7nL/MyZM7JarS6qqvr4+/vr1ltv1YkTJ1xdSrW4esxuluMpSS1btlTjxo1r3TGdMGGC1q1bp23btqlp06a27VarVcXFxTp//rxd/9p2DK81v/J069ZNkmrVMfTy8lLr1q3VtWtXJSQkqFOnTnrvvfdMc/yuNb/y1Lbjl5qaqtzcXHXp0kUeHh7y8PBQcnKy5s2bJw8PDwUFBbn0GBJ2qoGXl5e6du2qLVu22LaVlpZqy5YtdtdnzeLixYvKyMhQcHCwq0upFi1atJDVarU7nvn5+dqzZ48pj6ck/fDDDzp79mytOaaGYWjChAlavXq1tm7dqhYtWti1d+3aVZ6ennbHMD09XVlZWbXiGP7e/MqTlpYmSbXmGJantLRURUVFtf74XcvV+ZWnth2/Xr166dChQ0pLS7Mtt99+u4YOHWr77NJjWO23QN+kVq5caXh7exuJiYnGkSNHjKeeesrw9/c3cnJyXF1alf3pT38ytm/fbmRmZhpfffWVER0dbTRu3NjIzc11dWmVduHCBePAgQPGgQMHDEnG22+/bRw4cMA4efKkYRiGMWfOHMPf39/47LPPjIMHDxoDBgwwWrRoYfz8888urrxirje/CxcuGC+88IKRkpJiZGZmGps3bza6dOlitGnTxigsLHR16RUyfvx4w8/Pz9i+fbuRnZ1tWy5dumTr88wzzxjNmjUztm7dauzfv9+IiooyoqKiXFh1xf3e/E6cOGHMmjXL2L9/v5GZmWl89tlnRsuWLY0ePXq4uPKKmzp1qpGcnGxkZmYaBw8eNKZOnWpYLBZj48aNhmHU7uNnGNefnxmOX3l++4SZK48hYacavf/++0azZs0MLy8v48477zR2797t6pKc4oknnjCCg4MNLy8v45ZbbjGeeOIJ48SJE64uq0q2bdtmSCqzjBw50jCMXx4/f+WVV4ygoCDD29vb6NWrl5Genu7aoh1wvfldunTJ6N27t9GkSRPD09PTCAsLM8aNG1ergnl5c5NkLF261Nbn559/Np599lmjYcOGRr169YxHH33UyM7Odl3RDvi9+WVlZRk9evQwAgICDG9vb6N169bGiy++aOTl5bm2cAeMGTPGCAsLM7y8vIwmTZoYvXr1sgUdw6jdx88wrj8/Mxy/8vw27LjyGFoMwzCq//wRAACAa3DPDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgBT6tmzpyZNmnTdPomJifL393do3ObNm+vdd9+tdF0AbjzCDnATGDVqlCwWi5555pkybbGxsbJYLBo1atSNL+xXli1bpu7du5fbVplQkpSUpFdffdW2Xl5IeeKJJ/Tdd985Wup1zZgxQxaLRX369CnT9uabb8pisahnz55l2n744Qd5eXkpIiKi3HGTk5P1wAMPKCAgQPXq1VObNm00cuRIFRcX2/osWrRInTp1ko+Pj/z9/XXbbbcpISHBaXMDaivCDnCTCA0N1cqVK/Xzzz/bthUWFmrFihVq1qyZCyv7xWeffab/+q//ctp4AQEBatCgwXX71K1bV4GBgU7b51XBwcHatm2bfvjhB7vtS5Ysuea/dWJioh5//HHl5+drz549dm1HjhxRnz59dPvtt2vHjh06dOiQ3n//fXl5eamkpMQ29qRJk/T8888rLS1NX331lV566SVdvHjR6fMDahvCDnCT6NKli0JDQ5WUlGTblpSUpGbNmum2226z67t+/Xp1795d/v7+atSokR5++GFlZGTY2ouLizVhwgQFBwerTp06CgsLs51BMAxDM2bMULNmzeTt7a2QkBA9//zz162tsLBQGzdurHDYmTFjhjp37qz/+Z//UfPmzeXn56fBgwfrwoULtj6/vozVs2dPnTx5UpMnT5bFYpHFYpFU9oxRRkaGBgwYoKCgIPn4+OiOO+7Q5s2bK1TTrwUGBqp3795atmyZbduuXbv0n//8R/369SvT3zAMLV26VMOHD9eTTz6pxYsX27Vv3LhRVqtVc+fOVUREhFq1aqU+ffpo0aJFqlu3riTp888/1+OPP66xY8eqdevW6tChg4YMGaLXX3/d4foBsyHsADeRMWPGaOnSpbb1JUuWaPTo0WX6FRQUKC4uTvv379eWLVvk5uamRx99VKWlpZKkefPm6fPPP9cnn3yi9PR0LV++XM2bN5ckffrpp3rnnXf0t7/9TcePH9eaNWvUsWPH69a1ZcsW3XLLLWrXrl2F55KRkaE1a9Zo3bp1WrdunZKTkzVnzpxy+yYlJalp06aaNWuWsrOzlZ2dXW6/ixcv6qGHHtKWLVt04MAB9enTR/3791dWVlaF67pqzJgxSkxMtK0vWbJEQ4cOlZeXV5m+27Zt06VLlxQdHa1hw4Zp5cqVKigosLVbrVZlZ2drx44d19yf1WrV7t27dfLkSYdrBcyOsAPcRIYNG6adO3fq5MmTOnnypL766isNGzasTL9BgwZp4MCBat26tTp37qwlS5bo0KFDOnLkiCQpKytLbdq0Uffu3RUWFqbu3btryJAhtjar1aro6Gg1a9ZMd955p8aNG3fduipzCau0tFSJiYmKiIjQvffeq+HDh2vLli3l9g0ICJC7u7saNGggq9Uqq9Vabr9OnTrp6aefVkREhNq0aaNXX31VrVq10ueff+5QbZL08MMPKz8/Xzt27FBBQYE++eQTjRkzpty+ixcv1uDBg+Xu7q6IiAi1bNlSq1atsrU/9thjGjJkiO677z4FBwfr0Ucf1QcffKD8/Hxbn+nTp8vf31/NmzdX27ZtNWrUKH3yySe2gArczAg7wE2kSZMm6tevnxITE7V06VL169dPjRs3LtPv+PHjGjJkiFq2bClfX1/bWZurZzhGjRqltLQ0tW3bVs8//7w2btxo++5jjz2mn3/+WS1bttS4ceO0evVqXbly5Zo1GYahtWvXOhx2mjdvbndPTnBwsHJzcx0a47cuXryoF154Qe3bt5e/v798fHx09OjRSp3Z8fT01LBhw7R06VKtWrVKt956qyIjI8v0O3/+vJKSkuxC57Bhw+wuZbm7u2vp0qX64YcfNHfuXN1yyy2aPXu2OnToYDtLFRwcrJSUFB06dEgTJ07UlStXNHLkSPXp04fAg5seYQe4yVy9vLJs2bJrnmno37+/zp07p0WLFmnPnj22G2avPvnTpUsXZWZm6tVXX9XPP/+sxx9/XH/4wx8k/XIjdHp6uj788EPVrVtXzz77rHr06KHLly+Xu6+9e/fqypUruvvuux2ah6enp926xWKp8h/1F154QatXr9bs2bP173//W2lpaerYsaPdE0+OGDNmjFatWqX58+df8996xYoVKiwsVLdu3eTh4SEPDw9NmTJFO3fuLPOk2C233KLhw4frgw8+0OHDh1VYWKiFCxfa9YmIiNCzzz6rf/zjH9q0aZM2bdqk5OTkStUPmAVhB7jJ9OnTR8XFxbp8+bJiYmLKtJ89e1bp6el6+eWX1atXL7Vv314//fRTmX6+vr564okntGjRIn388cf69NNPde7cOUm/POXUv39/zZs3T9u3b7edcSjPZ599pn79+snd3d25E/2NXz+5dC1fffWVRo0apUcffVQdO3aU1WrV999/X+l9dujQQR06dNC3336rJ598stw+ixcv1p/+9CelpaXZlm+++Ub33nuvlixZcs2xGzZsqODgYLt7e34rPDxckq7bB7gZeLi6AAA3lru7u44ePWr7/FsNGzZUo0aN9Pe//13BwcHKysrS1KlT7fq8/fbbCg4O1m233SY3NzetWrVKVqtV/v7+SkxMVElJibp166Z69erpH//4h+rWrauwsLBy6/n88881a9Ys50/0N5o3b64dO3Zo8ODB8vb2LvfyXZs2bZSUlKT+/fvLYrHolVdeqfLZoq1bt+ry5cvlvicoLS1NX3/9tZYvX17m5uwhQ4Zo1qxZeu2117R48WKlpaXp0UcfVatWrVRYWKiPPvpIhw8f1vvvvy9JGj9+vEJCQvTAAw+oadOmys7O1muvvaYmTZooKiqqSnMAajvO7AA3IV9fX/n6+pbb5ubmppUrVyo1NVURERGaPHmy3nzzTbs+DRo00Ny5c3X77bfrjjvu0Pfff68vvvhCbm5u8vf316JFi3TPPfcoMjJSmzdv1tq1a9WoUaMy+8rIyNCJEyfKPcPkbLNmzdL333+vVq1aqUmTJuX2efvtt9WwYUPdfffd6t+/v2JiYtSlS5cq7bd+/frXfCHi4sWLFR4eXu5TaI8++qhyc3P1xRdf6M4779TFixf1zDPPqEOHDrrvvvu0e/durVmzRvfdd58kKTo6Wrt379Zjjz2mW2+9VYMGDVKdOnW0ZcuWcv/tgZuJxTAMw9VFALg5vf3229q8ebO++OILV5cCwMQ4swPAZZo2bar4+HhXlwHA5DizAwAATI0zOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNT+P5QmO5kqyB3lAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Visualizing the Mass Distribution at Different Stages\n", "\n", diff --git a/docs/examples/lagrangian/testing_times.py b/docs/examples/lagrangian/testing_times.py index 47ee57915..49cf7b098 100644 --- a/docs/examples/lagrangian/testing_times.py +++ b/docs/examples/lagrangian/testing_times.py @@ -5,7 +5,6 @@ import torch import numpy as np import matplotlib.pyplot as plt -from tqdm import tqdm from particula.lagrangian import boundary, integration, collisions, particle_property, particle_pairs # Initializing the Torch Generator and setting the data type @@ -14,13 +13,12 @@ # %% # Setting up the Simulation Parameters and Initial Conditions -progress_bar = True # Define fixed parameters TOTAL_NUMBER_OF_PARTICLES = 500 TIME_STEP = 0.01 -SIMULATION_TIME = 1000 +SIMULATION_TIME = 100 MASS = 3 -CUBE_SIDE = 50 +CUBE_SIDE = 100 speed = 1 save_points = 50 @@ -76,6 +74,11 @@ valid_collision_indices_pairs = particle_pairs.full_sweep_and_prune( position=position, radius=radius) + # check 3d distance for collision pairs + detla_position = position.unsqueeze(2) - position.unsqueeze(1) + # Compute pairwise Euclidean distances + distance = torch.sqrt(torch.sum(detla_position**2, dim=0)) + if valid_collision_indices_pairs.shape[0] > 0: # Coalesce particles that have collided and update their velocity and mass velocity, mass = collisions.coalescence( From bd462fc4707c6fe507f69750d6430c8218ce0a29 Mon Sep 17 00:00:00 2001 From: Kyle Gorkowski Date: Thu, 30 Nov 2023 12:08:34 -0700 Subject: [PATCH 07/11] added collison validation check, and test update Fixes #411 --- .../lagrangian/basic_lagrangian_box.ipynb | 2610 +---------------- docs/examples/lagrangian/testing_times.py | 45 +- particula/lagrangian/boundary.py | 16 +- particula/lagrangian/collisions.py | 16 + particula/lagrangian/particle_pairs.py | 25 + particula/lagrangian/tests/collisions_test.py | 11 +- 6 files changed, 126 insertions(+), 2597 deletions(-) diff --git a/docs/examples/lagrangian/basic_lagrangian_box.ipynb b/docs/examples/lagrangian/basic_lagrangian_box.ipynb index b02770d95..5cecf6287 100644 --- a/docs/examples/lagrangian/basic_lagrangian_box.ipynb +++ b/docs/examples/lagrangian/basic_lagrangian_box.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -50,19 +50,19 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Setting up the Simulation Parameters and Initial Conditions\n", "\n", "# Define fixed parameters\n", - "TOTAL_NUMBER_OF_PARTICLES = 500\n", + "TOTAL_NUMBER_OF_PARTICLES = 200\n", "TIME_STEP = 0.01\n", "SIMULATION_TIME = 100\n", "MASS = 3\n", - "CUBE_SIDE = 100\n", - "speed = 1\n", + "CUBE_SIDE = 50\n", + "speed = 10\n", "save_points = 50\n", "\n", "# Initialize particle positions randomly within the cube\n", @@ -107,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -141,2571 +141,15 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n", - "Error in collision detection\n" - ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[1;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "\u001b[1;32mc:\\Users\\kkgor\\OneDrive\\Areas\\GitHub\\particula\\docs\\examples\\lagrangian\\basic_lagrangian_box.ipynb Cell 8\u001b[0m line \u001b[0;36m3\n\u001b[0;32m 27\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mError in collision detection\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m 29\u001b[0m \u001b[39m# Coalesce particles that have collided and update their velocity and mass\u001b[39;00m\n\u001b[1;32m---> 30\u001b[0m velocity, mass \u001b[39m=\u001b[39m collisions\u001b[39m.\u001b[39;49mcoalescence(\n\u001b[0;32m 31\u001b[0m velocity\u001b[39m=\u001b[39;49mvelocity, mass\u001b[39m=\u001b[39;49mmass, collision_indices_pairs\u001b[39m=\u001b[39;49mvalid_collision_indices_pairs)\n\u001b[0;32m 33\u001b[0m \u001b[39m# Calculate the force acting on the particles (e.g., gravity)\u001b[39;00m\n\u001b[0;32m 34\u001b[0m force \u001b[39m=\u001b[39m mass \u001b[39m*\u001b[39m gravity\n", - "File \u001b[1;32m~\\OneDrive\\Areas\\GitHub\\particula\\particula\\lagrangian\\collisions.py:104\u001b[0m, in \u001b[0;36mcoalescence\u001b[1;34m(velocity, mass, collision_indices_pairs)\u001b[0m\n\u001b[0;32m 102\u001b[0m sorted_pairs, _ \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39msort(collision_indices_pairs, dim\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m)\n\u001b[0;32m 103\u001b[0m unique_left_indices \u001b[39m=\u001b[39m particle_pairs\u001b[39m.\u001b[39mremove_duplicates(sorted_pairs, \u001b[39m0\u001b[39m)\n\u001b[1;32m--> 104\u001b[0m unique_indices \u001b[39m=\u001b[39m particle_pairs\u001b[39m.\u001b[39;49mremove_duplicates(unique_left_indices, \u001b[39m1\u001b[39;49m)\n\u001b[0;32m 106\u001b[0m \u001b[39m# Update velocities based on conservation of momentum\u001b[39;00m\n\u001b[0;32m 107\u001b[0m total_mass \u001b[39m=\u001b[39m mass[unique_indices[:, \u001b[39m0\u001b[39m]] \u001b[39m+\u001b[39m mass[unique_indices[:, \u001b[39m1\u001b[39m]]\n", - "File \u001b[1;32m~\\OneDrive\\Areas\\GitHub\\particula\\particula\\lagrangian\\particle_pairs.py:36\u001b[0m, in \u001b[0;36mremove_duplicates\u001b[1;34m(index_pairs, index_to_remove)\u001b[0m\n\u001b[0;32m 11\u001b[0m \u001b[39m\u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 12\u001b[0m \u001b[39mRemoves duplicate entries from a specified column in a tensor of index\u001b[39;00m\n\u001b[0;32m 13\u001b[0m \u001b[39mpairs.\u001b[39;00m\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m 33\u001b[0m \u001b[39m duplicates.\u001b[39;00m\n\u001b[0;32m 34\u001b[0m \u001b[39m\"\"\"\u001b[39;00m\n\u001b[0;32m 35\u001b[0m \u001b[39m# Sort index_pairs by the index_to_remove column\u001b[39;00m\n\u001b[1;32m---> 36\u001b[0m sorted_index_pairs, indices_sorted \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39;49msort(\n\u001b[0;32m 37\u001b[0m index_pairs[:, index_to_remove], dim\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m)\n\u001b[0;32m 39\u001b[0m \u001b[39m# Find unique entries in the index_to_remove column\u001b[39;00m\n\u001b[0;32m 40\u001b[0m \u001b[39m# diff_index is True for unique entries\u001b[39;00m\n\u001b[0;32m 41\u001b[0m diff_index \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mdiff(sorted_index_pairs, prepend\u001b[39m=\u001b[39mtorch\u001b[39m.\u001b[39mtensor([\u001b[39m-\u001b[39m\u001b[39m1\u001b[39m])) \u001b[39m>\u001b[39m \u001b[39m0\u001b[39m\n", - "\u001b[1;31mKeyboardInterrupt\u001b[0m: " + "Total wall time: 13.365594625473022 seconds\n", + "Ratio of wall time to simulation time: 0.13365594625473023\n" ] } ], @@ -2730,9 +174,14 @@ " valid_collision_indices_pairs = collisions.find_collisions(\n", " distance_matrix=distance_matrix, indices=indices, mass=mass)\n", "\n", - " # Coalesce particles that have collided and update their velocity and mass\n", + " # Validate and coalesce particles that have collided and update their velocity and mass\n", " velocity, mass = collisions.coalescence(\n", - " velocity=velocity, mass=mass, collision_indices_pairs=valid_collision_indices_pairs)\n", + " velocity=velocity,\n", + " position=position,\n", + " mass=mass,\n", + " radius=radius,\n", + " collision_indices_pairs=valid_collision_indices_pairs\n", + " )\n", "\n", " # Calculate the force acting on the particles (e.g., gravity)\n", " force = mass * gravity\n", @@ -2771,19 +220,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Number of particles at the end: 417\n" + "Number of particles at the end: 29\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2852,12 +301,12 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2873,14 +322,17 @@ "fig = plt.figure()\n", "ax = fig.add_subplot()\n", "\n", - "# Plot histograms of mass distribution at different stages\n", "# Normalizing by initial MASS to observe distribution changes\n", - "ax.hist(save_mass[filter_zero_mass, 0] / MASS, bins=25,\n", - " alpha=0.8, label='Initial', range=(0, 40))\n", - "ax.hist(save_mass[filter_zero_mass, 24] / MASS, bins=25,\n", - " alpha=0.6, label='Middle', range=(0, 40))\n", - "ax.hist(save_mass[filter_zero_mass, -1] / MASS, bins=25,\n", - " alpha=0.5, label='Final', range=(0, 40))\n", + "normalized_mass = save_mass[filter_zero_mass, :] / MASS\n", + "max_mass = normalized_mass.max()\n", + "\n", + "# Plot histograms of mass distribution at different stages\n", + "ax.hist(normalized_mass[:, 0], bins=25,\n", + " alpha=0.8, label='Initial', range=(0, max_mass))\n", + "ax.hist(normalized_mass[:, 24], bins=25,\n", + " alpha=0.6, label='Middle', range=(0, max_mass))\n", + "ax.hist(normalized_mass[:, -1], bins=25,\n", + " alpha=0.5, label='Final', range=(0, max_mass))\n", "\n", "# Setting labels and title for the plot\n", "ax.set_xlabel('Mass / Initial MASS')\n", diff --git a/docs/examples/lagrangian/testing_times.py b/docs/examples/lagrangian/testing_times.py index 49cf7b098..2e147b4bc 100644 --- a/docs/examples/lagrangian/testing_times.py +++ b/docs/examples/lagrangian/testing_times.py @@ -14,12 +14,12 @@ # %% # Setting up the Simulation Parameters and Initial Conditions # Define fixed parameters -TOTAL_NUMBER_OF_PARTICLES = 500 +TOTAL_NUMBER_OF_PARTICLES = 1000 TIME_STEP = 0.01 SIMULATION_TIME = 100 MASS = 3 -CUBE_SIDE = 100 -speed = 1 +CUBE_SIDE = 50 +speed = 10 save_points = 50 # Initialize particle positions randomly within the cube @@ -74,15 +74,26 @@ valid_collision_indices_pairs = particle_pairs.full_sweep_and_prune( position=position, radius=radius) - # check 3d distance for collision pairs - detla_position = position.unsqueeze(2) - position.unsqueeze(1) - # Compute pairwise Euclidean distances - distance = torch.sqrt(torch.sum(detla_position**2, dim=0)) + # if valid_collision_indices_pairs.shape[0] > 0: + # # check 3d distance for collision pairs + # detla_position = position[:, valid_collision_indices_pairs[:, 0]] - \ + # position[:, valid_collision_indices_pairs[:, 1]] + # # Compute pairwise Euclidean distances + # distance = torch.sqrt(torch.sum(detla_position**2, dim=0)) + # distance_threshold = radius[valid_collision_indices_pairs[:, 0]] + \ + # radius[valid_collision_indices_pairs[:, 1]] + # # Check for collisions + # valid_collision_indices_pairs_final = valid_collision_indices_pairs[distance < distance_threshold] + # else: + # valid_collision_indices_pairs_final = torch.tensor([], dtype=torch.int64) if valid_collision_indices_pairs.shape[0] > 0: # Coalesce particles that have collided and update their velocity and mass velocity, mass = collisions.coalescence( - velocity=velocity, mass=mass, + position=position, + velocity=velocity, + mass=mass, + radius=radius, collision_indices_pairs=valid_collision_indices_pairs) # Calculate the force acting on the particles (e.g., gravity) @@ -114,7 +125,7 @@ # Processing the Final Data for Visualization # Select the final time index for the data -time_index = -1 +time_index = -2 position_final = save_position[:, :, time_index] mass_final = save_mass[:, time_index] @@ -167,15 +178,17 @@ # Create a new figure for the histogram fig = plt.figure() ax = fig.add_subplot() +# Normalizing by initial MASS to observe distribution changes +normalized_mass = save_mass[filter_zero_mass, :] / MASS +max_mass = normalized_mass.max() # Plot histograms of mass distribution at different stages -# Normalizing by initial MASS to observe distribution changes -ax.hist(save_mass[filter_zero_mass, 0] / MASS, bins=25, - alpha=0.8, label='Initial', range=(0, 60)) -ax.hist(save_mass[filter_zero_mass, 24] / MASS, bins=25, - alpha=0.6, label='Middle', range=(0, 60)) -ax.hist(save_mass[filter_zero_mass, -1] / MASS, bins=25, - alpha=0.5, label='Final', range=(0, 60)) +ax.hist(normalized_mass[:, 0], bins=25, + alpha=0.8, label='Initial', range=(0, max_mass)) +ax.hist(normalized_mass[:, 24], bins=25, + alpha=0.6, label='Middle', range=(0, max_mass)) +ax.hist(normalized_mass[:, -1], bins=25, + alpha=0.5, label='Final', range=(0, max_mass)) # Setting labels and title for the plot ax.set_xlabel('Mass / Initial MASS') diff --git a/particula/lagrangian/boundary.py b/particula/lagrangian/boundary.py index 13d4a98a9..8c988080f 100644 --- a/particula/lagrangian/boundary.py +++ b/particula/lagrangian/boundary.py @@ -11,7 +11,8 @@ def wrapped_cube( This function modifies positions that exceed the cubic domain side, wrapping them around to the opposite side of the domain. It handles both positive and negative overflows. The center of the cube is assumed to be - at zero. + at zero. If a particle is way outside the cube, it is wrapped around to + the opposite side of the cube. Parameters: - position (torch.Tensor): A tensor representing positions that might @@ -40,4 +41,17 @@ def wrapped_cube( position < -half_cube_side, position + cube_side, position) + + # Wrap around for very large positive overflow + position = torch.where( + position > half_cube_side, + -half_cube_side, + position) + + # Wrap around for very large negative overflow + position = torch.where( + position < -half_cube_side, + half_cube_side, + position) + return position diff --git a/particula/lagrangian/collisions.py b/particula/lagrangian/collisions.py index b170f1123..f8bc0bb58 100644 --- a/particula/lagrangian/collisions.py +++ b/particula/lagrangian/collisions.py @@ -67,8 +67,10 @@ def find_collisions( def coalescence( + position: torch.Tensor, velocity: torch.Tensor, mass: torch.Tensor, + radius: torch.Tensor, collision_indices_pairs: torch.Tensor, ) -> Tuple[torch.Tensor, torch.Tensor]: """ @@ -80,9 +82,12 @@ def coalescence( according to the conservation of mass and momentum. Parameters: + position (torch.Tensor): A 2D tensor of shape [n_dimensions, n_particles] + representing the positions of particles. velocity (torch.Tensor): A 2D tensor of shape [n_dimensions, n_particles] representing the velocities of particles. mass (torch.Tensor): A 1D tensor containing the mass of each particle. + radius (torch.Tensor): A 1D tensor containing the radius of each particle. collision_indices_pairs (torch.Tensor): A 2D tensor containing pairs of indices representing colliding particles. remove_duplicates_func (function): A function to remove duplicate entries @@ -102,6 +107,17 @@ def coalescence( sorted_pairs, _ = torch.sort(collision_indices_pairs, dim=1) unique_left_indices = particle_pairs.remove_duplicates(sorted_pairs, 0) unique_indices = particle_pairs.remove_duplicates(unique_left_indices, 1) + # fast return if no collisions + if unique_indices.shape[0] == 0: + return velocity, mass + unique_indices = particle_pairs.validate_pair_distance( + collision_indices_pairs=unique_indices, + position=position, + radius=radius, + ) + # fast return if no collisions + if unique_indices.shape[0] == 0: + return velocity, mass # Update velocities based on conservation of momentum total_mass = mass[unique_indices[:, 0]] + mass[unique_indices[:, 1]] diff --git a/particula/lagrangian/particle_pairs.py b/particula/lagrangian/particle_pairs.py index 69a4bd26a..a05c85bc1 100644 --- a/particula/lagrangian/particle_pairs.py +++ b/particula/lagrangian/particle_pairs.py @@ -76,6 +76,31 @@ def calculate_pairwise_distance(position: torch.Tensor) -> torch.Tensor: return torch.sqrt(torch.sum(detla_position**2, dim=0)) +def validate_pair_distance( + collision_indices_pairs: torch.Tensor, + position: torch.Tensor, + radius: torch.Tensor +) -> torch.Tensor: + """ + need to test this: + Calculate if the pairwise Euclidean distances between points in a given + position tensor is smaller than the sum of the radius of the particles. + """ + # Fast return if there are no particles + if collision_indices_pairs.shape[0] == 0: + return torch.tensor([]) + + # check 3d distance for collision pairs + detla_position = position[:, collision_indices_pairs[:, 0]] - \ + position[:, collision_indices_pairs[:, 1]] + # Compute pairwise Euclidean distances + distance = torch.sqrt(torch.sum(detla_position**2, dim=0)) + distance_threshold = radius[collision_indices_pairs[:, 0]] + \ + radius[collision_indices_pairs[:, 1]] + # Check and return collision pairs + return collision_indices_pairs[distance < distance_threshold] + + def single_axis_sweep_and_prune( position_axis: torch.Tensor, radius: torch.Tensor diff --git a/particula/lagrangian/tests/collisions_test.py b/particula/lagrangian/tests/collisions_test.py index 120f85872..c05ba7a7e 100644 --- a/particula/lagrangian/tests/collisions_test.py +++ b/particula/lagrangian/tests/collisions_test.py @@ -23,6 +23,11 @@ def test_coalescence(): [7.0, 8.0, 9.0], [0.0, 0.0, 0.0]]).T mass = torch.tensor([1.0, 2.0, 3.0, 1.0]) + radius = torch.tensor([1.0, 2.0, 0.5, 0.5]) + position = torch.tensor([[1.0, 1.0, 2.0], + [1.0, 1.0, 3.0], + [7.0, 8.0, 9.0], + [0.0, 0.0, 0.0]]).T collision_indices_pairs = torch.tensor([[0, 1]], dtype=torch.int32) expected_velocity = torch.tensor([[1.0, 2.0, 5.0], [0.0, 0.0, 0.0], @@ -30,6 +35,10 @@ def test_coalescence(): [0.0, 0.0, 0.0]]).T expected_mass = torch.tensor([3.0, 0.0, 3.0, 1.0]) result_velocity, result_mass = collisions.coalescence( - velocity, mass, collision_indices_pairs) + position=position, + velocity=velocity, + mass=mass, + radius=radius, + collision_indices_pairs=collision_indices_pairs) assert torch.allclose(result_mass, expected_mass, atol=1e-4) assert torch.allclose(result_velocity, expected_velocity, atol=1e-4) From 14276c1afb2945e10b9d16fa03309af3ca0d646b Mon Sep 17 00:00:00 2001 From: Kyle Gorkowski Date: Thu, 30 Nov 2023 12:58:31 -0700 Subject: [PATCH 08/11] updated example --- docs/_toc.yml | 1 + .../lagrangian/basic_lagrangian_box.ipynb | 43 +- .../examples/lagrangian/sweep_and_prune.ipynb | 396 ++++++++++++++++++ docs/examples/lagrangian/testing_times.py | 207 --------- 4 files changed, 419 insertions(+), 228 deletions(-) create mode 100644 docs/examples/lagrangian/sweep_and_prune.ipynb delete mode 100644 docs/examples/lagrangian/testing_times.py diff --git a/docs/_toc.yml b/docs/_toc.yml index ef85e06c7..52cb903d2 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -27,6 +27,7 @@ parts: - file: examples/lagrangian/lagrangian_intro sections: - file: examples/lagrangian/basic_lagrangian_box + - file: examples/lagrangian/sweep_and_prune - file: examples/equilibria/equilibria_intro sections: - file: examples/equilibria/activity_part1 diff --git a/docs/examples/lagrangian/basic_lagrangian_box.ipynb b/docs/examples/lagrangian/basic_lagrangian_box.ipynb index 5cecf6287..cb2997fc7 100644 --- a/docs/examples/lagrangian/basic_lagrangian_box.ipynb +++ b/docs/examples/lagrangian/basic_lagrangian_box.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -35,7 +35,7 @@ "from particula.lagrangian import boundary, integration, collisions, particle_property, particle_pairs\n", "\n", "# Initializing the Torch Generator and setting the data type\n", - "t_gen = torch.Generator()\n", + "torch.manual_seed(1234) # Set the seed for reproducibility\n", "t_type = torch.float32" ] }, @@ -50,19 +50,19 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Setting up the Simulation Parameters and Initial Conditions\n", "\n", "# Define fixed parameters\n", - "TOTAL_NUMBER_OF_PARTICLES = 200\n", + "TOTAL_NUMBER_OF_PARTICLES = 500\n", "TIME_STEP = 0.01\n", "SIMULATION_TIME = 100\n", "MASS = 3\n", "CUBE_SIDE = 50\n", - "speed = 10\n", + "speed = 5\n", "save_points = 50\n", "\n", "# Initialize particle positions randomly within the cube\n", @@ -107,7 +107,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -141,15 +141,15 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Total wall time: 13.365594625473022 seconds\n", - "Ratio of wall time to simulation time: 0.13365594625473023\n" + "Total wall time: 24.14953637123108 seconds\n", + "Ratio of wall time to simulation time: 0.24149536371231078\n" ] } ], @@ -174,14 +174,15 @@ " valid_collision_indices_pairs = collisions.find_collisions(\n", " distance_matrix=distance_matrix, indices=indices, mass=mass)\n", "\n", - " # Validate and coalesce particles that have collided and update their velocity and mass\n", - " velocity, mass = collisions.coalescence(\n", - " velocity=velocity,\n", - " position=position,\n", - " mass=mass,\n", - " radius=radius,\n", - " collision_indices_pairs=valid_collision_indices_pairs\n", - " )\n", + " if valid_collision_indices_pairs.shape[0] > 0:\n", + " # Coalesce particles that have collided and update their velocity and\n", + " # mass\n", + " velocity, mass = collisions.coalescence(\n", + " position=position,\n", + " velocity=velocity,\n", + " mass=mass,\n", + " radius=radius,\n", + " collision_indices_pairs=valid_collision_indices_pairs)\n", "\n", " # Calculate the force acting on the particles (e.g., gravity)\n", " force = mass * gravity\n", @@ -220,19 +221,19 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Number of particles at the end: 29\n" + "Number of particles at the end: 64\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -306,7 +307,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAGwCAYAAACzXI8XAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA7hUlEQVR4nO3de1hVZf7//9cGAVFOgiCQCHhOEU+l4SlLJzFjSq3MskTLDmKeOulMHmvU7NNJU5txFGwmh7LQ0m+jKSmmoaVJahkpg4dGlEYTFAUR1u+PLvcv4uDeuHGz8Pm4rnVd7LXufe/3vZdd+9W9ThbDMAwBAACYkIuzCwAAAKguggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADCtes4uoKaVlpbq+PHj8vb2lsVicXY5AADABoZh6OzZswoNDZWLS+XzLnU+yBw/flxhYWHOLgMAAFTDsWPH1LRp00q31/kg4+3tLenXL8LHx8fJ1QAAAFvk5+crLCzM+jteGacGmSVLlmjJkiU6fPiwJKl9+/aaPn26Bg4cKEkqLCzUM888o+TkZBUVFWnAgAFavHixmjRpYvNnXD6c5OPjQ5ABAMBkrnRaiFNP9m3atKnmzZun3bt3a9euXbr99tt1991367vvvpMkTZo0SWvXrtWqVauUlpam48ePa8iQIc4sGQAA1CKW2vbQSH9/f7366qu69957FRgYqJUrV+ree++VJP3www+68cYblZ6erltuucWm/vLz8+Xr66u8vDxmZAAAMAlbf79rzeXXJSUlSk5OVkFBgWJiYrR7924VFxerf//+1jZt27ZVs2bNlJ6eXmk/RUVFys/PL7MAAIC6yekn++7bt08xMTEqLCyUl5eXVq9erXbt2ikjI0Pu7u7y8/Mr075JkyY6ceJEpf3NnTtXs2bNquGqAQB1TUlJiYqLi51dxnXDzc1Nrq6uV92P04NMmzZtlJGRoby8PH344YcaOXKk0tLSqt3f1KlTNXnyZOvry2c9AwBQEcMwdOLECZ05c8bZpVx3/Pz8FBwcfFX3eXN6kHF3d1fLli0lSV27dtXXX3+tt956S8OGDdPFixd15syZMrMyJ0+eVHBwcKX9eXh4yMPDo6bLBgDUEZdDTFBQkBo0aMDNU68BwzB0/vx55ebmSpJCQkKq3ZfTg8zvlZaWqqioSF27dpWbm5tSU1M1dOhQSVJmZqaOHj2qmJgYJ1cJAKgLSkpKrCEmICDA2eVcVzw9PSVJubm5CgoKqvZhJqcGmalTp2rgwIFq1qyZzp49q5UrV2rLli3asGGDfH199eijj2ry5Mny9/eXj4+Pnn76acXExNh8xRIAAFW5fE5MgwYNnFzJ9eny915cXGzOIJObm6tHHnlEOTk58vX1VXR0tDZs2KA//OEPkqQ33nhDLi4uGjp0aJkb4gEA4EgcTnIOR3zvte4+Mo7GfWQAAJUpLCxUdna2IiMjVb9+fWeXc92p6vs33X1kAAAA7FXrTvYFAKA2iFu47Zp91tqne9X4Z1gsFq1evVr33HNPpW3i4+N15swZrVmzxqY+Dx8+rMjISO3Zs0edOnVySJ32IsgAAGBC9oaOnJwcNWrUSFLlAeStt96S2c44IcgAAHAdqOoebJf5+vpeg0oci3NkAAAwub59+2r8+PF6/vnn5e/vr+DgYM2cObNMG4vFYp29iYyMlCR17txZFotFffv2lfTrLM9vDz2tX79evXr1kp+fnwICAnTXXXcpKyvrGozIdszIXAVHHT+9FsdGAQB124oVKzR58mTt3LlT6enpio+PV8+ePa23NPmtr776St26ddOmTZvUvn17ubu7V9hnQUGBJk+erOjoaJ07d07Tp0/X4MGDlZGRIReX2jEXQpABAKAOiI6O1owZMyRJrVq10ttvv63U1NQKg0xgYKAkKSAgoMpDTpfvrH/Z8uXLFRgYqO+//15RUVEOrL76akecAgAAVyU6OrrM65CQEOuzjKrr4MGDGj58uJo3by4fHx9FRERIko4ePXpV/ToSMzIAANQBbm5uZV5bLBaVlpZeVZ9xcXEKDw/X0qVLFRoaqtLSUkVFRenixYtX1a8jEWQAALjOXD4npqSkpNI2p06dUmZmppYuXarevXtLkrZtu3b31rEVQQYAgOtMUFCQPD09tX79ejVt2lT169cvd+l1o0aNFBAQoL/97W8KCQnR0aNHNWXKFCdVXDmCDAAAFajLV5TWq1dPCxYs0OzZszV9+nT17t1bW7ZsKdPGxcVFycnJGj9+vKKiotSmTRstWLDAeql2bcFDI68Cl18DgLnx0Ejn4qGRAADgukaQAQAApkWQAQAApkWQAQAApkWQAQAApkWQAQAApkWQAQAApkWQAQAApkWQAQCgjuvbt68mTpxYZZuIiAi9+eabVbaxWCxas2aNJOnw4cOyWCzKyMhwSI3VxSMKAACoyNoJ1+6z4t6y+y3x8fFasWKFnnjiCb3zzjtltiUkJGjx4sUaOXKkkpKSlJKSUu7p2HUFMzIAAJhUWFiYkpOTdeHCBeu6wsJCrVy5Us2aNbOu8/f3l7e3tzNKrHEEGQAATKpLly4KCwtTSkqKdV1KSoqaNWumzp07W9f9/tBSbm6u4uLi5OnpqcjISL333nvl+j548KD69Omj+vXrq127dtq4ceMV69m/f78GDhwoLy8vNWnSRA8//LD+97//Xd0gr4AgAwCAiY0ePVqJiYnW18uXL9eoUaOqfE98fLyOHTumzZs368MPP9TixYuVm5tr3V5aWqohQ4bI3d1dO3fu1DvvvKMXXnihyj7PnDmj22+/XZ07d9auXbu0fv16nTx5Uvfff//VDfAKOEcGAAATGzFihKZOnaojR45IkrZv367k5GRt2bKlwvY//vij/v3vf+urr77SzTffLElatmyZbrzxRmubTZs26YcfftCGDRsUGhoqSZozZ44GDhxYaR1vv/22OnfurDlz5ljXLV++XGFhYfrxxx/VunXrqx1qhQgyAACYWGBgoAYNGqSkpCQZhqFBgwapcePGlbY/cOCA6tWrp65du1rXtW3bVn5+fmXahIWFWUOMJMXExFRZx7fffqvNmzfLy8ur3LasrCyCDAAAqNjo0aM1btw4SdKiRYucUsO5c+cUFxenV155pdy2kJCQGvtcggwAACYXGxurixcvymKxaMCAAVW2bdu2rS5duqTdu3dbDy1lZmbqzJkz1jY33nijjh07ppycHGsI2bFjR5X9dunSRR999JEiIiJUr961ixec7AsAgMm5urrqwIED+v777+Xq6lpl2zZt2ig2NlZPPPGEdu7cqd27d+uxxx6Tp6entU3//v3VunVrjRw5Ut9++62++OIL/fnPf66y34SEBJ0+fVrDhw/X119/raysLG3YsEGjRo1SSUmJQ8ZZEYIMAAB1gI+Pj3x8fGxqm5iYqNDQUN16660aMmSIHn/8cQUFBVm3u7i4aPXq1bpw4YK6deumxx57TH/5y1+q7DM0NFTbt29XSUmJ7rjjDnXo0EETJ06Un5+fXFxqLm5YDMMwaqz3WiA/P1++vr7Ky8uzeQfbKm7hNof0s/bpXg7pBwBgn8LCQmVnZysyMlL169d3djnXnaq+f1t/v5mRAQAApkWQAQAApkWQAQAApkWQAQAApkWQAQAApkWQAQAApkWQAQAApkWQAQAApkWQAQAApkWQAQCgDunbt68mTpzo0D5nzpypTp06ObRPR+Hp1wAAVGBxxuJr9lljO421+z3x8fFasWJFufU7d+7UjTfe6IiyTIEgAwCAScXGxioxMbHMusDAwCs+Absu4dASAAAm5eHhoeDg4DJLv379yhxaioiI0Jw5czR69Gh5e3urWbNm+tvf/lamnxdeeEGtW7dWgwYN1Lx5c02bNk3FxcXXeDTVQ5ABAKCOe+2113TTTTdpz549Gjt2rJ566illZmZat3t7eyspKUnff/+93nrrLS1dulRvvPGGEyu2HUEGAACTWrdunby8vKzLfffdV2G7O++8U2PHjlXLli31wgsvqHHjxtq8ebN1+4svvqgePXooIiJCcXFxevbZZ/XBBx9cq2FcFc6RAQDApG677TYtWbLE+rphw4YaPnx4uXbR0dHWvy0Wi4KDg5Wbm2td9/7772vBggXKysrSuXPndOnSJfn4+NRs8Q5CkAEAwKQaNmyoli1bXrGdm5tbmdcWi0WlpaWSpPT0dD300EOaNWuWBgwYIF9fXyUnJ+u1116rkZodzamHlubOnaubb75Z3t7eCgoK0j333FPmmJ306/XwFoulzPLkk086qWIAAOqWL7/8UuHh4frzn/+sm266Sa1atdKRI0ecXZbNnBpk0tLSlJCQoB07dmjjxo0qLi7WHXfcoYKCgjLtxowZo5ycHOsyf/58J1UMAEDd0qpVKx09elTJycnKysrSggULtHr1ameXZTOnHlpav359mddJSUkKCgrS7t271adPH+v6Bg0aKDg42KY+i4qKVFRUZH2dn5/vmGIBAKiD/vjHP2rSpEkaN26cioqKNGjQIE2bNk0zZ850dmk2sRiGYTi7iMsOHTqkVq1aad++fYqKipL066Gl7777ToZhKDg4WHFxcZo2bZoaNGhQYR8zZ87UrFmzyq3Py8tz+IlLcQu3OaSftU/3ckg/AAD7FBYWKjs7W5GRkapfv76zy7nuVPX95+fny9fX94q/37XmZN/S0lJNnDhRPXv2tIYYSXrwwQcVHh6u0NBQ7d27Vy+88IIyMzOVkpJSYT9Tp07V5MmTra/z8/MVFhZW4/UDAIBrr9YEmYSEBO3fv1/btpWd5Xj88cetf3fo0EEhISHq16+fsrKy1KJFi3L9eHh4yMPDo8brBQAAzlcrbog3btw4rVu3Tps3b1bTpk2rbNu9e3dJvx6GAgAA1zenzsgYhqGnn35aq1ev1pYtWxQZGXnF92RkZEiSQkJCarg6AABQ2zk1yCQkJGjlypX6+OOP5e3trRMnTkiSfH195enpqaysLK1cuVJ33nmnAgICtHfvXk2aNEl9+vQpc5dCAACuRi267uW64ojv3alB5vJtlfv27VtmfWJiouLj4+Xu7q5NmzbpzTffVEFBgcLCwjR06FC9+OKLTqgWAFDXXL7j7fnz5+Xp6enkaq4/58+fl1T+zsP2cPqhpaqEhYUpLS3tGlUDALjeuLq6ys/Pz/rcoQYNGshisTi5qrrPMAydP39eubm58vPzk6ura7X7qjVXLQEA4AyXb7j624co4trw8/Oz+Ya3lSHIAACuaxaLRSEhIQoKClJxcbGzy7luuLm5XdVMzGUEGQAA9OthJkf8sOLaqhX3kQEAAKgOggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtggwAADAtu4PMihUr9P/+3/+zvn7++efl5+enHj166MiRIw4tDgAAoCp2B5k5c+bI09NTkpSenq5FixZp/vz5aty4sSZNmuTwAgEAACpTz943HDt2TC1btpQkrVmzRkOHDtXjjz+unj17qm/fvo6uDwAAoFJ2z8h4eXnp1KlTkqTPPvtMf/jDHyRJ9evX14ULFxxbHQAAQBXsDjJ/+MMf9Nhjj+mxxx7Tjz/+qDvvvFOS9N133ykiIsKuvubOnaubb75Z3t7eCgoK0j333KPMzMwybQoLC5WQkKCAgAB5eXlp6NChOnnypL1lAwCAOsjuILNo0SLFxMTo559/1kcffaSAgABJ0u7duzV8+HC7+kpLS1NCQoJ27NihjRs3qri4WHfccYcKCgqsbSZNmqS1a9dq1apVSktL0/HjxzVkyBB7ywYAAHWQxTAMw9lFXPbzzz8rKChIaWlp6tOnj/Ly8hQYGKiVK1fq3nvvlST98MMPuvHGG5Wenq5bbrnlin3m5+fL19dXeXl58vHxcWi9cQu3OaSftU/3ckg/AADUFbb+flfrPjJffPGFRowYoR49eui///2vJOkf//iHtm27uh/2vLw8SZK/v7+kX2d5iouL1b9/f2ubtm3bqlmzZkpPT6+wj6KiIuXn55dZAABA3WR3kPnoo480YMAAeXp66ptvvlFRUZGkX0PInDlzql1IaWmpJk6cqJ49eyoqKkqSdOLECbm7u8vPz69M2yZNmujEiRMV9jN37lz5+vpal7CwsGrXBAAAaje7g8zLL7+sd955R0uXLpWbm5t1fc+ePfXNN99Uu5CEhATt379fycnJ1e5DkqZOnaq8vDzrcuzYsavqDwAA1F5230cmMzNTffr0Kbfe19dXZ86cqVYR48aN07p167R161Y1bdrUuj44OFgXL17UmTNnyszKnDx5UsHBwRX25eHhIQ8Pj2rVAQAAzMXuGZng4GAdOnSo3Ppt27apefPmdvVlGIbGjRun1atX6/PPP1dkZGSZ7V27dpWbm5tSU1Ot6zIzM3X06FHFxMTYWzoAAKhj7J6RGTNmjCZMmKDly5fLYrHo+PHjSk9P17PPPqtp06bZ1VdCQoJWrlypjz/+WN7e3tbzXnx9feXp6SlfX189+uijmjx5svz9/eXj46Onn35aMTExNl2xBAAA6ja7g8yUKVNUWlqqfv366fz58+rTp488PDz07LPP6umnn7arryVLlkhSuUcbJCYmKj4+XpL0xhtvyMXFRUOHDlVRUZEGDBigxYsX21s2AACog6p9H5mLFy/q0KFDOnfunNq1aycvLy9H1+YQ3EcGAADzsfX32+4Zmcvc3d3Vrl276r4dAADgqtkUZOx5JEBKSkq1iwEAALCHTUHG19e3pusAAACwm01BJjExsabrAAAAsJvd95HJzs7WwYMHy60/ePCgDh8+7IiaAAAAbGJ3kImPj9eXX35Zbv3OnTutl0wDAABcC3YHmT179qhnz57l1t9yyy3KyMhwRE0AAAA2sTvIWCwWnT17ttz6vLw8lZSUOKQoAAAAW9gdZPr06aO5c+eWCS0lJSWaO3euevXixm4AAODasfuGeK+88or69OmjNm3aqHfv3pKkL774Qvn5+fr8888dXiAAAEBl7J6Radeunfbu3av7779fubm5Onv2rB555BH98MMPioqKqokaAQAAKlStRxSEhoZqzpw5jq4FAADALjYFmb179yoqKkouLi7au3dvlW2jo6MdUhgAAMCV2BRkOnXqpBMnTigoKEidOnWSxWJRRQ/NtlgsXLkEAACuGZuCTHZ2tgIDA61/AwAA1AY2BZnw8HDr30eOHFGPHj1Ur17Zt166dElffvllmbYAAAA1ye6rlm677TadPn263Pq8vDzddtttDikKAADAFnYHGcMwZLFYyq0/deqUGjZs6JCiAAAAbGHz5ddDhgyR9OsJvfHx8fLw8LBuKykp0d69e9WjRw/HVwgAAFAJm4OMr6+vpF9nZLy9veXp6Wnd5u7urltuuUVjxoxxfIUAAACVsDnIJCYmWi+5Xrhwoby8vGqsKAAAAFvYdY6MYRh67733lJOTU1P1AAAA2MyuIOPi4qJWrVrp1KlTNVUPAACAzey+amnevHl67rnntH///pqoBwAAwGZ2PzTykUce0fnz59WxY0e5u7uXOelXUoX3mAEAAKgJdgeZN998swbKAAAAsJ/dQWbkyJE1UQcAAIDd7A4yv1VYWKiLFy+WWefj43NVBQEAANjK7pN9CwoKNG7cOAUFBalhw4Zq1KhRmQUAAOBasTvIPP/88/r888+1ZMkSeXh46O9//7tmzZql0NBQvfvuuzVRIwAAQIXsPrS0du1avfvuu+rbt69GjRql3r17q2XLlgoPD9d7772nhx56qCbqBAAAKMfuGZnTp0+refPmkn49H+by5da9evXS1q1bHVsdAABAFewOMs2bN1d2drYkqW3btvrggw8k/TpT4+fn59DiAAAAqmJ3kBk1apS+/fZbSdKUKVO0aNEi1a9fX5MmTdJzzz3n8AIBAAAqY/c5MpMmTbL+3b9/f/3www/avXu3WrZsqejoaIcWBwAAUBWbg0xpaaleffVVffLJJ7p48aL69eunGTNmKDw8XOHh4TVZIwAAQIVsPrT0l7/8RX/605/k5eWlG264QW+99ZYSEhJqsjYAAIAq2Rxk3n33XS1evFgbNmzQmjVrtHbtWr333nsqLS2tyfoAAAAqZXOQOXr0qO68807r6/79+8tisej48eM1UhgAAMCV2BxkLl26pPr165dZ5+bmpuLiYocXBQAAYAubT/Y1DEPx8fHy8PCwrissLNSTTz6phg0bWtelpKQ4tkIAAIBK2BxkRo4cWW7diBEjHFoMAACAPWwOMomJiTVZBwAAgN3svrMvAABAbUGQAQAApkWQAQAApkWQAQAApmVTkOnSpYt++eUXSdLs2bN1/vz5Gi0KAADAFjYFmQMHDqigoECSNGvWLJ07d65GiwIAALCFTZdfd+rUSaNGjVKvXr1kGIb+7//+T15eXhW2nT59ukMLBAAAqIxNMzJJSUkKCAjQunXrZLFY9O9//1urV68ut6xZs8auD9+6davi4uIUGhoqi8VS7v3x8fGyWCxlltjYWLs+AwAA1F02zci0adNGycnJkiQXFxelpqYqKCjoqj+8oKBAHTt21OjRozVkyJAK28TGxpa5Gd9vH5EAAACubzbf2fey0tJSh334wIEDNXDgwCrbeHh4KDg42GGfCQAA6g67g4wkZWVl6c0339SBAwckSe3atdOECRPUokULhxYnSVu2bFFQUJAaNWqk22+/XS+//LICAgIqbV9UVKSioiLr6/z8fIfXBAAAage77yOzYcMGtWvXTl999ZWio6MVHR2tnTt3qn379tq4caNDi4uNjdW7776r1NRUvfLKK0pLS9PAgQNVUlJS6Xvmzp0rX19f6xIWFubQmgAAQO1hMQzDsOcNnTt31oABAzRv3rwy66dMmaLPPvtM33zzTfUKsVi0evVq3XPPPZW2+c9//qMWLVpo06ZN6tevX4VtKpqRCQsLU15ennx8fKpVW2XiFm5zSD9rn+7lkH4AAKgr8vPz5evre8Xfb7tnZA4cOKBHH3203PrRo0fr+++/t7c7uzRv3lyNGzfWoUOHKm3j4eEhHx+fMgsAAKib7A4ygYGBysjIKLc+IyPDIVcyVeWnn37SqVOnFBISUqOfAwAAzMHuk33HjBmjxx9/XP/5z3/Uo0cPSdL27dv1yiuvaPLkyXb1de7cuTKzK9nZ2crIyJC/v7/8/f01a9YsDR06VMHBwcrKytLzzz+vli1basCAAfaWDQAA6iC7g8y0adPk7e2t1157TVOnTpUkhYaGaubMmRo/frxdfe3atUu33Xab9fXlIDRy5EgtWbJEe/fu1YoVK3TmzBmFhobqjjvu0EsvvcS9ZAAAgKRqnOz7W2fPnpUkeXt7O6wgR7P1ZKHq4GRfAABqhq2/39W6j8xltTnAAACAus/uk30BAABqC4IMAAAwLYIMAAAwLbuCTHFxsfr166eDBw/WVD0AAAA2syvIuLm5ae/evTVVCwAAgF3sPrQ0YsQILVu2rCZqAQAAsIvdl19funRJy5cv16ZNm9S1a1c1bNiwzPbXX3/dYcUBAABUxe4gs3//fnXp0kWS9OOPP5bZZrFYHFMVAACADewOMps3b66JOgAAAOxW7cuvDx06pA0bNujChQuSpKt40gEAAEC12B1kTp06pX79+ql169a68847lZOTI0l69NFH9cwzzzi8QAAAgMrYHWQmTZokNzc3HT16VA0aNLCuHzZsmNavX+/Q4gAAAKpi9zkyn332mTZs2KCmTZuWWd+qVSsdOXLEYYUBAABcid0zMgUFBWVmYi47ffq0PDw8HFIUAACALewOMr1799a7775rfW2xWFRaWqr58+frtttuc2hxAAAAVbH70NL8+fPVr18/7dq1SxcvXtTzzz+v7777TqdPn9b27dtrokYAAIAK2T0jExUVpR9//FG9evXS3XffrYKCAg0ZMkR79uxRixYtaqJGAACACtk9IyNJvr6++vOf/+zoWgAAAOxSrSDzyy+/aNmyZTpw4IAkqV27dho1apT8/f0dWhwAAEBV7D60tHXrVkVERGjBggX65Zdf9Msvv2jBggWKjIzU1q1ba6JGAACACtk9I5OQkKBhw4ZpyZIlcnV1lSSVlJRo7NixSkhI0L59+xxeJAAAQEXsnpE5dOiQnnnmGWuIkSRXV1dNnjxZhw4dcmhxAAAAVbE7yHTp0sV6bsxvHThwQB07dnRIUQAAALaw6dDS3r17rX+PHz9eEyZM0KFDh3TLLbdIknbs2KFFixZp3rx5NVMlAABABSyGYRhXauTi4iKLxaIrNbVYLCopKXFYcY6Qn58vX19f5eXlycfHx6F9xy3c5pB+1j7dyyH9AABQV9j6+23TjEx2drbDCgMAAHAUm4JMeHh4TdcBAABgt2rdEO/48ePatm2bcnNzVVpaWmbb+PHjHVIYAADAldgdZJKSkvTEE0/I3d1dAQEBslgs1m0Wi4UgAwAArhm7g8y0adM0ffp0TZ06VS4udl+9DQAA4DB2J5Hz58/rgQceIMQAAACnszuNPProo1q1alVN1AIAAGAXuw8tzZ07V3fddZfWr1+vDh06yM3Nrcz2119/3WHFAQAAVKVaQWbDhg1q06aNJJU72RcAAOBasTvIvPbaa1q+fLni4+NroBwAAADb2X2OjIeHh3r27FkTtQAAANjF7iAzYcIELVy4sCZqAQAAsIvdh5a++uorff7551q3bp3at29f7mTflJQUhxUHAABQFbuDjJ+fn4YMGVITtQAAANjF7iCTmJhYE3UAAADYjdvzAgAA07J7RiYyMrLK+8X85z//uaqCAAAAbGV3kJk4cWKZ18XFxdqzZ4/Wr1+v5557zlF1AQAAXJHdQWbChAkVrl+0aJF27dp11QUBAADYymHnyAwcOFAfffSRo7oDAAC4IocFmQ8//FD+/v6O6g4AAOCK7D601Llz5zIn+xqGoRMnTujnn3/W4sWLHVocAABAVewOMvfcc0+Z1y4uLgoMDFTfvn3Vtm1bR9UFAABwRXYHmRkzZtREHQAAAHZz6g3xtm7dqri4OIWGhspisWjNmjVlthuGoenTpyskJESenp7q37+/Dh486JxiAQBArWNzkHFxcZGrq2uVS7169k3wFBQUqGPHjlq0aFGF2+fPn68FCxbonXfe0c6dO9WwYUMNGDBAhYWFdn0OAACom2xOHqtXr650W3p6uhYsWKDS0lK7PnzgwIEaOHBghdsMw9Cbb76pF198UXfffbck6d1331WTJk20Zs0aPfDAAxW+r6ioSEVFRdbX+fn5dtUEAADMw+YgczlM/FZmZqamTJmitWvX6qGHHtLs2bMdVlh2drZOnDih/v37W9f5+vqqe/fuSk9PrzTIzJ07V7NmzXJYHQAAoPaq1jkyx48f15gxY9ShQwddunRJGRkZWrFihcLDwx1W2IkTJyRJTZo0KbO+SZMm1m0VmTp1qvLy8qzLsWPHHFYTAACoXew6qSUvL09z5szRwoUL1alTJ6Wmpqp37941VVu1eHh4yMPDw9llAACAa8DmGZn58+erefPmWrdunf71r3/pyy+/rNEQExwcLEk6efJkmfUnT560bgMAANc3m2dkpkyZIk9PT7Vs2VIrVqzQihUrKmyXkpLikMIiIyMVHBys1NRUderUSdKvJ+7u3LlTTz31lEM+AwAAmJvNQeaRRx4p82gCRzh37pwOHTpkfZ2dna2MjAz5+/urWbNmmjhxol5++WW1atVKkZGRmjZtmkJDQ8vdXRgAAFyfbA4ySUlJDv/wXbt26bbbbrO+njx5siRp5MiRSkpK0vPPP6+CggI9/vjjOnPmjHr16qX169erfv36Dq8FAACYj8UwDMPZRdSk/Px8+fr6Ki8vTz4+Pg7tO27hNof0s/bpXg7pBwCAusLW32+nPqIAAADgahBkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAaRFkAACAadVzdgGQtHaC4/qKe8txfQEAUMsxIwMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLZy1dhYRzCx3Sz+Lz5x3SjySNdVhPAADUfszIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0+JZS1fhM+9ch/TTUl4O6QcAgOsNMzIAAMC0CDIAAMC0CDIAAMC0CDIAAMC0CDIAAMC0CDIAAMC0CDIAAMC0anWQmTlzpiwWS5mlbdu2zi4LAADUErX+hnjt27fXpk2brK/r1av1JQMAgGuk1qeCevXqKTg42NllAACAWqhWH1qSpIMHDyo0NFTNmzfXQw89pKNHj1bZvqioSPn5+WUWAABQN9XqGZnu3bsrKSlJbdq0UU5OjmbNmqXevXtr//798vb2rvA9c+fO1axZs65xpXXP4vfjHNLP2GFrHdIPAAAVqdUzMgMHDtR9992n6OhoDRgwQJ9++qnOnDmjDz74oNL3TJ06VXl5edbl2LFj17BiAABwLdXqGZnf8/PzU+vWrXXo0KFK23h4eMjDw+MaVgUAAJylVs/I/N65c+eUlZWlkJAQZ5cCAABqgVodZJ599lmlpaXp8OHD+vLLLzV48GC5urpq+PDhzi4NAADUArX60NJPP/2k4cOH69SpUwoMDFSvXr20Y8cOBQYGOrs0AABQC9TqIJOcnOzsEgAAQC1Wqw8tAQAAVIUgAwAATIsgAwAATIsgAwAATIsgAwAATKtWX7WEalg7wdkVAABwzTAjAwAATIsgAwAATIsgAwAATIsgAwAATIsgAwAATIsgAwAATIsgAwAATIsgAwAATIsgAwAATIsgAwAATIsgAwAATItnLeH64qhnUcW95Zh+AABXhRkZAABgWgQZAABgWgQZAABgWgQZAABgWgQZAABgWgQZAABgWgQZAABgWgQZAABgWgQZAABgWgQZAABgWgQZAABgWjxrqY5ZfP4/zi6hjMUZix3Sz9hOYx3Sj6PU1XEBgNkwIwMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLIAMAAEyLh0aiZmX+2zH9HMt0SDeOe6hmGwf1U7vwMMyqOer7cRRHfc/sd5gZMzIAAMC0CDIAAMC0CDIAAMC0CDIAAMC0CDIAAMC0CDIAAMC0CDIAAMC0TBFkFi1apIiICNWvX1/du3fXV1995eySAABALVDrg8z777+vyZMna8aMGfrmm2/UsWNHDRgwQLm5uc4uDQAAOFmtDzKvv/66xowZo1GjRqldu3Z655131KBBAy1fvtzZpQEAACer1Y8ouHjxonbv3q2pU6da17m4uKh///5KT0+v8D1FRUUqKiqyvs7Ly5Mk5efnO7y+oguXHNLPhfPFDumnLstX0ZUb2cBh3/W5Cw7ppib+XV6NC3V0XI7iqO/HURz1PbPfURtd/vdkGEbVDY1a7L///a8hyfjyyy/LrH/uueeMbt26VfieGTNmGJJYWFhYWFhY6sBy7NixKrNCrZ6RqY6pU6dq8uTJ1telpaU6ffq0AgICZLFYHPY5+fn5CgsL07Fjx+Tj4+OwfmuTuj7Guj4+qe6PkfGZX10fI+OrPsMwdPbsWYWGhlbZrlYHmcaNG8vV1VUnT54ss/7kyZMKDg6u8D0eHh7y8PAos87Pz6+mSpSPj0+d/Mf5W3V9jHV9fFLdHyPjM7+6PkbGVz2+vr5XbFOrT/Z1d3dX165dlZqaal1XWlqq1NRUxcTEOLEyAABQG9TqGRlJmjx5skaOHKmbbrpJ3bp105tvvqmCggKNGjXK2aUBAAAnq/VBZtiwYfr55581ffp0nThxQp06ddL69evVpEkTp9bl4eGhGTNmlDuMVZfU9THW9fFJdX+MjM/86voYGV/NsxjGla5rAgAAqJ1q9TkyAAAAVSHIAAAA0yLIAAAA0yLIAAAA0yLIVNOiRYsUERGh+vXrq3v37vrqq6+cXZJDzJw5UxaLpczStm1bZ5d1VbZu3aq4uDiFhobKYrFozZo1ZbYbhqHp06crJCREnp6e6t+/vw4ePOicYqvhSuOLj48vt09jY2OdU2w1zJ07VzfffLO8vb0VFBSke+65R5mZmWXaFBYWKiEhQQEBAfLy8tLQoUPL3UizNrNljH379i23H5988kknVWyfJUuWKDo62nrTtJiYGP373/+2bjf7/rvS+My87yoyb948WSwWTZw40brOmfuQIFMN77//viZPnqwZM2bom2++UceOHTVgwADl5uY6uzSHaN++vXJycqzLtm3bnF3SVSkoKFDHjh21aNGiCrfPnz9fCxYs0DvvvKOdO3eqYcOGGjBggAoLC69xpdVzpfFJUmxsbJl9+q9//esaVnh10tLSlJCQoB07dmjjxo0qLi7WHXfcoYKCAmubSZMmae3atVq1apXS0tJ0/PhxDRkyxIlV28eWMUrSmDFjyuzH+fPnO6li+zRt2lTz5s3T7t27tWvXLt1+++26++679d1330ky//670vgk8+673/v666/117/+VdHR0WXWO3UfOuTpjteZbt26GQkJCdbXJSUlRmhoqDF37lwnVuUYM2bMMDp27OjsMmqMJGP16tXW16WlpUZwcLDx6quvWtedOXPG8PDwMP71r385ocKr8/vxGYZhjBw50rj77rudUk9NyM3NNSQZaWlphmH8ur/c3NyMVatWWdscOHDAkGSkp6c7q8yr8vsxGoZh3HrrrcaECROcV5SDNWrUyPj73/9eJ/efYfz/4zOMurPvzp49a7Rq1crYuHFjmTE5ex8yI2Onixcvavfu3erfv791nYuLi/r376/09HQnVuY4Bw8eVGhoqJo3b66HHnpIR48edXZJNSY7O1snTpwosz99fX3VvXv3OrM/JWnLli0KCgpSmzZt9NRTT+nUqVPOLqna8vLyJEn+/v6SpN27d6u4uLjMPmzbtq2aNWtm2n34+zFe9t5776lx48aKiorS1KlTdf78eWeUd1VKSkqUnJysgoICxcTE1Ln99/vxXVYX9l1CQoIGDRpUZl9Jzv9vsNbf2be2+d///qeSkpJydxZu0qSJfvjhBydV5Tjdu3dXUlKS2rRpo5ycHM2aNUu9e/fW/v375e3t7ezyHO7EiROSVOH+vLzN7GJjYzVkyBBFRkYqKytLf/rTnzRw4EClp6fL1dXV2eXZpbS0VBMnTlTPnj0VFRUl6dd96O7uXu7hsGbdhxWNUZIefPBBhYeHKzQ0VHv37tULL7ygzMxMpaSkOLFa2+3bt08xMTEqLCyUl5eXVq9erXbt2ikjI6NO7L/KxieZf99JUnJysr755ht9/fXX5bY5+79BggzKGDhwoPXv6Ohode/eXeHh4frggw/06KOPOrEyVNcDDzxg/btDhw6Kjo5WixYttGXLFvXr18+JldkvISFB+/fvN/15W1WpbIyPP/649e8OHTooJCRE/fr1U1ZWllq0aHGty7RbmzZtlJGRoby8PH344YcaOXKk0tLSnF2Ww1Q2vnbt2pl+3x07dkwTJkzQxo0bVb9+fWeXUw6HluzUuHFjubq6ljsb++TJkwoODnZSVTXHz89PrVu31qFDh5xdSo24vM+ul/0pSc2bN1fjxo1Nt0/HjRundevWafPmzWratKl1fXBwsC5evKgzZ86UaW/GfVjZGCvSvXt3STLNfnR3d1fLli3VtWtXzZ07Vx07dtRbb71VZ/ZfZeOriNn23e7du5Wbm6suXbqoXr16qlevntLS0rRgwQLVq1dPTZo0ceo+JMjYyd3dXV27dlVqaqp1XWlpqVJTU8scD60rzp07p6ysLIWEhDi7lBoRGRmp4ODgMvszPz9fO3furJP7U5J++uknnTp1yjT71DAMjRs3TqtXr9bnn3+uyMjIMtu7du0qNze3MvswMzNTR48eNc0+vNIYK5KRkSFJptmPv1daWqqioqI6sf8qcnl8FTHbvuvXr5/27dunjIwM63LTTTfpoYcesv7t1H1Y46cT10HJycmGh4eHkZSUZHz//ffG448/bvj5+RknTpxwdmlX7ZlnnjG2bNliZGdnG9u3bzf69+9vNG7c2MjNzXV2adV29uxZY8+ePcaePXsMScbrr79u7Nmzxzhy5IhhGIYxb948w8/Pz/j444+NvXv3GnfffbcRGRlpXLhwwcmV26aq8Z09e9Z49tlnjfT0dCM7O9vYtGmT0aVLF6NVq1ZGYWGhs0u3yVNPPWX4+voaW7ZsMXJycqzL+fPnrW2efPJJo1mzZsbnn39u7Nq1y4iJiTFiYmKcWLV9rjTGQ4cOGbNnzzZ27dplZGdnGx9//LHRvHlzo0+fPk6u3DZTpkwx0tLSjOzsbGPv3r3GlClTDIvFYnz22WeGYZh//1U1PrPvu8r8/kosZ+5Dgkw1LVy40GjWrJnh7u5udOvWzdixY4ezS3KIYcOGGSEhIYa7u7txww03GMOGDTMOHTrk7LKuyubNmw1J5ZaRI0cahvHrJdjTpk0zmjRpYnh4eBj9+vUzMjMznVu0Haoa3/nz54077rjDCAwMNNzc3Izw8HBjzJgxpgrdFY1NkpGYmGhtc+HCBWPs2LFGo0aNjAYNGhiDBw82cnJynFe0na40xqNHjxp9+vQx/P39DQ8PD6Nly5bGc889Z+Tl5Tm3cBuNHj3aCA8PN9zd3Y3AwECjX79+1hBjGObff1WNz+z7rjK/DzLO3IcWwzCMmp/3AQAAcDzOkQEAAKZFkAEAAKZFkAEAAKZFkAEAAKZFkAEAAKZFkAEAAKZFkAEAAKZFkAEAAKZFkAFgOn379tXEiROrbJOUlCQ/Pz+7+o2IiNCbb75Z7boAXHsEGcDk4uPjZbFY9OSTT5bblpCQIIvFovj4+Gtf2G+sWLFCvXr1qnBbdQJHSkqKXnrpJevrigLIsGHD9OOPP9pbapVmzpwpi8Wi2NjYctteffVVWSwW9e3bt9y2n376Se7u7oqKiqqw37S0NN1+++3y9/dXgwYN1KpVK40cOVIXL160tlm6dKk6duwoLy8v+fn5qXPnzpo7d67DxgaYFUEGqAPCwsKUnJysCxcuWNcVFhZq5cqVatasmRMr+9XHH3+sP/7xjw7rz9/fX97e3lW28fT0VFBQkMM+87KQkBBt3rxZP/30U5n1y5cvr/S7TkpK0v333299svpvff/994qNjdVNN92krVu3at++fVq4cKHc3d1VUlJi7XvixIkaP368MjIytH37dj3//PM6d+6cw8cHmA1BBqgDunTporCwMKWkpFjXpaSkqFmzZurcuXOZtuvXr1evXr3k5+engIAA3XXXXcrKyrJuv3jxosaNG6eQkBDVr19f4eHh1v/zNwxDM2fOVLNmzeTh4aHQ0FCNHz++ytoKCwv12Wef2RxkZs6cqU6dOukf//iHIiIi5OvrqwceeEBnz561tvntoaW+ffvqyJEjmjRpkiwWiywWi6TyMz1ZWVm6++671aRJE3l5eenmm2/Wpk2bbKrpt4KCgnTHHXdoxYoV1nVffvml/ve//2nQoEHl2huGocTERD388MN68MEHtWzZsjLbP/vsMwUHB2v+/PmKiopSixYtFBsbq6VLl8rT01OS9Mknn+j+++/Xo48+qpYtW6p9+/YaPny4/vKXv9hdP1DXEGSAOmL06NFKTEy0vl6+fLlGjRpVrl1BQYEmT56sXbt2KTU1VS4uLho8eLBKS0slSQsWLNAnn3yiDz74QJmZmXrvvfcUEREhSfroo4/0xhtv6K9//asOHjyoNWvWqEOHDlXWlZqaqhtuuEFt27a1eSxZWVlas2aN1q1bp3Xr1iktLU3z5s2rsG1KSoqaNm2q2bNnKycnRzk5ORW2O3funO68806lpqZqz549io2NVVxcnI4ePWpzXZeNHj1aSUlJ1tfLly/XQw89JHd393JtN2/erPPnz6t///4aMWKEkpOTVVBQYN0eHBysnJwcbd26tdLPCw4O1o4dO3TkyBG7awXqOoIMUEeMGDFC27Zt05EjR3TkyBFt375dI0aMKNdu6NChGjJkiFq2bKlOnTpp+fLl2rdvn77//ntJ0tGjR9WqVSv16tVL4eHh6tWrl4YPH27dFhwcrP79+6tZs2bq1q2bxowZU2Vd1TmsVFpaqqSkJEVFRal37956+OGHlZqaWmFbf39/ubq6ytvbW8HBwQoODq6wXceOHfXEE08oKipKrVq10ksvvaQWLVrok08+sas2SbrrrruUn5+vrVu3qqCgQB988IFGjx5dYdtly5bpgQcekKurq6KiotS8eXOtWrXKuv2+++7T8OHDdeuttyokJESDBw/W22+/rfz8fGubGTNmyM/PTxEREWrTpo3i4+P1wQcfWMMncD0jyAB1RGBgoAYNGqSkpCQlJiZq0KBBaty4cbl2Bw8e1PDhw9W8eXP5+PhYZ1suz0zEx8crIyNDbdq00fjx4/XZZ59Z33vffffpwoULat68ucaMGaPVq1fr0qVLldZkGIbWrl1rd5CJiIgocw5MSEiIcnNz7erj986dO6dnn31WN954o/z8/OTl5aUDBw5Ua0bGzc1NI0aMUGJiolatWqXWrVsrOjq6XLszZ84oJSWlTKAcMWJEmcNLrq6uSkxM1E8//aT58+frhhtu0Jw5c9S+fXvr7FJISIjS09O1b98+TZgwQZcuXdLIkSMVGxtLmMF1jyAD1CGXD3msWLGi0hmCuLg4nT59WkuXLtXOnTutJ59evkKmS5cuys7O1ksvvaQLFy7o/vvv17333ivp15OKMzMztXjxYnl6emrs2LHq06ePiouLK/ysr776SpcuXVKPHj3sGoebm1uZ1xaL5ap/sJ999lmtXr1ac+bM0RdffKGMjAx16NChzJVB9hg9erRWrVqlRYsWVfpdr1y5UoWFherevbvq1aunevXq6YUXXtC2bdvKXVF1ww036OGHH9bbb7+t7777ToWFhXrnnXfKtImKitLYsWP1z3/+Uxs3btTGjRuVlpZWrfqBuoIgA9QhsbGxunjxooqLizVgwIBy20+dOqXMzEy9+OKL6tevn2688Ub98ssv5dr5+Pho2LBhWrp0qd5//3199NFHOn36tKRfrwaKi4vTggULtGXLFutMQUU+/vhjDRo0SK6uro4d6O/89gqfymzfvl3x8fEaPHiwOnTooODgYB0+fLjan9m+fXu1b99e+/fv14MPPlhhm2XLlumZZ55RRkaGdfn222/Vu3dvLV++vNK+GzVqpJCQkDLn0vxeu3btJKnKNsD1oJ6zCwDgOK6urjpw4ID1799r1KiRAgIC9Le//U0hISE6evSopkyZUqbN66+/rpCQEHXu3FkuLi5atWqVgoOD5efnp6SkJJWUlKh79+5q0KCB/vnPf8rT01Ph4eEV1vPJJ59o9uzZjh/o70RERGjr1q164IEH5OHhUeEhtVatWiklJUVxcXGyWCyaNm3aVc/yfP755youLq7wPjgZGRn65ptv9N5775U70Xn48OGaPXu2Xn75ZS1btkwZGRkaPHiwWrRoocLCQr377rv67rvvtHDhQknSU089pdDQUN1+++1q2rSpcnJy9PLLLyswMFAxMTFXNQbA7JiRAeoYHx8f+fj4VLjNxcVFycnJ2r17t6KiojRp0iS9+uqrZdp4e3tr/vz5uummm3TzzTfr8OHD+vTTT+Xi4iI/Pz8tXbpUPXv2VHR0tDZt2qS1a9cqICCg3GdlZWXp0KFDFc4MOdrs2bN1+PBhtWjRQoGBgRW2ef3119WoUSP16NFDcXFxGjBggLp06XJVn9uwYcNKb+a3bNkytWvXrsKrtQYPHqzc3Fx9+umn6tatm86dO6cnn3xS7du316233qodO3ZozZo1uvXWWyVJ/fv3144dO3TfffepdevWGjp0qOrXr6/U1NQKv3vgemIxDMNwdhEA6p7XX39dmzZt0qeffursUgDUYczIAKgRTZs21dSpU51dBoA6jhkZAABgWszIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0yLIAAAA0/r/AF6O1UB2G9zzAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] diff --git a/docs/examples/lagrangian/sweep_and_prune.ipynb b/docs/examples/lagrangian/sweep_and_prune.ipynb new file mode 100644 index 000000000..6ee0c4bcf --- /dev/null +++ b/docs/examples/lagrangian/sweep_and_prune.ipynb @@ -0,0 +1,396 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Sweep and Prune Algorithm \n", + "\n", + "In our previous approach to collision detection, we compared each particle with every other particle, resulting in a computationally expensive $O(N^2)$ operation, where $N$ is the number of particles. To enhance efficiency, we now implement the sweep and prune algorithm.\n", + "\n", + "## Concept of Sweep and Prune\n", + "\n", + "The sweep and prune algorithm is a more efficient method for collision detection. Its efficiency stems from reducing the number of particle pairs we need to check. The key steps of this algorithm are:\n", + "\n", + "**Sweep:** Sort the particles along one axis, typically the $x$-axis. This step orders the particles in a way that adjacent particles in the sorted list are likely to be close in space.\n", + "\n", + "**Prune:** After sorting, we then check for potential collisions only between neighboring particles in this sorted list. This pruning significantly reduces the number of comparisons.\n", + "\n", + "**Repeat for Other Axes:** The process is repeated for the $y$-axis and the $z$-axis. In each iteration, we eliminate pairs of particles that are too far apart to collide based on their coordinates in the respective axis.\n", + "\n", + "**Euclidean Distance Check:** Finally, we validate potential collisions by checking the actual Euclidean distance between particle pairs that remained after the pruning steps. This step ensures accurate detection of collisions.\n", + "\n", + "### Efficiency Gains\n", + "This method dramatically reduces the number of comparisons from $O(N^2)$ to approximately $O(N \\log N)$, mainly due to sorting. The actual number of particle pairs checked for collision is usually much less than $N$, especially in sparsely populated spaces. This makes the sweep and prune algorithm significantly more efficient for collision detection in systems with a large number of particles.\n", + "\n", + "Note: The exact efficiency depends on the distribution and density of particles. In cases where particles are uniformly distributed, the sweep and prune method shows substantial efficiency improvements. However, in highly clustered scenarios, the performance gain might be less pronounced, but it still outperforms the brute-force $N^2$ approach." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Code Section: Importing Necessary Libraries and Initializing Variables\n", + "import time\n", + "import torch\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from particula.lagrangian import boundary, integration, collisions, particle_property, particle_pairs\n", + "\n", + "# Initializing the Torch Generator and setting the data type\n", + "torch.manual_seed(1234) # Set the seed for reproducibility\n", + "t_type = torch.float32" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialization\n", + "\n", + "We'll use the same initialization as in the previous notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Setting up the Simulation Parameters and Initial Conditions\n", + "# Define fixed parameters\n", + "TOTAL_NUMBER_OF_PARTICLES = 500\n", + "TIME_STEP = 0.01\n", + "SIMULATION_TIME = 100\n", + "MASS = 3\n", + "CUBE_SIDE = 50\n", + "speed = 5\n", + "save_points = 50\n", + "\n", + "# Initialize particle positions randomly within the cube\n", + "position = torch.rand(\n", + " 3,\n", + " TOTAL_NUMBER_OF_PARTICLES,\n", + " dtype=t_type) * CUBE_SIDE - CUBE_SIDE / 2\n", + "\n", + "# Initialize particle velocities randomly\n", + "velocity = torch.rand(3, TOTAL_NUMBER_OF_PARTICLES,\n", + " dtype=t_type) * speed - speed / 2\n", + "\n", + "# Initialize force as zero for all particles\n", + "force = torch.zeros(3, TOTAL_NUMBER_OF_PARTICLES, dtype=t_type)\n", + "\n", + "# Set constant mass and density for all particles\n", + "mass = torch.ones(TOTAL_NUMBER_OF_PARTICLES, dtype=t_type) * MASS\n", + "density = torch.ones(TOTAL_NUMBER_OF_PARTICLES, dtype=t_type) * 1\n", + "\n", + "# Generate indices for particles, could be integer type\n", + "indices = torch.arange(TOTAL_NUMBER_OF_PARTICLES, dtype=t_type) # could be int\n", + "\n", + "# Calculate the total number of iterations for the simulation\n", + "total_iterations = int(SIMULATION_TIME / TIME_STEP)\n", + "\n", + "# Initialize a tensor to track the total mass over iterations\n", + "total_mass = torch.zeros(total_iterations, dtype=t_type)\n", + "\n", + "# Define gravity acting on all particles\n", + "gravity = torch.tensor(\n", + " [0, -9.81, 0]).repeat(TOTAL_NUMBER_OF_PARTICLES, 1).transpose(0, 1)\n", + "\n", + "# Initializing Arrays for Saving Position and Mass Data\n", + "# Create arrays to store position and mass data at each save point\n", + "save_position = np.zeros((3, TOTAL_NUMBER_OF_PARTICLES, save_points))\n", + "save_mass = np.zeros((TOTAL_NUMBER_OF_PARTICLES, save_points))\n", + "\n", + "# Determine which iterations will correspond to the save points\n", + "save_iterations = np.linspace(0, total_iterations, save_points, dtype=int)\n", + "radius = particle_property.radius(mass=mass, density=density)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total wall time: 10.669302225112915 seconds\n", + "Ratio of wall time to simulation time: 0.10669302225112914\n" + ] + } + ], + "source": [ + "# Initialize counter for saving data\n", + "save_counter = 0\n", + "start_time = time.time()\n", + "\n", + "for i in range(total_iterations):\n", + "\n", + " # NEW calculate sweep and prune collision pairs\n", + " radius = particle_property.radius(mass=mass, density=density)\n", + " valid_collision_indices_pairs = particle_pairs.full_sweep_and_prune(\n", + " position=position, radius=radius)\n", + "\n", + " if valid_collision_indices_pairs.shape[0] > 0:\n", + " # Coalesce particles that have collided and update their velocity and mass\n", + " velocity, mass = collisions.coalescence(\n", + " position=position,\n", + " velocity=velocity,\n", + " mass=mass,\n", + " radius=radius,\n", + " collision_indices_pairs=valid_collision_indices_pairs)\n", + "\n", + " # Calculate the force acting on the particles (e.g., gravity)\n", + " force = mass * gravity\n", + "\n", + " # Integrate the equations of motion to update position and velocity\n", + " position, velocity = integration.leapfrog(\n", + " position=position, velocity=velocity, force=force, mass=mass, time_step=TIME_STEP)\n", + "\n", + " # Apply boundary conditions for the cube (wrap-around)\n", + " position = boundary.wrapped_cube(position=position, cube_side=CUBE_SIDE)\n", + "\n", + " # Save the position and mass data at designated save points\n", + " if i == save_iterations[save_counter]:\n", + " save_position[:, :, save_counter] = position.detach().numpy()\n", + " save_mass[:, save_counter] = mass.detach().numpy()\n", + " save_counter += 1\n", + "\n", + "# Perform a final save of the position and mass data\n", + "save_position[:, :, -1] = position.detach().numpy()\n", + "save_mass[:, -1] = mass.detach().numpy()\n", + "\n", + "# Calculate the total simulation time\n", + "end_time = time.time()\n", + "print(f\"Total wall time: {end_time - start_time} seconds\")\n", + "print(f\"Ratio of wall time to simulation time: {(end_time - start_time) / SIMULATION_TIME}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot Positions\n", + "\n", + "Compared to the previous notebook, the sweep and prune is about 2x faster for this scenario. The exact speedup depends on the number of particles and the distribution of particles in space." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of particles at the end: 96\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Processing the Final Data for Visualization\n", + "\n", + "# Select the final time index for the data\n", + "time_index = -2\n", + "position_final = save_position[:, :, time_index]\n", + "mass_final = save_mass[:, time_index]\n", + "\n", + "# Filter out particles with zero mass\n", + "filter_zero_mass = mass_final > 0\n", + "\n", + "# Calculate the radius and area of each particle\n", + "radius_final = particle_property.radius(mass=mass_final, density=density)\n", + "particle_area = np.pi * radius_final**2\n", + "\n", + "# Display the number of remaining particles\n", + "print(f\"Number of particles at the end: {filter_zero_mass.sum()}\")\n", + "\n", + "# Creating a 3D Plot for Visualization\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(projection='3d')\n", + "\n", + "# Choose a color map for the scatter plot\n", + "cmap = plt.cm.viridis\n", + "\n", + "# Plot the final positions of particles with non-zero mass\n", + "scatter_plot = ax.scatter(\n", + " position_final[0, filter_zero_mass],\n", + " position_final[1, filter_zero_mass],\n", + " position_final[2, filter_zero_mass],\n", + " c=mass_final[filter_zero_mass],\n", + " cmap=cmap,\n", + " s=particle_area[filter_zero_mass] # Particle size based on area\n", + ")\n", + "\n", + "# Set axis limits based on cube dimensions\n", + "ax.set_xlim(-CUBE_SIDE / 2, CUBE_SIDE / 2)\n", + "ax.set_ylim(-CUBE_SIDE / 2, CUBE_SIDE / 2)\n", + "ax.set_zlim(-CUBE_SIDE / 2, CUBE_SIDE / 2)\n", + "\n", + "# Add a color bar indicating particle mass\n", + "color_bar = plt.colorbar(scatter_plot, ax=ax)\n", + "color_bar.set_label('Mass')\n", + "\n", + "# Show the plot with optimized layout\n", + "plt.show()\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " ## Analyzing the Mass Distribution of Particles" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualizing the Mass Distribution at Different Stages\n", + "\n", + "# Create a new figure for the histogram\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot()\n", + "# Normalizing by initial MASS to observe distribution changes\n", + "normalized_mass = save_mass[filter_zero_mass, :] / MASS\n", + "max_mass = normalized_mass.max()\n", + "\n", + "# Plot histograms of mass distribution at different stages\n", + "ax.hist(normalized_mass[:, 0], bins=25,\n", + " alpha=0.8, label='Initial', range=(0, max_mass))\n", + "ax.hist(normalized_mass[:, 24], bins=25,\n", + " alpha=0.6, label='Middle', range=(0, max_mass))\n", + "ax.hist(normalized_mass[:, -1], bins=25,\n", + " alpha=0.5, label='Final', range=(0, max_mass))\n", + "\n", + "# Setting labels and title for the plot\n", + "ax.set_xlabel('Mass / Initial MASS')\n", + "ax.set_ylabel('Number of Particles')\n", + "\n", + "# Add a legend to the plot\n", + "ax.legend()\n", + "\n", + "# Display the plot\n", + "plt.show()\n", + "\n", + "# Adjust layout for optimal visualization\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary of the Sweep and Prune Algorithm\n", + "\n", + "In our recent work, we've successfully implemented the sweep and prune algorithm for efficient collision detection. This method has demonstrated a notable efficiency improvement over the traditional brute-force approach. As we progress, the next notebook will introduce realistic aerosol initialization and dynamics, further enhancing our simulation's applicability.\n", + "\n", + "### Understanding Sweep and Prune (AABB Algorithm)\n", + "\n", + "The sweep and prune algorithm is often referred to as the Axis-Aligned Bounding Box (AABB) algorithm. This designation stems from the technique's reliance on comparing axis-aligned bounding boxes of particles to detect potential collisions. An axis-aligned bounding box is the smallest box that entirely encapsulates a particle and is aligned with the coordinate axes. By working with these boxes, the algorithm efficiently narrows down collision checks to only those particles whose bounding boxes overlap, significantly reducing the number of necessary calculations.\n", + "\n", + "### Additional Context on AABB\n", + "\n", + "- Efficient Sorting: The key to its efficiency lies in sorting particles along each axis and then checking for overlap, which is computationally less intensive than checking every pair of particles.\n", + "- Use in Various Domains: While commonly used in computer graphics and game development for spatial partitioning and collision detection, the AABB approach is also highly relevant in scientific simulations like aerosol dynamics.\n", + "\n", + "## Exploring Other Collision Detection Methods\n", + "\n", + "Beyond sweep and prune, several other advanced collision detection techniques offer improved efficiency over brute-force methods, albeit with increased complexity in implementation. Some noteworthy methods include:\n", + "\n", + "- K-d Tree (Smarter Space Partitioning): This method involves partitioning space into regions using a k-dimensional tree, allowing for efficient searching and nearest-neighbor queries, particularly useful in sparsely populated spaces.\n", + "- Bounding Volume Hierarchy (BVH): BVH involves creating a tree structure of bounding volumes, where each node encompasses a subset of objects in the space. Collision detection then proceeds by traversing this tree, significantly speeding up the process in complex scenes.\n", + "- GJK Algorithm (Gilbert-Johnson-Keerthi): The GJK algorithm is used for collision detection between convex shapes. It efficiently determines whether two convex shapes intersect and can be extended to calculate the minimum distance between them.\n", + "\n", + "### Additional Considerations\n", + "\n", + "- Choosing the Right Method: The choice of collision detection algorithm depends on the specific requirements of the simulation, such as the number of particles, their distribution, and the required accuracy.\n", + "- Hybrid Approaches: In practice, a combination of these methods can be used, depending on the scale and complexity of the simulation environment.\n", + "By incorporating these advanced collision detection methods, we can further optimize our simulations for more realistic and computationally efficient aerosol behavior modeling." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Help on function single_axis_sweep_and_prune in module particula.lagrangian.particle_pairs:\n", + "\n", + "single_axis_sweep_and_prune(position_axis: torch.Tensor, radius: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]\n", + " Sweep and prune algorithm for collision detection along a single axis.\n", + " This function identifies pairs of particles that are close enough to\n", + " potentially collide.\n", + " \n", + " Args:\n", + " position_axis (torch.Tensor): The position of particles along a single\n", + " axis.\n", + " radius (torch.Tensor): The radius of particles.\n", + " \n", + " Returns:\n", + " Tuple[torch.Tensor, torch.Tensor]: Two tensors containing the indices\n", + " of potentially colliding particles.\n", + "\n" + ] + } + ], + "source": [ + "## sweep and prune along one axis\n", + "help(particle_pairs.single_axis_sweep_and_prune)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ParticulaDev_py39", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/examples/lagrangian/testing_times.py b/docs/examples/lagrangian/testing_times.py deleted file mode 100644 index 2e147b4bc..000000000 --- a/docs/examples/lagrangian/testing_times.py +++ /dev/null @@ -1,207 +0,0 @@ - -# %% -# Code Section: Importing Necessary Libraries and Initializing Variables -import time -import torch -import numpy as np -import matplotlib.pyplot as plt -from particula.lagrangian import boundary, integration, collisions, particle_property, particle_pairs - -# Initializing the Torch Generator and setting the data type -t_gen = torch.Generator() -t_type = torch.float32 - -# %% -# Setting up the Simulation Parameters and Initial Conditions -# Define fixed parameters -TOTAL_NUMBER_OF_PARTICLES = 1000 -TIME_STEP = 0.01 -SIMULATION_TIME = 100 -MASS = 3 -CUBE_SIDE = 50 -speed = 10 -save_points = 50 - -# Initialize particle positions randomly within the cube -position = torch.rand( - 3, - TOTAL_NUMBER_OF_PARTICLES, - dtype=t_type) * CUBE_SIDE - CUBE_SIDE / 2 - -# Initialize particle velocities randomly -velocity = torch.rand(3, TOTAL_NUMBER_OF_PARTICLES, - dtype=t_type) * speed - speed / 2 - -# Initialize force as zero for all particles -force = torch.zeros(3, TOTAL_NUMBER_OF_PARTICLES, dtype=t_type) - -# Set constant mass and density for all particles -mass = torch.ones(TOTAL_NUMBER_OF_PARTICLES, dtype=t_type) * MASS -density = torch.ones(TOTAL_NUMBER_OF_PARTICLES, dtype=t_type) * 1 - -# Generate indices for particles, could be integer type -indices = torch.arange(TOTAL_NUMBER_OF_PARTICLES, dtype=t_type) # could be int - -# Calculate the total number of iterations for the simulation -total_iterations = int(SIMULATION_TIME / TIME_STEP) - -# Initialize a tensor to track the total mass over iterations -total_mass = torch.zeros(total_iterations, dtype=t_type) - -# Define gravity acting on all particles -gravity = torch.tensor( - [0, -9.81, 0]).repeat(TOTAL_NUMBER_OF_PARTICLES, 1).transpose(0, 1) - -# Initializing Arrays for Saving Position and Mass Data -# Create arrays to store position and mass data at each save point -save_position = np.zeros((3, TOTAL_NUMBER_OF_PARTICLES, save_points)) -save_mass = np.zeros((TOTAL_NUMBER_OF_PARTICLES, save_points)) - -# Determine which iterations will correspond to the save points -save_iterations = np.linspace(0, total_iterations, save_points, dtype=int) -radius = particle_property.radius(mass=mass, density=density) - - -# %% -# Initialize counter for saving data -save_counter = 0 -start_time = time.time() - -for i in range(total_iterations): - - # calculate sweep and prune collision pairs - radius = particle_property.radius(mass=mass, density=density) - valid_collision_indices_pairs = particle_pairs.full_sweep_and_prune( - position=position, radius=radius) - - # if valid_collision_indices_pairs.shape[0] > 0: - # # check 3d distance for collision pairs - # detla_position = position[:, valid_collision_indices_pairs[:, 0]] - \ - # position[:, valid_collision_indices_pairs[:, 1]] - # # Compute pairwise Euclidean distances - # distance = torch.sqrt(torch.sum(detla_position**2, dim=0)) - # distance_threshold = radius[valid_collision_indices_pairs[:, 0]] + \ - # radius[valid_collision_indices_pairs[:, 1]] - # # Check for collisions - # valid_collision_indices_pairs_final = valid_collision_indices_pairs[distance < distance_threshold] - # else: - # valid_collision_indices_pairs_final = torch.tensor([], dtype=torch.int64) - - if valid_collision_indices_pairs.shape[0] > 0: - # Coalesce particles that have collided and update their velocity and mass - velocity, mass = collisions.coalescence( - position=position, - velocity=velocity, - mass=mass, - radius=radius, - collision_indices_pairs=valid_collision_indices_pairs) - - # Calculate the force acting on the particles (e.g., gravity) - force = mass * gravity - - # Integrate the equations of motion to update position and velocity - position, velocity = integration.leapfrog( - position=position, velocity=velocity, force=force, mass=mass, time_step=TIME_STEP) - - # Apply boundary conditions for the cube (wrap-around) - position = boundary.wrapped_cube(position=position, cube_side=CUBE_SIDE) - - # Save the position and mass data at designated save points - if i == save_iterations[save_counter]: - save_position[:, :, save_counter] = position.detach().numpy() - save_mass[:, save_counter] = mass.detach().numpy() - save_counter += 1 - -# Perform a final save of the position and mass data -save_position[:, :, -1] = position.detach().numpy() -save_mass[:, -1] = mass.detach().numpy() - -# Calculate the total simulation time -end_time = time.time() -print(f"Total wall time: {end_time - start_time} seconds") -print(f"Ratio of wall time to simulation time: {(end_time - start_time) / SIMULATION_TIME}") - -# %% -# Processing the Final Data for Visualization - -# Select the final time index for the data -time_index = -2 -position_final = save_position[:, :, time_index] -mass_final = save_mass[:, time_index] - -# Filter out particles with zero mass -filter_zero_mass = mass_final > 0 - -# Calculate the radius and area of each particle -radius_final = particle_property.radius(mass=mass_final, density=density) -particle_area = np.pi * radius_final**2 - -# Display the number of remaining particles -print(f"Number of particles at the end: {filter_zero_mass.sum()}") - -# Creating a 3D Plot for Visualization -fig = plt.figure() -ax = fig.add_subplot(projection='3d') - -# Choose a color map for the scatter plot -cmap = plt.cm.viridis - -# Plot the final positions of particles with non-zero mass -scatter_plot = ax.scatter( - position_final[0, filter_zero_mass], - position_final[1, filter_zero_mass], - position_final[2, filter_zero_mass], - c=mass_final[filter_zero_mass], - cmap=cmap, - s=particle_area[filter_zero_mass] # Particle size based on area -) - -# Set axis limits based on cube dimensions -ax.set_xlim(-CUBE_SIDE / 2, CUBE_SIDE / 2) -ax.set_ylim(-CUBE_SIDE / 2, CUBE_SIDE / 2) -ax.set_zlim(-CUBE_SIDE / 2, CUBE_SIDE / 2) - -# Add a color bar indicating particle mass -color_bar = plt.colorbar(scatter_plot, ax=ax) -color_bar.set_label('Mass') - -# Show the plot with optimized layout -plt.show() -fig.tight_layout() - -# %% [markdown] -# ## Analyzing the Mass Distribution of Particles - -# %% -# Visualizing the Mass Distribution at Different Stages - -# Create a new figure for the histogram -fig = plt.figure() -ax = fig.add_subplot() -# Normalizing by initial MASS to observe distribution changes -normalized_mass = save_mass[filter_zero_mass, :] / MASS -max_mass = normalized_mass.max() - -# Plot histograms of mass distribution at different stages -ax.hist(normalized_mass[:, 0], bins=25, - alpha=0.8, label='Initial', range=(0, max_mass)) -ax.hist(normalized_mass[:, 24], bins=25, - alpha=0.6, label='Middle', range=(0, max_mass)) -ax.hist(normalized_mass[:, -1], bins=25, - alpha=0.5, label='Final', range=(0, max_mass)) - -# Setting labels and title for the plot -ax.set_xlabel('Mass / Initial MASS') -ax.set_ylabel('Number of Particles') - -# Add a legend to the plot -ax.legend() - -# Display the plot -plt.show() - -# Adjust layout for optimal visualization -fig.tight_layout() - -# %% [markdown] -# ## Summary of the Lagrangian Particle Simulation From c1c30ad30e19e6032a06ff6cfa8312f194adc9a2 Mon Sep 17 00:00:00 2001 From: Kyle Gorkowski Date: Thu, 30 Nov 2023 13:02:28 -0700 Subject: [PATCH 09/11] added doc to test --- particula/lagrangian/tests/particle_pairs_test.py | 1 + 1 file changed, 1 insertion(+) diff --git a/particula/lagrangian/tests/particle_pairs_test.py b/particula/lagrangian/tests/particle_pairs_test.py index 0c48d27bf..f8bf93071 100644 --- a/particula/lagrangian/tests/particle_pairs_test.py +++ b/particula/lagrangian/tests/particle_pairs_test.py @@ -24,6 +24,7 @@ def test_calculate_pairwise_distance(): def test_single_axis_sweep_and_prune(): + """Test single axis sweep and prune algorithm.""" # Test case with some overlapping particles position_axis = torch.tensor([1.0, 2.0, 4.0, 5.0]) radius = torch.tensor([0.5, 1.5, 0.2, 0.2]) From 89725dafc77a6be30334e77b10772f6514b2f8e7 Mon Sep 17 00:00:00 2001 From: Kyle Gorkowski Date: Thu, 30 Nov 2023 14:26:29 -0700 Subject: [PATCH 10/11] updated validate pair distance with test --- .../examples/lagrangian/sweep_and_prune.ipynb | 6 +-- particula/lagrangian/particle_pairs.py | 44 ++++++++++++------- .../lagrangian/tests/particle_pairs_test.py | 22 ++++++++++ 3 files changed, 54 insertions(+), 18 deletions(-) diff --git a/docs/examples/lagrangian/sweep_and_prune.ipynb b/docs/examples/lagrangian/sweep_and_prune.ipynb index 6ee0c4bcf..1b6c65608 100644 --- a/docs/examples/lagrangian/sweep_and_prune.ipynb +++ b/docs/examples/lagrangian/sweep_and_prune.ipynb @@ -118,8 +118,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "Total wall time: 10.669302225112915 seconds\n", - "Ratio of wall time to simulation time: 0.10669302225112914\n" + "Total wall time: 12.119566679000854 seconds\n", + "Ratio of wall time to simulation time: 0.12119566679000854\n" ] } ], @@ -340,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": {}, "outputs": [ { diff --git a/particula/lagrangian/particle_pairs.py b/particula/lagrangian/particle_pairs.py index a05c85bc1..75edbc6e5 100644 --- a/particula/lagrangian/particle_pairs.py +++ b/particula/lagrangian/particle_pairs.py @@ -82,22 +82,36 @@ def validate_pair_distance( radius: torch.Tensor ) -> torch.Tensor: """ - need to test this: - Calculate if the pairwise Euclidean distances between points in a given - position tensor is smaller than the sum of the radius of the particles. - """ - # Fast return if there are no particles - if collision_indices_pairs.shape[0] == 0: - return torch.tensor([]) + Validates if the Euclidean distances between pairs of points are smaller + than the sum of their radii. - # check 3d distance for collision pairs - detla_position = position[:, collision_indices_pairs[:, 0]] - \ - position[:, collision_indices_pairs[:, 1]] - # Compute pairwise Euclidean distances - distance = torch.sqrt(torch.sum(detla_position**2, dim=0)) - distance_threshold = radius[collision_indices_pairs[:, 0]] + \ - radius[collision_indices_pairs[:, 1]] - # Check and return collision pairs + Args: + collision_indices_pairs (torch.Tensor): A tensor containing pairs of + indices of potentially colliding particles. + position (torch.Tensor): A 2D tensor of particle positions, where each + column represents a particle, and each row represents an axis. + radius (torch.Tensor): A 1D tensor representing the radius of each + particle. + + Returns: + torch.Tensor: A tensor containing the indices of the pairs of + particles that are actually colliding. + """ + # Fast return if there are no particle pairs + if collision_indices_pairs.numel() == 0: + return torch.tensor([], dtype=torch.int64) + + # Calculate 3D distance for each pair of particles + delta_position = position[:, collision_indices_pairs[:, 0]] \ + - position[:, collision_indices_pairs[:, 1]] + # Euclidean distance between particles + distance = torch.sqrt(torch.sum(delta_position**2, axis=0)) + # radius sum of both particles + distance_threshold = radius[collision_indices_pairs[:, 0]] \ + + radius[collision_indices_pairs[:, 1]] + + # Return the pairs of particles where the distance is less than the sum of + # their radii return collision_indices_pairs[distance < distance_threshold] diff --git a/particula/lagrangian/tests/particle_pairs_test.py b/particula/lagrangian/tests/particle_pairs_test.py index f8bf93071..43810ea08 100644 --- a/particula/lagrangian/tests/particle_pairs_test.py +++ b/particula/lagrangian/tests/particle_pairs_test.py @@ -42,3 +42,25 @@ def test_single_axis_sweep_and_prune(): assert torch.equal(left_indices, torch.tensor([])) assert torch.equal(right_indices, torch.tensor([])) + + +def test_validate_pair_distance(): + """Test validating pair distances.""" + # Mock data + collision_indices_pairs = torch.tensor([[0, 1], [1, 2]]) + position = torch.tensor([[0.0, 1.0, 1.0], + [0.0, 0.0, 0.0], + [5.0, 5.0, 0.0]]) + radius = torch.tensor([1.5, 1.5, 0.5]) + + # Expected output: Only the first pair should collide + expected_output = torch.tensor([[0, 1]]) + + # Run the function + actual_output = particle_pairs.validate_pair_distance( + collision_indices_pairs=collision_indices_pairs, + position=position, + radius=radius) + + # Assert the result + assert torch.equal(actual_output, expected_output) From e5f1a687bac108aeb94d4861acb0498e9e08466d Mon Sep 17 00:00:00 2001 From: Kyle Gorkowski Date: Sun, 3 Dec 2023 07:56:00 -0800 Subject: [PATCH 11/11] review edits Fixes #411 --- particula/lagrangian/collisions.py | 3 --- particula/lagrangian/particle_pairs.py | 7 +++++-- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/particula/lagrangian/collisions.py b/particula/lagrangian/collisions.py index f8bc0bb58..91d240401 100644 --- a/particula/lagrangian/collisions.py +++ b/particula/lagrangian/collisions.py @@ -107,9 +107,6 @@ def coalescence( sorted_pairs, _ = torch.sort(collision_indices_pairs, dim=1) unique_left_indices = particle_pairs.remove_duplicates(sorted_pairs, 0) unique_indices = particle_pairs.remove_duplicates(unique_left_indices, 1) - # fast return if no collisions - if unique_indices.shape[0] == 0: - return velocity, mass unique_indices = particle_pairs.validate_pair_distance( collision_indices_pairs=unique_indices, position=position, diff --git a/particula/lagrangian/particle_pairs.py b/particula/lagrangian/particle_pairs.py index 75edbc6e5..1d65b967e 100644 --- a/particula/lagrangian/particle_pairs.py +++ b/particula/lagrangian/particle_pairs.py @@ -99,7 +99,7 @@ def validate_pair_distance( """ # Fast return if there are no particle pairs if collision_indices_pairs.numel() == 0: - return torch.tensor([], dtype=torch.int64) + return torch.tensor([], dtype=torch.bool) # Calculate 3D distance for each pair of particles delta_position = position[:, collision_indices_pairs[:, 0]] \ @@ -239,7 +239,8 @@ def full_sweep_and_prune( def full_sweep_and_prune_simplified( position: torch.Tensor, - radius: torch.Tensor + radius: torch.Tensor, + working_yet: bool = False ) -> torch.Tensor: """ A simplified version of the full sweep and prune algorithm for collision @@ -259,6 +260,8 @@ def full_sweep_and_prune_simplified( torch.Tensor: A tensor containing pairs of indices of potentially colliding particles. """ + if not working_yet: + raise NotImplementedError if radius.shape[0] == 0: return torch.tensor([])