Skip to content
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

feat(core): implement 3D grid generation #256

Draft
wants to merge 6 commits into
base: master
Choose a base branch
from
Draft

feat(core): implement 3D grid generation #256

Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
0472e4c
write a hex gen fucntion for 3D beta values
imrn99 Dec 13, 2024
25062fc
Merge branch 'master' into builder-3d-grid
imrn99 Jan 20, 2025
b33ea81
WIP
imrn99 Feb 6, 2025
ccc3dde
Merge branch 'builder-3d-grid' of https://github.com/LIHPC-Computatio…
imrn99 Feb 6, 2025
1b2c430
Merge branch 'master' into builder-3d-grid
imrn99 Feb 6, 2025
5be6c92
finish the build_3d_grid routine
imrn99 Feb 6, 2025
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
281 changes: 281 additions & 0 deletions honeycomb-core/src/cmap/builder/grid.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,3 +1,7 @@
use std::usize;

use crate::cmap::{CMap3, VertexIdType};
use crate::geometry::{Vector3, Vertex3};
use crate::prelude::{BuilderError, CMap2, DartIdType, Vector2, Vertex2};
use crate::{attributes::AttrStorageManager, geometry::CoordsFloat};

Expand Down Expand Up @@ -163,6 +167,8 @@ impl<T: CoordsFloat> GridDescriptor<T> {

// --- building routines

// ------ 2D

/// Internal grid-building routine
#[allow(clippy::too_many_lines)]
pub fn build_2d_grid<T: CoordsFloat>(
Expand Down Expand Up @@ -378,3 +384,278 @@ fn generate_tris_beta_values(n_x: usize, n_y: usize) -> impl Iterator<Item = [Da
})
})
}

// ------ 3D

/// Internal grid-building routine
#[allow(clippy::too_many_lines)]
pub fn build_3d_grid<T: CoordsFloat>(
origin: Vertex3<T>,
ns: [usize; 3],
lens: [T; 3],
manager: AttrStorageManager,
) -> CMap3<T> {
let [n_square_x, n_square_y, n_square_z] = ns;
let n_darts = 24 * n_square_x * n_square_y * n_square_z;

let map: CMap3<T> = CMap3::new_with_undefined_attributes(n_darts, manager);

// init beta functions
(1..=n_darts as DartIdType)
.zip(generate_hex_beta_values(ns))
.for_each(|(dart, images)| {
map.set_betas(dart, images);
});

// place vertices
(1..=n_darts as DartIdType)
.filter(|d| *d as VertexIdType == map.vertex_id(*d))
.for_each(|d| {
let v = origin + generate_hex_offset(d, ns, lens);
map.force_write_vertex(d as VertexIdType, v);
});

// check the number of built volumes
// this is set as debug only because the operation cost scales with map size
// this can quickly overshadow the exectime of all previous code
debug_assert_eq!(
map.iter_volumes().count(),
n_square_x * n_square_y * n_square_z
);

map
}

