Plane Sweep Algorithms for Data Collection in Wireless Sensor Network using Mobile Sink

TL;DR

This paper introduces plane sweep algorithms to optimize data collection schedules and sub-sink data distributions in wireless sensor networks with mobile sinks, significantly reducing data gathering latency.

Contribution

It formulates two novel optimization problems for data gathering in WSNs and proposes plane sweep algorithms to solve them efficiently.

Findings

Optimized data gathering schedules reduce latency.

Optimal data distribution among sub-sinks improves performance.

Algorithms are validated through simulation results.

Abstract

Usage of mobile sink(s) for data gathering in wireless sensor networks(WSNs) improves the performance of WSNs in many respects such as power consumption, lifetime, etc. In some applications, the mobile sink $MS$ travels along a predefined path to collect data from the nearby sensors, which are referred as sub-sinks. Due to the slow speed of the $MS$, the data delivery latency is high. However, optimizing the {\em data gathering schedule}, i.e. optimizing the transmission schedule of the sub-sinks to the $MS$ and the movement speed of the $MS$ can reduce data gathering latency. We formulate two novel optimization problems for data gathering in minimum time. The first problem determines an optimal data gathering schedule of the $MS$ by controlling the data transmission schedule and the speed of the $MS$, where the data availabilities of the sub-sinks are given. The second problem generalizes the first, where the data availabilities of the sub-sinks are unknown. Plane sweep algorithms are proposed for finding optimal data gathering schedule and data availabilities of the sub-sinks. The performances of the proposed algorithms are evaluated through simulations. The simulation results reveal that the optimal distribution of data among the sub-sinks together with optimal data gathering schedule improves the data gathering time.

Figures

Tables

Table 1. TABLE I: Simulation Parameters

Parameter	Value
Rectangular deployment area	1000m $\times$ 400m
No. of sensors	100, 120, 140, 160
Maximum speed of $MS$	2 m/s
Communication range of sensor	75 m
Data transmission rate	2 Kbps
$e_r$	2 $\mu$ Joule/bit
$e_t$	3 $\mu$ Joule/bit

Equations

$$\sum _{j=1}^{2m+1}\sum _{i:s{s}_i\in SS(I_j)}{t}_j^i$$

$$\sum _{i:s{s}_i\in SS(I_j)}{t}_j^i\ge \frac{|I_j|}{V},j=1\dots (2m+1)$$

$$\sum _{j:s{s}_i\in SS(I_j)}{t}_j^i\ge DT(s{s}_i),i=1\dots m$$

$$t_j^i\ge 0,i=0\dots m,j=1\dots (2m+1)$$

$$E_i=(e_r\ast d_r^i+e_t\ast d_t^i)$$

$$E_{total}=\sum _{i=1}^n{E}_i$$

Full text

I Introduction

In WSNs, data generated at the sensor nodes are either transmitted through multi-hop transmission to a base station [8, 3], or a mobile sink ($MS$) moves through the communication regions of the sensors and collects data from sensors directly/indirectly and brings them to a base station [9, 14]. In multi-hop transmission, sensors located near the base station are overloaded for relaying data from other sensors to the base station and are therefore prone to deplete their energy faster than other far away sensors.

Recently, mobile sink based data gathering has been gaining popularity significantly in wireless sensor networks (WSNs). In some applications, the MS periodically patrols the sensors, collects their data, returns to the base station and dumps the collected data at the base station. The problem of determining the tour of the $MS$ has been studied rigorously in [9, 14, 4]. Mobile sink based data gathering improves the performance of WSNs in terms of energy consumption and lifetime of the sensors. However, introducing $MS$ as a data carrier in the network increases the data delivery latency due to the slow speed of the $MS$. Reducing the data delivery latency is a critical issue for the $MS$ based data gathering. Ren and Liang et al. [17] have shown that the volume of data collection is proportional to the data delivery latency. Time-sensitive applications such as forest fire detection, intrusion detection etc., demand time bound data delivery. Thus, improving data collection with minimum delivery latency is one of the most challenging issues in $MS$ based data gathering.

Several data gathering algorithms are proposed to improve the data gathering time using mobile sink by shortening the tour length of the $MS$ [9, 14, 4]. The data gathering time depends on the speed of the $MS$ and the length of the tour. There are some studies in [18, 10] on the adaptive speed planning of $MS$ along a predefined path. The $MS$ adjust its speed to maximize network utility and minimize energy consumption. Data gathering problems for rechargeable sensor networks are formulated in [22, Zhang:2016, Guo:2014] by jointly optimizing mobile data gathering and energy provisioning. Gao et. al. [6, 7] propose novel data collection scheme, where a $MS$ is moving along a predefined path with a fixed speed. But, the $MS$ gets limited communication time to collect data from its nearby sensor nodes, referred as sub-sinks. Besides, a metaheuristic (genetic) algorithm is proposed to find data forwarding paths to improve the network throughput as well as to conserve energy. Due to the non-deterministic nature of the algorithm, the solution may vary each time you run the algorithm on the same instance. Therefore, the existing data gathering techniques using $MS$ find optimal tour of $MS$ or find data forwarding paths to $MS$ to improve the network performance, but there is a lack of studies on how to maximize data collection and minimize the data gathering time by controlling the data transmission schedule and speed of the $MS$. The data transmission schedule of the sub-sinks to the $MS$ together with the speed schedule of the $MS$ is called as data gathering schedule of $MS$. To further improve the total data gathering time, we consider the above two factors and find an optimal distribution of the data generated within sensors among the sub-sinks. In addition, our algorithms are based on the geometric characteristics of the problem and are deterministic. Their correctnesses are also shown.

An example of such type of network is illustrated in Figure 1. A mobile sink $MS$ moves along a given path $P$. It collects pre-cached data from a few sensors which are directly reachable from the trajectory path $P$. Those directly reachable sensors are referred as sub-sinks ($ss_{1},ss_{2},ss_{3},ss_{4},ss_{5}$). The $MS$ may collect data from a sub-sink whenever the $MS$ comes under the communication range of the sub-sink. Thus, the sub-sinks send their data to the $MS$ directly. The $MS$ may be within multiple sub-sinks' communication regions, and it receives data from any one of them at a time. Therefore, proper data transmission schedule of the sub-sinks are also required. The remaining sensors, which are not directly reachable to $MS$ ( e.g. $s_{1},s_{2},\ldots,s_{11}$) send their data to the $MS$ through the sub-sinks using multi-hop communication. The major challenges are to find the optimal data transmission schedule of the sub-sinks to the $MS$ for their data delivery and speed variation of $MS$ along $P$. Moreover, since a sensor can send data to $MS$ through multiple sub-sinks, finding the optimal data distribution among the sub-sinks is another challenging issue in $MS$ based data gathering. Our major contributions in this article are summarized as follows.

