Old/Mobility/MobilityModels: ReferencePointMoveManyDestinationsMultiNodeIsUniqueAdded.pl

File ReferencePointMoveManyDestinationsMultiNodeIsUniqueAdded.pl, 12.5 KB (added by mrodoper, 18 years 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";
350 return 0;
351 }
352 $j = $j + 1;
353 }
354 $loopIterator++;
355 $j = 0;
356 }
357 return 1;
358}