//
// y+
// z+ |
// \ |
// \ |
// \|
// +------x+
//
//
// +------+
// |\ |\
// | \13 \
// | \ 21| \
// |17 +------+
// +- -|- + 9 |
// \ | \ |
// \ |1 5 |
// \| \|
// +------+
//
// down: 1
// sides: 5, 9, 13, 17
// up: 21
//
#[allow(clippy::inline_always, unused)]
#[rustfmt::skip]
#[inline(always)]
fn generate_hex_beta_values(
[n_x, n_y, n_z]: [usize; 3],
) -> impl Iterator<Item = [DartIdType; 4]> {
// this loop hierarchy yields the value in correct order
// left to right first, then bottom to top
(0..n_z).flat_map(move |iz| {
(0..n_y).flat_map(move |iy| {
(0..n_x).flat_map(move |ix| {
let d1 = (1 + 24 * ix + n_x * 24 * iy + n_x * n_y * 24 * iz) as DartIdType;
let ( d2 , d3 , d4 , d5 , d6 , d7 , d8 ,
d9 , d10, d11, d12, d13, d14, d15, d16,
d17, d18, d19, d20, d21, d22, d23, d24,
) = ( d1 + 1 , d1 + 2 , d1 + 3 , d1 + 4 , d1 + 5 , d1 + 6 , d1 + 7 ,
d1 + 8 , d1 + 9 , d1 + 10, d1 + 11, d1 + 12, d1 + 13, d1 + 14, d1 + 15,
d1 + 16, d1 + 17, d1 + 18, d1 + 19, d1 + 20, d1 + 21, d1 + 22, d1 + 23,
);
let noffset_x = 24;
let noffset_y = 24 * n_x as DartIdType;
let noffset_z = 24 * (n_x * n_y ) as DartIdType;

// beta images of the cube (tm)
[
// down (1, y-)
[d4 , d2 , d5 , if iy == 0 { 0 } else { d21 - noffset_y }],
[d1 , d3 , d9 , if iy == 0 { 0 } else { d24 - noffset_y }],
[d2 , d4 , d13, if iy == 0 { 0 } else { d23 - noffset_y }],
[d3 , d1 , d17, if iy == 0 { 0 } else { d22 - noffset_y }],
// side (5 , z-)
[d8 , d6 , d1 , if iz == 0 { 0 } else { d13 - noffset_z }],
[d5 , d7 , d10, if iz == 0 { 0 } else { d16 - noffset_z }],
[d6 , d8 , d21, if iz == 0 { 0 } else { d15 - noffset_z }],
[d7 , d5 , d20, if iz == 0 { 0 } else { d14 - noffset_z }],
// side (9 , x+)
[d12, d10, d2 , if ix == n_x - 1 { 0 } else { d17 - noffset_z }],
[d9 , d11, d6 , if ix == n_x - 1 { 0 } else { d20 - noffset_z }],
[d10, d12, d24, if ix == n_x - 1 { 0 } else { d19 - noffset_z }],
[d11, d9 , d14, if ix == n_x - 1 { 0 } else { d18 - noffset_z }],
// side (13, z+)
[d16, d14, d3 , if iz == n_z - 1 { 0 } else { d5 + noffset_z }],
[d13, d15, d12, if iz == n_z - 1 { 0 } else { d8 + noffset_z }],
[d14, d16, d23, if iz == n_z - 1 { 0 } else { d7 + noffset_z }],
[d15, d13, d18, if iz == n_z - 1 { 0 } else { d6 + noffset_z }],
// side (17, x-)
[d20, d18, d4 , if ix == 0 { 0 } else { d9 + noffset_z }],
[d17, d19, d16, if ix == 0 { 0 } else { d12 + noffset_z }],
[d18, d20, d22, if ix == 0 { 0 } else { d11 + noffset_z }],
[d19, d17, d8 , if ix == 0 { 0 } else { d10 + noffset_z }],
// up (21, y+)
[d24, d22, d7 , if iy == n_y - 1 { 0 } else { d1 + noffset_y }],
[d21, d23, d14, if iy == n_y - 1 { 0 } else { d4 + noffset_y }],
[d22, d24, d15, if iy == n_y - 1 { 0 } else { d3 + noffset_y }],
[d23, d21, d11, if iy == n_y - 1 { 0 } else { d2 + noffset_y }],
]
.into_iter()
})
})
})
}

#[allow(clippy::inline_always, unused)]
#[inline(always)]
fn generate_hex_offset<T: CoordsFloat>(
dart: DartIdType,
[n_x, n_y, _]: [usize; 3],
[lx, ly, lz]: [T; 3],
) -> Vector3<T> {
// d = p + 24*x + 24*NX*y + 24*NX*NY*z
let d = dart as usize;
let dm = d % 24;
let dmm = d % (24 * n_x);
let dmmm = d % (24 * n_x * n_y);
let p = dm;
let x = (dmm - dm) / 24;
let y = (dmmm - dmm) / (24 * n_x);
let z = dmmm / (24 * n_x * n_y);
match p {
// d1 to d24
// y- face
1 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z).unwrap() * lz,
),
2 => Vector3(
T::from(x).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z).unwrap() * lz,
),
3 => Vector3(
T::from(x).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
4 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
// z- face
5 => Vector3(
T::from(x).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z).unwrap() * lz,
),
6 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z).unwrap() * lz,
),
7 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z).unwrap() * lz,
),
8 => Vector3(
T::from(x).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z).unwrap() * lz,
),
// x+ face
9 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z).unwrap() * lz,
),
10 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
11 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
12 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z).unwrap() * lz,
),
// z+ face
13 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
14 => Vector3(
T::from(x).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
15 => Vector3(
T::from(x).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
16 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
// x- face
17 => Vector3(
T::from(x).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
18 => Vector3(
T::from(x).unwrap() * lx,
T::from(y).unwrap() * ly,
T::from(z).unwrap() * lz,
),
19 => Vector3(
T::from(x).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z).unwrap() * lz,
),
20 => Vector3(
T::from(x).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
// y+ face
21 => Vector3(
T::from(x).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z).unwrap() * lz,
),
22 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z).unwrap() * lz,
),
23 => Vector3(
T::from(x + 1).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
0 => Vector3(
T::from(x).unwrap() * lx,
T::from(y + 1).unwrap() * ly,
T::from(z + 1).unwrap() * lz,
),
_ => unreachable!(),
}
}
Loading