reservoir order formalized

    min_release: f64,

    catchment_inflow: Vec<f64>,

    target_release: Vec<f64>,

    simulation_order: i32,

}

#[derive(FromPyObject)]

    let n = first_reservoir.catchment_inflow.len();

    let mut results = HashMap::new();

    let reservoir_names: Vec<&String> = cascade_data.reservoirs.keys().collect();

    for name in reservoir_names.iter() {

        let reservoir = &cascade_data.reservoirs[*name];

    // Create and sort reservoirs by simulation order

    let mut ordered_reservoirs: Vec<(&String, &ReservoirData)> = cascade_data.reservoirs

        .iter()

        .collect();

    ordered_reservoirs.sort_by_key(|(_, data)| data.simulation_order);

    // Initialize results

    // Initialize results (similar to before, but using ordered_reservoirs)

    for (name, reservoir_data) in &ordered_reservoirs {

        let mut storage = vec![0.0; n];

        storage[0] = reservoir.initial_storage;

        results.insert(name.to_string(), ReservoirResults {

        storage[0] = reservoir_data.initial_storage;

        results.insert((*name).to_string(), ReservoirResults {

            storage,

            release: vec![0.0; n],

            spill: vec![0.0; n],

            catchment_inflow: reservoir.catchment_inflow.clone(),

            catchment_inflow: reservoir_data.catchment_inflow.clone(),

            total_inflow: vec![0.0; n],

            target_release: reservoir.target_release.clone(),

            target_release: reservoir_data.target_release.clone(),

        });

    }

    // simulation loop

    for t in 0..n {

        for (i, name) in reservoir_names.iter().enumerate() {

            let reservoir  = &cascade_data.reservoirs[*name];

        for (i, (name, reservoir_data)) in ordered_reservoirs.iter().enumerate() {

            // Calculate inflow: use input inflow for first reservoir,

            // otherwise use outflow from previous reservoir

            let current_inflow = if i == 0 {

                reservoir.catchment_inflow[t]

                reservoir_data.catchment_inflow[t]

            } else {

                let prev_name = &reservoir_names[i-1];

                let prev_name = &ordered_reservoirs[i-1].0;

                let prev_results = &results[*prev_name];

                reservoir.catchment_inflow[t] + prev_results.release[t] + prev_results.spill[t]

                reservoir_data.catchment_inflow[t] + prev_results.release[t] + prev_results.spill[t]

            };

            // Get previous storage for this reservoir

            let current_results = results.get_mut(*name).unwrap();  // Changed to use ReservoirResults

            let previous_storage = if t == 0 { 

                reservoir.initial_storage 

                reservoir_data.initial_storage 

            } else { 

                current_results.storage[t-1]  

            };

            // Simulate this timestep

            let state = simulate_timestep(

                reservoir,

                reservoir_data,

                current_inflow,

                reservoir.target_release[t],

                reservoir_data.target_release[t],

                previous_storage,

            );