Mobility/MobilityModels: RandomWaypointMoveManyDestinationsMultiNodeIsUniqueAdded.pl

File RandomWaypointMoveManyDestinationsMultiNodeIsUniqueAdded.pl, 12.0 kB (added by mrodoper, 6 months ago)
Line 
1# Author: Mete Rodoper
2# For more detail refer the How to code and use Various Mobility Model Scripts to Emulate Mobility at ORBIT tutorial
3
4# **this code is based on reference node model**
5
6
7#!/usr/bin/perl
8
9use Math::Round qw(:all);
10use Math::Trig 'rad2deg';
11
12#############################################################################################################
13######################################## Enter the values here ##############################################
14#############################################################################################################
15
16@sourceXValue = (1, 1, 4); # Source X values of all 3 VMs.
17@sourceYValue = (1, 4, 12); # Source Y values of all 3 VMs.
18
19$numberOfDestinations = 3; # The number of destinations that you want VM to travel
20$maxIntervalTime = 100; #Maximum waiting time at a node
21$minIntervalTime = 10; #Maximum waiting time at a node
22@accelerationRandomness = ([25, -5, -2],
23                           [12, -4, -4],
24                           [32, -12, 3]);  # Acceleration values between checkpoints, e.g.: Between VM1 source and 1st checkpoint point acceleration is 25, then -5, last, -2 and same for other VMs.
25$randomnessInterval = 1; # Maximum distance that a node can jump at an iteration
26
27#############################################################################################################
28#############################################################################################################
29#############################################################################################################
30
31$numberOfDestinationsIterator = 1;
32$numberOfSources = scalar(@sourceXValue);
33$numberOfSources--;
34
35while ($numberOfSources > -1)
36{
37        while (1 + $numberOfDestinations > $numberOfDestinationsIterator)
38        {
39                $randX = 1 + int(rand(19));
40                $randY = 1 + int(rand(19));
41
42                push @{$destinationXValue{$numberOfSources}}, $randX;
43                push @{$destinationYValue{$numberOfSources}}, $randY;
44
45                $numberOfDestinationsIterator++;
46        }
47        $numberOfSources--;
48        $numberOfDestinationsIterator = 1;
49}
50
51$randomTemp;
52$intervalTime = $maxIntervalTime;
53$mobileNumber = scalar(@sourceXValue);
54$cumulativeTime = 0;
55
56$mobileNumberIterator = 0;
57
58$previousNode = "";
59
60while($mobileNumberIterator < $mobileNumber)
61{
62$mobileNumberIteratorToPrint = $mobileNumberIterator +1;
63print "Mobile node $mobileNumberIteratorToPrint starts\n";
64
65        $cumulativeTime = 0;
66        $cumulativeTimeOld = 0;
67        $intervalTime = $maxIntervalTime;
68
69        $randomTemp = int(rand($accelerationRandomness[$mobileNumberIterator][0]));
70        if ($intervalTime - $randomTemp >= $minIntervalTime && $intervalTime - $randomTemp <= $maxIntervalTime)
71        {
72                $intervalTime = $intervalTime - $randomTemp;
73        }
74
75        $cumulativeTime = $cumulativeTime + $intervalTime;
76        $cumulativeTimeOld = $cumulativeTime-$intervalTime;
77
78        $nodeNumber = $sourceXValue[$mobileNumberIterator] * 100 + $sourceYValue[$mobileNumberIterator];
79
80        if(isUnique($intervalTime , $cumulativeTime, $nodeNumber, @timer))
81        {
82                $loopIterator = 0;
83                while ($loopIterator < $intervalTime)
84                {
85                        push @{$timer{$nodeNumber}}, $cumulativeTimeOld + $loopIterator;
86                        $loopIterator++;
87                }
88
89                $nodeNameAndTime = "$cumulativeTimeOld node$sourceXValue[$mobileNumberIterator]-$sourceYValue[$mobileNumberIterator]";
90                print "$cumulativeTimeOld node$sourceXValue[$mobileNumberIterator]-$sourceYValue[$mobileNumberIterator]\n";
91                push @{$store{$mobileNumberIterator}}, $nodeNameAndTime;
92        }
93        else
94        {
95                $k--;
96        }
97
98        for($destinationNo = 0 ; $destinationNo < $numberOfDestinations ; $destinationNo++)
99        {
100
101                $distance = sqrt((${$destinationYValue{$mobileNumberIterator}}[$destinationNo]-$sourceYValue[$mobileNumberIterator])*(${$destinationYValue{$mobileNumberIterator}}[$destinationNo]-$sourceYValue[$mobileNumberIterator]) + (${$destinationXValue{$mobileNumberIterator}}[$destinationNo]-$sourceXValue[$mobileNumberIterator])*(${$destinationXValue{$mobileNumberIterator}}[$destinationNo]-$sourceXValue[$mobileNumberIterator]));
102
103                $absdistance = int($distance);
104
105                $angle = atan2((${$destinationYValue{$mobileNumberIterator}}[$destinationNo]-$sourceYValue[$mobileNumberIterator]), (${$destinationXValue{$mobileNumberIterator}}[$destinationNo]-$sourceXValue[$mobileNumberIterator]));
106                $angle2 = rad2deg($angle);
107               
108                $k=1;
109
110                while ($k < $absdistance)
111                {
112                        do{
113                                $pointX = $sourceXValue[$mobileNumberIterator] + $k * cos($angle) + rand($randomnessInterval)-($randomnessInterval)/2;
114                        }while($pointX > 20);
115                        do{
116                                $pointY = $sourceYValue[$mobileNumberIterator] + $k * sin($angle) + rand($randomnessInterval)-($randomnessInterval)/2;
117                        }while($pointY > 20);
118       
119                        $fractionX = $pointX - int($pointX);
120                        $fractionY = $pointY - int($pointY);
121               
122                        $firstQuarter = $fractionY * $fractionY + $fractionX * $fractionX;
123                        $secondQuarter = $fractionY * $fractionY + (1-$fractionX) * (1-$fractionX);
124                        $thirdQuarter = (1-$fractionY) * (1-$fractionY) + (1-$fractionX) * (1-$fractionX);
125                        $fourthQuarter = (1-$fractionY) * (1-$fractionY) + $fractionX * $fractionX;
126               
127                        $floorX = int($pointX);
128                        $floorY = int($pointY);
129                        $ceilingX = $floorX+1;
130                        $ceilingY = $floorY+1;
131                       
132                        $minDistance = $firstQuarter;
133                        $min = "1";
134                        if ($secondQuarter < $minDistance)
135                        {
136                                $min = "2";
137                                $minDistance = $secondQuarter;
138                        }
139                        if ($thirdQuarter < $minDistance)
140                        {
141                                $min = "3";
142                                $minDistance = $thirdQuarter;
143                        }
144                        if ($fourthQuarter < $minDistance)
145                        {
146                                $min = "4";
147                        }
148       
149                        if ($min == "1")
150                        {
151
152                                $nodeName = "node$floorX-$floorY";
153                                if ($previousNode ne $nodeName)
154                                {
155                                        $randomTemp = int(rand($accelerationRandomness[$mobileNumberIterator][$destinationNo]));
156                                        if ($intervalTime - $randomTemp >= $minIntervalTime && $intervalTime - $randomTemp <= $maxIntervalTime)
157                                        {
158                                                $intervalTime = $intervalTime - $randomTemp;
159                                        }
160                                        $cumulativeTime = $cumulativeTime + $intervalTime;
161                                        $cumulativeTimeOld = $cumulativeTime-$intervalTime;
162                                        $nodeNumber = $floorX * 100 + $floorY;
163
164                                        if(isUnique($intervalTime, $cumulativeTime, $nodeNumber, @timer))
165                                        {
166                                                $loopIterator = 0;
167                                                while ($loopIterator < $intervalTime)
168                                                {
169                                                        push @{$timer{$nodeNumber}}, $cumulativeTimeOld + $loopIterator;
170                                                        $loopIterator++;
171                                                }
172
173                                                $nodeNameAndTime = "$cumulativeTimeOld node$floorX-$floorY";
174                                                print "$nodeNameAndTime\n";
175                                                push @{$store{$mobileNumberIterator}}, $nodeNameAndTime;
176                                                $previousNode = $nodeName;
177                                        }
178                                        else
179                                        {
180                                                $k--;
181                                        }
182                                }
183                        }
184                        elsif ($min == "2")
185                        {
186                                $nodeName = "node$ceilingX-$floorY";
187                                if ($previousNode ne $nodeName)
188                                {
189                                        $randomTemp = int(rand($accelerationRandomness[$mobileNumberIterator][$destinationNo]));
190                                        if ($intervalTime - $randomTemp >= $minIntervalTime && $intervalTime - $randomTemp <= $maxIntervalTime)
191                                        {
192                                                $intervalTime = $intervalTime - $randomTemp;
193                                        }
194                                        $cumulativeTime = $cumulativeTime + $intervalTime;
195                                        $cumulativeTimeOld = $cumulativeTime-$intervalTime;
196                                        $nodeNumber = $ceilingX * 100 + $floorY;
197
198                                        if(isUnique($intervalTime , $cumulativeTime, $nodeNumber, @timer))
199                                        {
200                                                $loopIterator = 0;
201                                                while ($loopIterator < $intervalTime)
202                                                {
203                                                        push @{$timer{$nodeNumber}}, $cumulativeTimeOld + $loopIterator;
204                                                        $loopIterator++;
205                                                }
206
207                                                $nodeNameAndTime = "$cumulativeTimeOld node$ceilingX-$floorY";
208                                                print "$nodeNameAndTime\n";
209                                                push @{$store{$mobileNumberIterator}}, $nodeNameAndTime;
210                                                $previousNode = $nodeName;
211                                        }
212                                        else
213                                        {
214                                                $k--;
215                                        }
216                                }
217                        }
218                        elsif ($min == "3")
219                        {
220                                $nodeName = "node$ceilingX-$ceilingY";
221                                if ($previousNode ne $nodeName)
222                                {
223                                        $randomTemp = int(rand($accelerationRandomness[$mobileNumberIterator][$destinationNo]));
224                                        if ($intervalTime - $randomTemp >= $minIntervalTime && $intervalTime - $randomTemp <= $maxIntervalTime)
225                                        {
226                                                $intervalTime = $intervalTime - $randomTemp;
227                                        }
228                                        $cumulativeTime = $cumulativeTime + $intervalTime;
229                                        $cumulativeTimeOld = $cumulativeTime-$intervalTime;
230                                        $nodeNumber = $ceilingX * 100 + $ceilingY;
231                                        if(isUnique($intervalTime , $cumulativeTime, $nodeNumber, @timer))
232                                        {
233                                                $loopIterator = 0;
234                                                while ($loopIterator < $intervalTime)
235                                                {
236                                                        push @{$timer{$nodeNumber}}, $cumulativeTimeOld + $loopIterator;
237                                                        $loopIterator++;
238                                                }
239       
240                                                $nodeNameAndTime = "$cumulativeTimeOld node$ceilingX-$ceilingY";
241                                                print "$nodeNameAndTime\n";
242                                                push @{$store{$mobileNumberIterator}}, $nodeNameAndTime;
243                                                $previousNode = $nodeName;
244                                        }
245                                        else
246                                        {
247                                                $k--;
248                                        }
249                                }
250                        }
251                        elsif ($min == "4")
252                        {
253                                $nodeName = "node$floorX-$ceilingY";
254                                if ($previousNode ne $nodeName)
255                                {       
256                                        $randomTemp = int(rand($accelerationRandomness[$mobileNumberIterator][$destinationNo]));
257                                        if ($intervalTime - $randomTemp >= $minIntervalTime && $intervalTime - $randomTemp <= $maxIntervalTime)
258                                        {
259                                                $intervalTime = $intervalTime - $randomTemp;
260                                        }
261                                        $cumulativeTime = $cumulativeTime + $intervalTime;
262                                        $cumulativeTimeOld = $cumulativeTime-$intervalTime;
263                                        $nodeNumber = $floorX * 100 + $ceilingY;
264                                        if(isUnique($intervalTime , $cumulativeTime, $nodeNumber, @timer))
265                                        {
266                                                $loopIterator = 0;
267                                                while ($loopIterator < $intervalTime)
268                                                {
269                                                        push @{$timer{$nodeNumber}}, $cumulativeTimeOld + $loopIterator;
270                                                        $loopIterator++;
271                                                }
272
273                                                $nodeNameAndTime = "$cumulativeTimeOld node$floorX-$ceilingY";
274                                                print "$nodeNameAndTime\n";
275                                                push @{$store{$mobileNumberIterator}}, $nodeNameAndTime;
276                                                $previousNode = $nodeName;
277                                        }
278                                        else
279                                        {
280                                                $k--;
281                                        }
282                                }
283                        }
284                $k++;
285                }
286
287                $nodeName = "node${$destinationXValue{$mobileNumberIterator}}[$destinationNo]-$destinationYValu[$mobileNumberIterator][$destinationNo]";
288                if ($previousNode ne $nodeName)
289                {       
290                        $randomTemp = int(rand($accelerationRandomness[$mobileNumberIterator][$destinationNo]));
291                        if ($intervalTime - $randomTemp >= $minIntervalTime && $intervalTime - $randomTemp <= $maxIntervalTime)
292                        {
293                                $intervalTime = $intervalTime - $randomTemp;
294                        }
295                        $cumulativeTime = $cumulativeTime + $intervalTime;
296                        $cumulativeTimeOld = $cumulativeTime-$intervalTime;
297                        $nodeNumber = ${$destinationXValue{$mobileNumberIterator}}[$destinationNo] * 100 + ${$destinationYValue{$mobileNumberIterator}}[$destinationNo];
298                        if(isUnique($intervalTime , $cumulativeTime, $nodeNumber, @timer))
299                        {
300                                $loopIterator = 0;
301                                while ($loopIterator < $intervalTime)
302                                {
303                                        push @{$timer{$nodeNumber}}, $cumulativeTimeOld + $loopIterator;
304                                        $loopIterator++;
305                                }
306       
307                                $nodeNameAndTime = "$cumulativeTimeOld node${$destinationXValue{$mobileNumberIterator}}[$destinationNo]-${$destinationYValue{$mobileNumberIterator}}[$destinationNo]";
308                                print "$cumulativeTimeOld node${$destinationXValue{$mobileNumberIterator}}[$destinationNo]-${$destinationYValue{$mobileNumberIterator}}[$destinationNo]\n";
309                                push @{$store{$mobileNumberIterator}}, $nodeNameAndTime;
310                                $previousNode = $nodeName;
311                        }
312                }
313
314        $destinationNoToPrint = $destinationNo +1;
315        print "Destination No : $destinationNoToPrint is Reached for Mobile Node Number : $mobileNumberIteratorToPrint\n";     
316
317        $sourceXValue[$mobileNumberIterator] = ${$destinationXValue{$mobileNumberIterator}}[$destinationNo];
318        $sourceYValue[$mobileNumberIterator]= ${$destinationYValue{$mobileNumberIterator}}[$destinationNo];
319        }
320$destinationNo = 0;
321$mobileNumberIterator++;
322print "\n";
323}
324
325$j = 0;
326
327$mobileNumberIterator--;
328$printNode = $mobileNumberIterator + 1;
329
330while($mobileNumberIterator > -1)
331{
332        while (${$store{$mobileNumberIterator}}[$j] ne ())
333        {
334                $tempWrite = ${$store{$mobileNumberIterator}}[$j];
335                system("echo $tempWrite >> VM$printNode.txt");
336                $j = $j + 1;
337        }
338        $mobileNumberIterator--;
339        $printNode--;
340        $j = 0;
341}
342
343sub isUnique
344{
345        $intervalTime = $_[0];
346        $cumulativeTime = $_[1];
347        $nodeNumber = $_[2];
348        @timer = @_[3];
349       
350        $cumulativeTimeOld = $cumulativeTime - $intervalTime;
351        $loopIterator = 0;
352
353        while ($loopIterator < $intervalTime)
354        {       
355                while (${$timer{$nodeNumber}}[$j] ne ())
356                {
357                        if (${$timer{$nodeNumber}}[$j] == $cumulativeTimeOld + $loopIterator)
358                        {
359                                print "ERROR ${$timer{$nodeNumber}}[$j]\n";
360                                return 0;
361                        }
362                        $j = $j + 1;
363                }
364                $loopIterator++;
365                $j = 0;
366        }
367        return 1;
368}