Introduce a time-sensitive data gathering problem using a speed adjustable mobile sink to collect data from sensor networks. 2. 2.

Linear programming formulation of the problem is discussed, where the initial data availabilities of the sub-sinks are given. 3. 3.

Plane sweep based data gathering algorithm is proposed to collect data from the sub-sinks by controlling the data transmission schedule of sub-sinks and speed of the $MS$. 4. 4.

It is further generalized, where data availabilities of the sub-sinks are optimized by controlling sensors' data distribution among the sub-sinks to improve the data gathering time.

The rest of the article is organized as follows. Section II discusses some related works on data gathering problems. Section III presents system model and problem statement. Background and related terminologies are defined in section IV. Section V describes a plane sweep algorithm for data gathering in minimum time, where data availabilities of the sub-sinks are given. Section VI presents a plane sweep algorithm to improve the data gathering time by optimizing the data availability values of the sub-sinks so that the total data gathering time can be reduced. Section VII measures the performance of our proposed solutions. Finally, section VIII concludes the article.

II Related Works

Several data gathering algorithms have been proposed in the literature using mobile sink $MS$ where the path of the $MS$ is controllable or fixed. Depending on applications, different objectives are attained such as maximizing network lifetime, minimizing the total energy consumption, reducing total tour length, etc. In this section, we classify the literature based on whether the path of the $MS$ is controllable or fixed.

Somasundara et. al. [19] claim that the sensors with higher variation in sensed data demand more frequent data collection than others. They proposed a solution based on optimizing travelling path of the $MS$ that allows the $MS$ to visit sensor with a different frequency to reduce buffer overflow. They prove that the decision version of the problem is NP-complete and two heuristic algorithms are proposed. The authors in [20] analyze various models of motion planning of mobile sink to solve mobile sink scheduling problem in order to minimize the data delivery latency of the network. He et. al. formulate the data gathering problem using $MS$ as a travelling salesman problem (TSP) with neighborhoods [9]. They schedule $MS$ through the deployed region to improve the tour length of the $MS$ and consider multi-rate wireless communication for data transmission. In [14], a periodic data gathering protocol is proposed for a disconnected sensor network. The $MS$ traverses the entire sensor network, polls sensors and gathers sensed data from sensors. It improves the scalability issue of large-scale sensor networks. Sayyed et al. in [18] investigate the utility of speed control mobile sink for collecting data in WSN. Single-hop clustering technique is used to increase the data collection rate as well as to decrease the data collection latency.

To overcome the delay due to the slow speed of the $MS$, a subset of sensors are selected as rendezvous nodes. These nodes are used to buffer the data temporarily from the nearby sensors. When the $MS$ visits these rendezvous nodes, then they transfer their data to the mobile sink. In [1], sensors are grouped into single hop clusters, and the mobile sink visits the centroids of these clusters. If the tour length of the set of centroids is greater than a given upper bound, then some of the clusters are removed until the tour length is less than the upper bound. In [2], a shortest path tree rooted at the initial position of the mobile sink is built, and then a sensor node having sufficient energy as well as many nearby sensors within its vicinity is chosen as the next rendezvous node. In this way, a set of rendezvous nodes are selected and then a travelling salesman tour is obtained over the selected rendezvous nodes. In [11], k-means clustering with a weight function is used for finding the rendezvous points and an efficient tour among the rendezvous points is determined for the $MS$. In addition, an efficient data gathering scheme is also proposed to reduce the total packet drop. In [21], rendezvous nodes are selected using set covering problem. The $MS$ tour is scheduled to pass through those rendezvous points. They introduce novel rendezvous node rotation scheme for fair utilization of all the nodes. Konstantopoulos et. al. in [12] use multiple mobile sinks to ensure timely delivery of data to the base station. Mobile sinks visit only a subset of rendezvous points while the remaining sensors forward their data to the rendezvous points through multi-hop communication. The proposed approach increases network lifetime by finding tour passing through energy-rich zones as well as through regions where energy consumption is high.

In some scenarios, the trajectory of the $MS$ is predefined to a fixed path. Efficient data collection algorithms are proposed to improve network performance. In [6, 7], data gathering algorithms are proposed for such cases to improve network performance. Data forwarding paths from the sensors to the sub-sinks are determined to maximize the data collection and balance the energy consumption. Huang et. al. in [10] consider a scenario where a label of importance is assigned to each sensing region. A path-constrained ground vehicle with adaptive speed is used to collect data from the sensing field. Although the approach tries to improve the data collection throughput, their speed control algorithms are reactive due to the adaptive nature of speed learning characteristics of the $MS$. Besides, these algorithms don't have any specific solution for controlling or optimizing the speed of the $MS$ to improve the data collection rate and minimize delay. In article [Kumar:2017], a deterministic algorithm is proposed for maximization of data collection using fixed speed mobile sink. However, it may not provide quality data collection due to the mismatch between the data available to the gateways and the data communication time between the gateways and $MS$. Maximizing the data collection throughput in rechargeable sensor networks is addressed in [15]. Zhang et. al. [22] maximize data collection while maintaining the fairness of the network in rechargeable sensor networks. In [5, 13], data gathering protocols are proposed from path-constrained mobile sensors. The major drawback of the $MS$ based system is its slow speed, which causes long data gathering delay. Since sensors have limited memory, it causes buffer overflow in the sensors. To avoid buffer overflow, multiple mobile sinks are deployed and they periodically collect data from the mobile sensors and deliver the collected data to the base station.

It can be noted that several data gathering techniques have been proposed which focus on reducing the data gathering time of the mobile sink. The existing literature on path constrained mobile sink mostly consider efficient data forwarding mechanism from the sensors to the mobile sink through the sub-sinks to improve the network performances. But, no existing works consider controlling the data transmission schedule of the sub-sinks to the $MS$ along with the speed of the $MS$ and the sensor's data distribution among sub-sinks to improve the total data collection and the total data gathering time of the mobile sink.

III System Model and Problem Formulation

