Skip to content

Preparation for collisions. Optimization #30

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
vasarm wants to merge 8 commits into
base: master
Choose a base branch
from
Open

Preparation for collisions. Optimization #30

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
fbcef1e
Preparation for collisions. Optimization
vasarm Jun 5, 2023
029c0f3
Refactor. Checkpoint.
vasarm Jun 9, 2023
1f6871e
Test fix.
vasarm Jun 9, 2023
67fa89a
Collision fix.
vasarm Jun 14, 2023
2bbacf2
Fix max_step parameter usage.
vasarm Jun 27, 2023
a12b562
Bug fix
vasarm Jun 28, 2023
45c0ab1
Bug fix
vasarm Jun 28, 2023
2c21862
Memeory fix
vasarm Jun 28, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions .gitignore
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,8 @@
dependencies/OpenCL
bubbleSim/data

# CLtracer files (used for profiling OpenCL)
*.cltracer

# User-specific files
*.rsuser
Expand Down
113 changes: 57 additions & 56 deletions bubbleSim/bubbleSim.vcxproj.filters
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,96 +1,97 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
</Filter>
<Filter Include="Resource Files">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
<Filter Include="Kernels">
<UniqueIdentifier>{ad3d76ba-6f94-404f-bc5d-04c6fe891d8f}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Objects">
<UniqueIdentifier>{ead60fb0-b85b-4979-a0a9-ef637c5cf283}</UniqueIdentifier>
<Filter Include="Physics">
<UniqueIdentifier>{d8b60eea-a10a-4d44-93e7-1c97ff73bee3}</UniqueIdentifier>
</Filter>
<Filter Include="Physics\Particle">
<UniqueIdentifier>{95515f3a-561d-4459-b2c3-c2100ac20678}</UniqueIdentifier>
</Filter>
<Filter Include="Header Files\Objects">
<UniqueIdentifier>{0187af86-67e0-4ada-9316-2c50a6d1db91}</UniqueIdentifier>
<Filter Include="Physics\Bubble">
<UniqueIdentifier>{0a343cca-4fdc-401b-a415-4dcaa58ee610}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Generators">
<UniqueIdentifier>{70c9ae99-7764-4421-ad94-5ac76b6b096b}</UniqueIdentifier>
<Filter Include="Physics\Dynamics">
<UniqueIdentifier>{8d4d525e-9435-47ad-9eb5-1de1e4fb1975}</UniqueIdentifier>
</Filter>
<Filter Include="Source Files\Streamers">
<UniqueIdentifier>{a5c559dd-9d80-4aef-a16b-8988be73efcd}</UniqueIdentifier>
<Filter Include="Stream">
<UniqueIdentifier>{3c2ad733-df12-4a24-b5ff-a4632821a808}</UniqueIdentifier>
</Filter>
<Filter Include="Header Files\Streamers">
<UniqueIdentifier>{729ee2fd-1b8b-46ac-87ea-9dccda36f30d}</UniqueIdentifier>
<Filter Include="OpenCL">
<UniqueIdentifier>{01d28b61-e628-46b8-b3f5-1a908e45d035}</UniqueIdentifier>
</Filter>
<Filter Include="Config">
<UniqueIdentifier>{737877a4-c2eb-4180-b746-d325876d14d1}</UniqueIdentifier>
</Filter>
<Filter Include="Code">
<UniqueIdentifier>{f596f1c2-9307-4993-9c65-9f20f7cfe7bc}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="simulation.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="source.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="base.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="opencl_kernels.h">
<Filter>Header Files</Filter>
<ClInclude Include="particle.h">
<Filter>Physics\Particle</Filter>
</ClInclude>
<ClInclude Include="bubble.h">
<Filter>Header Files\Objects</Filter>
</ClInclude>
<ClInclude Include="particle.h">
<Filter>Header Files\Objects</Filter>
<Filter>Physics\Bubble</Filter>
</ClInclude>
<ClInclude Include="objects.h">
<Filter>Header Files\Objects</Filter>
<Filter>Physics</Filter>
</ClInclude>
<ClInclude Include="random_number.hpp">
<Filter>Source Files\Generators</Filter>
<ClInclude Include="collision.h">
<Filter>Physics\Dynamics</Filter>
</ClInclude>
<ClInclude Include="datastreamer.h">
<Filter>Stream</Filter>
</ClInclude>
<ClInclude Include="opencl_kernels.h">
<Filter>OpenCL</Filter>
</ClInclude>
<ClInclude Include="config_reader.hpp">
<Filter>Header Files</Filter>
<Filter>Config</Filter>
</ClInclude>
<ClInclude Include="collision.h">
<Filter>Header Files</Filter>
<ClInclude Include="base.h">
<Filter>Code</Filter>
</ClInclude>
<ClInclude Include="datastreamer.h">
<Filter>Header Files\Streamers</Filter>
<ClInclude Include="simulation.h">
<Filter>Code</Filter>
</ClInclude>
<ClInclude Include="source.h">
<Filter>Code</Filter>
</ClInclude>
<ClInclude Include="timestep.h">
<Filter>Header Files</Filter>
<Filter>Code</Filter>
</ClInclude>
<ClInclude Include="random_number.hpp">
<Filter>Code</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="simulation.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="source.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="opencl_kernels.cpp">
<Filter>Source Files</Filter>
<ClCompile Include="particle.cpp">
<Filter>Physics\Particle</Filter>
</ClCompile>
<ClCompile Include="bubble.cpp">
<Filter>Source Files\Objects</Filter>
</ClCompile>
<ClCompile Include="particle.cpp">
<Filter>Source Files\Objects</Filter>
<Filter>Physics\Bubble</Filter>
</ClCompile>
<ClCompile Include="collision.cpp">
<Filter>Source Files</Filter>
<Filter>Physics\Dynamics</Filter>
</ClCompile>
<ClCompile Include="datastreamer.cpp">
<Filter>Source Files\Streamers</Filter>
<Filter>Stream</Filter>
</ClCompile>
<ClCompile Include="opencl_kernels.cpp">
<Filter>OpenCL</Filter>
</ClCompile>
<ClCompile Include="simulation.cpp">
<Filter>Code</Filter>
</ClCompile>
<ClCompile Include="source.cpp">
<Filter>Code</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
Expand Down
132 changes: 105 additions & 27 deletions bubbleSim/collision.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,22 +5,23 @@ CollisionCellCollection::CollisionCellCollection(
bool t_doubleCellCount, cl::Context& cl_context) {
int openCLerrNum;

/* TODO
* Add label to particles which distinguises if particle is inside or outside the bubble -> collision cell count gets 2x bigger
*
*/
m_doubleCellCount = t_doubleCellCount;

if (t_cellCountInOneAxis % 2 != 1) {
std::cerr << "Cell count in one axis must be odd. (" << t_cellCountInOneAxis
<< ")" << std::endl;
std::terminate();
}

if (t_doubleCellCount) {
m_cellCount = 2 * (unsigned int)std::pow(t_cellCountInOneAxis, 3) + 1;
} else {
m_cellCount = (unsigned int)std::pow(t_cellCountInOneAxis, 3) + 1;
}
m_cellCount = (unsigned int)std::pow(t_cellCountInOneAxis, 3) + 1;
m_cellCountBuffer =
cl::Buffer(cl_context, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
sizeof(unsigned int), &m_cellCount, &openCLerrNum);

m_doubleCellCount = t_doubleCellCount;

m_meanFreePath = t_meanFreePath;

m_cellCountInOneAxis = t_cellCountInOneAxis;
Expand Down Expand Up @@ -52,46 +53,62 @@ CollisionCellCollection::CollisionCellCollection(

void CollisionCellCollection::generateShiftVector(
RandomNumberGenerator& t_rng) {
m_shiftVector = {m_cellLength / 2. - t_rng.generate_number() * m_cellLength,
m_cellLength / 2. - t_rng.generate_number() * m_cellLength,
m_cellLength / 2. - t_rng.generate_number() * m_cellLength};
m_shiftVector = {m_cellLength / (numType)2. - t_rng.generate_number() * m_cellLength,
m_cellLength / (numType)2. - t_rng.generate_number() * m_cellLength,
m_cellLength / (numType)2. - t_rng.generate_number() * m_cellLength};
}

void CollisionCellCollection::recalculate_cells(
std::vector<Particle>& t_particles, RandomNumberGenerator& t_rng) {
// 0 index cell is for particles outside the collision cell grid

double phi, theta;
numType phi, theta;

std::vector<std::array<cl_numType, 5>> frames;
frames.resize(m_cellCount);
std::vector<std::array<cl_numType, 6>> frames(m_cellCount, { (cl_numType)0,(cl_numType)0,(cl_numType)0,(cl_numType)0,(cl_numType)0,(cl_numType)1 });
/*
* Sum up all momentums, energies and masses for each cell
*/
for (Particle particle : t_particles) {
for (Particle& particle : t_particles) {
if (particle.idxCollisionCell == 0) continue;
frames[particle.idxCollisionCell][0] += particle.p_x;
frames[particle.idxCollisionCell][1] += particle.p_y;
frames[particle.idxCollisionCell][2] += particle.p_z;
frames[particle.idxCollisionCell][0] += particle.pX;
frames[particle.idxCollisionCell][1] += particle.pY;
frames[particle.idxCollisionCell][2] += particle.pZ;
frames[particle.idxCollisionCell][3] += particle.E;
frames[particle.idxCollisionCell][4] += 1;
frames[particle.idxCollisionCell][5] *= particle.E;
}
/*
* Calculate velocities for each collision cell
*/
for (size_t i = 1; i < m_cellCount; i++) {
m_collisionCells[i].particle_count = (int)frames[i][4];
if (frames[i][4] > 1) {
/*if (frames[i][4] != 2) {
m_collisionCells[i].particle_count = (int)0;
continue;
}
if (t_rng.generate_number() >= 0.01*0.01 / (9*frames[i][5])) {
m_collisionCells[i].particle_count = (int)0;
continue;
}
*/

if (t_rng.generate_number() >= std::pow(0.01, frames[i][4]) / (9*frames[i][5])) {
m_collisionCells[i].particle_count = (int)0;
continue;
}


m_collisionCells[i].v_x = frames[i][0] / frames[i][3];
m_collisionCells[i].v_y = frames[i][1] / frames[i][3];
m_collisionCells[i].v_z = frames[i][2] / frames[i][3];
m_collisionCells[i].total_mass =
std::sqrt(std::pow(frames[i][3], 2) - std::pow(frames[i][0], 2) -
std::pow(frames[i][1], 2) - std::pow(frames[i][2], 2));
m_collisionCells[i].p_x = frames[i][0] / frames[i][4];
m_collisionCells[i].p_y = frames[i][1] / frames[i][4];
m_collisionCells[i].p_z = frames[i][2] / frames[i][4];
m_collisionCells[i].p_E = frames[i][3] / frames[i][4];
m_collisionCells[i].pX = frames[i][0] / frames[i][4];
m_collisionCells[i].pY = frames[i][1] / frames[i][4];
m_collisionCells[i].pZ = frames[i][2] / frames[i][4];
m_collisionCells[i].pE = frames[i][3] / frames[i][4];

/*
* beta = sqrt(v_x^2 + v_y^2 + v_z^2);
Expand All @@ -104,16 +121,77 @@ void CollisionCellCollection::recalculate_cells(
* gamma = 1/sqrt(1-beta^2)
*/
m_collisionCells[i].gamma = 1 / std::sqrt(1 - m_collisionCells[i].v2);
phi = std::acos(1 - 2 * t_rng.generate_number());
theta = 2 * M_PI * t_rng.generate_number();

/*
* Generate rotation axis and angle for CollisionCell
*/
m_collisionCells[i].theta = 2 * M_PI * t_rng.generate_number();
// Generate parameters for rotation axis
phi = std::acos((numType)1. - (numType)2. * t_rng.generate_number());
theta = (numType)2. * (numType)M_PI * t_rng.generate_number();

// Define rotation angle and axis
m_collisionCells[i].theta = (numType)2. * (numType)M_PI * t_rng.generate_number();
m_collisionCells[i].x = std::sin(phi) * std::cos(theta);
m_collisionCells[i].y = std::sin(phi) * std::sin(theta);
m_collisionCells[i].z = std::cos(phi);
}
}
}

void CollisionCellCollection::recalculate_cells2(
std::vector<Particle>& t_particles, RandomNumberGenerator& t_rng) {
// 0 index cell is for particles outside the collision cell grid

numType phi, theta;

std::vector<std::array<cl_numType, 5>> frames;
frames.resize(m_cellCount);
/*
* Sum up all momentums, energies and masses for each cell
*/
for (Particle& particle : t_particles) {
if (particle.idxCollisionCell == 0) continue;
frames[particle.idxCollisionCell][0] += particle.pX;
frames[particle.idxCollisionCell][1] += particle.pY;
frames[particle.idxCollisionCell][2] += particle.pZ;
frames[particle.idxCollisionCell][3] += particle.E;
frames[particle.idxCollisionCell][4] += 1;
}
/*
* Calculate velocities for each collision cell
*/
for (size_t i = 1; i < m_cellCount; i++) {
m_collisionCells[i].particle_count = (int)frames[i][4];
if (frames[i][4] > 1) {
m_collisionCells[i].v_x = frames[i][0] / frames[i][3];
m_collisionCells[i].v_y = frames[i][1] / frames[i][3];
m_collisionCells[i].v_z = frames[i][2] / frames[i][3];
m_collisionCells[i].total_mass =
std::sqrt(std::pow(frames[i][3], 2) - std::pow(frames[i][0], 2) -
std::pow(frames[i][1], 2) - std::pow(frames[i][2], 2));
m_collisionCells[i].pX = frames[i][0] / frames[i][4];
m_collisionCells[i].pY = frames[i][1] / frames[i][4];
m_collisionCells[i].pZ = frames[i][2] / frames[i][4];
m_collisionCells[i].pE = frames[i][3] / frames[i][4];

/*
* beta = sqrt(v_x^2 + v_y^2 + v_z^2);
*/
m_collisionCells[i].v2 =
std::fma(m_collisionCells[i].v_x, m_collisionCells[i].v_x,
std::fma(m_collisionCells[i].v_y, m_collisionCells[i].v_y,
m_collisionCells[i].v_z * m_collisionCells[i].v_z));
/*
* gamma = 1/sqrt(1-beta^2)
*/
m_collisionCells[i].gamma = 1 / std::sqrt(1 - m_collisionCells[i].v2);

// Generate parameters for rotation axis
phi = std::acos((numType)1. - (numType)2. * t_rng.generate_number());
theta = (numType)2. * (numType)M_PI * t_rng.generate_number();

// Define rotation angle and axis
m_collisionCells[i].theta = (numType)2. * (numType)M_PI * t_rng.generate_number();
m_collisionCells[i].x = std::sin(phi) * std::cos(theta);
m_collisionCells[i].y = std::sin(phi) * std::sin(theta);
m_collisionCells[i].z = std::cos(phi);
}
}
}
15 changes: 10 additions & 5 deletions bubbleSim/collision.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,6 +2,7 @@
#include "base.h"
#include "objects.h"
typedef struct CollisionCell {
cl_numType gamma;
cl_numType v_x;
cl_numType v_y;
cl_numType v_z;
Expand All @@ -12,13 +13,12 @@ typedef struct CollisionCell {

cl_numType theta;

cl_numType p_E;
cl_numType p_x;
cl_numType p_y;
cl_numType p_z;
cl_numType pE;
cl_numType pX;
cl_numType pY;
cl_numType pZ;

cl_numType v2;
cl_numType gamma;
cl_numType total_mass;
cl_uint particle_count;
} CollisionCell;
Expand All @@ -30,9 +30,14 @@ class CollisionCellCollection {

std::array<numType, 3>& getShiftVector() { return m_shiftVector; }

unsigned int getCellCount() { return m_cellCount; }

void recalculate_cells(std::vector<Particle>& t_particles,
RandomNumberGenerator& t_rng);

void recalculate_cells2(std::vector<Particle>& t_particles,
RandomNumberGenerator& t_rng);

void generateShiftVector(RandomNumberGenerator& t_rng);

cl::Buffer& getCellBuffer() { return m_collisionCellsBuffer; }
Expand Down
Loading