Old/Mobility/MobilityModels: RandomWaypointMoveManyDestinationsMultiNodeIsUniqueAdded.pl

File RandomWaypointMoveManyDestinationsMultiNodeIsUniqueAdded.pl, 12.0 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# **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}