We consider a wireless sensor network (WSN) which consists of a set of sensors $N=\{s_{1},s_{2},\ldots,s_{n}\}$. Sensor $s_{i}$ generates/senses $DG(s_{i})$ amount of data from its environment. The communication topology of the network is modelled as an undirected graph $G(N,E)$. The communication regions of the sensors are modelled as disks. There is a mobile sink $MS$ moving on a given path $P$. We assume that the path $P$ is approximated as piecewise straight line segments. The $MS$ can move with a given maximum speed value $V$ to collect data from the sub-sinks. However, the $MS$ can change its speed depending upon the data availabilities of the sub-sinks. The $MS$ can collect data from sensors whose communication disks intersect the path $P$. Based on the relative position of the sensors with respect to $P$, sensors are divided into two groups, sub-sinks and far-away sensors. Sensors which can directly communicate with $MS$ on $P$ are referred as sub-sinks and rest of the sensors are referred as far-away sensors. The far-away sensors send their data to $MS$ through the sub-sinks. Let $\mathbb{SS}=\{ss_{1},ss_{2},\ldots,ss_{m}\}$ represent a set of sub-sinks which is a subset of $N$.

Furthermore, we also assume that the $MS$ and the sensors have sufficient energy and memory to collect and store all the sensed/relayed data temporarily. The data delivery capacity of a sub-sink is the amount of data that can be delivered by the sub-sink to the $MS$. The data delivery capacity of a sub-sink $ss_{i}$ depends on the time $t^{i}$ the $MS$ allocates to $ss_{i}$ for its data delivery within the communication region of $ss_{i}$ and the data transmission rate $dtr$. We assume that the $MS$ can receive data from one sub-sink at a time. We also assume that there is no data aggregation in the network. Then, our problems are stated as follows.

Problem 1: Let the data availabilities of the sub-sinks be $DA=\{DA(ss_{1}),DA(ss_{2}),\ldots,DA(ss_{m})\}$. Our objective is to find data transmission schedule of the sub-sinks to the $MS$ and a speed-schedule of the $MS$ through $P$ such that the $MS$ can collect complete data from all the sub-sinks in minimum time.

Our second problem generalizes the previous one, where data gathering time is further improved by optimizing the data availabilities of the sub-sinks.

Problem 2: Find an optimal data availabilities of the sub-sinks $DA=\{DA(ss_{1}),DA(ss_{2}),\ldots,DA(ss_{m})\}$ by distributing the sensors' data among the sub-sinks along with their data transmission schedule to the $MS$ and the speed-schedule of the $MS$ through $P$ such that the $MS$ can collect complete data from all the sub-sinks in minimum time.

IV Background and Terminologies

The far-away sensors send their data to the $MS$ through the sub-sinks. A sub-sink generates its data and receives data from other sensors and store them temporarily in its local buffer. This buffered data is delivered by the sub-sink to the $MS$ when it passes through the sub-sink's communication region. We refer this buffered data as data availability of the sub-sink.

Since the maximum speed $V$ of the $MS$ is given, a naive approach for the $MS$ is to move at this maximum speed $V$ on $P$ and visit all the sub-sinks and collect their data. But it may not collect complete data from all the sub-sinks. However, if the speed of the $MS$ can be varied according to the data availabilities of the sub-sinks, then it may improve the amount of data collection.

For instance, the $MS$ should move at slow speed within the communication range of a sub-sink, which has more data, whereas it should move at a faster speed within the communication range of a sub-sink which has less or no data. Furthermore, the $MS$ should move with its maximum speed of $V$, when it is not under the communication range of any sub-sink or the sub-sinks do not have data to deliver. Determining the speed of the $MS$ at different position on $P$ is referred as speed-schedule of $MS$. Note that the speed of the $MS$ can vary between [math] to $V$. It may happen that the $MS$ is within multiple sub-sinks communication regions then one of the sub-sinks can transmit data to the $MS$. Therefore, proper time sharing among the sub-sinks is also required. We refer it as data transmission schedule of the sub-sinks. The data transmission schedule of the sub-sinks to the $MS$ together with the speed schedule of the $MS$ is called as data gathering schedule of $MS$. Our objectives are to find optimal data gathering schedule of the $MS$ through the communication regions of the sub-sinks along the path $P$ to collect complete data from the sub-sinks in minimum time.

A possible speed-schedule for $MS$ is shown in Figure 2. Figure 2(a) shows the path $P$ of the $MS$ with dashed line and circles denote the communication disks of the sub-sinks. Let the $MS$ start from $S$ and end at $E$ while travelling through the path $P$. Figure 2(b) shows the speed-schedule of the mobile-sink at different position on $P$. It shows that the speed of $MS$ is slow within the communication disks of the sub-sinks whereas it runs with its maximum speed $V$ outside the communication disks.

We introduce some terminologies to describe our algorithm, which are as follows.

Definition 1**.**

Start-point ($p_{i}^{s}$) :* It is a first point on $P$ from which a sub-sink $ss_{i}$ can communicate or start delivering data to the $MS$.*

Definition 2**.**

End-point ($p_{i}^{e}$) :* It is a last point on $P$ after which a sub-sink $ss_{i}$ cannot communicate or ends delivering data to the $MS$.*

Definition 3**.**

*Data availability ($DA(ss_{i})$) : *** It is the amount of data available at a sub-sink $ss_{i}$.

Definition 4**.**

*Data delivery time ($DT(ss_{i})$) : *** It is the minimum time requirement to transmit the data available at a sub-sink $ss_{i}$ to the $MS$.

Data delivery time is determined using $DT(ss_{i})$ = $\frac{DA(ss_{i})}{dtr}$ formula, where $dtr$ denotes the data transmission rate between $ss_{i}$ and $MS$.

V Data Gathering in Minimum Time (data availability of sub-sinks are known apriori)

In this section, we first discuss linear programming problem (LPP) formulation of the proposed problem, thereafter we discuss a plane sweep based algorithm. The mobile sink $MS$ travels through the path $P$ and collects complete data from all the sub-sinks. The data availability values of the sub-sinks are given. The $MS$ receives data from one sub-sink at a time. The objective is to collect the complete data from all the sub-sinks in minimum time. We control the data gathering schedule of the $MS$. In other words, the time allocation of the $MS$ to the sub-sinks and the time spent by the $MS$ within their communication regions are determined based on their data availability values to minimize the data gathering process.

V-A LPP Formulation

The ordering of the start-points and end-points of the sub-sinks partition the path $P$ into disjoint segments/intervals. An example of partitioning the path $P$ into segments is shown in Figure 3. In Figure 3(a), a set of sub-sinks $\mathbb{SS}=\{ss_{1},ss_{2}\ldots ss_{5}\}$ and their start-points and end-points are shown on the path $P$. The ordering of the start-points and end-points of the sub-sinks partition the path $P$ into disjoint segments, which are shown in Figure 3(b). Zero or more sub-sinks are reachable to the $MS$ from a particular segment. The idea of the solution is that the data gathering time within each segment is shared properly among the sub-sinks such that the $MS$ can collect complete data from all the sub-sinks through the segments and total data gathering time from the starting position $S$ to the ending position $E$ is minimum. Also, the $MS$ maintains the maximum speed limit constraint.

