Mobility/MobilityModels: ReferencePointMoveManyDestinationsMultiNodeIsUniqueAdded.pl

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