oxiphysics-gpu 0.1.1

GPU acceleration backends for the OxiPhysics engine
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

//! # TemperatureScaleKernel - Trait Implementations
//!
//! This module contains trait implementations for `TemperatureScaleKernel`.
//!
//! ## Implemented Traits
//!
//! - `ComputeKernel`
//!
//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)

#[allow(unused_imports)]
use super::functions::*;
use crate::compute::ComputeKernel;

use super::types::TemperatureScaleKernel;

impl ComputeKernel for TemperatureScaleKernel {
    fn name(&self) -> &str {
        "TemperatureScaleKernel"
    }
    fn execute(&self, inputs: &[&[f64]], outputs: &mut [Vec<f64>], work_size: usize) {
        if inputs.len() < 3 || outputs.len() < 2 {
            return;
        }
        let vel_flat = inputs[0];
        let masses = inputs[1];
        let params = inputs[2];
        if params.len() < 2 {
            return;
        }
        let t_target = params[0];
        let kb = params[1];
        let n = work_size;
        let ke2: f64 = (0..n)
            .map(|i| {
                let m = if i < masses.len() { masses[i] } else { 1.0 };
                let vx = vel_flat[i * 3];
                let vy = vel_flat[i * 3 + 1];
                let vz = vel_flat[i * 3 + 2];
                m * (vx * vx + vy * vy + vz * vz)
            })
            .sum();
        let n_dof = (3 * n) as f64;
        let t_before = if kb > 1e-30 { ke2 / (n_dof * kb) } else { 0.0 };
        let scale = if t_before > 1e-30 && t_target >= 0.0 {
            (t_target / t_before).sqrt()
        } else {
            1.0
        };
        let mut new_vel = vel_flat.to_vec();
        for i in 0..n {
            new_vel[i * 3] *= scale;
            new_vel[i * 3 + 1] *= scale;
            new_vel[i * 3 + 2] *= scale;
        }
        let ke2_after: f64 = (0..n)
            .map(|i| {
                let m = if i < masses.len() { masses[i] } else { 1.0 };
                let vx = new_vel[i * 3];
                let vy = new_vel[i * 3 + 1];
                let vz = new_vel[i * 3 + 2];
                m * (vx * vx + vy * vy + vz * vz)
            })
            .sum();
        let t_after = if kb > 1e-30 {
            ke2_after / (n_dof * kb)
        } else {
            0.0
        };
        outputs[0] = new_vel;
        outputs[1] = vec![t_before, t_after];
    }
}