The start-points and end-points of the sub-sinks partition the path $P$ into disjoint segments/intervals. The $m$ sub-sinks have $2m$ end-points. This will partition the path $P$ into at most $2m+1$ disjoint segments $\{I_{1},I_{2},\ldots I_{2m+1}\}$. For each segment, we use a set of variables for the set of sub-sinks reachable from the segment. Within a particular segment $I_{j}$, the set of sub-sinks reachable to the $MS$ remains unchanged. Let $SS(I_{j})$ denote the sub-sinks in $\mathbb{SS}$ reachable to the $MS$ within the segment $I_{j}$. Let $t_{j}^{i}$ denote the time allocated to sub-sink $ss_{i}\in SS(I_{j})$ for transferring its data to the $MS$ on the segment $I_{j}$. If a segment $I_{j}$ is not reachable to any sub-sink, then we assume that it is reachable from a virtual sub-sink $ss_{0}$ which has no data, i.e. $DA(ss_{0})=0$, and the time the $MS$ spends to cross the segment $I_{j}$ is denoted by $T(I_{j})=t_{j}^{0}\geq\frac{|I_{j}|}{V}$. Similarly, if from segment $I_{j}$ two sub-sinks $ss_{i}$ and $ss_{k}$ are reachable, i.e. $SS(I_{j})=\{ss_{i},ss_{k}\}$, then there are two variables $t_{j}^{i}$ and $t_{j}^{k}$ corresponding to two sub-sinks for the segment $I_{j}$. Each variable value denotes the amount of time allocated to the corresponding sub-sink for data delivery when the $MS$ travels through the segment $I_{j}$.

There are two types of constraints (i) time spent on each segment $I_{j}$ by the $MS$ is at least the travelling time $\frac{|I_{j}|}{V}$, and (ii) total time $t^{i}=\sum_{j=1}^{2m+1}{t_{j}^{i}}:ss_{i}\in SS(I_{j})$, allocated by the $MS$ to a sub-sink $ss_{i}$ for its data delivery, must be greater than or equal to the sub-sink's data delivery time $DT(ss_{i})$. The LPP formulation of the said problem is shown in Equation 1.

[TABLE]

After solving the LPP in Equation 1, $t_{j}^{i},\quad i=0\dots m,j=1\dots(2m+1)$ are known, which denote the data transmission schedule of the sub-sinks. The lengths of the segments $I_{i},i=1\dots(2m+1)$ are already derived from the start-points and end-points. Hence, the speed of the $MS$ at different segments can be determined easily. The following subsection discusses a plane sweep based algorithm for the problem.

V-B Plane Sweep Algorithm

The mobile sink $MS$ moves through the path $P$. When the $MS$ is within the multiple sub-sinks' communication range, then the $MS$ receives data from only one of them by prioritizing them according to their end-points positions on $P$. The sub-sink whose end-point appears first on $P$ has higher priority than that sub-sink whose end-point appears later. Let $PR(ss_{i})$ denote the priority of a sub-sink $ss_{i}$.

In the plane sweep algorithm, it is simulated by moving a sweep line through the path $P$. We consider a horizontal data gathering path $P$ for the $MS$ and a virtual vertical line perpendicular to $P$, called sweep line moves (sweeps) through the path $P$ from $S$ to $E$. While sweeping the sweep line intersects the sub-sinks' communication disks. We have defined two types of events : start-point event and end-point event for every sub-sink. Start-points and end-points of the sub-sinks are stored in an event queue $Q$ according to their appearance on $P$ from left to right. At a particular position of the sweep line on $P$, we maintain a list of sub-sinks in a status line data structure $L$. The sub-sinks whose communication disks intersect the sweep line on $P$ are in $L$. At a particular position on $P$, if multiple sub-sinks' communication disks intersect the sweep line on $P$ and they have data, then a sub-sink $ss_{i}$ in $L$ with maximum priority gets the preference to deliver data to $MS$.

Initially, all the start-points and end-points of the sub-sinks are added to the event queue $Q$. We are calling three methods to perform different operations on the event queue $Q$. $InsertInQ()$ method is used for inserting an event, $RemoveFromQ()$ method removes the leftmost event on $P$, and $PeekFromQ()$ method retrieves the leftmost event but does not remove it from the queue. Similarly, three methods $InsertInL()$, $RemoveFromL()$, and $PeekFromL()$ are used to perform three different operations on the status line data structure $L$. Events are processed one by one from the event queue $Q$, as the sweep line moves through the path $P$. The top event is removed from $Q$ and is referred as current event $CE$. A sub-sink $ss_{i}$ is inserted into $L$, whenever the sweep line processes its start-point $p_{i}^{s}$. If the sweep line is processing an end-point $p_{i}^{e}$ of sub-sink $ss_{i}$ and the complete data of $ss_{i}$ is not yet delivered, then the $MS$ waits at the end-point $p_{i}^{e}$ and receives the remaining data from $ss_{i}$. Subsequently, the sub-sink $ss_{i}$ is removed from $L$. Thereafter, the next event point $NE$ is picked from the event queue $Q$. Travel time $TT$ of the $MS$ between current event $CE$ and the next event $NE$ is determined assuming that the $MS$ moves with its maximum speed $V$ in between the two events. Thereafter, maximum priority sub-sink $ss_{j}$ is picked from $L$. If the data transmission time $DT(ss_{j})$ of the sub-sink $ss_{j}$ is $\leq TT$, then the sub-sink $ss_{j}$ completes data delivery to the $MS$ between the two events. The sub-sink $ss_{j}$ is removed from $L$. Subsequently, the next highest priority sub-sink in $L$ is picked for data delivery. This process continues until the sweep line reaches another event point or the data delivery process is completed. If there is no sub-sink in $L$ having data to deliver then the $MS$ moves with its maximum speed $V$. The detailed algorithm is presented in Algorithm 1.

In Figure 3(a), the $MS$ starts its journey from $S$ with speed $V$. As it reaches $p_{1}^{s}$, then the sub-sink $ss_{1}$ is inserted into $L$. Thereafter, $MS$ starts receiving data form $ss_{1}$ until it reaches $p_{2}^{s}$. If the data delivery of $ss_{1}$ is not over, then there are two sub-sinks $ss_{1}$, $ss_{2}$ reachable to $MS$ within segment $[p_{2}^{s}p_{1}^{e}]$. As the end-point $p_{1}^{e}$ appears before $p_{2}^{e}$, therefore, according to our algorithm, sub-sink $ss_{1}$ gets the privilege to deliver its remaining data to $MS$ within the segment $[p_{2}^{s}p_{1}^{e}]$. If the data delivery of $ss_{1}$ is still not over within $\frac{|p_{1}^{s}p_{1}^{e}|}{V}$ time, then the $MS$ waits at point $p_{1}^{e}$ for the remaining data delivery time for the duration of $DT(ss_{1})-\frac{|p_{1}^{s}p_{1}^{e}|}{V}$ time. Otherwise, the $MS$ starts receiving data from $ss_{2}$ after crossing the start-point $p_{2}^{s}$ and allocating $DT(ss_{1})$ time to $ss_{1}$. In this way, the $MS$ either moves with its maximum speed or waits at the end-points of the sub-sinks until it reaches the end of the path $E$.

