##// END OF EJS Templates
radarsys_met
RSS
Operation mode: Automatic or Manual...
Fiorella Quino -
r192:18678523d9f7
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1043 +1,1038
1 1 from django.db import models
2 2 from apps.main.models import Configuration
3 3 from django.core.urlresolvers import reverse
4 4 # Create your models here.
5 5
6 6 import ast
7 7 import socket
8 8 import json
9 9 import requests
10 10 import struct
11 11 import sys, time
12 12
13 13 import multiprocessing
14 14
15 15
16 16 antenna_default = json.dumps({
17 17 "antenna_up": [[0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
18 18 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
19 19 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
20 20 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
21 21 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
22 22 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
23 23 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0],
24 24 [0.5,0.5,0.5,0.5,1.0,1.0,1.0,1.0]
25 25 ]
26 26 ,
27 27 "antenna_down": [[0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
28 28 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
29 29 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
30 30 [0.0,0.0,0.0,0.0,0.5,0.5,0.5,0.5],
31 31 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
32 32 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
33 33 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0],
34 34 [0.5,0.5,0.5,0.5,3.0,3.0,3.0,3.0]],
35 35 })
36 36
37 37
38 38 tx_default = json.dumps({
39 39 "up": [[1,1,1,1,0,0,0,0],
40 40 [1,1,1,1,0,0,0,0],
41 41 [1,1,1,1,0,0,0,0],
42 42 [1,1,1,1,0,0,0,0],
43 43 [0,0,0,0,1,1,1,1],
44 44 [0,0,0,0,1,1,1,1],
45 45 [0,0,0,0,1,1,1,1],
46 46 [0,0,0,0,1,1,1,1]],
47 47
48 48 "down": [[1,1,1,1,0,0,0,0],
49 49 [1,1,1,1,0,0,0,0],
50 50 [1,1,1,1,0,0,0,0],
51 51 [1,1,1,1,0,0,0,0],
52 52 [0,0,0,0,1,1,1,1],
53 53 [0,0,0,0,1,1,1,1],
54 54 [0,0,0,0,1,1,1,1],
55 55 [0,0,0,0,1,1,1,1]],
56 56 })
57 57
58 58 rx_default = json.dumps({
59 59 "up": [[1,1,1,1,0,0,0,0],
60 60 [1,1,1,1,0,0,0,0],
61 61 [1,1,1,1,0,0,0,0],
62 62 [1,1,1,1,0,0,0,0],
63 63 [0,0,0,0,1,1,1,1],
64 64 [0,0,0,0,1,1,1,1],
65 65 [0,0,0,0,1,1,1,1],
66 66 [0,0,0,0,1,1,1,1]],
67 67
68 68 "down": [[1,1,1,1,0,0,0,0],
69 69 [1,1,1,1,0,0,0,0],
70 70 [1,1,1,1,0,0,0,0],
71 71 [1,1,1,1,0,0,0,0],
72 72 [0,0,0,0,1,1,1,1],
73 73 [0,0,0,0,1,1,1,1],
74 74 [0,0,0,0,1,1,1,1],
75 75 [0,0,0,0,1,1,1,1]],
76 76 })
77 77
78 78 conf_default = {}
79 79 status_default = {}
80 80 for i in range(1,65):
81 81 conf_default[str(i)] = ""
82 82 status_default[str(i)] = 0
83 83
84 84 ues_default = json.dumps({
85 85 "up": [0.533333,0.00000,1.06667,0.00000],
86 86 "down": [0.533333,0.00000,1.06667,0.00000]
87 87 })
88 88
89 89 onlyrx_default = json.dumps({
90 90 "up": False,
91 91 "down": False
92 92 })
93 93
94 94 def up_convertion(cadena):
95 95 valores = []
96 96 for c in cadena:
97 97 if c == 1.0: valores=valores+['000']
98 98 if c == 2.0: valores=valores+['001']
99 99 if c == 3.0: valores=valores+['010']
100 100 if c == 0.0: valores=valores+['011']
101 101 if c == 0.5: valores=valores+['100']
102 102 if c == 1.5: valores=valores+['101']
103 103 if c == 2.5: valores=valores+['110']
104 104 if c == 3.5: valores=valores+['111']
105 105
106 106 return valores
107 107
108 108 def up_conv_bits(value):
109 109
110 110 if value == 1.0: bits="000"
111 111 if value == 2.0: bits="001"
112 112 if value == 3.0: bits="010"
113 113 if value == 0.0: bits="011"
114 114 if value == 0.5: bits="100"
115 115 if value == 1.5: bits="101"
116 116 if value == 2.5: bits="110"
117 117 if value == 3.5: bits="111"
118 118
119 119 return bits
120 120
121 121 def down_convertion(cadena):
122 122 valores = []
123 123 for c in cadena:
124 124 if c == 1.0: valores=valores+['000']
125 125 if c == 2.0: valores=valores+['001']
126 126 if c == 3.0: valores=valores+['010']
127 127 if c == 0.0: valores=valores+['011']
128 128 if c == 0.5: valores=valores+['100']
129 129 if c == 1.5: valores=valores+['101']
130 130 if c == 2.5: valores=valores+['110']
131 131 if c == 3.5: valores=valores+['111']
132 132
133 133 return valores
134 134
135 135 def down_conv_bits(value):
136 136
137 137 if value == 1.0: bits="000"
138 138 if value == 2.0: bits="001"
139 139 if value == 3.0: bits="010"
140 140 if value == 0.0: bits="011"
141 141 if value == 0.5: bits="100"
142 142 if value == 1.5: bits="101"
143 143 if value == 2.5: bits="110"
144 144 if value == 3.5: bits="111"
145 145
146 146 return bits
147 147
148 148 def ip2position(module_number):
149 149 j=0
150 150 i=0
151 151 for x in range(0,module_number-1):
152 152 j=j+1
153 153 if j==8:
154 154 i=i+1
155 155 j=0
156 156
157 157 pos = [i,j]
158 158 return pos
159 159
160 160
161 161 def fromBinary2Char(binary_string):
162 162 number = int(binary_string, 2)
163 163 #Plus 33 to avoid more than 1 characters values such as: '\x01'-'\x1f'
164 164 number = number + 33
165 165 char = chr(number)
166 166 return char
167 167
168 168 def fromChar2Binary(char):
169 169 number = ord(char) - 33
170 170 #Minus 33 to get the real value
171 171 bits = bin(number)[2:]
172 172 #To ensure we have a string with 6bits
173 173 if len(bits) < 6:
174 174 bits = bits.zfill(6)
175 175 return bits
176 176
177 OPERATION_MODES = (
178 (0, 'Manual'),
179 (1, 'Automatic'),
180 )
181
177 182
178 183 class ABSConfiguration(Configuration):
179 184 active_beam = models.CharField(verbose_name='Active Beam', max_length=20000, default="{}")
180 185 module_status = models.CharField(verbose_name='Module Status', max_length=10000, default=json.dumps(status_default))
186 operation_mode = models.CharField(verbose_name='Operation Mode', max_length = 20, choices=OPERATION_MODES, default = 0)
187 operation_value = models.CharField(verbose_name='Periodic (seconds)', max_length=20000, default="10", null=True, blank=True)
181 188
182 189 class Meta:
183 190 db_table = 'abs_configurations'
184 191
185 192 def get_absolute_url_plot(self):
186 193 return reverse('url_plot_abs_patterns', args=[str(self.id)])
187 194
188 195
189 196 def parms_to_dict(self):
190 197
191 198 parameters = {}
192 199
193 200 parameters['device_id'] = self.device.id
194 201 parameters['name'] = self.name
195 202 parameters['beams'] = {}
196 203
197 204 beams = ABSBeam.objects.filter(abs_conf=self)
198 205 b=1
199 206 for beam in beams:
200 207 #absbeam = ABSBeam.objects.get(pk=beams[beam])
201 208 parameters['beams']['beam'+str(b)] = beam.parms_to_dict()#absbeam.parms_to_dict()
202 209 b+=1
203 210
204 211 return parameters
205 212
206 213 def dict_to_parms(self, parameters):
207 214
208 215 self.name = parameters['name']
209 216
210 217 absbeams = ABSBeam.objects.filter(abs_conf=self)
211 218 beams = parameters['beams']
212 219
213 220 if absbeams:
214 221 beams_number = len(beams)
215 222 absbeams_number = len(absbeams)
216 223 if beams_number==absbeams_number:
217 224 i = 1
218 225 for absbeam in absbeams:
219 226 absbeam.dict_to_parms(beams['beam'+str(i)])
220 227 i = i+1
221 228 elif beams_number > absbeams_number:
222 229 i = 1
223 230 for absbeam in absbeams:
224 231 absbeam.dict_to_parms(beams['beam'+str(i)])
225 232 i=i+1
226 233 for x in range(i,beams_number+1):
227 234 new_beam = ABSBeam(
228 235 name =beams['beam'+str(i)]['name'],
229 236 antenna =json.dumps(beams['beam'+str(i)]['antenna']),
230 237 abs_conf = self,
231 238 tx =json.dumps(beams['beam'+str(i)]['tx']),
232 239 rx =json.dumps(beams['beam'+str(i)]['rx']),
233 240 ues =json.dumps(beams['beam'+str(i)]['ues']),
234 241 only_rx =json.dumps(beams['beam'+str(i)]['only_rx'])
235 242 )
236 243 new_beam.save()
237 244 i=i+1
238 245 else: #beams_number < absbeams_number:
239 246 i = 1
240 247 for absbeam in absbeams:
241 248 if i <= beams_number:
242 249 absbeam.dict_to_parms(beams['beam'+str(i)])
243 250 i=i+1
244 251 else:
245 252 absbeam.delete()
246 253 else:
247 254 for beam in beams:
248 255 new_beam = ABSBeam(
249 256 name =beams[beam]['name'],
250 257 antenna =json.dumps(beams[beam]['antenna']),
251 258 abs_conf = self,
252 259 tx =json.dumps(beams[beam]['tx']),
253 260 rx =json.dumps(beams[beam]['rx']),
254 261 ues =json.dumps(beams[beam]['ues']),
255 262 only_rx =json.dumps(beams[beam]['only_rx'])
256 263 )
257 264 new_beam.save()
258 265
259 266
260 267
261 268 def update_from_file(self, parameters):
262 269
263 270 self.dict_to_parms(parameters)
264 271 self.save()
265 272
266 273
267 274 def get_beams(self, **kwargs):
268 275 '''
269 276 This function returns ABS Configuration beams
270 277 '''
271 278 return ABSBeam.objects.filter(abs_conf=self.pk, **kwargs)
272 279
273 280 def clone(self, **kwargs):
274 281
275 282 beams = self.get_beams()
276 283 self.pk = None
277 284 self.id = None
278 285 for attr, value in kwargs.items():
279 286 setattr(self, attr, value)
280 287 self.save()
281 288
282 289 for beam in beams:
283 290 beam.clone(abs_conf=self)
284 291
285 292 return self
286 293
287 294
288 295 def module_conf(self, module_num, beams):
289 296 """
290 297 This function creates beam configurations for one abs module.
291 298 """
292 299 ip_address = self.device.ip_address
293 300 ip_address = ip_address.split('.')
294 301 module_seq = (ip_address[0],ip_address[1],ip_address[2])
295 302 dot = '.'
296 303 module_ip = dot.join(module_seq)+'.'+str(module_num)
297 304 module_port = self.device.port_address
298 305 write_route = 'http://'+module_ip+':'+str(module_port)+'/write'
299 306
300 307 header = 'JROABSCeCnModCnMod01000108SNDFexperimento1.ab1'
301 308 module = 'ABS_'+str(module_num)
302 309 bs = '' #{}
303 310 i=1
304 311 #beams = {1: '001000', 2: '010001', 3: '010010', 4: '000011', 5: '101100', 6: '101101',
305 312 # 7: '110110', 8: '111111', 9: '000000', 10: '001001', 11: '010010', 12: '011011'}
306 313 for beam in beams:
307 314 #bs[i] = fromBinary2Char(beam.module_6bits(module_num))
308 315 bs = bs + fromBinary2Char(beam.module_6bits(module_num))
309 316 i=i+1
310 317
311 318 beams = bs
312 319
313 320 parameters = {}
314 321 parameters['header'] = header
315 322 parameters['module'] = module
316 323 parameters['beams'] = beams #json.dumps(beams)
317 324 print parameters['beams']
318 325 answer = ''
319 326
320 327 try:
321 328 r_write = requests.post(write_route, parameters, timeout=0.5)
322 329 answer = r_write.json()
323 330 self.message = answer['message']
324 331 except:
325 332 self.message = "Could not write ABS parameters"
326 333 return 0
327 334 return 1
328 335
329 336 def read_module(self, module):
330 337
331 338 """
332 339 Read out-bits (up-down) of 1 abs module NOT for Configuration
333 340 """
334 341
335 342 parameters = {}
336 343 ip_address = self.device.ip_address
337 344 ip_address = ip_address.split('.')
338 345 module_seq = (ip_address[0],ip_address[1],ip_address[2])
339 346 dot = '.'
340 347 module_ip = dot.join(module_seq)+'.'+str(module)
341 348 module_port = self.device.port_address
342 349 read_route = 'http://'+module_ip+':'+str(module_port)+'/read'
343 350
344 351 print(read_route)
345 352
346 353 answer = ''
347 354 module_bits = ''
348 355
349 356 try:
350 357 r_write = requests.get(read_route, timeout=0.7)
351 358 answer = r_write.json()
352 359 self.message = answer['message']
353 360 module_bits = answer['allbits']
354 361 except:
355 362 #message = "Could not read ABS parameters"
356 363 return 0
357 364
358 365 return module_bits
359 366
367
368 def read_module(self, module):
369
370 return True
371
360 372 def status_device(self):
361 373 """
362 374 This function gets the status of each abs module. It sends GET method to Web Application
363 375 in Python Bottle.
364 376 """
365 377 ip_address = self.device.ip_address
366 378 ip_address = ip_address.split('.')
367 379 module_seq = (ip_address[0],ip_address[1],ip_address[2])
368 380 dot = '.'
369 381 module_port = self.device.port_address
370 382
371 383 modules_status = json.loads(self.module_status)
372 384
373 385 for i in range(1,65):
374 386 module_ip = dot.join(module_seq)+'.'+str(i)
375 387 print module_ip
376 388
377 389 route = 'http://'+module_ip+':'+str(module_port)+'/hello'
378 390
379 391 try:
380 392 r = requests.get(route, timeout=0.7)
381 393 modules_status[str(i)] = 1
382 394 except:
383 395 modules_status[str(i)] = 0
384 396 pass
385 397
386 398 self.message = 'ABS modules Status have been updated.'
387 399 self.module_status=json.dumps(modules_status)
388 400 self.save()
389 401
390 402 return
391 403
392 404
393 405 def write_device(self):
394 406 """
395 407 This function sends the beams list to every abs module.
396 408 It needs 'module_conf' function
397 409 """
398 410
399 ###beams_list = ast.literal_eval(self.beams)
400 ###beams = []
401 411 beams = ABSBeam.objects.filter(abs_conf=self)
402 ###for bl in range(1,len(beams_list)+1):
403 ### b = ABSBeam.objects.get(pk=beams_list['beam'+str(bl)])
404 ### beams.append(b)
405 412
406 #---Write each abs module---
413 #-------------Write each abs module-----------
407 414 if beams:
408 415 beams_status = ast.literal_eval(self.module_status)
409 416 for i in range(62,65): #(62,65)
410 417 try:
411 418 answer = self.module_conf(i, beams)
412 419 beams_status[str(i)] = 1
413 420 self.module_status = json.dumps(beams_status)
414 421 self.save()
415 #self.module_conf(63,beams)
416 #beams_status[str(63)] = 1
417 #self.module_status = json.dumps(beams_status)
422
418 423 except:
419 424 beams_status[str(i)] = 0
420 425 self.module_status = json.dumps(beams_status)
421 426 self.save()
422 427 answer = 0
423 428 return 0
424 429 else:
425 430 self.message = "ABS Configuration does not have beams"
426 431 return 0
427 432
428 433 #self.device.status = 1
429 434 ##
430 435 if answer==1:
431 436 self.message = "ABS Beams List have been sent to ABS Modules"
437 beams[0].set_as_activebeam()
432 438 else:
433 439 self.message = "Could not read ABS parameters"
434
435 440 ##
436 441 self.save()
437 442 return 1
438 443
439 444
440 445 def write_module(self, module):
441 446
442 447 """
443 448 Send configuration to one abs module
444 449 """
445 450
446 451 parameters = {}
447 452 ip_address = self.abs_conf.device.ip_address
448 453 ip_address = ip_address.split('.')
449 454 module_seq = (ip_address[0],ip_address[1],ip_address[2])
450 455 dot = '.'
451 456 module_ip = dot.join(module_seq)+'.'+str(module)
452 457 module_port = self.abs_conf.device.port_address
453 458 write_route = 'http://'+module_ip+':'+str(module_port)+'/write'
454 459
455 460 #print write_route
456 461
457 462 header = 'JROABSCeCnModCnMod01000108SNDFexperimento1.ab1'
458 463 module = 'ABS_'+str(module)
459 464 beams = {1: '001000', 2: '010001', 3: '010010', 4: '000011', 5: '101100', 6: '101101',
460 465 7: '110110', 8: '111111', 9: '000000', 10: '001001', 11: '010010', 12: '011011'}
461 466
462 467 parameters['header'] = header
463 468 parameters['module'] = module
464 469 parameters['beams'] = json.dumps(beams)
465 470
466 471 answer = ''
467 472
468 473 try:
469 474 r_write = requests.post(write_route, parameters, timeout=0.5)
470 475 answer = r_write.json()
471 476 self.message = answer['message']
472 477 except:
473 478 self.message = "Could not write ABS parameters"
474 479 return 0
475 480
476 481
477 482 #self.device.status = int(answer['status'])
478 483
479 484 return 1
480 485
481 486
482 487 def beam_selector(self, module, beam_pos):
483 488 """
484 489 This function selects the beam number for one absmodule.
485 490 """
486 491
487 492 if beam_pos > 0:
488 493 beam_pos = beam_pos - 1
489 494 else:
490 495 beam_pos = 0
491 496
492 497 #El indice del apunte debe ser menor que el numero total de apuntes
493 498 #El servidor tcp en el embebido comienza a contar desde 0
494 499 beams_list = ABSBeam.objects.filter(abs_conf=self)
495 500 if len(beams_list) < beam_pos:
496 501 return 0
497 502
498 503 flag = 1
499 504 if beam_pos>9:
500 505 flag = 2
501 506
502 507 module_address = ('192.168.1.'+str(module), 5500)
503 508 header = 'JROABSCeCnModCnMod0100000'
504 509 numbers = len(str(beam_pos))
505 510 function = 'CHGB'
506 511
507 512 message_tx = header+str(numbers)+function+str(beam_pos)+'0'
508 513
509 514 # Create the datagram socket
510 515 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
511 516 #sock.connect(module_address)
512 517 try:
513 518 sock.connect(module_address)
514 519 sock.send(message_tx)
515 520 sock.close()
516 521 print("Writing abs module:"+module_address[0]+"...")
517 522 except:
518 523 sock = None
519 524 print("Problem writing abs module:"+module_address[0])
520 525 return 0
521 526
522 527 return 1
523 528
524 529
525 530 def change_beam(self, beam_pos):
526 531 """
527 532 This function selects the beam number for all absmodules.
528 533 """
529 534 for i in range(1,65):
530 535 try:
531 536 self.beam_selector(i,beam_pos)
532 537 except:
533 538 print("Problem with module: 192.168.1."+str(i))
534 539 self.message = "Problem with module: 192.168.1."+str(i)
535 540 #return 0
536 541 return 1
537 542
538 543
539 544 def send_beam_num(self, beam_pos):
540 545 """
541 546 This function connects to a multicast group and sends the beam number
542 547 to all abs modules.
543 548 """
544 549
545 550 if beam_pos > 0:
546 551 beam_pos = beam_pos - 1
547 552 else:
548 553 beam_pos = 0
549 554
550 555 #El indice del apunte debe ser menor que el numero total de apuntes
551 556 #El servidor tcp en el embebido comienza a contar desde 0
552 557 beams_list = ABSBeam.objects.filter(abs_conf=self)
553 558 if len(beams_list) < beam_pos:
554 559 return 0
555 560
556 561 flag = 1
557 562 if beam_pos>9:
558 563 flag = 2
559 564
560 565 header = 'JROABSCeCnModCnMod0100000'
561 566 flag = str(flag)
562 567 function = 'CHGB'
563 568 message_tx = header+flag+function+str(beam_pos)+'0'
564 569
565 570 multicast_group = '224.3.29.71'
566 571 server_address = ('',10000)
567 572
568 573 # Create the socket
569 574 sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
570 575 # Bind to the server address
571 576 sock.bind(server_address)
572 577 # Telling the OS add the socket to the multicast on all interfaces
573 578 group = socket.inet_aton(multicast_group)
574 579 mreq = struct.pack('4sL', group, socket.INADDR_ANY)
575 580 sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
576 581
577 582 #print 'sending acknowledgement to all: \n' + message_tx
578 583 sock.sendto(message_tx, (multicast_group, 10000))
579 584 sock.close()
580 585 sock = None
581 586
582 587 return 1
583 588
584 589 def test1(self):
585 590 t1 = time.time()
586 591 t2 = 0
587 592 while (t2-t1)<100:#300
588 593 t2 = time.time()
589 594 self.send_beam_num(2)
590 595 time.sleep(0.04)
591 596 self.send_beam_num(1)
592 597 time.sleep(0.04)
593 598 return
594 599
595 600 def change_procs_test1(self, module):
596 601
597 602 for i in range (1,300):#300
598 603 beam_pos = 1
599 604 module_address = ('192.168.1.'+str(module), 5500)
600 605 header = 'JROABSCeCnModCnMod0100000'
601 606 numbers = len(str(beam_pos))
602 607 function = 'CHGB'
603 608
604 609 message_tx = header+str(numbers)+function+str(beam_pos)+'0'
605 610
606 611 # Create the datagram socket
607 612 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
608 613 sock.connect(module_address)
609 614
610 615 sock.send(message_tx)
611 616 #t = sock.recv(1024)
612 617 sock.close()
613 618 sock = None
614 619
615 620
616 621 time.sleep(0.04)
617 622
618 623
619 624 beam_pos = 0
620 625 numbers = len(str(beam_pos))
621 626
622 627 message_tx = header+str(numbers)+function+str(beam_pos)+'0'
623 628
624 629 # Create the datagram socket
625 630 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
626 631 sock.connect(module_address)
627 632 sock.send(message_tx)
628 633 sock.close()
629 634 sock = None
630 635
631 636 time.sleep(0.04)
632 637
633 638
634 639 def multi_procs_test1(self):
635 640
636 641 """
637 642 This function sends the beam number to all abs modules using multiprocessing.
638 643 """
639 644
640 645 #if __name__ == "__main__":
641 646 size = 10000000 # Number of random numbers to add
642 647 procs = 65 # (Number-1) of processes to create (absmodule)
643 648
644 649 # Create a list of jobs and then iterate through
645 650 # the number of processes appending each process to
646 651 # the job list
647 652 jobs = []
648 653 for i in range(1, procs):
649 654
650 655 process = multiprocessing.Process(target=self.change_procs_test1,args=(i,))
651 656 jobs.append(process)
652 657 #print jobs
653 658
654 659 # Start the processes (i.e. calculate the random number lists)
655 660 for j in jobs:
656 661 #time.sleep(0.4)
657 662 #print j
658 663 j.start()
659 664
660 665 # Ensure all of the processes have finished
661 666 for j in jobs:
662 667 j.join()
663 668
664 669 print("List processing complete.")
665 670 return 1
666 671
667 672
668 673
669 674 def multi_procs_test2(self):
670 675 """
671 676 This function use multiprocessing python library. Importing Pool we can select
672 677 the number of cores we want to use
673 678 After 'nproc' linux command, we know how many cores computer has.
674 679 NOT WORKING
675 680 """
676 681 import multiprocessing
677 682 pool = multiprocessing.Pool(3) # cores
678 683
679 684 tasks = []
680 685 procs = 65
681 686 for i in range(62, procs):
682 687 tasks.append( (i,))
683 688 #print tasks
684 689 #pool.apply_async(self.change_procs_test1, 62)
685 690 results = [pool.apply( self.change_procs_test1, t ) for t in tasks]
686 691 #for result in results:
687 692 #result.get()
688 693 #(plotNum, plotFilename) = result.get()
689 694 #print("Result: plot %d written to %s" % (plotNum, plotFilename) )
690 695
691 696 return 1
692 697
693 698
694 699 def multi_procs_test3(self):
695 700 """
696 701 This function use multiprocessing python library. Importing Pool we can select
697 702 the number of cores we want to use
698 703 After 'nproc' linux command, we know how many cores computer has.
699 704 """
700 705 from multiprocessing import Pool
701 706 import time
702 707
703 708 def f(x):
704 709 return x*x
705 710
706 711 tasks = []
707 712 procs = 65
708 713 pool = Pool(processes=4)
709 714
710 715 #for i in range(62, procs):
711 716 #result = pool.map(f, range(62,65))
712 717 it = pool.imap(self.change_procs_test1, range(62,65))
713 718 #result.get(timeout=5)
714 719
715 720 return 1
716 721
717 722
718 723 def f(x):
719 724 print x
720 725 return
721 726
722 727 def multi_procs_test4(self):
723 728 import multiprocessing as mp
724 729
725 730
726 731 num_workers = mp.cpu_count()
727 732
728 733 pool = mp.Pool(num_workers)
729 734 procs = 65
730 735 for i in range(62, procs):
731 736 #for task in tasks:
732 737 pool.apply_async(self.f, args = (i,))
733 738
734 739 pool.close()
735 740 pool.join()
736 741
737 742 return 1
738 743
739 744
740 745 def get_absolute_url_import(self):
741 746 return reverse('url_import_abs_conf', args=[str(self.id)])
742 747
743 748
744 749
745 750
746 751 class ABSBeam(models.Model):
747 752
748 753 name = models.CharField(max_length=60, default='Beam')
749 754 antenna = models.CharField(verbose_name='Antenna', max_length=1000, default=antenna_default)
750 755 abs_conf = models.ForeignKey(ABSConfiguration, null=True, verbose_name='ABS Configuration')
751 756 tx = models.CharField(verbose_name='Tx', max_length=1000, default=tx_default)
752 757 rx = models.CharField(verbose_name='Rx', max_length=1000, default=rx_default)
753 758 s_time = models.TimeField(verbose_name='Star Time', default='00:00:00')
754 759 e_time = models.TimeField(verbose_name='End Time', default='23:59:59')
755 760 modules_conf = models.CharField(verbose_name='Modules', max_length=2000, default=json.dumps(conf_default))
756 761 ues = models.CharField(verbose_name='Ues', max_length=100, default=ues_default)
757 762 only_rx = models.CharField(verbose_name='Only RX', max_length=40, default=onlyrx_default)
758 763
759 764 class Meta:
760 765 db_table = 'abs_beams'
761 766
762 767 def __unicode__(self):
763 768 return u'%s' % (self.name)
764 769
765 770 def parms_to_dict(self):
766 771
767 772 #Update data
768 773 self.modules_6bits()
769 774
770 775 parameters = {}
771 776
772 777 parameters['name'] = self.name
773 778 parameters['antenna'] = ast.literal_eval(self.antenna)
774 779 parameters['abs_conf'] = self.abs_conf.name
775 780 parameters['tx'] = ast.literal_eval(self.tx)
776 781 parameters['rx'] = ast.literal_eval(self.rx)
777 782 parameters['s_time'] = self.s_time.strftime("%H:%M:%S")
778 783 parameters['e_time'] = self.e_time.strftime("%H:%M:%S")
779 784 parameters['configuration'] = ast.literal_eval(self.modules_conf)
780 785 parameters['ues'] = ast.literal_eval(self.ues)
781 786 parameters['only_rx'] = json.loads(self.only_rx)
782 787
783 788 return parameters
784 789
785 790 def dict_to_parms(self, parameters):
786 791
787 792 self.name = parameters['name']
788 793 self.antenna = json.dumps(parameters['antenna'])
789 794 #self.abs_conf = parameters['abs_conf']
790 795 self.tx = json.dumps(parameters['tx'])
791 796 self.rx = json.dumps(parameters['rx'])
792 797 #self.s_time = parameters['s_time']
793 798 #self.e_time = parameters['e_time']
794 799 self.ues = json.dumps(parameters['ues'])
795 800 self.only_rx = json.dumps(parameters['only_rx'])
796 801
797 802 self.modules_6bits()
798 803 self.save()
799 804
800 805
801 806 def clone(self, **kwargs):
802 807
803 808 self.pk = None
804 809 self.id = None
805 810 for attr, value in kwargs.items():
806 811 setattr(self, attr, value)
807 812
808 813 self.save()
809 814
810 815 return self
811 816
812 def set_activebeam(self):
813 """
814 This function change de active beam of ABS Configuration
815 """
816 conf = self.abs_conf
817 active_beam = {}
818 active_beam['active_beam'] = self.id
819 conf.active_beam = json.dumps(active_beam)
820 conf.save()
821
822 return
823
824 817
825 818
826 819 def module_6bits(self, module):
827 820 """
828 821 This function reads antenna pattern and choose 6bits (upbits-downbits) for one abs module
829 822 """
830 823 if module > 64:
831 824 beam_bits = ""
832 825 return beam_bits
833 826
834 827 data = ast.literal_eval(self.antenna)
835 828 up_data = data['antenna_up']
836 829 down_data = data['antenna_down']
837 830
838 831 pos = ip2position(module)
839 832 up_value = up_data[pos[0]][pos[1]]
840 833 down_value = down_data[pos[0]][pos[1]]
841 834
842 835 up_bits = up_conv_bits(up_value)
843 836 down_bits = down_conv_bits(down_value)
844 837 beam_bits = up_bits+down_bits
845 838
846 839 return beam_bits
847 840
848 841 def modules_6bits(self):
849 842 """
850 843 This function returns 6bits from every abs module (1-64) in a dict
851 844 """
852 845 modules_configuration = ast.literal_eval(self.modules_conf)
853 846
854 847 for i in range(1,65):
855 848 modules_configuration[str(i)] = self.module_6bits(i)
856 849
857 850 self.modules_conf = json.dumps(modules_configuration)
858 851 self.save()
859 852
860 853 return self.modules_conf
861 854
862 855
863 def active_beam(self):
856 def set_as_activebeam(self):
864 857 """
865 858 This function set this beam as the active beam of its ABS Configuration.
866 859 """
867 860 self.abs_conf.active_beam = json.dumps({'active_beam': self.id})
868 861 self.abs_conf.save()
862
869 863 return
870 864
865
871 866 @property
872 867 def get_upvalues(self):
873 868 """
874 869 This function reads antenna pattern and show the up-value of one abs module
875 870 """
876 871
877 872 data = ast.literal_eval(self.antenna)
878 873 up_data = data['antenna_up']
879 874
880 875 up_values = []
881 876 for data in up_data:
882 877 for i in range(0,8):
883 878 up_values.append(data[i])
884 879
885 880 return up_values
886 881
887 882 @property
888 883 def antenna_upvalues(self):
889 884 """
890 885 This function reads antenna pattern and show the up - values of one abs beam
891 886 in a particular order
892 887 """
893 888 data = ast.literal_eval(self.antenna)
894 889 up_data = data['antenna_up']
895 890
896 891 return up_data
897 892
898 893 @property
899 894 def antenna_downvalues(self):
900 895 """
901 896 This function reads antenna pattern and show the down - values of one abs beam
902 897 in a particular order
903 898 """
904 899 data = ast.literal_eval(self.antenna)
905 900 down_data = data['antenna_down']
906 901
907 902 return down_data
908 903
909 904 @property
910 905 def get_downvalues(self):
911 906 """
912 907 This function reads antenna pattern and show the down-value of one abs module
913 908 """
914 909
915 910 data = ast.literal_eval(self.antenna)
916 911 down_data = data['antenna_down']
917 912
918 913 down_values = []
919 914 for data in down_data:
920 915 for i in range(0,8):
921 916 down_values.append(data[i])
922 917
923 918 return down_values
924 919
925 920 @property
926 921 def get_up_ues(self):
927 922 """
928 923 This function shows the up-ues-value of one beam
929 924 """
930 925 data = ast.literal_eval(self.ues)
931 926 up_ues = data['up']
932 927
933 928 return up_ues
934 929
935 930 @property
936 931 def get_down_ues(self):
937 932 """
938 933 This function shows the down-ues-value of one beam
939 934 """
940 935 data = ast.literal_eval(self.ues)
941 936 down_ues = data['down']
942 937
943 938 return down_ues
944 939
945 940 @property
946 941 def get_up_onlyrx(self):
947 942 """
948 943 This function shows the up-onlyrx-value of one beam
949 944 """
950 945 data = json.loads(self.only_rx)
951 946 up_onlyrx = data['up']
952 947
953 948 return up_onlyrx
954 949
955 950 @property
956 951 def get_down_onlyrx(self):
957 952 """
958 953 This function shows the down-onlyrx-value of one beam
959 954 """
960 955 data = json.loads(self.only_rx)
961 956 down_onlyrx = data['down']
962 957
963 958 return down_onlyrx
964 959
965 960 @property
966 961 def get_tx(self):
967 962 """
968 963 This function shows the tx-values of one beam
969 964 """
970 965 data = json.loads(self.tx)
971 966
972 967 return data
973 968
974 969 @property
975 970 def get_uptx(self):
976 971 """
977 972 This function shows the up-tx-values of one beam
978 973 """
979 974 data = json.loads(self.tx)
980 975 up_data = data['up']
981 976
982 977 up_values = []
983 978 for data in up_data:
984 979 for i in range(0,8):
985 980 up_values.append(data[i])
986 981
987 982 return up_values
988 983
989 984 @property
990 985 def get_downtx(self):
991 986 """
992 987 This function shows the down-tx-values of one beam
993 988 """
994 989 data = json.loads(self.tx)
995 990 down_data = data['down']
996 991
997 992 down_values = []
998 993 for data in down_data:
999 994 for i in range(0,8):
1000 995 down_values.append(data[i])
1001 996
1002 997 return down_values
1003 998
1004 999
1005 1000
1006 1001 @property
1007 1002 def get_rx(self):
1008 1003 """
1009 1004 This function shows the rx-values of one beam
1010 1005 """
1011 1006 data = json.loads(self.rx)
1012 1007
1013 1008 return data
1014 1009
1015 1010 @property
1016 1011 def get_uprx(self):
1017 1012 """
1018 1013 This function shows the up-rx-values of one beam
1019 1014 """
1020 1015 data = json.loads(self.rx)
1021 1016 up_data = data['up']
1022 1017
1023 1018 up_values = []
1024 1019 for data in up_data:
1025 1020 for i in range(0,8):
1026 1021 up_values.append(data[i])
1027 1022
1028 1023 return up_values
1029 1024
1030 1025 @property
1031 1026 def get_downrx(self):
1032 1027 """
1033 1028 This function shows the down-rx-values of one beam
1034 1029 """
1035 1030 data = json.loads(self.rx)
1036 1031 down_data = data['down']
1037 1032
1038 1033 down_values = []
1039 1034 for data in down_data:
1040 1035 for i in range(0,8):
1041 1036 down_values.append(data[i])
1042 1037
1043 1038 return down_values
General Comments 0
You need to be logged in to leave comments. Login now