conspire 0.6.0

The Rust interface to conspire.
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

use crate::{
    EPSILON,
    math::{
        Scalar,
        test::{TestError, assert_eq_from_fd},
    },
    physics::{
        BOLTZMANN_CONSTANT, ROOM_TEMPERATURE,
        molecular::single_chain::{Ensemble, ExtensibleFreelyJointedChain, Thermodynamics},
    },
};

const STIFFNESS: Scalar = 5.0 * BOLTZMANN_CONSTANT * ROOM_TEMPERATURE;
const NUM: usize = 333;

#[test]
fn monte_carlo() {
    use crate::physics::molecular::single_chain::MonteCarloExtensible;
    let model = ExtensibleFreelyJointedChain {
        link_length: 1.0,
        link_stiffness: STIFFNESS,
        number_of_links: 5,
        ensemble: Ensemble::Isometric(ROOM_TEMPERATURE),
    };
    let (gamma, g) =
        MonteCarloExtensible::nondimensional_radial_distribution(&model, 0.0, 333, 10_000, 1, 3.0);
    gamma
        .into_iter()
        .zip(g)
        .for_each(|(gamma_i, g_i)| println!("[{gamma_i}, {g_i}],"))
}

#[test]
fn finite_difference() -> Result<(), TestError> {
    let link_stiffness = 1e3;
    [Ensemble::Isotensional(ROOM_TEMPERATURE)]
        .into_iter()
        .try_for_each(|ensemble| {
            (3..16).into_iter().try_for_each(|number_of_links| {
                let model = ExtensibleFreelyJointedChain {
                    link_length: 1.0,
                    link_stiffness,
                    number_of_links,
                    ensemble,
                };
                (10..NUM)
                    .map(|k| k as Scalar / NUM as Scalar * 0.6 * link_stiffness)
                    .into_iter()
                    .try_for_each(|mut nondimensional_force| {
                        nondimensional_force += 0.5 * EPSILON;
                        let mut finite_difference_3 = -model
                            .nondimensional_gibbs_free_energy_per_link(nondimensional_force)?;
                        // let mut finite_difference_4 =
                        //     model.nondimensional_extension(nondimensional_force)?;
                        nondimensional_force -= EPSILON;
                        finite_difference_3 -= -model
                            .nondimensional_gibbs_free_energy_per_link(nondimensional_force)?;
                        // finite_difference_4 -=
                        //     model.nondimensional_extension(nondimensional_force)?;
                        nondimensional_force += 0.5 * EPSILON;
                        let nondimensional_extension =
                            model.nondimensional_extension(nondimensional_force)?;
                        // let nondimensional_compliance =
                        //     model.nondimensional_compliance(nondimensional_force)?;
                        assert_eq_from_fd(
                            &nondimensional_extension,
                            &(finite_difference_3 / EPSILON),
                        )
                        // assert_eq_from_fd(
                        //     &nondimensional_compliance,
                        //     &(finite_difference_4 / EPSILON),
                        // )
                    })
            })
        })
}