Corollary 1**.**

Data gathering sub-paths of the mobile sink $MS$ on $P$ from a sub-sink $ss_{i}$ is confined within $[p_{i}^{s},p_{i}^{e}]$ for $i\in\{1\ldots m\}$.

Theorem 1**.**

If the mobile sink $MS$ follows the Algorithm 1 for data gathering, then it receives complete data from all the sub-sinks.

Proof.

Algorithm 1 selects the highest priority sub-sink in $L$ for data delivery to the $MS$. A sub-sink $ss_{i}\in\mathbb{SS}$ is removed from $L$ only when the $MS$ finishes receiving its data by allocating $DT(ss_{i})$ time to $ss_{i}$. The time allocation may be continuous or discontinuous. A sub-sinks $ss_{i}$ is inserted to $L$ whenever the $MS$ crosses $p_{i}^{s}$. Since all the star-points and end-points of the sub-sinks are in $Q$ and are processed. Therefore, all the sub-sinks get a chance to be in $L$. Once the algorithm ends then the event queue $Q$ and the list $L$ become empty. Therefore, all the sub-sinks must have delivered their complete data to the $MS$. ∎

Theorem 2**.**

The mobile sink $MS$ completes the data gathering process in minimum time by following Algorithm 1.

Proof.

Assume for the sake of contradiction that the $MS$ does not complete the data gathering process in minimum time. According to our algorithm, the $MS$ moves with its maximum speed $V$ throughout the path except at some end-points. So, there is an extra delay at some end-points. Extra delay for receiving data from a sub-sink $ss_{i}$ is possible only when the $MS$ waits at $p_{i}^{e}$, but for some sub-path of $[p_{i}^{s},p_{i}^{e}]$, the $MS$ moves without receiving data from any sub-sink or receives data from a sub-sink $ss_{j}$, whose end-point $p_{j}^{e}$ appears after $p_{i}^{e}$. This is because the sub-sinks, whose end-points appear after $p_{i}^{e}$ can deliver data beyond $[p_{i}^{s},p_{i}^{e}]$, and may overall reduce the waiting time at $p_{i}^{e}$.

According to Algorithm 1, once the $MS$ enters $[p_{i}^{s},p_{i}^{e}]$, it either receives data from $ss_{i}$, or any other sub-sink $ss_{j}$ such that $PR(ss_{j})\geq PR(ss_{i})$ in $L$. This implies $p_{j}^{e}$ appears before $p_{i}^{e}$. Therefore, there is no sub-path within $[p_{i}^{s},p_{i}^{e}]$ where the $MS$ moves/waits without receiving data from any sub-sink $ss_{j}\in L$, where $PR(ss_{j})\geq PR(ss_{i})$ and waits at $p_{i}^{e}$. Hence, the $MS$ does not make extra delay at any end-point and completes the data gathering process in minimum time. ∎

Theorem 3**.**

*Time complexity of the plane sweep algorithm 1 is $O(m\log{m})$.

Proof.

Throughout the algorithm, an event point (start-point/end-point) of a sub-sink is inserted once and removed once in the event queue $Q$, and in total $2m$ event points are processed. The events are processed from event queue $Q$ using a heap data structure. Inserting and then removing the event points require $O(m\log{m})$ time. During the processing of an event, some basic operations on the status line data structure $L$ are performed. In the worst case, $m$ sub-sinks are simultaneously in $L$. Therefore, the time needed to perform an insert or delete operation on the status line is $O(\log{m})$ and the peek operation takes $O(1)$ time.

The plane sweep algorithm processes $2m$ event points for $m$ sub-sinks. In total $m$ insert and $m$ delete operations, and at most $2m$ peek operations are performed on the status line data structure $L$, and each such operation takes at most $O(\log{m})$ time. Hence, it follows that the total time processing all the events is $O(m\log{m})$. ∎

VI Improving the Data Gathering Time By Optimizing The Data Availabilities of the Sub-sinks

The solution in the previous section finds a data gathering schedule of the $MS$, where the data availability values of the sub-sinks are given. This section generalizes the problem, where data availabilities of the sub-sinks are determined to improve the data gathering time. Proper distribution of the sensors' data among the sub-sinks is carried out to improve the data gathering time. Determining an optimal data distribution among the sub-sinks is another challenging issue in WSN. The data availability values of the sub-sinks are determined using a plane sweep algorithm for the given sensor network. After determining the optimal data availability values of the sub-sinks, we consider the values as data delivery capacity of the sub-sinks and the sensors' data are pushed to those sub-sinks using network flow algorithm. Thereafter, Algorithm 1 is used to complete the data gathering process in minimum time. In summary, this section discusses the solution for the Problem 2, where our objective is to distribute the sensors' data among the sub-sinks properly so that the $MS$ can collect complete data from all the sub-sinks in minimum time.

VI-A Determining Data Availabilities of the Sub-Sinks Using Plane Sweep Algorithm

In this subsection, we determine the data availability values of the sub-sinks for a given network topology. We assume that the data generated on the sensors are known, which are denoted as $DG(s_{i}):i=1:n$. Using a plane sweep algorithm, we determine the data availability values of the sub-sinks $DA(ss_{i}):i=1:m$. Initially, the sensor network is partitioned into connected components $C=\{c_{1},c_{2},\ldots c_{k}\}$ based on its communication topology $G$. The idea of this algorithm is that the data generated in a component is distributed among its corresponding sub-sinks so that the $MS$ can collect complete data from the component through its sub-sinks in minimum time. The $MS$ moves with its maximum speed $V$ through $P$, except at a few end-points.

