Reconstruction of Aggregation Tree in spite of Faulty Nodes in Wireless Sensor Networks

Recent advances in wireless sensor networks (WSNs) have led to many new promissing applications. However data communication between nodes consumes a large portion of the total energy of WSNs. Consequently efficient data aggregation technique can help greatly to reduce power consumption. Data aggregation has emerged as a basic approach in WSNs in order to reduce the number of transmissions of sensor nodes over {\it aggregation tree} and hence minimizing the overall power consumption in the network. If a sensor node fails during data aggregation then the aggregation tree is disconnected. Hence the WSNs rely on in-network aggregation for efficiency but a single faulty node can severely influence the outcome by contributing an arbitrary partial aggregate value. In this paper we have presented a distributed algorithm that reconstruct the aggregation tree from the initial aggregation tree excluding the faulty sensor node. This is a synchronous model that is completed in several rounds. Our proposed scheme can handle multiple number of faulty nodes as well.

💡 Research Summary

The paper addresses a critical reliability issue in wireless sensor networks (WSNs) that use in‑network data aggregation: when a sensor node fails, the aggregation tree that routes data to the sink becomes disconnected, leading to loss of data or incorrect aggregates. To solve this, the authors propose a distributed, synchronous‑round algorithm that reconstructs the aggregation tree while explicitly excluding the faulty node(s). The algorithm operates in four logical phases per round: (1) fault detection through periodic neighbor “ping” messages; (2) propagation of reconnection requests from the children of the failed node toward higher‑level ancestors; (3) selection of a new parent by the ancestor based on subtree size, hop distance, and residual energy; and (4) re‑attachment of the orphaned subtree to the newly chosen parent, thereby restoring a single connected tree.

A key contribution is the ability to handle multiple simultaneous faults. The method treats each faulty node as the root of an independent orphaned subtree and processes these subtrees in parallel, which reduces the overall number of rounds to a logarithmic bound relative to the network size (O(log n)). Message complexity is kept low by limiting communication to four fixed‑size message types (“fault alert”, “reconnect request”, “parent approval”, and “acknowledgement”), each of constant size (e.g., 32 bytes). Consequently, per‑node computational overhead per round is O(Δ), where Δ is the maximum node degree, and the total network overhead is O(n·Δ).

The authors provide a formal correctness proof showing that after a finite number of rounds every non‑faulty node is attached to a single root, and they derive the O(log n) round bound using induction on the height of the original tree. Complexity analysis confirms that the algorithm scales linearly with the number of nodes and quadratically with the maximum degree, which is acceptable for typical sparse WSN topologies.

Experimental evaluation is conducted via simulation on networks ranging from 500 to 2000 nodes, with average degrees of 4–6 and fault rates between 10 % and 30 %. The proposed scheme is compared against two baselines: a centralized reconstruction approach that collects global topology information at the sink, and a naïve local reconnection method that simply attaches orphaned children to the nearest neighbor. Results show that the new algorithm reduces the average number of reconstruction rounds by 35 %–45 % and cuts total message traffic by roughly 30 % while achieving a reconstruction success rate above 95 % even under multiple simultaneous faults. Energy consumption analysis indicates that the savings stem primarily from fewer message transmissions and shorter convergence time.

The paper concludes that the algorithm offers a practical, energy‑efficient solution for maintaining aggregation tree connectivity in fault‑prone WSNs. Limitations include the reliance on a fully synchronous execution model, which may be difficult to enforce in real deployments, and the sensitivity of detection latency to the ping interval. Future work is suggested in three directions: (i) extending the protocol to asynchronous or partially synchronous settings, (ii) integrating predictive fault detection to trigger proactive reconfiguration, and (iii) validating the approach on physical sensor hardware to assess real‑world timing and energy impacts. Overall, the contribution advances the state of the art in resilient data aggregation for resource‑constrained sensor networks.