Struct ThermalProfile 

pub struct ThermalProfile {
    pub rate: CoolingRate,
    pub max_cooling_duration: Duration,
    pub detect_clustering: bool,
    pub detect_phase_transitions: bool,
    pub detect_conservation: bool,
    pub detect_correlations: bool,
}

The thermal profile controls how the kiln cools.

Just as a potter controls the cooling rate to influence crackle patterns, the thermal profile controls the sensitivity and character of pattern detection.

Fields

rate: CoolingRate

The cooling rate.

max_cooling_duration: Duration

Maximum time to spend in cooling phase per task.

detect_clustering: bool

Whether to enable clustering pattern detection.

detect_phase_transitions: bool

Whether to enable phase transition detection.

detect_conservation: bool

Whether to enable conservation law detection.

detect_correlations: bool

Whether to enable correlation detection.

Implementations

impl ThermalProfile

pub fn fast_cooling() -> Self

Create a profile optimized for fast cooling — many fine patterns.

Examples found in repository

examples/basic.rs (line 30)

fn main() {
    let mut kiln = Kiln::new(ThermalProfile::fast_cooling());

        kiln.fire_and_record(NumberTask { value: 2.0, name: "a".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 2.1, name: "b".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 9.8, name: "c".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 10.0, name: "d".into() }).unwrap();
    kiln.fire_and_record(NumberTask { value: 2.2, name: "e".into() }).unwrap();

    println!("Tasks in kiln: {}", kiln.task_count());

    let patterns = kiln.cool();
    println!("\nDetected {} pattern(s):\n", patterns.len());

    for p in &patterns {
        println!("[{}] {}", p.kind(), p.description());
        println!("  confidence: {:.2}", p.confidence());
        println!("  tasks: {:?}\n", p.involved_tasks());
    }
}

examples/event_stream_processor.rs (line 114)