For individual connected component, the total data generated by the sensors in the corresponding component is determined. Let $\{DG(c_{1}),DG(c_{2}),\ldots DG(c_{k})\}$ denote the data generated in the components. The data availabilities of the sub-sinks are initialized to zero : $DA(ss_{1})=0,DA(ss_{2})=0,\ldots DA(ss_{m})=0$. The start-points and end-points of the sub-sinks are determined. The sub-sinks are labelled with their corresponding component identity. Let $C(ss_{i})$ denote the component identity of a sub-sink $ss_{i}$. The last sub-sink of a component $c_{i}$ denoted by $LSS(c_{i})$ is a sub-sink, whose end-point appears last on $P$ among all the sub-sinks in $c_{i}$. For each component $c_{i}$, identify its last sub-sink $LSS(c_{i})$. The start-points and end-points of the sub-sinks are stored in an event queue $Q$ according to their order on the path $P$. The status line data structure $L$ is initialized to $\emptyset$.

A virtual perpendicular sweep line moves through the path $P$ and process the events one after another from the event queue. At a particular position on the path $P$ of the sweep line, it keeps track of all the sub-sinks in a status line $L$, whose communication disks intersect the sweep line on the path $P$. The priority of a sub-sink $ss_{i}$ in $L$ is based on the two parameters : its corresponding component's last sub-sink's end-point position, i.e. end-point of $LSS(ss_{i})$, and its start-point $p_{i}^{s}$ on $P$. If two sub-sinks $ss_{i}$ and $ss_{j}$ belong to same component, i.e. $C(ss_{i})=C(ss_{j})$, then the sub-sink whose start-point appears first on $P$, has higher priority than the other sub-sink. If the two sub-sinks belong to different components, i.e. $C(ss_{i})\neq C(ss_{j})$ and the end-point of $LSS(C(ss_{i}))$ appears before the end-point of $LSS(C(ss_{j}))$ on $P$, then $PR(ss_{i})>PR(ss_{j})$.

The top event is removed from the queue $Q$ and is referred as the current event $CE$. If $CE$ is a start-point of $ss_{i}$, then $ss_{i}$ is inserted into $L$. If $CE$ is an end-point of sub-sink $ss_{i}$ and it is the last sub-sink of its corresponding component $c_{j}$ and the component has data ($DA(c_{j})>0$) then the data availability of $ss_{i}$ is increased by $DA(c_{j})$. Subsequently, the sub-sink $ss_{i}$ is removed from $L$. Thereafter, the next event point $NE$ is picked from the event queue $Q$. Travel time $TT$ of the $MS$ between current event $CE$ and the next event $NE$ is determined assuming that the $MS$ moves with its maximum speed $V$ in between the two events.

Next, the maximum priority sub-sink $ss_{j}$ is picked from $L$. Let $C(ss_{j})$ denote the component of sub-sink $ss_{j}$. If the remaining data availability of the component $C(ss_{j})$, which is $DA(C(ss_{j}))\leq TT*dtr$ (data transmission capacity of $ss_{j}$ between the two event points), then data availability of $ss_{j}$ is increased by $DA(C(ss_{j}))$. The sub-sink $ss_{j}$ is removed from $L$. The remaining travel time between the two events $CE$ and $NE$ of the $MS$ is updated accordingly. This process continues until the remaining travel time by the $MS$ is exhausted and subsequently process the next event. In other words, if data transfer from a component $c_{i}$ is over before the sweep line reaches the end-point of its corresponding last sub-sink $LSS(c_{i})$, then all the sub-sinks in $c_{i}$ are removed from $L$. This process continues until the sweep line reaches the next event point or the data delivery process is completed. The detailed algorithm for finding data availabilities of the sub-sinks is shown in Algorithm 2.

Theorem 4**.**

*Time complexity of the plane sweep algorithm 2 is $O(n+e+m\log{m})$, where $n$ and $e$ denote the number of sensors and number of links in the communication graph $G$.

Proof.

Depth first search is used for partitioning the network into components which can be performed in $O(n+e)$ time. Computing total data generated for each component can be performed in $O(n)$ time. Finding the start-points and end-points of the sub-sinks can be done in $O(m)$ time. Identifying the last sub-sink for each component can be done in $O(n)$ time. The time complexity analysis for the rest of the algorithm is similar to Algorithm 1. The plane sweep algorithm processes $2m$ event points. The events are inserted and then removed from the event queue, which takes overall $O(m\log{m})$ time. During the processing of an event, some basic operations on the status line data structure are performed. There are at most $m$ sub-sinks intersecting the sweep line on $P$ at any time and therefore, the time needed to perform an insert or delete operation on status line is $O(\log{m})$ and peek operation can be performed in $O(1)$ time. Through the algorithm, a sub-sink is inserted once and removed once from the status line data structure. Therefore, the total time spent on accessing the sweep line status data structure is $O(m\log{m})$. Hence, it follows that the total time spent processing all the events is $O(m\log{m})$. Therefore, the total time complexity of the algorithm is $O(n+e+m\log{m})$ ∎

VI-B *Distributing Data Among the Sub-Sinks Using Network Flow Algorithm *

Once the data availability values of the sub-sinks $DA(ss_{1}),DA(ss_{2})$ $\ldots DA(ss_{m})$ are determined using Algorithm 2, this phase distributes the sensors' data among the sub-sinks. Data are pushed from the sensors to the sub-sinks based on their calculated data availability values. Sensors use the communication topology network to send data to the sub-sinks. Network flow algorithm is used for finding data flow from the sensors to the sub-sinks. Construction of network flow graph and determining the distribution of data from the sensors to the sub-sinks for a given communication topology is described with an example for the sensor network in Figure 1.

The connected components corresponding to the sensor network of Figure 1 are identified and labelled with $c_{1}$, and $c_{2}$ in Figure 4. To determine the data distribution from the sensors to the sub-sinks, a network flow graph is constructed using the communication topology of the sensor network. Thereafter, the sensors' data are distributed among the sub-sinks based on the data availability values of the sub-sinks, the amount of data generated within the sensors, and the communication topology. The network flow graph corresponding to the communication topology in Figure 4 is shown in Figure 5. A virtual source vertex $VS$ and a virtual sink vertex $VK$ are added to the network topology. To maintain the cleanness of the figure, we have drawn four duplicate virtual source vertices, but actually they are a single vertex $VS$. The virtual source vertex is incident to the sensor nodes including the sub-sinks using virtual links. The capacities of these virtual links are set based on their data generation capacities. Therefore, the capacity of a link between $VS$ and $s_{i}$ is $DG(s_{i})$. Similarly, the link capacity between $VS$ and $ss_{i}$ is $DG(ss_{i})$ because, as these are data generation limits of the sensor $s_{i}$ /sub-sink $ss_{i}$. The sub-sinks are incident to the virtual sink $VK$ through virtual links. The capacity of a virtual link between a sub-sink $ss_{i}$ and the virtual sink $VK$ is set to $DA(ss_{i})$, which is its data availability value determined in the previous phase. Other links represent the communication links among the sensors/sub-sinks, and their capacities are set to infinity because we assume that a sensor can forward the data generated within itself or received from its neighbors.

