hoomd-interaction 1.1.0

Hamiltonians and other interaction models that apply to hoomd-rs simulations.
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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

// Copyright (c) 2024-2026 The Regents of the University of Michigan.
// Part of hoomd-rs, released under the BSD 3-Clause License.

//! Test derive(MaximumInteractionRange)

use assert2::check;
use hoomd_interaction::{
    MaximumInteractionRange, SitePairEnergy,
    pairwise::{AngularMask, Anisotropic, HardSphere},
    univariate::Boxcar,
};
use hoomd_vector::Cartesian;

// Compile error
// #[derive(MaximumInteractionRange)]
// struct Tuple(f64);

// Compile error
// #[derive(MaximumInteractionRange)]
// enum Enum {
//     A,B
// }

// Compile error
// #[derive(MaximumInteractionRange)]
// union Union {
//     f1: u32,
//     f2: f32,
// }

// Compile Error
// #[derive(MaximumInteractionRange)]
// struct InvalidNamed {
//     positions: f64,
// }

struct One;
struct Two;
struct Three;

impl MaximumInteractionRange for One {
    fn maximum_interaction_range(&self) -> f64 {
        1.0
    }
}
impl MaximumInteractionRange for Two {
    fn maximum_interaction_range(&self) -> f64 {
        2.0
    }
}
impl MaximumInteractionRange for Three {
    fn maximum_interaction_range(&self) -> f64 {
        3.0
    }
}

#[derive(MaximumInteractionRange)]
struct Unit;

#[test]
fn unit() {
    let unit = Unit;
    check!(unit.maximum_interaction_range() == 0.0);
}

#[derive(MaximumInteractionRange)]
struct CombinedNamed {
    one: One,
    two: Two,
    three: Three,
}

#[test]
fn combined_named() {
    let combined_named = CombinedNamed {
        one: One,
        two: Two,
        three: Three,
    };
    check!(combined_named.maximum_interaction_range() == 3.0);
}

#[derive(MaximumInteractionRange)]
struct CombinedUnnamed(One, Two, Three);

#[test]
fn combined_unnamed() {
    let combined_unnamed = CombinedUnnamed(One, Two, Three);
    check!(combined_unnamed.maximum_interaction_range() == 3.0);
}

#[derive(MaximumInteractionRange)]
struct SitePair {
    maximum_interaction_range: f64,
}

#[test]
fn site_pair() {
    let site_pair = SitePair {
        maximum_interaction_range: 5.0,
    };
    check!(site_pair.maximum_interaction_range() == 5.0);
}

// Test that the derive macro doesn't have issues with Anisotropic<AngularMask...
// In some contexts, it needs to be used as Anisotropic::<AngularMask..., but cargo fmt
// removes the :: when not needed.

#[allow(dead_code, reason = "The test passes if it compiles")]
#[derive(MaximumInteractionRange, SitePairEnergy)]
struct SitePairInteraction {
    hard_disk: HardSphere,
    angular_mask: Anisotropic<AngularMask<Boxcar, Cartesian<2>>>,
}