fn main() {
    let total_events = 1000;
    let batch_size = 100;
    let num_batches = total_events / batch_size;

    println!("═══════════════════════════════════════════════════════════════");
    println!("  CRACKLE-RUNTIME: EVENT STREAM PROCESSOR TEST");
    println!("═══════════════════════════════════════════════════════════════\n");
    println!("Processing {} events across {} batches of {}...\n",
             total_events, num_batches, batch_size);

    let start = Instant::now();

    // Phase 1: Healthy system (batches 1-4)
    println!("─── Phase 1: Healthy System ───");
    let mut healthy_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batch 1-4: all healthy, 10ms baseline latency
    for batch_id in 1..=4 {
        let events = simulate_batch(batch_id, batch_size as u32, 10.0, 0.05);
        for event in events {
            healthy_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} fired ({} events, {:.0}ms)",
                 batch_id, num_batches, batch_size, elapsed.as_millis());
    }

    // Cool healthy phase
    let healthy_patterns = healthy_kiln.cool();
    println!("\n  Healthy system patterns ({} detected):", healthy_patterns.len());
    for p in &healthy_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }
    // Also check conservation on records_in/records_out
    let conservation = healthy_kiln.distribution_shift(10);
    println!("    Distribution shifts:");
    for (name, shift) in &conservation[..conservation.len().min(3)] {
        println!("      {} → KL = {:.4}", name, shift);
    }

    println!();

    // Phase 2: Degrading system (batches 5-8)
    println!("─── Phase 2: Degrading System ───");

    let mut degrading_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Batches where degradation ramps up
    let degradation_levels = [0.2, 0.5, 0.9, 1.5];
    for (i, &degradation) in degradation_levels.iter().enumerate() {
        let batch_id = (5 + i) as u32;
        // latency increases with degradation
        let base_latency = 10.0 + degradation * 50.0;

        let events = simulate_batch(batch_id, batch_size as u32, base_latency, degradation);
        for event in events {
            degrading_kiln.fire_and_record(event).unwrap();
        }

        let elapsed = start.elapsed();
        println!("  Batch {}/{} [degradation={:.1}x] fired (latency baseline: {:.0}ms, {:.0}ms total)",
                 batch_id, num_batches, degradation, base_latency, elapsed.as_millis());
    }

    let degrading_patterns = degrading_kiln.cool();
    println!("\n  Degrading system patterns ({} detected):", degrading_patterns.len());
    for p in &degrading_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // JSD shift (distribution shape changes)
    let jsd_shifts = degrading_kiln.jsd_shift(10);
    println!("    JSD shifts (distribution shape changes):");
    for (name, shift) in &jsd_shifts[..jsd_shifts.len().min(5)] {
        println!("      {} → JSD = {:.4}", name, shift);
    }

    // Permutation entropy (temporal structure)
    let pes = degrading_kiln.permutation_entropies(4);
    println!("    Permutation entropies (temporal structure):");
    for (name, pe) in &pes {
        println!("      {} → PE = {:.4}", name, pe);
    }

    println!();

    // Phase 3: Conservation law test — records in = records out should be violated
    // as errors increase
    println!("─── Phase 3: Conservation Law Verification ───");
    let mut conservation_kiln = Kiln::new(
        ThermalProfile::fast_cooling()
    );

    // Force records_in = records_out for first 3 batches (healthy conservation)
    for batch_id in 1..=3 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0,
            throughput: 100.0,
            memory_mb: 128.0,
            error_rate: 0.01,
            records_in: 1000.0,
            records_out: 995.0,  // nearly conserved
            cpu_temp_c: 65.0,
            latency_p99_ms: 25.0,
            consumer_lag: 10.0,
            gc_pause_ms: 5.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    // Force violation of records conservation (errors spike)
    for batch_id in 4..=6 {
        let event = ProcessedEvent {
            event_id: batch_id as u64,
            batch_id: batch_id as u32,
            processing_time_ms: 10.0 + batch_id as f64 * 10.0,
            throughput: 50.0,
            memory_mb: 256.0,
            error_rate: 0.3,
            records_in: 1000.0,
            records_out: 700.0,  // 30% loss — conservation violated
            cpu_temp_c: 80.0,
            latency_p99_ms: 100.0,
            consumer_lag: 500.0,
            gc_pause_ms: 20.0,
        };
        conservation_kiln.fire_and_record(event).unwrap();
    }

    let conservation_patterns = conservation_kiln.cool();
    println!("  Conservation-specific patterns ({} detected):", conservation_patterns.len());
    for p in &conservation_patterns {
        println!("    [{:?}] {} (conf: {:.2})", p.kind(), p.description(), p.confidence());
    }

    // MI matrix to show nonlinear dependencies
    let mi = conservation_kiln.mi_matrix(8);
    println!("  Mutual Information matrix (8 bins):");
    let metric_names = ["processing_time_ms", "error_rate", "records_in", "records_out", "memory_mb"];
    for (i, name_i) in metric_names.iter().enumerate() {
        for (j, name_j) in metric_names.iter().enumerate() {
            if i == j {
                println!("    I({:25}; {:25}) = H({})", name_i, name_j, name_i);
            } else {
                println!("    I({:25}; {:25}) = {:.4} bits", name_i, name_j, mi[i][j]);
            }
        }
    }

    println!();
    println!("───────────────────────────────────────────────────────────────");
    println!("  SUMMARY");
    println!("───────────────────────────────────────────────────────────────\n");

    // Degradation detection analysis
    println!("  Degradation Metrics:");
    let pt = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::PhaseTransition));
    let pt_count = pt.count();
    println!("    Phase transitions detected in degraded system: {} alerts",
             pt_count);

    let corr = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Correlation));
    let corr_count = corr.count();
    println!("    Correlations in degraded system: {} pairs", corr_count);

    let cons = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Conservation));
    let cons_count = cons.count();
    println!("    Conservation laws in degraded system: {} found", cons_count);

    let clust = degrading_patterns.iter().filter(|p| matches!(p.kind(), crackle_runtime::PatternKind::Clustering));
    let clust_count = clust.count();
    println!("    Clusters in degraded system: {} groups", clust_count);

    println!();
    let total_duration = start.elapsed();
    println!("  Total test duration: {:.2}s", total_duration.as_secs_f64());
    println!("  Events processed: {}", total_events);
    println!("  Avg throughput: {:.0} events/s",
             total_events as f64 / total_duration.as_secs_f64());
}

pub fn slow_cooling() -> Self

Create a profile optimized for slow cooling — fewer, larger patterns.

pub fn no_detection() -> Self

Create a profile with all detection disabled (useful for benchmarking).

pub fn with_rate(self, rate: CoolingRate) -> Self

Set the cooling rate.

pub fn without_clustering(self) -> Self

Disable clustering detection.

pub fn without_phase_transitions(self) -> Self

Disable phase transition detection.

pub fn without_conservation(self) -> Self

Disable conservation law detection.

pub fn without_correlations(self) -> Self

Disable correlation detection.

Trait Implementations

impl Clone for ThermalProfile

fn clone(&self) -> ThermalProfile

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ThermalProfile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ThermalProfile

fn default() -> Self

Returns the “default value” for a type.