Thereafter, the network flow algorithm is used for finding the maximum data flow from the $VS$ to $VK$. The flow value of the links denotes the data flow between the corresponding sensors/sub-sinks. Finally, data is delivered from a sub-sink to virtual sink $VK$. The flow value between a sub-sink and the virtual sink denotes the actual data delivery by the sub-sink to the $MS$.

VI-C *Gathering Data Using Algorithm 1 *

In this subsection, we find an optimal data gathering schedule of the mobile sink ($MS$) to collect complete data from all the sub-sinks in minimum time. Once the data availabilities of the sub-sinks $DA(ss_{1}),DA(ss_{2})\ldots DA(ss_{m})$ are determined, and data are pushed from the sensors to the sub-sinks, we use the Algorithm 1 of Section V to find the data gathering schedule of the $MS$.

Theorem 5**.**

If the data availabilities of the sub-sinks are determined using Algorithm 2 and $MS$ follows the speed-schedule using Algorithm 1, then the mobile sink $MS$ completes the data gathering process in minimum time.

Proof.

The data availabilities of the sub-sinks are determined using Algorithm 2 such that the $MS$ is able to receive complete data from a component while moving with its maximum speed $V$ and if required waits only at the last sub-sink's end-point. The data generated in the sensors are distributed among its sub-sinks based on the data availability values determined using Algorithm 2. According to Algorithm 1, while the $MS$ is moving, it receives data from the highest priority sub-sink having data to deliver. Let the first sub-sink of a component $c_{i}$ be a sub-sink $ss_{j}\in c_{i}$, whose start-point $p_{j}^{s}$ appears first on $P$. Let $c_{i}^{s}=p_{j}^{s}$ denote the start-point of the first sub-sink of $c_{i}$. Similarly, $c_{i}^{e}$ denotes the end-point of the sub-sink $LSS(c_{i})$.

Algorithm 2 prioritizes the sub-sinks based on their components' last sub-sink's end-point positions and sub-sinks' start-point positions. The sub-sink whose component's last sub-sink's end-point appears first on $P$, gets the highest preference for data delivery. If two sub-sinks are on the same component, then the sub-sink whose start-point appears first has a higher priority than the other. The $MS$ receives data from a sub-sink in $L$, which has maximum priority and has data to deliver. If there is no data, then it is immediately removed from $L$.

Similar to the proof of Theorem 2, assume for the sake of contradiction that the $MS$ does not complete the data gathering process in minimum time. It implies that there is a sub-path of $[c_{i}^{s},c_{i}^{e}]$ for component $c_{i}$, and the sub-path is under the communication disk of a sub-sink $ss_{k}\in c_{i}$, where the $MS$ moves without receiving data from any sub-sink or receives data from a sub-sink $ss_{l}$, whose priority $PR(ss_{l})<PR(ss_{k})$ and the $MS$ waits at $c_{i}^{e}$ for receiving data from component $c_{i}$. The sub-sink $ss_{l}$ may belong to (i) same component $c_{i}$ as of $ss_{k}$, or (ii) in a different component $c_{j}$, i.e. $c_{j}\neq c_{i}$.

In case (i), where sub-sink $ss_{l}\in c_{i}$, the $MS$ does not wait at $c_{i}^{e}$. This is because within the communication disk of $ss_{k}$, if the $MS$ receives data from sub-sink $ss_{l}\in c_{i}$ with $PR(ss_{l})<PR(ss_{k})$, then all the sub-sinks in $c_{i}$ with priority $\geq PR(ss_{k})$ do not have data to deliver.

In case (ii), where sub-sink $ss_{l}\in c_{j}$ and $c_{j}\neq c_{i}$, based on the first sub-sink's start-point and last sub-sink's end-point positions of a component, two components $c_{i}$ and $c_{j}$ have three different types of overlaps as shown in Figure 6. All other types of overlaps are equivalent to one of them. We will show that extra delay at $c_{i}^{e}$ does not hold for any of these three types of overlaps.

In Figure 6(a) type overlap, two components are disjoint. Hence, the $MS$ does not receive data from $ss_{l}\in c_{j}$ within [$c_{i}^{s},c_{i}^{e}$ ] and make an extra delay at $c_{i}^{e}$.

In Figure 6(b) type overlap, the second component starts before the end of first component. In this case, the priority of any sub-sink in component $c_{i}$ is higher than any sub-sink in component $c_{j}$. Hence, the $MS$ receives data from $ss_{l}\in c_{j}$ within [$c_{i}^{s},c_{i}^{e}$ ] only when there is no data in $ss_{k}$. If there is no data in $ss_{k}$, then all data from $c_{i}$ is already delivered to the $MS$ and the $MS$ does not wait at $c_{i}^{e}$.

In Figure 6(c) type overlap, the priority of any sub-sink in component $c_{j}$ is higher than any sub-sink in component $c_{i}$. So, $PR(ss_{l})$ can not be less than $PR(ss_{k})$.

Therefore, in both case (i) and case (ii) our assumption does not hold and hence the theorem is proved. ∎

VII Experiment and Performance Analysis

We evaluate the performance of our two proposed algorithms. We have used MATLAB for implementing our algorithms. In this section, we evaluate the performances of our proposed algorithms. We refer the algorithms for data gathering algorithm using speed controllable mobile-sink with known data availability (Algorithm 1) as VS-K-DA. VS-UK-DA refers to the case where data availabilities of the sub-sinks are unknown and optimized using Algorithm 2. Algorithm VS-UK-DA is combined with network flow algorithm for data distribution and with Algorithm 1 to find data gathering schedule. We compare the above two algorithms with a third algorithm FS-K-DA, where data availabilities of the sub-sinks are known apriori as in VS-K-DA and the mobile sink $MS$ is moving with its maximum speed as in [7] for collecting data from the sub-sinks.

VII-A Simulation environment

During simulation, the number of sensor nodes is varying for 100, 120, 140 and 160. The communication range of sensors is set to 75m. Sensors deployment region is a rectangular area of size 1000m x 400m. The rectangular region is vertically partitioned into four sub-regions of length 250m each. Within each sub-region of length 250m, sensors are randomly deployed within a vertical strip of [75m : 150m]. This is done to ensure that the random communication topology forms at least four connected components and there are gaps between the consecutive components. In the simulation, the $MS$ is moving along a horizontal path $P$ at the centre of the region (y=200m). The maximum speed $V$ of the $MS$ is set to 2 m/s. The $MS$ collects data from one sub-sink at a time, which is within the communication range. The data transfer rate between a sub-sink and the $MS$ is set to 2 Kbps. We assume that the sensors generate data randomly between 0 to 10 packets, and each packet is of size 1Kb. The far-away sensors send their sensed data to the sub-sinks through multi-hop forwarding. Data availabilities of the sub-sinks (for known apriori case) of problem 1 is determined using shortest path routing, where the sensors forward their data to its closest (hop-count) sub-sink.

