HeteroDRIME-Lite: Event-triggered cooperative planning for heterogeneous UAV fleets with warm-start RIME optimization

Abstract

Cooperative mission planning for heterogeneous unmanned aerial vehicle (UAV) fleets operating in contested or post-disaster environments remains a significant challenge due to the diversity of UAV capabilities and the unpredictability of operational conditions. This paper proposes HeteroDRIME-Lite, a dynamic cooperative planning framework for heterogeneous multi-UAV systems comprising three specialized types: Scout (reconnaissance), Relay (communication), and Carrier (delivery). The framework couples strict type–task matching, an event-triggered replanning mechanism, and a warm-start population initialization for the RIME optimizer. We evaluate the framework over five benchmark scenarios with 30 independent runs each and compare it against eleven baselines, including the published methods NSGA-II, MOEA/D, PSO, GA, DE, ACO, and consensus-based bundle auction (CBBA). Event-triggered replanning sustains 100% task coverage in every scenario, whereas a single-allocation static variant covers only 64–71%. HeteroDRIME-Lite attains significantly lower makespan and energy than all population-based metaheuristics (Wilcoxon signed-rank test, $p < 0.001$ , with large Cohen's d effect sizes), while keeping the average per-event replanning time near 40 ms, one to two orders of magnitude faster than those baselines. Warm-start initialization reduces the number of convergence iterations by about 40% (median $2.7 \times$ speedup) and lowers replanning energy by up to 60% relative to cold start; a sensitivity sweep confirms that the 30/30/40 inheritance–mutation–random ratio is near-optimal. We further clarify, through ablation, that heterogeneity in this framework is a mission-feasibility requirement rather than an efficiency gain, and we analyze the resulting makespan trade-off.

Keywords

Heterogeneous UAV cooperative mission planning event-triggered replanning RIME optimization warm-start initialization swarm intelligence

Introduction

The deployment of multi-UAV systems in complex defense and emergency missions, such as battlefield reconnaissance, post-disaster search and rescue, and logistics resupply under hostile conditions, has attracted growing research attention. In military operations, UAV swarms are relied upon for intelligence, surveillance, and reconnaissance (ISR), communication relay in denied environments, and rapid delivery of critical supplies. Heterogeneous fleets comprising UAVs with specialized capabilities can match each agent's strengths to specific mission requirements. However, planning missions for such fleets introduces significant challenges in task allocation, path planning, and dynamic coordination.

A fundamental limitation of many existing methods is their reliance on static allocation paradigms, where tasks are assigned once and executed without modification. This rigidity is at odds with the dynamic nature of operational environments, where new targets may be discovered, threat zones may appear, and agents may fail due to hostile interference. Dynamic replanning addresses this but introduces its own challenges: replanning too frequently wastes computational resources and energy, while replanning too infrequently causes delayed responses.

This paper proposes HeteroDRIME-Lite, an event-triggered cooperative planning framework for heterogeneous UAV fleets with warm-start optimization. We emphasize that the individual ingredients, heterogeneous task matching, event-triggered replanning, warm-start initialization, and the RIME optimizer, are each known in isolation. The contribution of this work is therefore not their mere combination, but the following specific and empirically validated claims:

A task-identity-keyed warm-start population transfer scheme that allows the RIME optimizer to inherit structure from the previous solution when the task set changes. We show on 30-run experiments that this reduces convergence iterations by about 40% (median $2.7 \times$ ) and replanning energy by up to 60% relative to cold start, and we provide a sensitivity analysis justifying the inheritance–mutation–random ratio.

An event-triggered replanning design whose three triggers (new target arrival, threat/obstacle discovery, and progress timeout) sustain 100% task coverage at an average replanning latency near 40 ms, compared with 64–71% coverage for a static single-allocation policy.

A controlled empirical study showing that, under the small per-event compute budget characteristic of online replanning, this combination significantly outperforms seven established planners (NSGA-II, MOEA/D, PSO, GA, DE, ACO, CBBA) on makespan and energy, and we analyze why. We additionally give an honest account of the role of heterogeneity, which we find to be a feasibility constraint rather than an efficiency gain.

The remainder of this paper is organized as follows. Section 2 reviews related work. Section 3 formulates the problem. Section 4 details the proposed framework. Section 5 presents experiments. Section 6 discusses findings. Section 7 concludes.

Related work

Multi-UAV task allocation

The Multi-Robot Task Allocation (MRTA) problem has been studied extensively, and several taxonomies organize it along the axes of single- versus multi-task robots, single- versus multi-robot tasks, and instantaneous versus time-extended assignment.^1–4 For heterogeneous systems, effective coordination requires explicit modeling of agent capabilities and task requirements.⁵ Two broad solution families dominate. Market- and auction-based methods, of which the consensus-based bundle algorithm (CBBA)⁶ is the canonical decentralized representative, achieve fast, conflict-free assignments but optimize bids myopically and can leave makespan far from optimal when assignment and routing are tightly coupled. Optimization- and metaheuristic-based methods cast allocation and routing jointly as a single combinatorial program and search it with evolutionary or swarm operators; this yields higher-quality plans at greater computational cost. Our work belongs to the second family but targets the online regime, where the compute budget per planning episode is small and is the binding constraint.

Dynamic replanning methods

Dynamic environments demand adaptive planning strategies. Existing dynamic vehicle routing studies generally identify event-driven and periodic replanning as the two main paradigms. Rolling-horizon optimization offers a middle ground but does not discriminate between situations that require urgent replanning and those where the current plan remains adequate. Event-triggered control, in which computation is invoked only when a measured condition crosses a threshold, has become a standard tool for reducing resource usage in networked and multi-agent systems; we adapt this principle to mission replanning. A recurring difficulty is that recomputing a plan from scratch at every event is wasteful, since consecutive plans are usually similar. This observation motivates our warm-start transfer, which is conceptually related to solution reuse in receding-horizon control and to population seeding in dynamic evolutionary optimization.

Swarm intelligence and metaheuristic optimization

Swarm intelligence and evolutionary algorithms have been applied widely to multi-robot optimization. Single-objective methods include particle swarm optimization (PSO),⁷ genetic algorithms (GA),⁸ differential evolution (DE),⁹ and ant colony optimization (ACO).¹⁰ Multi-objective methods such as NSGA-II,¹¹ NSGA-III,¹² and MOEA/D¹³ return a Pareto set rather than a single scalarized solution. The RIME algorithm,¹⁴ inspired by rime-ice formation, introduces a soft-rime search operator for global exploration and a hard-rime puncture operator for local refinement; its low parameter count is advantageous for online replanning where per-instance tuning is impractical. We use NSGA-II, MOEA/D, PSO, GA, DE, ACO, and CBBA as baselines in Section 5 so that the proposed framework is benchmarked against established, published methods rather than only against self-designed variants.

Beyond task allocation, metaheuristic and model-predictive techniques have proven effective for the lower-level guidance and control of individual UAVs, including metaheuristic-optimized path planning and tracking for payload hold-release missions¹⁵ and model predictive control of UAV-mounted gimbal systems for disturbance-aware target tracking.¹⁶ These works address trajectory generation, real-time decision-making, and disturbance rejection at the single-vehicle level and are complementary to the fleet-level coordination problem studied here. Broader surveys of multi-robot target detection and tracking,¹⁷ UAV applications and small-scale UAV platforms,^18–24 UAV communication networks,^20–23 and disaster-response deployment²² provide the general operational background for this study.

Problem formulation

System model

Consider a heterogeneous multi-UAV system comprising n UAVs operating in a 2D workspace $W \subset R^{2}$ containing obstacle or threat regions $O (t)$ that may change over time. The UAV fleet $U = {u_{1}, u_{2}, \dots, u_{n}}$ consists of three types: Scout UAVs $U_{S}$ with high speed for reconnaissance; Relay UAVs $U_{R}$ with enhanced communication range for network connectivity; and Carrier UAVs $U_{C}$ with high payload capacity for delivery.

Each UAV $u_{k}$ is characterized by the following parameters, with their physical meanings and units stated explicitly:

$v_{k}^{\max}$ (m/s): maximum cruise speed, which sets the travel time of a leg of given length.

$r_{k}^{comm}$ (m): communication radius, the maximum range over which $u_{k}$ can maintain a reliable link while acting as a relay.

$w_{k}$ (payload units): payload capacity; only Carrier UAVs carry a capacity sufficient for delivery tasks.

$e_{k}$ (J/m): energy coefficient, the energy expended per metre flown, used in the energy objective $F_{2} = \sum_{k} e_{k} D_{k}$ .

$L_{k}$ (m): maximum travel range (endurance expressed as distance), which bounds the total path length of $u_{k}$ through the constraint $D_{k} \leq L_{k}$ .

The system consists of 3 Scout, 2 Relay, and 3 Carrier UAVs $(n = 8)$ . Figure 1

Figure 1.

Comparison of three heterogeneous UAV types. Scout UAVs feature high speed for reconnaissance tasks; Relay UAVs have superior communication capability for network relay; Carrier UAVs possess high payload capacity for delivery missions. The bottom panel illustrates task–UAV matching relationships.

Task model

The task set evolves dynamically as $T (t) = T_{initial} \cup T_{discovered} (t)$ . Each task $T_{i}$ is defined by its location $(x_{i}, y_{i}) \in W$ , type $τ_{i} \in {Recon, Delivery, Relay}$ , and service time $s_{i}$ (s). Tasks in $T_{initial}$ are known at $t = 0$ ; tasks in $T_{discovered} (t)$ become known only at their release time and are one source of replanning events.

Type–task matching constraints

A strict type–task matching rule governs task assignment:

Match (τ_{i}, type (u_{k})) = {\begin{matrix} 1, & τ_{i} = Recon, u_{k} \in U_{S}, \\ 1, & τ_{i} = Delivery, u_{k} \in U_{C}, \\ 1, & τ_{i} = Relay, u_{k} \in U_{R} \cup U_{S} \cup U_{C}, \\ 0, & otherwise . \end{matrix}

This rule encodes a physical reality: a Recon task requires the sensor suite and speed of a Scout, and a Delivery task requires the payload capacity of a Carrier. It is therefore a feasibility constraint, not a tunable design choice, a point we return to in Section 6.

Objective functions

The cooperative planning problem involves three competing objectives. The makespan is the time at which the last UAV completes its assigned route,

F_{1} = \max_{k \in {1, \dots, n}} T_{k}^{complete},

the total energy consumption is

F_{2} = \sum_{k = 1}^{n} e_{k} \cdot D_{k},

where

D_{k}

is the total distance flown by

u_{k}

, and the task coverage is

F_{3} = \frac{| T_{covered} |}{| T (t) |} .

For algorithmic consistency, $F_{3}$ is converted to minimization form $(1 - F_{3})$ during optimization.

Constraints

x_{i k} \in {0, 1} \forall i, k; \sum_{k} x_{i k} \leq 1 \forall T_{i}; x_{i k} \leq Match (τ_{i}, type (u_{k})) \forall i, k; D_{k} \leq L_{k} \forall u_{k},

where $x_{i k}$ is the binary assignment variable. The constraints enforce, in order, binary assignment, single assignment of each task, type matching, and the range limit. A task that cannot be reached by its assigned UAV within the remaining range $L_{k} - D_{k}$ is treated as uncovered and penalized, which is how the range constraint couples to the coverage objective.

Scope of the model

The present model is a 2D kinematic abstraction: UAVs move along obstacle-aware piecewise-linear paths at constant cruise speed, and threats are modeled as circular no-fly regions. We deliberately exclude battery-discharge curves, turning-radius and altitude dynamics, wind, and explicit collision-avoidance maneuvering. This scope isolates the contribution of this paper, namely the allocation-and-replanning layer, from lower-level guidance and control. The communication limit is modeled through $r_{k}^{comm}$ : a Relay task incurs an additional repositioning cost when the serving UAV's communication range falls short of the required link, which is what makes the communication-limited scenario (S3) materially harder. Extending the model to 3D flight with realistic propagation, battery, and dynamics is the most immediate direction for future work (Section 6).

HeteroDRIME-Lite algorithm

System architecture

The overall architecture consists of four interconnected modules: an Input Module containing UAV fleet specifications, the task set, and environmental information; the RIME Optimizer for task allocation and path planning; the Dynamic Replanning Engine with event-trigger detection and warm-start initialization; and the Output Module generating task assignments and flight trajectories Figure 2.

Figure 2.

Overall architecture of the HeteroDRIME-lite algorithm, comprising the input, RIME optimizer, dynamic replanning engine, and output modules. The runtime monitoring loop enables continuous adaptation to evolving mission conditions.

Chromosome encoding

A two-segment encoding captures both task assignment and execution sequencing:

Chromosome = [a_{1}, a_{2}, \dots, a_{m} ∣ π_{1}, π_{2}, \dots, π_{m}] .

Each gene lies in $[0, 1]$ . The assignment gene $a_{i}$ selects a UAV for task $T_{i}$ from the set of type-feasible UAVs only; this structurally guarantees that every decoded solution satisfies the type–task matching constraint. The priority gene $π_{i}$ determines the execution order of task $T_{i}$ within its assigned UAV's queue (smaller value served earlier). The search space is thus the unit hypercube $[0, 1]^{2 m}$ , which is well matched to the bounded RIME operators.

RIME-based optimization with weighted-sum scalarization

The RIME algorithm uses two operators. The soft-rime (rime-ice formation) operator pulls a growing fraction of dimensions toward the incumbent best,

X_{i}^{t + 1} = X_{best}^{t} + r_{1} \cdot (X_{best}^{t} - X_{i}^{t}) \cdot \cos (θ),

where

r_{1} \in [- 1, 1]

, the angle

θ = (π / 2) (t / T)

shrinks the step from exploration toward exploitation over the iteration budget T, and the fraction of updated dimensions follows the attachment coefficient

E = \sqrt{t / T}

so that early iterations preserve diversity and later iterations converge. The hard-rime puncture operator performs Lévy-flight local search,

X_{i}^{t + 1} = X_{i}^{t} + r_{2} \cdot Levy (β) .

The three objectives are aggregated into a scalar fitness:

f (x) = w_{1} {\hat{F}}_{1} (x) + w_{2} {\hat{F}}_{2} (x) + w_{3} (1 - F_{3} (x)) + P \cdot u (x),

where

{\hat{F}}_{1}

and

{\hat{F}}_{2}

are normalized by fixed references,

w_{1} = 0.4

w_{2} = 0.3

w_{3} = 0.3

, and the final term is a standard penalty-based constraint-handling component (

P

a large constant,

u (x)

the number of range-infeasible uncovered tasks) that strongly discourages dropping tasks.

Event-triggered replanning

The replanning mechanism is event-driven:

Trigger (t) = I (| T_{new} (t) | \geq δ_{T}) \lor I (| O_{new} (t) | \geq 1) \lor I (\exists k : T_{k}^{elapsed} > γ \cdot T_{k}^{expected}),

where

δ_{T} = 1

is the new-task threshold and

γ

is the progress-timeout factor. When a trigger fires, the engine freezes the current fleet state, positions and remaining ranges, gathers the set of known incomplete tasks and the currently active obstacles, and invokes the optimizer on this reduced problem Figure 3.

Figure 3.

Flowchart of the event-triggered replanning mechanism, monitoring new target detection, threat/obstacle discovery, and progress timeout. When triggered, the warm-start module seeds the RIME population from the previous solution before re-optimization.

Warm-start initialization

When replanning is triggered, the previous solution is usually a good starting point because the task set typically changes only incrementally. The warm-start strategy constructs the initial population from three parts. A fraction (30%) is inherited: each new task that already existed in the previous solution copies that task's assignment and priority genes, keyed by task identity, so the previously chosen UAV and ordering are preserved; genuinely new tasks receive random genes. A second fraction (30%) is mutated: the inherited vector is perturbed by Gaussian noise to explore nearby assignments. The remaining 40% is generated at random to retain global exploration. The 30/30/40 ratio is validated by the sensitivity sweep in Section 5.5. The procedure is given in Algorithm 1. Figure 4

Figure 4.

Measured convergence of cold-start versus warm-start RIME during replanning, averaged over runs. Warm-start reaches cold-converged quality in far fewer iterations.

Algorithm 1. Warm-start population construction

Input: previous best genes keyed by task identity

g_{prev}

; new task list T; population size N; ratios

(ρ_{i}, ρ_{m}, ρ_{r})

1. Build a base vector

b

: for each task

T_{j}

, if

T_{j} \in g_{prev}

copy its assignment and priority genes, otherwise draw random genes.

2. Initialize the population

P \leftarrow \emptyset

3. Repeat

⌈ ρ_{i} N ⌉

times: add

clip (b + N (0, σ_{i}))

to P (inherited).

4. Repeat

⌈ ρ_{m} N ⌉

times: add

clip (b + N (0, σ_{m}))

to P (mutated).

5. For the remaining slots, add randomly generated vectors to P.

6. Return P.

Overall procedure and complexity

Algorithm 2 summarizes the full mission loop. The per-episode computational complexity is $O (N \times G \times | T |^{2})$ , where N is the population size, G the generation count, and $| T |$ the task count; the $| T |^{2}$ term reflects the route-evaluation cost, which we accelerate by precomputing an obstacle-aware distance matrix once per episode. Warm-start reduces the effective number of generations G required to reach a target quality (Section 5.5), which is where its runtime benefit originates.

Algorithm 2. HeteroDRIME-Lite mission loop

1. Plan the initially known tasks with cold-start RIME and begin execution.

2. While the mission is not complete, repeat steps 3–7.

3. Advance execution to the next event or to mission completion.

4. If a new task arrives, a new obstacle is discovered, or a progress timeout occurs, perform steps 5–7.

5. Freeze the current fleet state; collect the known incomplete tasks and the active obstacles.

6. Build the warm-start population from the previous solution (Algorithm 1).

7. Re-optimize with RIME, update the plan, and record the replanning latency.

Experiments

Experimental setup

Five benchmark scenarios with increasing complexity were designed within a $450 m \times 450 m$ workspace containing 8 UAVs (3 Scout, 2 Relay, 3 Carrier). Each scenario is generated deterministically from a single seed, so its obstacle layout, task layout, task types, service times, discovery times, and dynamic-obstacle appearance times are fully reproducible. Table 1 lists the configurations. The RIME optimizer uses population size $N = 50$ , 100 iterations for the initial plan, and 30 iterations during replanning. Every algorithm–scenario pair is run for 30 independent seeds. All experiments were executed on a single CPU core; the complete generation rules, parameters, and seeds are released with the source code to support reproducibility Figure 5 shows a representative S4 instance, and Table 2 lists the UAV type parameters.

Figure 5.

A real instance of the large scenario S4 (seed 0): UAV launch cluster, tasks distinguished by marker type, static obstacles shown as shaded regions, and dynamic obstacles shown with dashed boundaries, with the type-matched routes of the initial plan overlaid.

Table 1.

Benchmark scenario configurations.

Scenario	Tasks	Dyn. Obs.	Feature
S1 (baseline)	28	0	12 Standard
S2 (dynamic)	28	8–12	12 High dyn. load
S3 (comm-lim.)	28	4–6	12 Reduced range
S4 (large)	42	10–15	18 Large-scale
S5 (hetero.)	28	4–6	12 Capability diff.

Table 2.

UAV type parameter settings (energy coefficient and maximum range are model parameters expressed in the units stated in Section 3.1).

Parameter	Scout	Relay	Carrier	Unit
Quantity	3	2	3	–
Max speed $v^{\max}$	16	10	6	m/s
Comm. range $r^{comm}$	70	90	70	m
Energy coef. $e$	1.0	1.3	1.8	J/m
Max range $L$	4000	3500	2500	m
Payload capacity $w$	Low	Low	High	–

Baselines and statistical methodology

HeteroDRIME-Lite is compared against four internal variants (StaticRIME, a single-allocation policy; HomogeneousRIME, which disables type matching; GreedyAssignment; and RandomReplanning) and seven published methods: the Pareto-based NSGA-II and MOEA/D, the single-objective metaheuristics PSO, GA, DE, and ACO, and the auction-based CBBA. For a fair online comparison, every population-based baseline is given the same per-event iteration budget and is driven by the same event-triggered loop. Following standard practice for stochastic optimizers and nonparametric statistical testing,²⁵ we report the mean and standard deviation over 30 runs, 95% confidence intervals, the paired Wilcoxon signed-rank test against HeteroDRIME-Lite, Cohen's $d$ effect size, and the Friedman omnibus test across all algorithms. Significance is reported at $p < 0.05 (*)$ , $p < 0.01 (* *)$ , and $p < 0.001 (* * *)$ .

Comparison with baselines

Table 3 reports performance across the five scenarios. HeteroDRIME-Lite sustains 100% coverage everywhere. Against the population-based metaheuristics (NSGA-II, MOEA/D, PSO, GA, DE), it achieves both lower makespan and substantially lower energy in every scenario; the gap widens with scale, reaching a factor of roughly two in energy on the large scenario S4. The Friedman test rejects the null of equal performance in every scenario ( $p < 10^{- 43}$ for both makespan and energy), and the paired effect sizes against these five baselines are large (Table 4). Two specialized baselines behave differently and are reported honestly: ACO reaches solution quality comparable to HeteroDRIME-Lite, slightly better on energy, but at 7–24 s per planning episode versus about 1 s or less, making it unsuitable for online replanning; CBBA is near-instant and energy-efficient but yields markedly worse makespan.

Table 3.

Performance comparison across the five benchmark scenarios (mean $\pm$ std over 30 independent runs).

Scen.	Algorithm	Makespan (s)	Cov. (%)	Energy (J)	Time (s)
S1	HeteroDRIME-Lite	172.6 $\pm$ 16.5	100.0 $\pm$ 0.0	5705 $\pm$ 515	0.53 $\pm$ 0.07
S1	StaticRIME	140.2 $\pm$ 11.1	71.4 $\pm$ 0.0	4186 $\pm$ 438	0.21 $\pm$ 0.02
S1	HomogeneousRIME	154.0 $\pm$ 13.8	100.0 $\pm$ 0.0	5680 $\pm$ 435	0.60 $\pm$ 0.09
S1	GreedyAssignment	275.6 $\pm$ 54.9	100.0 $\pm$ 0.0	4504 $\pm$ 482	0.04 $\pm$ 0.01
S1	RandomReplanning	210.5 $\pm$ 21.1	100.0 $\pm$ 0.0	5797 $\pm$ 560	0.76 $\pm$ 0.08
S1	NSGA-II	182.9 $\pm$ 20.9	100.0 $\pm$ 0.0	7753 $\pm$ 1259	1.16 $\pm$ 0.13
S1	MOEA/D	200.9 $\pm$ 26.8	100.0 $\pm$ 0.0	9264 $\pm$ 1330	2.04 $\pm$ 0.18
S1	PSO	193.1 $\pm$ 26.7	100.0 $\pm$ 0.0	8182 $\pm$ 1213	0.72 $\pm$ 0.12
S1	GA	204.2 $\pm$ 30.7	100.0 $\pm$ 0.0	9044 $\pm$ 1454	1.31 $\pm$ 0.14
S1	DE	183.8 $\pm$ 18.9	100.0 $\pm$ 0.0	8099 $\pm$ 1275	1.31 $\pm$ 0.13
S1	ACO	171.1 $\pm$ 17.0	100.0 $\pm$ 0.0	5049 $\pm$ 428	6.68 $\pm$ 1.10
S1	CBBA	221.2 $\pm$ 36.2	100.0 $\pm$ 0.0	4701 $\pm$ 427	0.00 $\pm$ 0.00
S2	HeteroDRIME-Lite	188.8 $\pm$ 15.9	100.0 $\pm$ 0.0	5692 $\pm$ 559	1.12 $\pm$ 0.15
S2	StaticRIME	171.2 $\pm$ 13.1	64.3 $\pm$ 0.0	3814 $\pm$ 405	0.20 $\pm$ 0.02
S2	HomogeneousRIME	175.7 $\pm$ 10.1	100.0 $\pm$ 0.0	5919 $\pm$ 490	1.22 $\pm$ 0.19
S2	GreedyAssignment	285.8 $\pm$ 54.8	100.0 $\pm$ 0.0	4455 $\pm$ 444	0.15 $\pm$ 0.05
S2	RandomReplanning	225.2 $\pm$ 27.2	100.0 $\pm$ 0.0	6134 $\pm$ 602	0.88 $\pm$ 0.08
S2	NSGA-II	221.3 $\pm$ 30.8	100.0 $\pm$ 0.0	10389 $\pm$ 1965	2.55 $\pm$ 0.27
S2	MOEA/D	246.5 $\pm$ 35.7	100.0 $\pm$ 0.0	13081 $\pm$ 2037	4.25 $\pm$ 0.45
S2	PSO	231.9 $\pm$ 37.7	100.0 $\pm$ 0.0	11236 $\pm$ 2121	1.53 $\pm$ 0.21
S2	GA	249.3 $\pm$ 45.6	100.0 $\pm$ 0.0	13136 $\pm$ 2425	2.72 $\pm$ 0.28
S2	DE	225.7 $\pm$ 30.3	100.0 $\pm$ 0.0	11974 $\pm$ 2141	2.96 $\pm$ 0.34
S2	ACO	192.6 $\pm$ 18.5	100.0 $\pm$ 0.0	5065 $\pm$ 434	13.94 $\pm$ 3.06
S2	CBBA	240.1 $\pm$ 38.4	100.0 $\pm$ 0.0	4771 $\pm$ 503	0.01 $\pm$ 0.00
S3	HeteroDRIME-Lite	186.6 $\pm$ 17.3	100.0 $\pm$ 0.0	6743 $\pm$ 759	0.84 $\pm$ 0.11
S3	StaticRIME	162.1 $\pm$ 13.7	71.4 $\pm$ 0.0	4844 $\pm$ 572	0.21 $\pm$ 0.01
S3	HomogeneousRIME	169.0 $\pm$ 7.8	100.0 $\pm$ 0.0	7000 $\pm$ 979	0.89 $\pm$ 0.17
S3	GreedyAssignment	276.9 $\pm$ 59.7	100.0 $\pm$ 0.0	5230 $\pm$ 640	0.08 $\pm$ 0.03
S3	RandomReplanning	216.6 $\pm$ 21.0	100.0 $\pm$ 0.0	7634 $\pm$ 1044	0.88 $\pm$ 0.10
S3	NSGA-II	199.5 $\pm$ 20.7	100.0 $\pm$ 0.0	9640 $\pm$ 1719	1.86 $\pm$ 0.20
S3	MOEA/D	220.8 $\pm$ 26.8	100.0 $\pm$ 0.0	11867 $\pm$ 1888	3.08 $\pm$ 0.36
S3	PSO	221.2 $\pm$ 37.0	100.0 $\pm$ 0.0	10640 $\pm$ 1760	1.07 $\pm$ 0.18
S3	GA	220.4 $\pm$ 34.3	100.0 $\pm$ 0.0	11121 $\pm$ 2046	1.85 $\pm$ 0.20
S3	DE	209.6 $\pm$ 25.4	100.0 $\pm$ 0.0	11288 $\pm$ 2381	2.04 $\pm$ 0.25
S3	ACO	186.5 $\pm$ 16.6	100.0 $\pm$ 0.0	5845 $\pm$ 604	10.53 $\pm$ 2.26
S3	CBBA	239.6 $\pm$ 37.5	100.0 $\pm$ 0.0	5594 $\pm$ 640	0.01 $\pm$ 0.00
S4	HeteroDRIME-Lite	255.8 $\pm$ 18.0	100.0 $\pm$ 0.0	8163 $\pm$ 706	1.76 $\pm$ 0.26
S4	StaticRIME	238.7 $\pm$ 14.0	69.0 $\pm$ 0.0	5790 $\pm$ 599	0.26 $\pm$ 0.00
S4	HomogeneousRIME	238.0 $\pm$ 11.3	100.0 $\pm$ 0.0	8099 $\pm$ 834	1.68 $\pm$ 0.29
S4	GreedyAssignment	357.9 $\pm$ 52.3	100.0 $\pm$ 0.0	5939 $\pm$ 523	0.43 $\pm$ 0.12
S4	RandomReplanning	307.4 $\pm$ 28.0	100.0 $\pm$ 0.0	8627 $\pm$ 807	1.53 $\pm$ 0.22
S4	NSGA-II	324.3 $\pm$ 50.5	99.9 $\pm$ 0.4	17580 $\pm$ 3208	4.15 $\pm$ 0.51
S4	MOEA/D	391.3 $\pm$ 52.8	99.9 $\pm$ 0.4	22024 $\pm$ 3165	6.38 $\pm$ 0.61
S4	PSO	344.8 $\pm$ 51.3	100.0 $\pm$ 0.0	18743 $\pm$ 2789	2.51 $\pm$ 0.37
S4	GA	364.8 $\pm$ 54.3	99.9 $\pm$ 0.4	21406 $\pm$ 2697	4.05 $\pm$ 0.40
S4	DE	360.5 $\pm$ 60.8	100.0 $\pm$ 0.0	21431 $\pm$ 3520	4.40 $\pm$ 0.45
S4	ACO	254.2 $\pm$ 15.2	100.0 $\pm$ 0.0	6623 $\pm$ 588	24.22 $\pm$ 5.57
S4	CBBA	308.3 $\pm$ 45.6	100.0 $\pm$ 0.0	6356 $\pm$ 602	0.01 $\pm$ 0.00
S5	HeteroDRIME-Lite	191.0 $\pm$ 17.4	100.0 $\pm$ 0.0	5736 $\pm$ 447	0.88 $\pm$ 0.10
S5	StaticRIME	160.1 $\pm$ 12.4	71.4 $\pm$ 0.0	4160 $\pm$ 320	0.20 $\pm$ 0.01
S5	HomogeneousRIME	165.4 $\pm$ 7.0	100.0 $\pm$ 0.0	5793 $\pm$ 561	0.87 $\pm$ 0.16
S5	GreedyAssignment	270.3 $\pm$ 63.3	100.0 $\pm$ 0.0	4496 $\pm$ 472	0.07 $\pm$ 0.03
S5	RandomReplanning	218.0 $\pm$ 21.7	100.0 $\pm$ 0.0	5977 $\pm$ 696	0.87 $\pm$ 0.09
S5	NSGA-II	214.1 $\pm$ 31.0	100.0 $\pm$ 0.0	9062 $\pm$ 1439	2.17 $\pm$ 0.26
S5	MOEA/D	243.5 $\pm$ 38.2	100.0 $\pm$ 0.0	11236 $\pm$ 1801	3.25 $\pm$ 0.27
S5	PSO	230.9 $\pm$ 28.1	100.0 $\pm$ 0.0	9707 $\pm$ 1418	1.05 $\pm$ 0.15
S5	GA	233.6 $\pm$ 32.7	100.0 $\pm$ 0.0	10879 $\pm$ 1693	1.87 $\pm$ 0.19
S5	DE	214.1 $\pm$ 27.2	100.0 $\pm$ 0.0	10066 $\pm$ 2457	2.06 $\pm$ 0.26
S5	ACO	188.3 $\pm$ 19.0	100.0 $\pm$ 0.0	5145 $\pm$ 444	11.25 $\pm$ 2.76
S5	CBBA	238.9 $\pm$ 36.2	100.0 $\pm$ 0.0	4755 $\pm$ 532	0.00 $\pm$ 0.00

Table 4.

Effect size (Cohen's $d$ ) of HeteroDRIME-Lite versus the population-based baselines on the large scenario S4. Negative values indicate HeteroDRIME-Lite is better (lower makespan/energy); all are significant at $p < 0.001$ .

Baseline	$d$ (makespan)	$d$ (energy)
NSGA-II	$- 1.65$	$- 3.06$
MOEA/D	$- 2.93$	$- 4.55$
PSO	$- 1.99$	$- 3.90$
GA	$- 2.31$	$- 5.24$
DE	$- 1.98$	$- 3.89$

Ablation study

Table 5 reports the ablation over all five scenarios (30 runs each). Removing warm-start inflates replanning energy sharply (for example $+ 98 %$ on S4) and increases makespan, confirming that warm-start is the dominant efficiency mechanism. Removing the event trigger (fixed-interval replanning) increases makespan by 12–16%. Removing heterogeneity (the generic-fleet variant) is discussed separately in Section 6, because it lowers makespan, which we interpret not as evidence against the method but as a consequence of heterogeneity being a feasibility constraint.

Table 5.

Ablation study: contribution of each component, across the five scenarios (mean $\pm$ std over 30 runs).

Scen.	Algorithm	Makespan (s)	Cov. (%)	Energy (J)	Time (s)
S1	Full	172.6 $\pm$ 16.5	100.0 $\pm$ 0.0	5705 $\pm$ 515	1.30 $\pm$ 0.20
S1	w/o Event-Trigger	203.2 $\pm$ 23.3	100.0 $\pm$ 0.0	5904 $\pm$ 581	1.13 $\pm$ 0.09
S1	w/o Warm-Start	189.7 $\pm$ 28.1	100.0 $\pm$ 0.0	7427 $\pm$ 1189	1.36 $\pm$ 0.19
S1	w/o Heterogeneous	154.0 $\pm$ 13.8	100.0 $\pm$ 0.0	5680 $\pm$ 435	1.28 $\pm$ 0.18
S2	Full	188.8 $\pm$ 15.9	100.0 $\pm$ 0.0	5692 $\pm$ 559	2.62 $\pm$ 0.37
S2	w/o Event-Trigger	212.2 $\pm$ 25.9	100.0 $\pm$ 0.0	6030 $\pm$ 509	1.24 $\pm$ 0.07
S2	w/o Warm-Start	219.2 $\pm$ 29.9	100.0 $\pm$ 0.0	9769 $\pm$ 2179	2.87 $\pm$ 0.44
S2	w/o Heterogeneous	175.7 $\pm$ 10.1	100.0 $\pm$ 0.0	5919 $\pm$ 490	2.66 $\pm$ 0.42
S3	Full	186.6 $\pm$ 17.3	100.0 $\pm$ 0.0	6743 $\pm$ 759	1.90 $\pm$ 0.24
S3	w/o Event-Trigger	206.1 $\pm$ 21.6	100.0 $\pm$ 0.0	7156 $\pm$ 982	1.23 $\pm$ 0.08
S3	w/o Warm-Start	203.0 $\pm$ 26.2	100.0 $\pm$ 0.0	9651 $\pm$ 1776	2.07 $\pm$ 0.29
S3	w/o Heterogeneous	169.0 $\pm$ 7.8	100.0 $\pm$ 0.0	7000 $\pm$ 979	1.92 $\pm$ 0.36
S4	Full	255.8 $\pm$ 18.0	100.0 $\pm$ 0.0	8163 $\pm$ 706	3.74 $\pm$ 0.53
S4	w/o Event-Trigger	284.0 $\pm$ 25.0	100.0 $\pm$ 0.0	8471 $\pm$ 769	1.96 $\pm$ 0.14
S4	w/o Warm-Start	313.3 $\pm$ 41.7	100.0 $\pm$ 0.0	16154 $\pm$ 2588	4.38 $\pm$ 0.53
S4	w/o Heterogeneous	238.0 $\pm$ 11.3	100.0 $\pm$ 0.0	8099 $\pm$ 834	3.55 $\pm$ 0.63
S5	Full	191.0 $\pm$ 17.4	100.0 $\pm$ 0.0	5736 $\pm$ 447	1.83 $\pm$ 0.22
S5	w/o Event-Trigger	214.5 $\pm$ 24.0	100.0 $\pm$ 0.0	5917 $\pm$ 532	1.24 $\pm$ 0.08
S5	w/o Warm-Start	211.2 $\pm$ 31.5	100.0 $\pm$ 0.0	8436 $\pm$ 1546	2.03 $\pm$ 0.24
S5	w/o Heterogeneous	165.4 $\pm$ 7.0	100.0 $\pm$ 0.0	5793 $\pm$ 561	1.72 $\pm$ 0.49

Warm-start convergence and ratio sensitivity

Across all replanning events, warm-start reaches cold-converged solution quality in 22.7 iterations on average versus 37.4 for cold start, a median speedup of $2.7 \times$ (per-scenario means range from $6 \times$ to $15 \times$ ), and warm-start matches or improves the final fitness in 71% of instances. Figure 6 sweeps the inheritance/mutation/random ratio. The default 30/30/40 attains the fastest convergence (22.7 iterations) with near-best final fitness; pure inheritance (100/0/0) and pure cold start (0/0/100) are both clearly worse, and heavily inheritance-weighted ratios converge slightly slower because they under-explore. This validates the chosen ratio rather than assuming it.

Figure 6.

Warm-start ratio sensitivity: convergence iterations and final fitness across inheritance/mutation/random ratios.

Analysis

Replanning trigger analysis over all HeteroDRIME-Lite runs shows new-task detection as the dominant trigger (53.9%), followed by obstacle discovery (37.0%) and progress timeout (9.2%); Figure 7 shows the split. Computational-time analysis confirms an average per-event replanning time near 40 ms, well within real-time budgets. Coverage figures across the methods are shown in Figure 8.

Figure 7.

Replanning trigger composition across all scenarios.

Figure 8.

Task coverage by algorithm and scenario. HeteroDRIME-Lite holds 100% throughout, whereas the static single-allocation policy degrades to 64–71%.

Discussion

The experiments support three clear conclusions and one important caveat, which we examine in turn rather than merely listing.

Why event-triggered replanning matters

The static policy plans once over the initially known tasks and never revises, so every task discovered mid-mission goes unserved; this is exactly why its coverage settles at 64–71% while the event-triggered policy holds 100%. The cost of this gain is bounded because the trigger fires only on genuine change, keeping the average replanning latency near 40 ms.

Why warm-start dominates the efficiency picture

Under the small online compute budget (30 iterations per event), an optimizer that restarts from scratch cannot recover a good plan, which is visible both in the ablation (removing warm-start raises S4 energy by 98%) and in the baseline comparison: the cold-restarted metaheuristics NSGA-II, MOEA/D, PSO, GA, and DE spend their budget rediscovering structure that warm-start simply inherits, and therefore return plans with up to twice the energy. ACO is the instructive exception: its pheromone memory acts as an implicit warm-start and brings its quality close to ours, but it pays for that memory with an order-of-magnitude longer runtime, which disqualifies it for online use. In other words, the comparison is not RIME-versus-the-rest in the abstract; it is warm-started reuse versus cold restart under a tight latency budget.

The role of heterogeneity, stated honestly

Removing type specialization lowers makespan by about 9% and barely changes energy. We do not hide this: a generic fleet of identical average-capability UAVs has no slow Carrier to bottleneck the makespan. The crucial point is that such a fleet is a mathematical fiction. A real Carrier cannot fly at Scout speed and a real Scout cannot lift a Carrier payload; the type–task matching of Section 3.3 is a physical feasibility requirement, not a performance knob. Heterogeneity is therefore the premise of the problem, and the contribution of this paper is to coordinate a heterogeneous fleet effectively under that premise, accepting the modest makespan price that specialization imposes. The communication-limited scenario S3 makes the same point in miniature: forcing dedicated Relay UAVs into bridge roles under reduced range raises energy relative to an unconstrained generic fleet, again a consequence of realism, not a deficiency of the planner.

Theoretical perspective and limitations

The framework admits the per-episode complexity $O (N G | T |^{2})$ , and its online advantage rests on warm-start reducing the effective G; this is the theoretical lever behind the measured speedups. The main difficulty in applying the method is the compute–quality trade-off governed by the per-event iteration budget and the event thresholds $δ_{T}$ and $γ$ : too small a budget degrades quality, too large a budget or too sensitive a trigger erodes the latency advantage. The remaining limitations are the 2D kinematic abstraction and the weighted-sum scalarization, which cannot expose non-convex Pareto trade-offs. Extending the model to 3D flight with realistic propagation, battery, and dynamics, and replacing the scalarization with a fast Pareto-based inner solver, are the priorities for future work.

Conclusions

This paper presented HeteroDRIME-Lite, an event-triggered cooperative planning framework for heterogeneous multi-UAV systems combining type–task matching, event-triggered replanning, and warm-start RIME optimization. Across five benchmark scenarios with 30 independent runs each, the framework sustained 100% task coverage where a static policy reached only 64–71%, significantly outperformed seven established planners on makespan and energy under an online latency budget, and reduced convergence iterations by about 40% and replanning energy by up to 60% through warm-start, whose 30/30/40 ratio was validated by sensitivity analysis. We also clarified that heterogeneity functions as a feasibility requirement, and we quantified the makespan trade-off it imposes. Average per-event replanning time remained near 40 ms, demonstrating suitability for time-critical operations. Future work will target 3D environments with realistic propagation and battery models, a Pareto-based inner solver, and physical UAV validation.

Ethical statement

This study did not involve any experiments on human participants or animals performed by any of the authors; all results were obtained from numerical simulations. Therefore, ethical approval was not required.

Footnotes

ORCID iD

Jichao Wang

Consent to participate

Not applicable. This study did not involve human participants.

Consent for publication

Not applicable. This study did not involve human participants or any individual person's data.

Author contributions

Jichao Wang: Conceptualization, Methodology, Software, Resources, Formal analysis, Writing – original draft, Data curation, Supervision, Project administration, Funding acquisition.

Hanyu Zhang: Validation, Investigation, Data curation, Visualization.

Zhenqiao Hui: Conceptualization, Validation, Writing – review & editing, Supervision.

Shuai Zhang: Formal analysis, Writing – review & editing.

Sicong Pang: Software, Validation, Investigation, Data curation, Visualization, Writing – original draft.

Funding

The authors disclosed receipt of the following financial support for the research, authorship, and/or publication of this article: This work was supported by the The Natural Science Foundation of Cangzhou, The Scientific Research Program of the Hebei Provincial Department of Education, The Innovation and Entrepreneurship Training Program for College Students of the Hebei University of Water Resources and Electric Engineering, The Fundamental Research Funds for the Hebei University of Water Resources and Electric Engineering, (grant number No. 23244101025, 23241002014N, No. ZC2025095, No. 202510085003, No. SYKY2308).

Declaration of conflicting interests

The authors declared no potential conflicts of interest with respect to the research, authorship, and/or publication of this article.

Data availability

The simulation source code, scenario-generation rules, parameter settings, and per-run result files that reproduce every table and figure in this paper are available from the corresponding author upon reasonable request.

References

Khamis

Hussein

Elmogy

. Multi-robot task allocation: a review of the state-of-the-art. In: Cooperative robots and sensor networks. Springer, 2015, pp.31–51.

Nunes

Manner

Mitber

, et al. A taxonomy for task allocation problems with temporal and ordering constraints. Robot Autonom Syst 2017; 90: 55–70.

Gerkey

Mataric

. A formal analysis and taxonomy of task allocation in multi-robot systems. Int J Robot Res 2004; 23: 939–954.

Korsah

Stentz

Dias

. A comprehensive taxonomy for multi-robot task allocation. Int J Robot Res 2013; 32: 1495–1512.

Rizk

Awad

Tunstel

. Cooperative heterogeneous multi-robot systems: a survey. ACM Comput Surv 2019; 52: 1–31.

Choi

Brunet

How

. Consensus-based decentralized auctions for robust task allocation. IEEE Trans Robot 2009; 25: 912–926.

Kennedy

Eberhart

. Particle swarm optimization. In: Proceedings of ICNN’95. IEEE, 1995, pp.1942–1948.

Goldberg

. Genetic algorithms in search, optimization, and machine learning. Addison-Wesley, 1989.

Storn

Price

. Differential evolution: a simple and efficient heuristic for global optimization over continuous spaces. J Glob Opt 1997; 11: 341–359.

10.

Dorigo

Maniezzo

Colorni

. Ant system: optimization by a colony of cooperating agents. IEEE Trans Syst, Man, Cybern, B 1996; 26: 29–41.

11.

Deb

Pratap

Agarwal

, et al. A fast and elitist multiobjective genetic algorithm: NSGA-II. IEEE Trans Evol Comput 2002; 6: 182–197.

12.

Deb

Jain

. An evolutionary many-objective optimization algorithm using reference-point-based nondominated sorting approach, part I. IEEE Trans Evol Comput 2014; 18: 577–601.

13.

Zhang

. MOEA/D: a multiobjective evolutionary algorithm based on decomposition. IEEE Trans Evol Comput 2007; 11: 712–731.

14.

Zhao

Heidari

, et al. RIME: a physics-based optimization. Neurocomputing 2023; 532: 183–214.

15.

Belge

Altan

Hacıoğlu

. Metaheuristic optimization-based path planning and tracking of quadcopter for payload hold-release mission. Electronics 2022; 11: 1208.

16.

Altan

Hacıoğlu

. Model predictive control of three-axis gimbal system mounted on UAV for real-time target tracking under external disturbances. Mech Syst Signal Process 2020; 138: 106548.

17.

Robin

Lacroix

. Multi-robot target detection and tracking: taxonomy and survey. Autonomous Robots 2016; 40: 729–760.

18.

Otto

Agatz

Campbell

, et al. Optimization approaches for civil applications of unmanned aerial vehicles (UAVs) or aerial drones: a survey. Networks 2018; 72: 411–458.

19.

Shakhatreh

Sawalmeh

Al-Fuqaha

, et al. Unmanned aerial vehicles (UAVs): a survey on civil applications and key research challenges. IEEE Access 2019; 7: 48572–48634.

20.

Hayat

Yanmaz

Muzaffar

. Survey on unmanned aerial vehicle networks for civil applications: a communications viewpoint. IEEE Commun Surv Tutor 2016; 18: 2624–2661.

21.

Gupta

Jain

Vaszkun

. Survey of important issues in UAV communication networks. IEEE Commun Surv Tutor 2016; 18: 1123–1152.

22.

Erdelj

Natalizio

Chowdhury

, et al. Help from the sky: leveraging UAVs for disaster management. IEEE Pervasive Comput 2017; 16: 24–32.

23.

Zeng

Zhang

. Accessing from the sky: a tutorial on UAV communications for 5G and beyond. Proce IEEE 2019; 107: 2327–2375.

24.

Cai

Dias

Seneviratne

. A survey of small-scale unmanned aerial vehicles: recent advances and future development trends. Unmanned Syst 2014; 2: 175–199.

25.

Derrac

García

Molina

, et al. A practical tutorial on the use of nonparametric statistical tests as a methodology for comparing evolutionary and swarm intelligence algorithms. Swarm Evol Comput 2011; 1: 3–18.