causal-triangulations 0.0.1

Causal Dynamical Triangulations in d-dimensions
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

//! Basic example of using the Causal Dynamical Triangulations library
//!
//! This example shows how to:
//! - Create a CDT triangulation programmatically
//! - Configure simulation parameters
//! - Run a basic CDT simulation
//! - Extract and display results

use causal_triangulations::{CdtConfig, CdtTriangulation, MetropolisAlgorithm};
use log::{LevelFilter, info};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    env_logger::Builder::new()
        .filter_level(LevelFilter::Info)
        .init();

    info!("Starting basic CDT example");

    // Configuration parameters
    let vertices = 64;
    let timeslices = 4;
    let dimension = 2;

    // Create initial triangulation
    info!("Creating initial triangulation with {vertices} vertices and {timeslices} timeslices");
    let triangulation = CdtTriangulation::from_random_points(vertices, timeslices, dimension)?;

    info!(
        "Initial triangulation: {} vertices, {} edges, {} faces",
        triangulation.vertex_count(),
        triangulation.edge_count(),
        triangulation.face_count()
    );

    // Create a configuration for the simulation
    let mut config = CdtConfig::new(vertices, timeslices);
    config.temperature = 1.0;
    config.steps = 100;
    config.thermalization_steps = 20;
    config.measurement_frequency = 5;
    config.coupling_0 = 1.0;
    config.coupling_2 = 1.0;
    config.cosmological_constant = 0.1;

    // Extract individual configs
    let metropolis_config = config.to_metropolis_config();
    let action_config = config.to_action_config();

    // Run the simulation
    info!("Running CDT simulation...");
    let mut algorithm = MetropolisAlgorithm::new(metropolis_config, action_config);
    let results = algorithm.run(triangulation);

    // Display results
    info!("Simulation completed!");
    info!("Results:");
    info!("  Steps executed: {}", results.steps.len());
    info!(
        "  Acceptance rate: {:.2}%",
        results.acceptance_rate() * 100.0
    );
    info!("  Average action: {:.3}", results.average_action());

    // Final triangulation statistics
    let final_triangulation = &results.triangulation;
    info!("Final triangulation:");
    info!("  Vertices: {}", final_triangulation.vertex_count());
    info!("  Edges: {}", final_triangulation.edge_count());
    info!("  Faces: {}", final_triangulation.face_count());

    // Display some measurements
    if !results.measurements.is_empty() {
        info!("Sample measurements:");
        for measurement in results.measurements.iter().take(5) {
            info!(
                "  Step {}: Action={:.3}, V={}, E={}, T={}",
                measurement.step,
                measurement.action,
                measurement.vertices,
                measurement.edges,
                measurement.triangles
            );
        }

        if results.measurements.len() > 5 {
            info!(
                "  ... ({} more measurements)",
                results.measurements.len() - 5
            );
        }
    }

    info!("Example completed successfully!");
    Ok(())
}