Struct HiggsDetector 

pub struct HiggsDetector { /* private fields */ }

Specialized detector for Higgs bosons in collision data

Implementations

impl HiggsDetector

pub fn new(num_qubits: usize) -> Result<Self>

Creates a new Higgs detector

Examples found in repository

examples/hep_classification.rs (line 93)

fn main() -> Result<()> {
    println!("Quantum High-Energy Physics Classification Example");
    println!("=================================================");

    // Create a quantum classifier for high-energy physics data
    let num_qubits = 8;
    let feature_dim = 8;
    let num_classes = 2;

    println!("Creating HEP quantum classifier with {num_qubits} qubits...");
    let mut classifier = HEPQuantumClassifier::new(
        num_qubits,
        feature_dim,
        num_classes,
        quantrs2_ml::hep::HEPEncodingMethod::HybridEncoding,
        vec!["background".to_string(), "higgs".to_string()],
    )?;

    // Generate synthetic training data
    println!("Generating synthetic training data...");
    let (training_particles, training_labels) = generate_synthetic_data(500);

    println!("Training quantum classifier...");
    let start = Instant::now();
    let metrics = classifier.train_on_particles(
        &training_particles,
        &training_labels,
        20,   // epochs
        0.05, // learning rate
    )?;

    println!("Training completed in {:.2?}", start.elapsed());
    println!("Final loss: {:.4}", metrics.final_loss);

    // Generate test data
    println!("Generating test data...");
    let (test_particles, test_labels) = generate_synthetic_data(100);

    // Evaluate classifier
    println!("Evaluating classifier...");
    // Convert test data to ndarray format
    let num_samples = test_particles.len();
    let mut test_features = Array2::zeros((num_samples, classifier.feature_dimension));
    let mut test_labels_array = Array1::zeros(num_samples);

    for (i, particle) in test_particles.iter().enumerate() {
        let features = classifier.extract_features(particle)?;
        for j in 0..features.len() {
            test_features[[i, j]] = features[j];
        }
        test_labels_array[i] = test_labels[i] as f64;
    }

    let evaluation = classifier.evaluate(&test_features, &test_labels_array)?;

    println!("Evaluation results:");
    println!("  Overall accuracy: {:.2}%", evaluation.accuracy * 100.0);

    println!("Class accuracies:");
    for (i, &acc) in evaluation.class_accuracies.iter().enumerate() {
        println!("  {}: {:.2}%", evaluation.class_labels[i], acc * 100.0);
    }

    // Create a test collision event
    println!("\nClassifying a test collision event...");
    let event = create_test_collision_event();

    // Run classification
    let classifications = classifier.classify_event(&event)?;

    println!("Event classification results:");
    for (i, (class, confidence)) in classifications.iter().enumerate() {
        println!("  Particle {i}: {class} (confidence: {confidence:.2})");
    }

    // Create a Higgs detector
    println!("\nCreating Higgs detector...");
    let higgs_detector = quantrs2_ml::hep::HiggsDetector::new(num_qubits)?;

    // Detect Higgs
    let higgs_detections = higgs_detector.detect_higgs(&event)?;

    println!("Higgs detection results:");
    let higgs_count = higgs_detections.iter().filter(|&&x| x).count();
    println!("  Found {higgs_count} potential Higgs particles");

    Ok(())
}

pub fn detect_higgs(&self, event: &CollisionEvent) -> Result<Vec<bool>>

Detects Higgs bosons in a collision event

Examples found in repository

examples/hep_classification.rs (line 96)

fn main() -> Result<()> {
    println!("Quantum High-Energy Physics Classification Example");
    println!("=================================================");

    // Create a quantum classifier for high-energy physics data
    let num_qubits = 8;
    let feature_dim = 8;
    let num_classes = 2;

    println!("Creating HEP quantum classifier with {num_qubits} qubits...");
    let mut classifier = HEPQuantumClassifier::new(
        num_qubits,
        feature_dim,
        num_classes,
        quantrs2_ml::hep::HEPEncodingMethod::HybridEncoding,
        vec!["background".to_string(), "higgs".to_string()],
    )?;

    // Generate synthetic training data
    println!("Generating synthetic training data...");
    let (training_particles, training_labels) = generate_synthetic_data(500);

    println!("Training quantum classifier...");
    let start = Instant::now();
    let metrics = classifier.train_on_particles(
        &training_particles,
        &training_labels,
        20,   // epochs
        0.05, // learning rate
    )?;

    println!("Training completed in {:.2?}", start.elapsed());
    println!("Final loss: {:.4}", metrics.final_loss);

    // Generate test data
    println!("Generating test data...");
    let (test_particles, test_labels) = generate_synthetic_data(100);

    // Evaluate classifier
    println!("Evaluating classifier...");
    // Convert test data to ndarray format
    let num_samples = test_particles.len();
    let mut test_features = Array2::zeros((num_samples, classifier.feature_dimension));
    let mut test_labels_array = Array1::zeros(num_samples);

    for (i, particle) in test_particles.iter().enumerate() {
        let features = classifier.extract_features(particle)?;
        for j in 0..features.len() {
            test_features[[i, j]] = features[j];
        }
        test_labels_array[i] = test_labels[i] as f64;
    }

    let evaluation = classifier.evaluate(&test_features, &test_labels_array)?;

    println!("Evaluation results:");
    println!("  Overall accuracy: {:.2}%", evaluation.accuracy * 100.0);

    println!("Class accuracies:");
    for (i, &acc) in evaluation.class_accuracies.iter().enumerate() {
        println!("  {}: {:.2}%", evaluation.class_labels[i], acc * 100.0);
    }

    // Create a test collision event
    println!("\nClassifying a test collision event...");
    let event = create_test_collision_event();

    // Run classification
    let classifications = classifier.classify_event(&event)?;

    println!("Event classification results:");
    for (i, (class, confidence)) in classifications.iter().enumerate() {
        println!("  Particle {i}: {class} (confidence: {confidence:.2})");
    }

    // Create a Higgs detector
    println!("\nCreating Higgs detector...");
    let higgs_detector = quantrs2_ml::hep::HiggsDetector::new(num_qubits)?;

    // Detect Higgs
    let higgs_detections = higgs_detector.detect_higgs(&event)?;

    println!("Higgs detection results:");
    let higgs_count = higgs_detections.iter().filter(|&&x| x).count();
    println!("  Found {higgs_count} potential Higgs particles");

    Ok(())
}

pub fn score_particle(&self, particle: &ParticleFeatures) -> Result<f64>

Computes a score for a particle (higher = more likely to be a Higgs)

Trait Implementations

impl Clone for HiggsDetector

fn clone(&self) -> HiggsDetector

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HiggsDetector

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

Formats the value using the given formatter.