Let $e_{r}$ and $e_{t}$ denote energy consumption for receiving and transmitting unit bit data. Let $E_{i}$ represent the total energy consumption of a sensor $s_{i}$ for receiving $d_{r}^{i}$ bits, and transmitting $d_{t}^{i}$ bits. Therefore, $E_{i}$ can be written as :

[TABLE]

Total energy consumption of the network $E_{total}$ is calculated as the summation of energy consumption for forwarding data from the sensors to the $MS$ through their respective sub-sinks.

[TABLE]

Let $DD(ss_{i})$ denote data delivered by a sub-sink $ss_{i}$ to the $MS$. Hence, total energy consumption $E_{total}$ includes energy consumption for delivering data from the sub-sinks to the $MS$, which is $\sum_{i=1}^{m}{e_{t}*DD(ss_{i})}$. This is because the sub-sinks $\mathbb{SS}\subseteq N$. Table I summarizes the simulation parameters.

VII-B Performance analysis of the proposed algorithms

Figure 7 shows the total data collected by the mobile-sink with respect to the number of sensors. From the figure, it is obvious that the amount of data collection is proportional to the number of sensors. Data collection in VS-K-DA and VS-UK-DA are same because both the algorithms collect complete data from the network, whereas data collection in FS-K-DA is lesser than the two proposed algorithms. The difference between fixed speed and variable speed data gathering increases as the number of sensors increases. This is because, in VS-K-DA and VS-UK-DA, the complete data from the sub-sinks are collected by controlling the speed of the $MS$, whereas in FS-K-DA, the $MS$ moves with its maximum speed, and the sub-sinks do not get enough time to deliver their data completely.

Figure 8 shows the data gathering time with respect to the number of sensors. It shows that the data gathering time increases proportionally to the number of sensors for the two proposed algorithms VS-K-DA and VS-UK-DA. But data gathering time of FS-K-DA is constant and it does not depend on the number of sensors. This is because in FS-K-DA the $MS$ moves with its fixed maximum speed (2m/sec). Data gathering time in VS-UK-DA is lesser than VS-K-DA. The time difference between VS-K-DA and VS-UK-DA increases proportional to the number of sensors present in the network. Because in VS-UK-DA, sensors' data are forwarded to the sub-sinks to reduce the total data gathering time. In algorithm VS-UK-DA, sometimes data are forwarded to the sub-sinks at a longer hop count distance. It increases the energy consumption of the network, which is reflected in Figure 12.

Figure 9 shows the average speed of the $MS$ with respect to the number of sensors. For our two proposed algorithms, the average speed of the $MS$ decreases as the number of sensors increases. This is because as the number of sensors increase, more data are forwarded to the sub-sinks, and it increases the data transmission time from the individual sub-sink to the $MS$. The average speed of VS-UK-DA is little higher than VS-K-DA.

Idle period of the $MS$ denotes the time the $MS$ moves without receiving data from any sub-sink while moving on the path $P$. Figure 10 shows the idle period of the $MS$. The idle period decreases as the number of sensors increases. This is because as the number of sensors increases, more sub-sinks are there and hence, the total data transfer time increases and the idle time decreases. Idle period of VS-UK-DA is comparatively lower than the other, and the difference increases as the number of sensors increases.

Throughput measures the amount of data collected by the $MS$ per unit time. Figure 11 shows the throughput of the network with respect to the number of sensors. As the number of sensors increases, the number of sub-sinks and the total data collection by the $MS$ are also increased and hence, improves the throughput of the network. From the result, it is observed that the throughput of VS-UK-DA is comparatively higher than the other.

We evaluate the total energy consumption for forwarding data to the $MS$, but the energy consumption of the $MS$ is not considered. Figure 12 shows the total energy consumption with respect to the number of sensors. As the number of sensors increases total data generated in the network increases proportionally and hence, total energy consumption increases proportionally. In both VS-K-DA and FS-K-DA data gathering algorithms, the data generated in the sensors are transferred to the sub-sinks through the shortest path. But, in algorithm FS-K-DA, complete data from the sub-sinks are not delivered to the $MS$ and hence, energy consumption is little lesser than VS-K-DA. Whereas both VS-K-DA and VS-UK-DA algorithms deliver complete data to the $MS$, but algorithm VS-UK-DA forwards data to the sub-sinks to optimize total gathering time. Hence, sometimes sensors' data are forwarded to sub-sinks which are at a longer distance, which increases the total energy consumption of VS-UK-DA.

Finally, we study the performance of the algorithms, by varying the maximum speed limit $V$ of the $MS$ and evaluate the total data gathering time of the $MS$. Figure 13 shows the total data gathering time for different speeds. As the maximum speed limit increases, the data gathering time also decreases. This is because as the speed increases, the idle period of the $MS$ decreases proportionally. Also, the time difference between VS-K-DA and VS-UK-DA decreases proportionally. For fixed speed data gathering FS-K-DA, total data gathering time decreases linearly, which is reflected in the figure.

VIII Conclusion

In this article, we have studied two problems for the maximum data gathering using a mobile sink ($MS$) for time-sensitive applications. The $MS$ can adjust its movement speed while moving along a given path in the network. However, the speed of the $MS$ cannot go beyond a given maximum speed limit $V$. We have presented plane sweep based algorithms to find optimal data gathering schedule of the $MS$. In the first algorithm, the minimum time data gathering schedule of the mobile-sink is determined by controlling the data transmission schedule of the sub-sinks and speed of the $MS$, where the data availability values of the sub-sinks are known. The second algorithm improves the data gathering time and the throughput by optimizing the data availability values of the sub-sinks by controlling the data distribution from the sensors to the sub-sinks. It is observed from the experiment results that the data gathering time of Algorithm VS-UK-DA is better than the Algorithm VS-K-DA. But, energy consumption of VS-UK-DA is higher than VS-K-DA and FS-K-DA. The results also show that both VS-K-DA and VS-UK-DA have better data gathering capability and throughput than FS-K-DA. In future, we plan to find an optimal fixed speed of the $MS$ to improve the total data collection process. In addition, we will find an optimal path for the $MS$ to improve data collection for time-sensitive applications.

IX Acknowledgments

This work is supported by the Science & Engineering Research Board, DST, Govt. of India [Grant numbers: ECR/2016/001035]