Mobility/MobilityModels: WeightedWaypointMoveManyDestinationsMultiNodeIsUniqueAdded.pl

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