##// END OF EJS Templates
schain
RSS
Bug fixed in Signal Chain GUI: Updating FTP configuration from old SendByFTP operation.
Miguel Valdez -
r607:bc5d3588d2df
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,1209 +1,1209
1 1 '''
2 2 Created on September , 2012
3 3 @author:
4 4 '''
5 5 from xml.etree.ElementTree import Element, SubElement
6 6 from xml.etree import ElementTree as ET
7 7 from xml.dom import minidom
8 8
9 9 #import datetime
10 10 from model import *
11 11
12 12 try:
13 13 from gevent import sleep
14 14 except:
15 15 from time import sleep
16 16
17 17 import ast
18 18
19 19 def prettify(elem):
20 20 """Return a pretty-printed XML string for the Element.
21 21 """
22 22 rough_string = ET.tostring(elem, 'utf-8')
23 23 reparsed = minidom.parseString(rough_string)
24 24 return reparsed.toprettyxml(indent=" ")
25 25
26 26 class ParameterConf():
27 27
28 28 id = None
29 29 name = None
30 30 value = None
31 31 format = None
32 32
33 33 __formated_value = None
34 34
35 35 ELEMENTNAME = 'Parameter'
36 36
37 37 def __init__(self):
38 38
39 39 self.format = 'str'
40 40
41 41 def getElementName(self):
42 42
43 43 return self.ELEMENTNAME
44 44
45 45 def getValue(self):
46 46
47 47 value = self.value
48 48 format = self.format
49 49
50 50 if self.__formated_value != None:
51 51
52 52 return self.__formated_value
53 53
54 54 if format == 'str':
55 55 self.__formated_value = str(value)
56 56 return self.__formated_value
57 57
58 58 if value == '':
59 59 raise ValueError, "%s: This parameter value is empty" %self.name
60 60
61 61 if format == 'bool':
62 62 value = int(value)
63 63
64 64 if format == 'list':
65 65 strList = value.split(',')
66 66
67 67 self.__formated_value = strList
68 68
69 69 return self.__formated_value
70 70
71 71 if format == 'intlist':
72 72 """
73 73 Example:
74 74 value = (0,1,2)
75 75 """
76 76 value = value.replace('(', '')
77 77 value = value.replace(')', '')
78 78
79 79 value = value.replace('[', '')
80 80 value = value.replace(']', '')
81 81
82 82 strList = value.split(',')
83 83 intList = [int(x) for x in strList]
84 84
85 85 self.__formated_value = intList
86 86
87 87 return self.__formated_value
88 88
89 89 if format == 'floatlist':
90 90 """
91 91 Example:
92 92 value = (0.5, 1.4, 2.7)
93 93 """
94 94
95 95 value = value.replace('(', '')
96 96 value = value.replace(')', '')
97 97
98 98 value = value.replace('[', '')
99 99 value = value.replace(']', '')
100 100
101 101 strList = value.split(',')
102 102 floatList = [float(x) for x in strList]
103 103
104 104 self.__formated_value = floatList
105 105
106 106 return self.__formated_value
107 107
108 108 if format == 'date':
109 109 strList = value.split('/')
110 110 intList = [int(x) for x in strList]
111 111 date = datetime.date(intList[0], intList[1], intList[2])
112 112
113 113 self.__formated_value = date
114 114
115 115 return self.__formated_value
116 116
117 117 if format == 'time':
118 118 strList = value.split(':')
119 119 intList = [int(x) for x in strList]
120 120 time = datetime.time(intList[0], intList[1], intList[2])
121 121
122 122 self.__formated_value = time
123 123
124 124 return self.__formated_value
125 125
126 126 if format == 'pairslist':
127 127 """
128 128 Example:
129 129 value = (0,1),(1,2)
130 130 """
131 131
132 132 value = value.replace('(', '')
133 133 value = value.replace(')', '')
134 134
135 135 value = value.replace('[', '')
136 136 value = value.replace(']', '')
137 137
138 138 strList = value.split(',')
139 139 intList = [int(item) for item in strList]
140 140 pairList = []
141 141 for i in range(len(intList)/2):
142 142 pairList.append((intList[i*2], intList[i*2 + 1]))
143 143
144 144 self.__formated_value = pairList
145 145
146 146 return self.__formated_value
147 147
148 148 if format == 'multilist':
149 149 """
150 150 Example:
151 151 value = (0,1,2),(3,4,5)
152 152 """
153 153 multiList = ast.literal_eval(value)
154 154
155 155 if type(multiList[0]) == int:
156 156 multiList = ast.literal_eval("(" + value + ")")
157 157
158 158 self.__formated_value = multiList
159 159
160 160 return self.__formated_value
161 161
162 162 format_func = eval(format)
163 163
164 164 self.__formated_value = format_func(value)
165 165
166 166 return self.__formated_value
167 167
168 168 def updateId(self, new_id):
169 169
170 170 self.id = str(new_id)
171 171
172 172 def setup(self, id, name, value, format='str'):
173 173
174 174 self.id = str(id)
175 175 self.name = name
176 176 self.value = str(value)
177 177 self.format = str.lower(format)
178 178
179 179 def update(self, name, value, format='str'):
180 180
181 181 self.name = name
182 182 self.value = str(value)
183 183 self.format = format
184 184
185 185 def makeXml(self, opElement):
186 186
187 187 parmElement = SubElement(opElement, self.ELEMENTNAME)
188 188 parmElement.set('id', str(self.id))
189 189 parmElement.set('name', self.name)
190 190 parmElement.set('value', self.value)
191 191 parmElement.set('format', self.format)
192 192
193 193 def readXml(self, parmElement):
194 194
195 195 self.id = parmElement.get('id')
196 196 self.name = parmElement.get('name')
197 197 self.value = parmElement.get('value')
198 198 self.format = str.lower(parmElement.get('format'))
199 199
200 200 #Compatible with old signal chain version
201 201 if self.format == 'int' and self.name == 'idfigure':
202 202 self.name = 'id'
203 203
204 204 def printattr(self):
205 205
206 206 print "Parameter[%s]: name = %s, value = %s, format = %s" %(self.id, self.name, self.value, self.format)
207 207
208 208 class OperationConf():
209 209
210 210 id = None
211 211 name = None
212 212 priority = None
213 213 type = None
214 214
215 215 parmConfObjList = []
216 216
217 217 ELEMENTNAME = 'Operation'
218 218
219 219 def __init__(self):
220 220
221 221 self.id = '0'
222 222 self.name = None
223 223 self.priority = None
224 224 self.type = 'self'
225 225
226 226
227 227 def __getNewId(self):
228 228
229 229 return int(self.id)*10 + len(self.parmConfObjList) + 1
230 230
231 231 def updateId(self, new_id):
232 232
233 233 self.id = str(new_id)
234 234
235 235 n = 1
236 236 for parmObj in self.parmConfObjList:
237 237
238 238 idParm = str(int(new_id)*10 + n)
239 239 parmObj.updateId(idParm)
240 240
241 241 n += 1
242 242
243 243 def getElementName(self):
244 244
245 245 return self.ELEMENTNAME
246 246
247 247 def getParameterObjList(self):
248 248
249 249 return self.parmConfObjList
250 250
251 251 def getParameterObj(self, parameterName):
252 252
253 253 for parmConfObj in self.parmConfObjList:
254 254
255 255 if parmConfObj.name != parameterName:
256 256 continue
257 257
258 258 return parmConfObj
259 259
260 260 return None
261 261
262 262 def getParameterObjfromValue(self, parameterValue):
263 263
264 264 for parmConfObj in self.parmConfObjList:
265 265
266 266 if parmConfObj.getValue() != parameterValue:
267 267 continue
268 268
269 269 return parmConfObj.getValue()
270 270
271 271 return None
272 272
273 273 def getParameterValue(self, parameterName):
274 274
275 275 parameterObj = self.getParameterObj(parameterName)
276 276
277 if not parameterObj:
278 return None
277 # if not parameterObj:
278 # return None
279 279
280 280 value = parameterObj.getValue()
281 281
282 282 return value
283 283
284 284 def setup(self, id, name, priority, type):
285 285
286 286 self.id = str(id)
287 287 self.name = name
288 288 self.type = type
289 289 self.priority = priority
290 290
291 291 self.parmConfObjList = []
292 292
293 293 def removeParameters(self):
294 294
295 295 for obj in self.parmConfObjList:
296 296 del obj
297 297
298 298 self.parmConfObjList = []
299 299
300 300 def addParameter(self, name, value, format='str'):
301 301
302 302 id = self.__getNewId()
303 303
304 304 parmConfObj = ParameterConf()
305 305 parmConfObj.setup(id, name, value, format)
306 306
307 307 self.parmConfObjList.append(parmConfObj)
308 308
309 309 return parmConfObj
310 310
311 311 def changeParameter(self, name, value, format='str'):
312 312
313 313 parmConfObj = self.getParameterObj(name)
314 314 parmConfObj.update(name, value, format)
315 315
316 316 return parmConfObj
317 317
318 318 def makeXml(self, upElement):
319 319
320 320 opElement = SubElement(upElement, self.ELEMENTNAME)
321 321 opElement.set('id', str(self.id))
322 322 opElement.set('name', self.name)
323 323 opElement.set('type', self.type)
324 324 opElement.set('priority', str(self.priority))
325 325
326 326 for parmConfObj in self.parmConfObjList:
327 327 parmConfObj.makeXml(opElement)
328 328
329 329 def readXml(self, opElement):
330 330
331 331 self.id = opElement.get('id')
332 332 self.name = opElement.get('name')
333 333 self.type = opElement.get('type')
334 334 self.priority = opElement.get('priority')
335 335
336 336 #Compatible with old signal chain version
337 337 #Use of 'run' method instead 'init'
338 338 if self.type == 'self' and self.name == 'init':
339 339 self.name = 'run'
340 340
341 341 self.parmConfObjList = []
342 342
343 343 parmElementList = opElement.getiterator(ParameterConf().getElementName())
344 344
345 345 for parmElement in parmElementList:
346 346 parmConfObj = ParameterConf()
347 347 parmConfObj.readXml(parmElement)
348 348
349 349 #Compatible with old signal chain version
350 350 #If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
351 351 if self.type != 'self' and self.name == 'Plot':
352 352 if parmConfObj.format == 'str' and parmConfObj.name == 'type':
353 353 self.name = parmConfObj.value
354 354 continue
355 355
356 356 self.parmConfObjList.append(parmConfObj)
357 357
358 358 def printattr(self):
359 359
360 360 print "%s[%s]: name = %s, type = %s, priority = %s" %(self.ELEMENTNAME,
361 361 self.id,
362 362 self.name,
363 363 self.type,
364 364 self.priority)
365 365
366 366 for parmConfObj in self.parmConfObjList:
367 367 parmConfObj.printattr()
368 368
369 369 def createObject(self):
370 370
371 371 if self.type == 'self':
372 372 raise ValueError, "This operation type cannot be created"
373 373
374 374 if self.type == 'external' or self.type == 'other':
375 375 className = eval(self.name)
376 376 opObj = className()
377 377
378 378 return opObj
379 379
380 380 class ProcUnitConf():
381 381
382 382 id = None
383 383 name = None
384 384 datatype = None
385 385 inputId = None
386 386 parentId = None
387 387
388 388 opConfObjList = []
389 389
390 390 procUnitObj = None
391 391 opObjList = []
392 392
393 393 ELEMENTNAME = 'ProcUnit'
394 394
395 395 def __init__(self):
396 396
397 397 self.id = None
398 398 self.datatype = None
399 399 self.name = None
400 400 self.inputId = None
401 401
402 402 self.opConfObjList = []
403 403
404 404 self.procUnitObj = None
405 405 self.opObjDict = {}
406 406
407 407 def __getPriority(self):
408 408
409 409 return len(self.opConfObjList)+1
410 410
411 411 def __getNewId(self):
412 412
413 413 return int(self.id)*10 + len(self.opConfObjList) + 1
414 414
415 415 def getElementName(self):
416 416
417 417 return self.ELEMENTNAME
418 418
419 419 def getId(self):
420 420
421 421 return self.id
422 422
423 423 def updateId(self, new_id, parentId=parentId):
424 424
425 425
426 426 new_id = int(parentId)*10 + (int(self.id) % 10)
427 427 new_inputId = int(parentId)*10 + (int(self.inputId) % 10)
428 428
429 429 #If this proc unit has not inputs
430 430 if self.inputId == '0':
431 431 new_inputId = 0
432 432
433 433 n = 1
434 434 for opConfObj in self.opConfObjList:
435 435
436 436 idOp = str(int(new_id)*10 + n)
437 437 opConfObj.updateId(idOp)
438 438
439 439 n += 1
440 440
441 441 self.parentId = str(parentId)
442 442 self.id = str(new_id)
443 443 self.inputId = str(new_inputId)
444 444
445 445
446 446 def getInputId(self):
447 447
448 448 return self.inputId
449 449
450 450 def getOperationObjList(self):
451 451
452 452 return self.opConfObjList
453 453
454 454 def getOperationObj(self, name=None):
455 455
456 456 for opConfObj in self.opConfObjList:
457 457
458 458 if opConfObj.name != name:
459 459 continue
460 460
461 461 return opConfObj
462 462
463 463 return None
464 464
465 465 def getOpObjfromParamValue(self, value=None):
466 466
467 467 for opConfObj in self.opConfObjList:
468 468 if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
469 469 continue
470 470 return opConfObj
471 471 return None
472 472
473 473 def getProcUnitObj(self):
474 474
475 475 return self.procUnitObj
476 476
477 477 def setup(self, id, name, datatype, inputId, parentId=None):
478 478
479 479 #Compatible with old signal chain version
480 480 if datatype==None and name==None:
481 481 raise ValueError, "datatype or name should be defined"
482 482
483 483 if name==None:
484 484 if 'Proc' in datatype:
485 485 name = datatype
486 486 else:
487 487 name = '%sProc' %(datatype)
488 488
489 489 if datatype==None:
490 490 datatype = name.replace('Proc','')
491 491
492 492 self.id = str(id)
493 493 self.name = name
494 494 self.datatype = datatype
495 495 self.inputId = inputId
496 496 self.parentId = parentId
497 497
498 498 self.opConfObjList = []
499 499
500 500 self.addOperation(name='run', optype='self')
501 501
502 502 def removeOperations(self):
503 503
504 504 for obj in self.opConfObjList:
505 505 del obj
506 506
507 507 self.opConfObjList = []
508 508 self.addOperation(name='run')
509 509
510 510 def addParameter(self, **kwargs):
511 511 '''
512 512 Add parameters to "run" operation
513 513 '''
514 514 opObj = self.opConfObjList[0]
515 515
516 516 opObj.addParameter(**kwargs)
517 517
518 518 return opObj
519 519
520 520 def addOperation(self, name, optype='self'):
521 521
522 522 id = self.__getNewId()
523 523 priority = self.__getPriority()
524 524
525 525 opConfObj = OperationConf()
526 526 opConfObj.setup(id, name=name, priority=priority, type=optype)
527 527
528 528 self.opConfObjList.append(opConfObj)
529 529
530 530 return opConfObj
531 531
532 532 def makeXml(self, procUnitElement):
533 533
534 534 upElement = SubElement(procUnitElement, self.ELEMENTNAME)
535 535 upElement.set('id', str(self.id))
536 536 upElement.set('name', self.name)
537 537 upElement.set('datatype', self.datatype)
538 538 upElement.set('inputId', str(self.inputId))
539 539
540 540 for opConfObj in self.opConfObjList:
541 541 opConfObj.makeXml(upElement)
542 542
543 543 def readXml(self, upElement):
544 544
545 545 self.id = upElement.get('id')
546 546 self.name = upElement.get('name')
547 547 self.datatype = upElement.get('datatype')
548 548 self.inputId = upElement.get('inputId')
549 549
550 550 if self.ELEMENTNAME == "ReadUnit":
551 551 self.datatype = self.datatype.replace("Reader", "")
552 552
553 553 if self.ELEMENTNAME == "ProcUnit":
554 554 self.datatype = self.datatype.replace("Proc", "")
555 555
556 556 if self.inputId == 'None':
557 557 self.inputId = '0'
558 558
559 559 self.opConfObjList = []
560 560
561 561 opElementList = upElement.getiterator(OperationConf().getElementName())
562 562
563 563 for opElement in opElementList:
564 564 opConfObj = OperationConf()
565 565 opConfObj.readXml(opElement)
566 566 self.opConfObjList.append(opConfObj)
567 567
568 568 def printattr(self):
569 569
570 570 print "%s[%s]: name = %s, datatype = %s, inputId = %s" %(self.ELEMENTNAME,
571 571 self.id,
572 572 self.name,
573 573 self.datatype,
574 574 self.inputId)
575 575
576 576 for opConfObj in self.opConfObjList:
577 577 opConfObj.printattr()
578 578
579 579 def createObjects(self):
580 580
581 581 className = eval(self.name)
582 582 procUnitObj = className()
583 583
584 584 for opConfObj in self.opConfObjList:
585 585
586 586 if opConfObj.type == 'self':
587 587 continue
588 588
589 589 opObj = opConfObj.createObject()
590 590
591 591 self.opObjDict[opConfObj.id] = opObj
592 592 procUnitObj.addOperation(opObj, opConfObj.id)
593 593
594 594 self.procUnitObj = procUnitObj
595 595
596 596 return procUnitObj
597 597
598 598 def run(self):
599 599
600 600 finalSts = False
601 601
602 602 for opConfObj in self.opConfObjList:
603 603
604 604 kwargs = {}
605 605 for parmConfObj in opConfObj.getParameterObjList():
606 606 if opConfObj.name == 'run' and parmConfObj.name == 'datatype':
607 607 continue
608 608
609 609 kwargs[parmConfObj.name] = parmConfObj.getValue()
610 610
611 611 #print "\tRunning the '%s' operation with %s" %(opConfObj.name, opConfObj.id)
612 612 sts = self.procUnitObj.call(opType = opConfObj.type,
613 613 opName = opConfObj.name,
614 614 opId = opConfObj.id,
615 615 **kwargs)
616 616 finalSts = finalSts or sts
617 617
618 618 return finalSts
619 619
620 620 def close(self):
621 621
622 622 for opConfObj in self.opConfObjList:
623 623 if opConfObj.type == 'self':
624 624 continue
625 625
626 626 opObj = self.procUnitObj.getOperationObj(opConfObj.id)
627 627 opObj.close()
628 628
629 629 self.procUnitObj.close()
630 630
631 631 return
632 632
633 633 class ReadUnitConf(ProcUnitConf):
634 634
635 635 path = None
636 636 startDate = None
637 637 endDate = None
638 638 startTime = None
639 639 endTime = None
640 640
641 641 ELEMENTNAME = 'ReadUnit'
642 642
643 643 def __init__(self):
644 644
645 645 self.id = None
646 646 self.datatype = None
647 647 self.name = None
648 648 self.inputId = None
649 649
650 650 self.parentId = None
651 651
652 652 self.opConfObjList = []
653 653 self.opObjList = []
654 654
655 655 def getElementName(self):
656 656
657 657 return self.ELEMENTNAME
658 658
659 659 def setup(self, id, name, datatype, path, startDate="", endDate="", startTime="", endTime="", parentId=None, **kwargs):
660 660
661 661 #Compatible with old signal chain version
662 662 if datatype==None and name==None:
663 663 raise ValueError, "datatype or name should be defined"
664 664
665 665 if name==None:
666 666 if 'Reader' in datatype:
667 667 name = datatype
668 668 else:
669 669 name = '%sReader' %(datatype)
670 670
671 671 if datatype==None:
672 672 datatype = name.replace('Reader','')
673 673
674 674 self.id = id
675 675 self.name = name
676 676 self.datatype = datatype
677 677
678 678 self.path = path
679 679 self.startDate = startDate
680 680 self.endDate = endDate
681 681 self.startTime = startTime
682 682 self.endTime = endTime
683 683
684 684 self.inputId = '0'
685 685 self.parentId = parentId
686 686
687 687 self.addRunOperation(**kwargs)
688 688
689 689 def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, name=None, **kwargs):
690 690
691 691 #Compatible with old signal chain version
692 692 if datatype==None and name==None:
693 693 raise ValueError, "datatype or name should be defined"
694 694
695 695 if name==None:
696 696 if 'Reader' in datatype:
697 697 name = datatype
698 698 else:
699 699 name = '%sReader' %(datatype)
700 700
701 701 if datatype==None:
702 702 datatype = name.replace('Reader','')
703 703
704 704 self.datatype = datatype
705 705 self.name = name
706 706 self.path = path
707 707 self.startDate = startDate
708 708 self.endDate = endDate
709 709 self.startTime = startTime
710 710 self.endTime = endTime
711 711
712 712 self.inputId = '0'
713 713 self.parentId = parentId
714 714
715 715 self.updateRunOperation(**kwargs)
716 716
717 717 def addRunOperation(self, **kwargs):
718 718
719 719 opObj = self.addOperation(name = 'run', optype = 'self')
720 720
721 721 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
722 722 opObj.addParameter(name='path' , value=self.path, format='str')
723 723 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
724 724 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
725 725 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
726 726 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
727 727
728 728 for key, value in kwargs.items():
729 729 opObj.addParameter(name=key, value=value, format=type(value).__name__)
730 730
731 731 return opObj
732 732
733 733 def updateRunOperation(self, **kwargs):
734 734
735 735 opObj = self.getOperationObj(name = 'run')
736 736 opObj.removeParameters()
737 737
738 738 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
739 739 opObj.addParameter(name='path' , value=self.path, format='str')
740 740 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
741 741 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
742 742 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
743 743 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
744 744
745 745 for key, value in kwargs.items():
746 746 opObj.addParameter(name=key, value=value, format=type(value).__name__)
747 747
748 748 return opObj
749 749
750 750 class Project():
751 751
752 752 id = None
753 753 name = None
754 754 description = None
755 755 # readUnitConfObjList = None
756 756 procUnitConfObjDict = None
757 757
758 758 ELEMENTNAME = 'Project'
759 759
760 760 def __init__(self, control=None, dataq=None):
761 761
762 762 self.id = None
763 763 self.name = None
764 764 self.description = None
765 765
766 766 self.procUnitConfObjDict = {}
767 767
768 768 #global data_q
769 769 #data_q = dataq
770 770
771 771 if control==None:
772 772 control = {'stop':False,'pause':False}
773 773
774 774 self.control = control
775 775
776 776 def __getNewId(self):
777 777
778 778 id = int(self.id)*10 + len(self.procUnitConfObjDict) + 1
779 779
780 780 return str(id)
781 781
782 782 def getElementName(self):
783 783
784 784 return self.ELEMENTNAME
785 785
786 786 def getId(self):
787 787
788 788 return self.id
789 789
790 790 def updateId(self, new_id):
791 791
792 792 self.id = str(new_id)
793 793
794 794 keyList = self.procUnitConfObjDict.keys()
795 795 keyList.sort()
796 796
797 797 n = 1
798 798 newProcUnitConfObjDict = {}
799 799
800 800 for procKey in keyList:
801 801
802 802 procUnitConfObj = self.procUnitConfObjDict[procKey]
803 803 idProcUnit = str(int(self.id)*10 + n)
804 804 procUnitConfObj.updateId(idProcUnit, parentId = self.id)
805 805
806 806 newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
807 807 n += 1
808 808
809 809 self.procUnitConfObjDict = newProcUnitConfObjDict
810 810
811 811 def setup(self, id, name, description):
812 812
813 813 self.id = str(id)
814 814 self.name = name
815 815 self.description = description
816 816
817 817 def update(self, name, description):
818 818
819 819 self.name = name
820 820 self.description = description
821 821
822 822 def addReadUnit(self, datatype=None, name=None, **kwargs):
823 823
824 824 idReadUnit = self.__getNewId()
825 825
826 826 readUnitConfObj = ReadUnitConf()
827 827 readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
828 828
829 829 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
830 830
831 831 return readUnitConfObj
832 832
833 833 def addProcUnit(self, inputId='0', datatype=None, name=None):
834 834
835 835 idProcUnit = self.__getNewId()
836 836
837 837 procUnitConfObj = ProcUnitConf()
838 838 procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
839 839
840 840 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
841 841
842 842 return procUnitConfObj
843 843
844 844 def removeProcUnit(self, id):
845 845
846 846 if id in self.procUnitConfObjDict.keys():
847 847 self.procUnitConfObjDict.pop(id)
848 848
849 849 def getReadUnitId(self):
850 850
851 851 readUnitConfObj = self.getReadUnitObj()
852 852
853 853 return readUnitConfObj.id
854 854
855 855 def getReadUnitObj(self):
856 856
857 857 for obj in self.procUnitConfObjDict.values():
858 858 if obj.getElementName() == "ReadUnit":
859 859 return obj
860 860
861 861 return None
862 862
863 863 def getProcUnitObj(self, id=None, name=None):
864 864
865 865 if id != None:
866 866 return self.procUnitConfObjDict[id]
867 867
868 868 if name != None:
869 869 return self.getProcUnitObjByName(name)
870 870
871 871 return None
872 872
873 873 def getProcUnitObjByName(self, name):
874 874
875 875 for obj in self.procUnitConfObjDict.values():
876 876 if obj.name == name:
877 877 return obj
878 878
879 879 return None
880 880
881 881 def procUnitItems(self):
882 882
883 883 return self.procUnitConfObjDict.items()
884 884
885 885 def makeXml(self):
886 886
887 887 projectElement = Element('Project')
888 888 projectElement.set('id', str(self.id))
889 889 projectElement.set('name', self.name)
890 890 projectElement.set('description', self.description)
891 891
892 892 # for readUnitConfObj in self.readUnitConfObjList:
893 893 # readUnitConfObj.makeXml(projectElement)
894 894
895 895 for procUnitConfObj in self.procUnitConfObjDict.values():
896 896 procUnitConfObj.makeXml(projectElement)
897 897
898 898 self.projectElement = projectElement
899 899
900 900 def writeXml(self, filename):
901 901
902 902 self.makeXml()
903 903
904 904 #print prettify(self.projectElement)
905 905
906 906 ElementTree(self.projectElement).write(filename, method='xml')
907 907
908 908 def readXml(self, filename):
909 909
910 910 #tree = ET.parse(filename)
911 911 self.projectElement = None
912 912 # self.readUnitConfObjList = []
913 913 self.procUnitConfObjDict = {}
914 914
915 915 self.projectElement = ElementTree().parse(filename)
916 916
917 917 self.project = self.projectElement.tag
918 918
919 919 self.id = self.projectElement.get('id')
920 920 self.name = self.projectElement.get('name')
921 921 self.description = self.projectElement.get('description')
922 922
923 923 readUnitElementList = self.projectElement.getiterator(ReadUnitConf().getElementName())
924 924
925 925 for readUnitElement in readUnitElementList:
926 926 readUnitConfObj = ReadUnitConf()
927 927 readUnitConfObj.readXml(readUnitElement)
928 928
929 929 if readUnitConfObj.parentId == None:
930 930 readUnitConfObj.parentId = self.id
931 931
932 932 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
933 933
934 934 procUnitElementList = self.projectElement.getiterator(ProcUnitConf().getElementName())
935 935
936 936 for procUnitElement in procUnitElementList:
937 937 procUnitConfObj = ProcUnitConf()
938 938 procUnitConfObj.readXml(procUnitElement)
939 939
940 940 if procUnitConfObj.parentId == None:
941 941 procUnitConfObj.parentId = self.id
942 942
943 943 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
944 944
945 945 def printattr(self):
946 946
947 947 print "Project[%s]: name = %s, description = %s" %(self.id,
948 948 self.name,
949 949 self.description)
950 950
951 951 # for readUnitConfObj in self.readUnitConfObjList:
952 952 # readUnitConfObj.printattr()
953 953
954 954 for procUnitConfObj in self.procUnitConfObjDict.values():
955 955 procUnitConfObj.printattr()
956 956
957 957 def createObjects(self):
958 958
959 959 # for readUnitConfObj in self.readUnitConfObjList:
960 960 # readUnitConfObj.createObjects()
961 961
962 962 for procUnitConfObj in self.procUnitConfObjDict.values():
963 963 procUnitConfObj.createObjects()
964 964
965 965 def __connect(self, objIN, thisObj):
966 966
967 967 thisObj.setInput(objIN.getOutputObj())
968 968
969 969 def connectObjects(self):
970 970
971 971 for thisPUConfObj in self.procUnitConfObjDict.values():
972 972
973 973 inputId = thisPUConfObj.getInputId()
974 974
975 975 if int(inputId) == 0:
976 976 continue
977 977
978 978 #Get input object
979 979 puConfINObj = self.procUnitConfObjDict[inputId]
980 980 puObjIN = puConfINObj.getProcUnitObj()
981 981
982 982 #Get current object
983 983 thisPUObj = thisPUConfObj.getProcUnitObj()
984 984
985 985 self.__connect(puObjIN, thisPUObj)
986 986
987 987 def run(self):
988 988
989 989 # for readUnitConfObj in self.readUnitConfObjList:
990 990 # readUnitConfObj.run()
991 991 print
992 992 print "*"*40
993 993 print " Starting SIGNAL CHAIN PROCESSING "
994 994 print "*"*40
995 995 print
996 996
997 997 keyList = self.procUnitConfObjDict.keys()
998 998 keyList.sort()
999 999
1000 1000 while(True):
1001 1001
1002 1002 finalSts = False
1003 1003
1004 1004 for procKey in keyList:
1005 1005 # print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
1006 1006
1007 1007 procUnitConfObj = self.procUnitConfObjDict[procKey]
1008 1008 sts = procUnitConfObj.run()
1009 1009 finalSts = finalSts or sts
1010 1010
1011 1011 #If every process unit finished so end process
1012 1012 if not(finalSts):
1013 1013 print "Every process unit have finished"
1014 1014 break
1015 1015
1016 1016 if self.control['pause']:
1017 1017 print "Process suspended"
1018 1018
1019 1019 while True:
1020 1020 sleep(0.1)
1021 1021
1022 1022 if not self.control['pause']:
1023 1023 break
1024 1024
1025 1025 if self.control['stop']:
1026 1026 break
1027 1027 print "Process reinitialized"
1028 1028
1029 1029 if self.control['stop']:
1030 1030 print "Process stopped"
1031 1031 break
1032 1032
1033 1033 #Closing every process
1034 1034 for procKey in keyList:
1035 1035 procUnitConfObj = self.procUnitConfObjDict[procKey]
1036 1036 procUnitConfObj.close()
1037 1037
1038 1038 print "Process finished"
1039 1039
1040 1040 def start(self, filename):
1041 1041
1042 1042 self.writeXml(filename)
1043 1043 self.readXml(filename)
1044 1044
1045 1045 self.createObjects()
1046 1046 self.connectObjects()
1047 1047 self.run()
1048 1048
1049 1049 class ControllerThread(threading.Thread, Project):
1050 1050
1051 1051 def __init__(self, filename):
1052 1052
1053 1053 threading.Thread.__init__(self)
1054 1054 Project.__init__(self)
1055 1055
1056 1056 self.setDaemon(True)
1057 1057
1058 1058 self.filename = filename
1059 1059 self.control = {'stop':False, 'pause':False}
1060 1060
1061 1061 def stop(self):
1062 1062 self.control['stop'] = True
1063 1063
1064 1064 def pause(self):
1065 1065 self.control['pause'] = not(self.control['pause'])
1066 1066
1067 1067 def run(self):
1068 1068 self.control['stop'] = False
1069 1069 self.control['pause'] = False
1070 1070
1071 1071 self.readXml(self.filename)
1072 1072 self.createObjects()
1073 1073 self.connectObjects()
1074 1074 Project.run(self)
1075 1075
1076 1076 if __name__ == '__main__':
1077 1077
1078 1078 desc = "Segundo Test"
1079 1079 filename = "schain.xml"
1080 1080
1081 1081 controllerObj = Project()
1082 1082
1083 1083 controllerObj.setup(id = '191', name='test01', description=desc)
1084 1084
1085 1085 readUnitConfObj = controllerObj.addReadUnit(datatype='Voltage',
1086 1086 path='data/rawdata/',
1087 1087 startDate='2011/01/01',
1088 1088 endDate='2012/12/31',
1089 1089 startTime='00:00:00',
1090 1090 endTime='23:59:59',
1091 1091 online=1,
1092 1092 walk=1)
1093 1093
1094 1094 # opObj00 = readUnitConfObj.addOperation(name='printInfo')
1095 1095
1096 1096 procUnitConfObj0 = controllerObj.addProcUnit(datatype='Voltage', inputId=readUnitConfObj.getId())
1097 1097
1098 1098 opObj10 = procUnitConfObj0.addOperation(name='selectChannels')
1099 1099 opObj10.addParameter(name='channelList', value='3,4,5', format='intlist')
1100 1100
1101 1101 opObj10 = procUnitConfObj0.addOperation(name='selectHeights')
1102 1102 opObj10.addParameter(name='minHei', value='90', format='float')
1103 1103 opObj10.addParameter(name='maxHei', value='180', format='float')
1104 1104
1105 1105 opObj12 = procUnitConfObj0.addOperation(name='CohInt', optype='external')
1106 1106 opObj12.addParameter(name='n', value='10', format='int')
1107 1107
1108 1108 procUnitConfObj1 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj0.getId())
1109 1109 procUnitConfObj1.addParameter(name='nFFTPoints', value='32', format='int')
1110 1110 # procUnitConfObj1.addParameter(name='pairList', value='(0,1),(0,2),(1,2)', format='')
1111 1111
1112 1112
1113 1113 opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
1114 1114 opObj11.addParameter(name='idfigure', value='1', format='int')
1115 1115 opObj11.addParameter(name='wintitle', value='SpectraPlot0', format='str')
1116 1116 opObj11.addParameter(name='zmin', value='40', format='int')
1117 1117 opObj11.addParameter(name='zmax', value='90', format='int')
1118 1118 opObj11.addParameter(name='showprofile', value='1', format='int')
1119 1119
1120 1120 # opObj11 = procUnitConfObj1.addOperation(name='CrossSpectraPlot', optype='external')
1121 1121 # opObj11.addParameter(name='idfigure', value='2', format='int')
1122 1122 # opObj11.addParameter(name='wintitle', value='CrossSpectraPlot', format='str')
1123 1123 # opObj11.addParameter(name='zmin', value='40', format='int')
1124 1124 # opObj11.addParameter(name='zmax', value='90', format='int')
1125 1125
1126 1126
1127 1127 # procUnitConfObj2 = controllerObj.addProcUnit(datatype='Voltage', inputId=procUnitConfObj0.getId())
1128 1128 #
1129 1129 # opObj12 = procUnitConfObj2.addOperation(name='CohInt', optype='external')
1130 1130 # opObj12.addParameter(name='n', value='2', format='int')
1131 1131 # opObj12.addParameter(name='overlapping', value='1', format='int')
1132 1132 #
1133 1133 # procUnitConfObj3 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj2.getId())
1134 1134 # procUnitConfObj3.addParameter(name='nFFTPoints', value='32', format='int')
1135 1135 #
1136 1136 # opObj11 = procUnitConfObj3.addOperation(name='SpectraPlot', optype='external')
1137 1137 # opObj11.addParameter(name='idfigure', value='2', format='int')
1138 1138 # opObj11.addParameter(name='wintitle', value='SpectraPlot1', format='str')
1139 1139 # opObj11.addParameter(name='zmin', value='40', format='int')
1140 1140 # opObj11.addParameter(name='zmax', value='90', format='int')
1141 1141 # opObj11.addParameter(name='showprofile', value='1', format='int')
1142 1142
1143 1143 # opObj11 = procUnitConfObj1.addOperation(name='RTIPlot', optype='external')
1144 1144 # opObj11.addParameter(name='idfigure', value='10', format='int')
1145 1145 # opObj11.addParameter(name='wintitle', value='RTI', format='str')
1146 1146 ## opObj11.addParameter(name='xmin', value='21', format='float')
1147 1147 ## opObj11.addParameter(name='xmax', value='22', format='float')
1148 1148 # opObj11.addParameter(name='zmin', value='40', format='int')
1149 1149 # opObj11.addParameter(name='zmax', value='90', format='int')
1150 1150 # opObj11.addParameter(name='showprofile', value='1', format='int')
1151 1151 # opObj11.addParameter(name='timerange', value=str(60), format='int')
1152 1152
1153 1153 # opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
1154 1154 # opObj10.addParameter(name='channelList', value='0,2,4,6', format='intlist')
1155 1155 #
1156 1156 # opObj12 = procUnitConfObj1.addOperation(name='IncohInt', optype='external')
1157 1157 # opObj12.addParameter(name='n', value='2', format='int')
1158 1158 #
1159 1159 # opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
1160 1160 # opObj11.addParameter(name='idfigure', value='2', format='int')
1161 1161 # opObj11.addParameter(name='wintitle', value='SpectraPlot10', format='str')
1162 1162 # opObj11.addParameter(name='zmin', value='70', format='int')
1163 1163 # opObj11.addParameter(name='zmax', value='90', format='int')
1164 1164 #
1165 1165 # opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
1166 1166 # opObj10.addParameter(name='channelList', value='2,6', format='intlist')
1167 1167 #
1168 1168 # opObj12 = procUnitConfObj1.addOperation(name='IncohInt', optype='external')
1169 1169 # opObj12.addParameter(name='n', value='2', format='int')
1170 1170 #
1171 1171 # opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
1172 1172 # opObj11.addParameter(name='idfigure', value='3', format='int')
1173 1173 # opObj11.addParameter(name='wintitle', value='SpectraPlot10', format='str')
1174 1174 # opObj11.addParameter(name='zmin', value='70', format='int')
1175 1175 # opObj11.addParameter(name='zmax', value='90', format='int')
1176 1176
1177 1177
1178 1178 # opObj12 = procUnitConfObj1.addOperation(name='decoder')
1179 1179 # opObj12.addParameter(name='ncode', value='2', format='int')
1180 1180 # opObj12.addParameter(name='nbauds', value='8', format='int')
1181 1181 # opObj12.addParameter(name='code0', value='001110011', format='int')
1182 1182 # opObj12.addParameter(name='code1', value='001110011', format='int')
1183 1183
1184 1184
1185 1185
1186 1186 # procUnitConfObj2 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj1.getId())
1187 1187 #
1188 1188 # opObj21 = procUnitConfObj2.addOperation(name='IncohInt', optype='external')
1189 1189 # opObj21.addParameter(name='n', value='2', format='int')
1190 1190 #
1191 1191 # opObj11 = procUnitConfObj2.addOperation(name='SpectraPlot', optype='external')
1192 1192 # opObj11.addParameter(name='idfigure', value='4', format='int')
1193 1193 # opObj11.addParameter(name='wintitle', value='SpectraPlot OBJ 2', format='str')
1194 1194 # opObj11.addParameter(name='zmin', value='70', format='int')
1195 1195 # opObj11.addParameter(name='zmax', value='90', format='int')
1196 1196
1197 1197 print "Escribiendo el archivo XML"
1198 1198
1199 1199 controllerObj.writeXml(filename)
1200 1200
1201 1201 print "Leyendo el archivo XML"
1202 1202 controllerObj.readXml(filename)
1203 1203 #controllerObj.printattr()
1204 1204
1205 1205 controllerObj.createObjects()
1206 1206 controllerObj.connectObjects()
1207 1207 controllerObj.run()
1208 1208
1209 1209 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,5840 +1,5684
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 Module implementing MainWindow.
4 4 #+++++++++++++GUI V1++++++++++++++#
5 5 @author: AlexanderValdezPortocarrero Γ±_Γ±
6 6 """
7 7 import os, sys, time
8 8 import datetime
9 9 import numpy
10 10 import Queue
11 11
12 12 from collections import OrderedDict
13 13 from os.path import expanduser
14 14 from time import sleep
15 15 import ast
16 16
17 17 from PyQt4.QtGui import QMainWindow
18 18 from PyQt4.QtCore import pyqtSignature
19 19 from PyQt4.QtCore import pyqtSignal
20 20 from PyQt4 import QtCore
21 21 from PyQt4 import QtGui
22 22
23 23 from schainpy.gui.viewer.ui_unitprocess import Ui_UnitProcess
24 24 from schainpy.gui.viewer.ui_ftp import Ui_Ftp
25 25 from schainpy.gui.viewer.ui_mainwindow import Ui_BasicWindow
26 26 from schainpy.controller import Project, ControllerThread
27 27
28 28 from propertiesViewModel import TreeModel, PropertyBuffer
29 29 from parametersModel import ProjectParms
30 30
31 31 from schainpy.gui.figures import tools
32 32
33 33 FIGURES_PATH = tools.get_path()
34 34 TEMPORAL_FILE = ".temp.xml"
35 35
36 36 def isRadarFile(file):
37 37 try:
38 38 year = int(file[1:5])
39 39 doy = int(file[5:8])
40 40 set = int(file[8:11])
41 41 except:
42 42 return 0
43 43
44 44 return 1
45 45
46 46 def isRadarPath(path):
47 47 try:
48 48 year = int(path[1:5])
49 49 doy = int(path[5:8])
50 50 except:
51 51 return 0
52 52
53 53 return 1
54 54
55 55 class BasicWindow(QMainWindow, Ui_BasicWindow):
56 56 """
57 57 """
58 58 def __init__(self, parent=None):
59 59 """
60 60
61 61 """
62 62 QMainWindow.__init__(self, parent)
63 63 self.setupUi(self)
64 64 self.__puObjDict = {}
65 65 self.__itemTreeDict = {}
66 66 self.readUnitConfObjList = []
67 67 self.operObjList = []
68 68 self.projecObjView = None
69 69 self.idProject = 0
70 70 # self.idImag = 0
71 71
72 72 self.idImagscope = 0
73 73 self.idImagspectra = 0
74 74 self.idImagcross = 0
75 75 self.idImagrti = 0
76 76 self.idImagcoherence = 0
77 77 self.idImagpower = 0
78 78 self.idImagrtinoise = 0
79 79 self.idImagspectraHeis = 0
80 80 self.idImagrtiHeis = 0
81 81
82 82 self.dataPath = None
83 83 self.online = 0
84 84 self.walk = 0
85 85 self.create = False
86 86 self.selectedItemTree = None
87 87 self.controllerObj = None
88 88 # self.commCtrlPThread = None
89 89 # self.create_figure()
90 90 self.temporalFTP = ftpBuffer()
91 91 self.projectProperCaracteristica = []
92 92 self.projectProperPrincipal = []
93 93 self.projectProperDescripcion = []
94 94 self.volProperCaracteristica = []
95 95 self.volProperPrincipal = []
96 96 self.volProperDescripcion = []
97 97 self.specProperCaracteristica = []
98 98 self.specProperPrincipal = []
99 99 self.specProperDescripcion = []
100 100
101 101 self.specHeisProperCaracteristica = []
102 102 self.specHeisProperPrincipal = []
103 103 self.specHeisProperDescripcion = []
104 104
105 105 # self.pathWorkSpace = './'
106 106
107 107 self.__projectObjDict = {}
108 108 self.__operationObjDict = {}
109 109
110 110 self.__puLocalFolder2FTP = {}
111 111 self.__initialized = False
112 112
113 113 # self.create_comm()
114 114 self.create_updating_timer()
115 115 self.setParameter()
116 116
117 117 @pyqtSignature("")
118 118 def on_actionOpen_triggered(self):
119 119 """
120 120 Slot documentation goes here.
121 121 """
122 122 self.openProject()
123 123
124 124 @pyqtSignature("")
125 125 def on_actionCreate_triggered(self):
126 126 """
127 127 Slot documentation goes here.
128 128 """
129 129 self.setInputsProject_View()
130 130 self.create = True
131 131
132 132 @pyqtSignature("")
133 133 def on_actionSave_triggered(self):
134 134 """
135 135 Slot documentation goes here.
136 136 """
137 137 self.saveProject()
138 138
139 139 @pyqtSignature("")
140 140 def on_actionClose_triggered(self):
141 141 """
142 142 Slot documentation goes here.
143 143 """
144 144 self.close()
145 145
146 146 @pyqtSignature("")
147 147 def on_actionStart_triggered(self):
148 148 """
149 149 """
150 150 self.playProject()
151 151
152 152 @pyqtSignature("")
153 153 def on_actionPause_triggered(self):
154 154 """
155 155 """
156 156 self.pauseProject()
157 157
158 158 @pyqtSignature("")
159 159 def on_actionStop_triggered(self):
160 160 """
161 161 """
162 162 self.stopProject()
163 163
164 164 @pyqtSignature("")
165 165 def on_actionFTP_triggered(self):
166 166 """
167 167 """
168 168 self.configFTPWindowObj = Ftp(self)
169 169
170 170 if not self.temporalFTP.create:
171 171 self.temporalFTP.setwithoutconfiguration()
172 172
173 173 self.configFTPWindowObj.setParmsfromTemporal(self.temporalFTP.server,
174 174 self.temporalFTP.remotefolder,
175 175 self.temporalFTP.username,
176 176 self.temporalFTP.password,
177 177 self.temporalFTP.ftp_wei,
178 178 self.temporalFTP.exp_code,
179 179 self.temporalFTP.sub_exp_code,
180 180 self.temporalFTP.plot_pos)
181 181
182 182 self.configFTPWindowObj.show()
183 183 self.configFTPWindowObj.closed.connect(self.createFTPConfig)
184 184
185 185 def createFTPConfig(self):
186 186
187 187 if not self.configFTPWindowObj.create:
188 188 self.console.clear()
189 189 self.console.append("There is no FTP configuration")
190 190 return
191 191
192 192 self.console.append("Push Ok in Spectra view to Add FTP Configuration")
193 193
194 194 server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.configFTPWindowObj.getParmsFromFtpWindow()
195 195 self.temporalFTP.save(server=server,
196 196 remotefolder=remotefolder,
197 197 username=username,
198 198 password=password,
199 199 ftp_wei=ftp_wei,
200 200 exp_code=exp_code,
201 201 sub_exp_code=sub_exp_code,
202 202 plot_pos=plot_pos)
203 203
204 204 @pyqtSignature("")
205 205 def on_actionOpenToolbar_triggered(self):
206 206 """
207 207 Slot documentation goes here.
208 208 """
209 209 self.openProject()
210 210
211 211 @pyqtSignature("")
212 212 def on_actionCreateToolbar_triggered(self):
213 213 """
214 214 Slot documentation goes here.
215 215 """
216 216 self.setInputsProject_View()
217 217 self.create = True
218 218
219 219 @pyqtSignature("")
220 220 def on_actionAddPU_triggered(self):
221 221 if len(self.__projectObjDict) == 0:
222 222 outputstr = "First Create a Project then add Processing Unit"
223 223 self.console.clear()
224 224 self.console.append(outputstr)
225 225 return 0
226 226 else:
227 227 self.addPUWindow()
228 228 self.console.clear()
229 229 self.console.append("Please, Choose the type of Processing Unit")
230 230 self.console.append("If your Datatype is rawdata, you will start with processing unit Type Voltage")
231 231 self.console.append("If your Datatype is pdata, you will choose between processing unit Type Spectra or Correlation")
232 232 self.console.append("If your Datatype is fits, you will start with processing unit Type SpectraHeis")
233 233
234 234
235 235 @pyqtSignature("")
236 236 def on_actionSaveToolbar_triggered(self):
237 237 """
238 238 Slot documentation goes here.
239 239 """
240 240 self.saveProject()
241 241
242 242 @pyqtSignature("")
243 243 def on_actionStarToolbar_triggered(self):
244 244 """
245 245 Slot documentation goes here.
246 246 """
247 247 self.playProject()
248 248
249 249 @pyqtSignature("")
250 250 def on_actionPauseToolbar_triggered(self):
251 251
252 252 self.pauseProject()
253 253
254 254 @pyqtSignature("")
255 255 def on_actionStopToolbar_triggered(self):
256 256 """
257 257 Slot documentation goes here.
258 258 """
259 259 self.stopProject()
260 260
261 261 @pyqtSignature("int")
262 262 def on_proComReadMode_activated(self, index):
263 263 """
264 264 SELECCION DEL MODO DE LECTURA ON=1, OFF=0
265 265 """
266 266 if index == 0:
267 267 self.online = 0
268 268 self.proDelay.setText("0")
269 269 self.proSet.setText("")
270 270 self.proSet.setEnabled(False)
271 271 self.proDelay.setEnabled(False)
272 272 elif index == 1:
273 273 self.online = 1
274 274 self.proSet.setText(" ")
275 275 self.proDelay.setText("5")
276 276 self.proSet.setEnabled(True)
277 277 self.proDelay.setEnabled(True)
278 278
279 279 @pyqtSignature("int")
280 280 def on_proComDataType_activated(self, index):
281 281 """
282 282 Voltage or Spectra
283 283 """
284 284 self.labelSet.show()
285 285 self.proSet.show()
286 286
287 287 self.labelIPPKm.hide()
288 288 self.proIPPKm.hide()
289 289
290 290 if index == 0:
291 291 extension = '.r'
292 292 elif index == 1:
293 293 extension = '.pdata'
294 294 elif index == 2:
295 295 extension = '.fits'
296 296 elif index == 3:
297 297 extension = '.hdf5'
298 298
299 299 self.labelSet.hide()
300 300 self.proSet.hide()
301 301 self.labelIPPKm.show()
302 302 self.proIPPKm.show()
303 303
304 304 self.proDataType.setText(extension)
305 305
306 306 @pyqtSignature("int")
307 307 def on_proComWalk_activated(self, index):
308 308 """
309 309
310 310 """
311 311 if index == 0:
312 312 self.walk = 0
313 313 elif index == 1:
314 314 self.walk = 1
315 315
316 316 @pyqtSignature("")
317 317 def on_proToolPath_clicked(self):
318 318 """
319 319 Choose your path
320 320 """
321 321
322 322 current_dpath = './'
323 323 if self.dataPath:
324 324 current_dpath = self.dataPath
325 325
326 326 datapath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', current_dpath, QtGui.QFileDialog.ShowDirsOnly))
327 327
328 328 #If it was canceled
329 329 if not datapath:
330 330 return
331 331
332 332 #If any change was done
333 333 if datapath == self.dataPath:
334 334 return
335 335
336 336 self.proDataPath.setText(datapath)
337 337
338 338 self.actionStart.setEnabled(False)
339 339 self.actionStarToolbar.setEnabled(False)
340 340 self.proOk.setEnabled(False)
341 341
342 342 self.proComStartDate.clear()
343 343 self.proComEndDate.clear()
344 344
345 345 if not os.path.exists(datapath):
346 346
347 347 self.console.clear()
348 348 self.console.append("Write a correct a path")
349 349 return
350 350
351 351 self.dataPath = datapath
352 352
353 353 self.console.clear()
354 354 self.console.append("Select the read mode and press 'load button'")
355 355
356 356
357 357 @pyqtSignature("")
358 358 def on_proLoadButton_clicked(self):
359 359
360 360 self.console.clear()
361 361
362 362 parameter_list = self.checkInputsProject()
363 363
364 364 if not parameter_list[0]:
365 365 return
366 366
367 367 parms_ok, project_name, datatype, ext, data_path, read_mode, delay, walk, set = parameter_list
368 368
369 369 if read_mode == "Offline":
370 370 self.proComStartDate.clear()
371 371 self.proComEndDate.clear()
372 372 self.proComStartDate.setEnabled(True)
373 373 self.proComEndDate.setEnabled(True)
374 374 self.proStartTime.setEnabled(True)
375 375 self.proEndTime.setEnabled(True)
376 376 self.frame_2.setEnabled(True)
377 377
378 378 if read_mode == "Online":
379 379 self.proComStartDate.addItem("2000/01/30")
380 380 self.proComEndDate.addItem("2016/12/31")
381 381 self.proComStartDate.setEnabled(False)
382 382 self.proComEndDate.setEnabled(False)
383 383 self.proStartTime.setEnabled(False)
384 384 self.proEndTime.setEnabled(False)
385 385 self.frame_2.setEnabled(True)
386 386
387 387 self.loadDays(data_path, ext, walk)
388 388
389 389 @pyqtSignature("int")
390 390 def on_proComStartDate_activated(self, index):
391 391 """
392 392 SELECCION DEL RANGO DE FECHAS -START DATE
393 393 """
394 394 stopIndex = self.proComEndDate.count() - self.proComEndDate.currentIndex()
395 395 self.proComEndDate.clear()
396 396 for i in self.dateList[index:]:
397 397 self.proComEndDate.addItem(i)
398 398 self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - stopIndex)
399 399
400 400 @pyqtSignature("int")
401 401 def on_proComEndDate_activated(self, index):
402 402 """
403 403 SELECCION DEL RANGO DE FECHAS-END DATE
404 404 """
405 405 startIndex = self.proComStartDate.currentIndex()
406 406 stopIndex = self.proComEndDate.count() - index
407 407 self.proComStartDate.clear()
408 408 for i in self.dateList[:len(self.dateList) - stopIndex + 1]:
409 409 self.proComStartDate.addItem(i)
410 410 self.proComStartDate.setCurrentIndex(startIndex)
411 411
412 412 @pyqtSignature("")
413 413 def on_proOk_clicked(self):
414 414 """
415 415 AΓ±ade al Obj XML de Projecto, name,datatype,date,time,readmode,wait,etc, crea el readUnitProcess del archivo xml.
416 416 Prepara la configuraciΓ³n del diΓ‘grama del Arbol del treeView numero 2
417 417 """
418 418
419 419 self.actionStart.setEnabled(False)
420 420 self.actionStarToolbar.setEnabled(False)
421 421
422 422 if self.create:
423 423
424 424 projectId = self.__getNewProjectId()
425 425
426 426 if not projectId:
427 427 return 0
428 428
429 429 projectObjView = self.createProjectView(projectId)
430 430
431 431 if not projectObjView:
432 432 return 0
433 433
434 434 readUnitObj = self.createReadUnitView(projectObjView)
435 435
436 436 if not readUnitObj:
437 437 return 0
438 438
439 439 else:
440 440 projectObjView = self.updateProjectView()
441 441
442 442 if not projectObjView:
443 443 return 0
444 444
445 445 projectId = projectObjView.getId()
446 446 idReadUnit = projectObjView.getReadUnitId()
447 447 readUnitObj = self.updateReadUnitView(projectObjView, idReadUnit)
448 448
449 449 if not readUnitObj:
450 450 return 0
451 451
452 452 self.__itemTreeDict[projectId].setText(projectObjView.name)
453 453 # Project Properties
454 454 self.refreshProjectProperties(projectObjView)
455 455 # Disable tabProject after finish the creation
456 456
457 457 self.actionStart.setEnabled(True)
458 458 self.actionStarToolbar.setEnabled(True)
459 459 self.console.clear()
460 460 self.console.append("The project parameters were validated")
461 461
462 462 return 1
463 463
464 464 @pyqtSignature("")
465 465 def on_proClear_clicked(self):
466 466
467 467 self.console.clear()
468 468
469 469 @pyqtSignature("int")
470 470 def on_volOpCebChannels_stateChanged(self, p0):
471 471 """
472 472 Check Box habilita operaciones de SelecciοΏ½n de Canales
473 473 """
474 474 if p0 == 2:
475 475 self.volOpComChannels.setEnabled(True)
476 476 self.volOpChannel.setEnabled(True)
477 477
478 478 if p0 == 0:
479 479 self.volOpComChannels.setEnabled(False)
480 480 self.volOpChannel.setEnabled(False)
481 481 self.volOpChannel.clear()
482 482
483 483 @pyqtSignature("int")
484 484 def on_volOpCebHeights_stateChanged(self, p0):
485 485 """
486 486 Check Box habilita operaciones de SelecciοΏ½n de Alturas
487 487 """
488 488 if p0 == 2:
489 489 self.volOpHeights.setEnabled(True)
490 490 self.volOpComHeights.setEnabled(True)
491 491
492 492 if p0 == 0:
493 493 self.volOpHeights.setEnabled(False)
494 494 self.volOpHeights.clear()
495 495 self.volOpComHeights.setEnabled(False)
496 496
497 497 @pyqtSignature("int")
498 498 def on_volOpCebFilter_stateChanged(self, p0):
499 499 """
500 500 Name='Decoder', optype='other'
501 501 """
502 502 if p0 == 2:
503 503 self.volOpFilter.setEnabled(True)
504 504
505 505 if p0 == 0:
506 506 self.volOpFilter.setEnabled(False)
507 507 self.volOpFilter.clear()
508 508
509 509 @pyqtSignature("int")
510 510 def on_volOpCebProfile_stateChanged(self, p0):
511 511 """
512 512 Check Box habilita ingreso del rango de Perfiles
513 513 """
514 514 if p0 == 2:
515 515 self.volOpComProfile.setEnabled(True)
516 516 self.volOpProfile.setEnabled(True)
517 517
518 518 if p0 == 0:
519 519 self.volOpComProfile.setEnabled(False)
520 520 self.volOpProfile.setEnabled(False)
521 521 self.volOpProfile.clear()
522 522
523 523 @pyqtSignature("int")
524 524 def on_volOpComProfile_activated(self, index):
525 525 """
526 526 Check Box habilita ingreso del rango de Perfiles
527 527 """
528 528 #Profile List
529 529 if index == 0:
530 530 self.volOpProfile.setToolTip('List of selected profiles. Example: 0, 1, 2, 3, 4, 5, 6, 7')
531 531
532 532 #Profile Range
533 533 if index == 1:
534 534 self.volOpProfile.setToolTip('Minimum and maximum profile index. Example: 0, 7')
535 535
536 536 #Profile Range List
537 537 if index == 2:
538 538 self.volOpProfile.setToolTip('List of profile ranges. Example: (0, 7), (12, 19), (100, 200)')
539 539
540 540 @pyqtSignature("int")
541 541 def on_volOpCebDecodification_stateChanged(self, p0):
542 542 """
543 543 Check Box habilita
544 544 """
545 545 if p0 == 2:
546 546 self.volOpComCode.setEnabled(True)
547 547 self.volOpComMode.setEnabled(True)
548 548 if p0 == 0:
549 549 self.volOpComCode.setEnabled(False)
550 550 self.volOpComMode.setEnabled(False)
551 551
552 552 @pyqtSignature("int")
553 553 def on_volOpComCode_activated(self, index):
554 554 """
555 555 Check Box habilita ingreso
556 556 """
557 557 if index == 13:
558 558 self.volOpCode.setEnabled(True)
559 559 else:
560 560 self.volOpCode.setEnabled(False)
561 561
562 562 if index == 0:
563 563 code = ''
564 564 self.volOpCode.setText(str(code))
565 565 return
566 566
567 567 if index == 1:
568 568 code = '(1,1,-1)'
569 569 nCode = '1'
570 570 nBaud = '3'
571 571 if index == 2:
572 572 code = '(1,1,-1,1)'
573 573 nCode = '1'
574 574 nBaud = '4'
575 575 if index == 3:
576 576 code = '(1,1,1,-1,1)'
577 577 nCode = '1'
578 578 nBaud = '5'
579 579 if index == 4:
580 580 code = '(1,1,1,-1,-1,1,-1)'
581 581 nCode = '1'
582 582 nBaud = '7'
583 583 if index == 5:
584 584 code = '(1,1,1,-1,-1,-1,1,-1,-1,1,-1)'
585 585 nCode = '1'
586 586 nBaud = '11'
587 587 if index == 6:
588 588 code = '(1,1,1,1,1,-1,-1,1,1,-1,1,-1,1)'
589 589 nCode = '1'
590 590 nBaud = '13'
591 591 if index == 7:
592 592 code = '(1,1,-1,-1,-1,1)'
593 593 nCode = '2'
594 594 nBaud = '3'
595 595 if index == 8:
596 596 code = '(1,1,-1,1,-1,-1,1,-1)'
597 597 nCode = '2'
598 598 nBaud = '4'
599 599 if index == 9:
600 600 code = '(1,1,1,-1,1,-1,-1,-1,1,-1)'
601 601 nCode = '2'
602 602 nBaud = '5'
603 603 if index == 10:
604 604 code = '(1,1,1,-1,-1,1,-1,-1,-1,-1,1,1,-1,1)'
605 605 nCode = '2'
606 606 nBaud = '7'
607 607 if index == 11:
608 608 code = '(1,1,1,-1,-1,-1,1,-1,-1,1,-1,-1 ,-1 ,-1 ,1 ,1,1,-1 ,1 ,1 ,-1 ,1)'
609 609 nCode = '2'
610 610 nBaud = '11'
611 611 if index == 12:
612 612 code = '(1,1,1,1,1,-1,-1,1,1,-1,1,-1,1,-1,-1,-1,-1,-1,1,1,-1,-1,1,-1,1,-1)'
613 613 nCode = '2'
614 614 nBaud = '13'
615 615
616 616 code = ast.literal_eval(code)
617 617 nCode = int(nCode)
618 618 nBaud = int(nBaud)
619 619
620 620 code = numpy.asarray(code).reshape((nCode, nBaud)).tolist()
621 621
622 622 self.volOpCode.setText(str(code))
623 623
624 624 @pyqtSignature("int")
625 625 def on_volOpCebFlip_stateChanged(self, p0):
626 626 """
627 627 Check Box habilita ingresode del numero de Integraciones a realizar
628 628 """
629 629 if p0 == 2:
630 630 self.volOpFlip.setEnabled(True)
631 631 if p0 == 0:
632 632 self.volOpFlip.setEnabled(False)
633 633 self.volOpFlip.clear()
634 634
635 635 @pyqtSignature("int")
636 636 def on_volOpCebCohInt_stateChanged(self, p0):
637 637 """
638 638 Check Box habilita ingresode del numero de Integraciones a realizar
639 639 """
640 640 if p0 == 2:
641 641 self.volOpCohInt.setEnabled(True)
642 642 if p0 == 0:
643 643 self.volOpCohInt.setEnabled(False)
644 644 self.volOpCohInt.clear()
645 645
646 646 @pyqtSignature("int")
647 647 def on_volOpCebRadarfrequency_stateChanged(self, p0):
648 648 """
649 649 Check Box habilita ingresode del numero de Integraciones a realizar
650 650 """
651 651 if p0 == 2:
652 652 self.volOpRadarfrequency.setEnabled(True)
653 653 if p0 == 0:
654 654 self.volOpRadarfrequency.clear()
655 655 self.volOpRadarfrequency.setEnabled(False)
656 656
657 657 @pyqtSignature("")
658 658 def on_volOutputToolPath_clicked(self):
659 659 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
660 660 self.volOutputPath.setText(dirOutPath)
661 661
662 662 @pyqtSignature("")
663 663 def on_specOutputToolPath_clicked(self):
664 664 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
665 665 self.specOutputPath.setText(dirOutPath)
666 666
667 667 @pyqtSignature("")
668 668 def on_specHeisOutputToolPath_clicked(self):
669 669 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
670 670 self.specHeisOutputPath.setText(dirOutPath)
671 671
672 672 @pyqtSignature("")
673 673 def on_specHeisOutputMetadaToolPath_clicked(self):
674 674
675 675 filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open text file", self.pathWorkSpace, self.tr("Text Files (*.xml)")))
676 676 self.specHeisOutputMetada.setText(filename)
677 677
678 678 @pyqtSignature("")
679 679 def on_volOpOk_clicked(self):
680 680 """
681 681 BUSCA EN LA LISTA DE OPERACIONES DEL TIPO VOLTAJE Y LES AοΏ½ADE EL PARAMETRO ADECUADO ESPERANDO LA ACEPTACION DEL USUARIO
682 682 PARA AGREGARLO AL ARCHIVO DE CONFIGURACION XML
683 683 """
684 684
685 685 checkPath = False
686 686
687 687 self.actionSaveToolbar.setEnabled(False)
688 688 self.actionStarToolbar.setEnabled(False)
689 689
690 690 puObj = self.getSelectedItemObj()
691 691 puObj.removeOperations()
692 692
693 693 if self.volOpCebRadarfrequency.isChecked():
694 694 value = str(self.volOpRadarfrequency.text())
695 695 format = 'float'
696 696 name_operation = 'setRadarFrequency'
697 697 name_parameter = 'frequency'
698 698 if not value == "":
699 699 try:
700 700 radarfreq = float(self.volOpRadarfrequency.text())*1e6
701 701 except:
702 702 self.console.clear()
703 703 self.console.append("Write the parameter Radar Frequency type float")
704 704 return 0
705 705 opObj = puObj.addOperation(name=name_operation)
706 706 opObj.addParameter(name=name_parameter, value=radarfreq, format=format)
707 707
708 708 if self.volOpCebChannels.isChecked():
709 709 value = str(self.volOpChannel.text())
710 710
711 711 if value == "":
712 712 print "Please fill channel list"
713 713 return 0
714 714
715 715 format = 'intlist'
716 716 if self.volOpComChannels.currentIndex() == 0:
717 717 name_operation = "selectChannels"
718 718 name_parameter = 'channelList'
719 719 else:
720 720 name_operation = "selectChannelsByIndex"
721 721 name_parameter = 'channelIndexList'
722 722
723 723 opObj = puObj.addOperation(name=name_operation)
724 724 opObj.addParameter(name=name_parameter, value=value, format=format)
725 725
726 726 if self.volOpCebHeights.isChecked():
727 727 value = str(self.volOpHeights.text())
728 728
729 729 if value == "":
730 730 print "Please fill height range"
731 731 return 0
732 732
733 733 valueList = value.split(',')
734 734 format = 'float'
735 735 if self.volOpComHeights.currentIndex() == 0:
736 736 name_operation = 'selectHeights'
737 737 name_parameter1 = 'minHei'
738 738 name_parameter2 = 'maxHei'
739 739 else:
740 740 name_operation = 'selectHeightsByIndex'
741 741 name_parameter1 = 'minIndex'
742 742 name_parameter2 = 'maxIndex'
743 743
744 744 opObj = puObj.addOperation(name=name_operation)
745 745 opObj.addParameter(name=name_parameter1, value=valueList[0], format=format)
746 746 opObj.addParameter(name=name_parameter2, value=valueList[1], format=format)
747 747
748 748 if self.volOpCebFilter.isChecked():
749 749 value = str(self.volOpFilter.text())
750 750 if value == "":
751 751 print "Please fill filter value"
752 752 return 0
753 753
754 754 format = 'int'
755 755 name_operation = 'filterByHeights'
756 756 name_parameter = 'window'
757 757 opObj = puObj.addOperation(name=name_operation)
758 758 opObj.addParameter(name=name_parameter, value=value, format=format)
759 759
760 760 if self.volOpCebProfile.isChecked():
761 761 value = str(self.volOpProfile.text())
762 762
763 763 if value == "":
764 764 print "Please fill profile value"
765 765 return 0
766 766
767 767 format = 'intlist'
768 768 optype = 'other'
769 769 name_operation = 'ProfileSelector'
770 770 if self.volOpComProfile.currentIndex() == 0:
771 771 name_parameter = 'profileList'
772 772 if self.volOpComProfile.currentIndex() == 1:
773 773 name_parameter = 'profileRangeList'
774 774 if self.volOpComProfile.currentIndex() == 2:
775 775 name_parameter = 'rangeList'
776 776
777 777 opObj = puObj.addOperation(name='ProfileSelector', optype='other')
778 778 opObj.addParameter(name=name_parameter, value=value, format=format)
779 779
780 780 if self.volOpCebDecodification.isChecked():
781 781
782 782 if self.volOpComMode.currentIndex() == 0:
783 783 mode = '0'
784 784 if self.volOpComMode.currentIndex() == 1:
785 785 mode = '1'
786 786 if self.volOpComMode.currentIndex() == 2:
787 787 mode = '2'
788 788
789 789 if self.volOpComCode.currentIndex() == 0:
790 790 opObj = puObj.addOperation(name='Decoder', optype='other')
791 791 opObj.addParameter(name='mode', value=mode, format='int')
792 792 else:
793 793 #User defined
794 794 code = str(self.volOpCode.text())
795 795 try:
796 796 code_tmp = ast.literal_eval(code)
797 797 except:
798 798 code_tmp = []
799 799
800 800 if len(code_tmp) < 1:
801 801 self.console.append("Please fill the code value")
802 802 return 0
803 803
804 804 if len(code_tmp) == 1 or type(code_tmp[0]) != int:
805 805 nBaud = len(code_tmp[0])
806 806 nCode = len(code_tmp)
807 807 else:
808 808 nBaud = len(code_tmp)
809 809 nCode = 1
810 810
811 811 opObj = puObj.addOperation(name='Decoder', optype='other')
812 812
813 813 code = code.replace("(", "")
814 814 code = code.replace(")", "")
815 815 code = code.replace("[", "")
816 816 code = code.replace("]", "")
817 817 opObj.addParameter(name='code', value=code, format='intlist')
818 818 opObj.addParameter(name='nCode', value=nCode, format='int')
819 819 opObj.addParameter(name='nBaud', value=nBaud, format='int')
820 820 opObj.addParameter(name='mode', value=mode, format='int')
821 821
822 822 if self.volOpCebFlip.isChecked():
823 823 name_operation = 'deFlip'
824 824 optype = 'self'
825 825 value = str(self.volOpFlip.text())
826 826 name_parameter = 'channelList'
827 827 format = 'intlist'
828 828
829 829 opObj = puObj.addOperation(name=name_operation, optype=optype)
830 830 if value:
831 831 opObj.addParameter(name=name_parameter, value=value, format=format)
832 832
833 833 if self.volOpCebCohInt.isChecked():
834 834 name_operation = 'CohInt'
835 835 optype = 'other'
836 836 value = str(self.volOpCohInt.text())
837 837
838 838 if value == "":
839 839 print "Please fill number of coherent integrations"
840 840 return 0
841 841
842 842 name_parameter = 'n'
843 843 format = 'float'
844 844
845 845 opObj = puObj.addOperation(name=name_operation, optype=optype)
846 846 opObj.addParameter(name=name_parameter, value=value, format=format)
847 847
848 848 if self.volGraphCebshow.isChecked():
849 849 name_operation = 'Scope'
850 850 optype = 'other'
851 851 name_parameter = 'type'
852 852 value = 'Scope'
853 853 if self.idImagscope == 0:
854 854 self.idImagscope = 100
855 855 else:
856 856 self.idImagscope = self.idImagscope + 1
857 857
858 858 name_parameter1 = 'id'
859 859 value1 = int(self.idImagscope)
860 860 format1 = 'int'
861 861 format = 'str'
862 862
863 863 opObj = puObj.addOperation(name=name_operation, optype=optype)
864 864 # opObj.addParameter(name=name_parameter, value=value, format=format)
865 865 opObj.addParameter(name=name_parameter1, value=opObj.id, format=format1)
866 866
867 867 channelList = str(self.volGraphChannelList.text()).replace(" ","")
868 868 xvalue = str(self.volGraphfreqrange.text()).replace(" ","")
869 869 yvalue = str(self.volGraphHeightrange.text()).replace(" ","")
870 870
871 871 if channelList:
872 872 opObj.addParameter(name='channelList', value=channelList, format='intlist')
873 873
874 874 if xvalue:
875 875 xvalueList = xvalue.split(',')
876 876 try:
877 877 value0 = float(xvalueList[0])
878 878 value1 = float(xvalueList[1])
879 879 except:
880 880 return 0
881 881 opObj.addParameter(name='xmin', value=value0, format='float')
882 882 opObj.addParameter(name='xmax', value=value1, format='float')
883 883
884 884
885 885 if not yvalue == "":
886 886 yvalueList = yvalue.split(",")
887 887 try:
888 888 value0 = int(yvalueList[0])
889 889 value1 = int(yvalueList[1])
890 890 except:
891 891 return 0
892 892
893 893 opObj.addParameter(name='ymin', value=value0, format='int')
894 894 opObj.addParameter(name='ymax', value=value1, format='int')
895 895
896 896 if self.volGraphCebSave.isChecked():
897 897 checkPath = True
898 898 opObj.addParameter(name='save', value='1', format='int')
899 899 opObj.addParameter(name='figpath', value=self.volGraphPath.text(), format='str')
900 900 value = str(self.volGraphPrefix.text()).replace(" ","")
901 901 if value:
902 902 opObj.addParameter(name='figfile', value=value, format='str')
903 903
904 904 localfolder = None
905 905 if checkPath:
906 906 localfolder = str(self.volGraphPath.text())
907 907 if localfolder == '':
908 908 self.console.clear()
909 909 self.console.append("Graphic path should be defined")
910 910 return 0
911 911
912 912 # if something happend
913 913 parms_ok, output_path, blocksperfile, profilesperblock = self.checkInputsPUSave(datatype='Voltage')
914 914 if parms_ok:
915 915 name_operation = 'VoltageWriter'
916 916 optype = 'other'
917 917 name_parameter1 = 'path'
918 918 name_parameter2 = 'blocksPerFile'
919 919 name_parameter3 = 'profilesPerBlock'
920 920 value1 = output_path
921 921 value2 = blocksperfile
922 922 value3 = profilesperblock
923 923 format = "int"
924 924 opObj = puObj.addOperation(name=name_operation, optype=optype)
925 925 opObj.addParameter(name=name_parameter1, value=value1)
926 926 opObj.addParameter(name=name_parameter2, value=value2, format=format)
927 927 opObj.addParameter(name=name_parameter3, value=value3, format=format)
928 928
929 929 self.console.clear()
930 930 try:
931 931 self.refreshPUProperties(puObj)
932 932 except:
933 933 self.console.append("Check input parameters")
934 934 return 0
935 935
936 936 self.console.append("If you want to save your project")
937 937 self.console.append("click on your project name in the Tree Project Explorer")
938 938
939 939 self.actionSaveToolbar.setEnabled(True)
940 940 self.actionStarToolbar.setEnabled(True)
941 941
942 942 return 1
943 943
944 944 """
945 945 Voltage Graph
946 946 """
947 947 @pyqtSignature("int")
948 948 def on_volGraphCebSave_stateChanged(self, p0):
949 949 """
950 950 Check Box habilita ingresode del numero de Integraciones a realizar
951 951 """
952 952 if p0 == 2:
953 953 self.volGraphPath.setEnabled(True)
954 954 self.volGraphPrefix.setEnabled(True)
955 955 self.volGraphToolPath.setEnabled(True)
956 956
957 957 if p0 == 0:
958 958 self.volGraphPath.setEnabled(False)
959 959 self.volGraphPrefix.setEnabled(False)
960 960 self.volGraphToolPath.setEnabled(False)
961 961
962 962 @pyqtSignature("")
963 963 def on_volGraphToolPath_clicked(self):
964 964 """
965 965 Donde se guardan los DATOS
966 966 """
967 967 self.dataPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
968 968 self.volGraphPath.setText(self.dataPath)
969 969
970 970 # if not os.path.exists(self.dataPath):
971 971 # self.volGraphOk.setEnabled(False)
972 972 # return
973 973
974 974 @pyqtSignature("int")
975 975 def on_volGraphCebshow_stateChanged(self, p0):
976 976 """
977 977 Check Box habilita ingresode del numero de Integraciones a realizar
978 978 """
979 979 if p0 == 0:
980 980
981 981 self.volGraphChannelList.setEnabled(False)
982 982 self.volGraphfreqrange.setEnabled(False)
983 983 self.volGraphHeightrange.setEnabled(False)
984 984 if p0 == 2:
985 985
986 986 self.volGraphChannelList.setEnabled(True)
987 987 self.volGraphfreqrange.setEnabled(True)
988 988 self.volGraphHeightrange.setEnabled(True)
989 989
990 990 """
991 991 Spectra operation
992 992 """
993 993 @pyqtSignature("int")
994 994 def on_specOpCebRadarfrequency_stateChanged(self, p0):
995 995 """
996 996 Check Box habilita ingresode del numero de Integraciones a realizar
997 997 """
998 998 if p0 == 2:
999 999 self.specOpRadarfrequency.setEnabled(True)
1000 1000 if p0 == 0:
1001 1001 self.specOpRadarfrequency.clear()
1002 1002 self.specOpRadarfrequency.setEnabled(False)
1003 1003
1004 1004
1005 1005 @pyqtSignature("int")
1006 1006 def on_specOpCebCrossSpectra_stateChanged(self, p0):
1007 1007 """
1008 1008 Habilita la opcion de aοΏ½adir el parοΏ½metro CrossSpectra a la Unidad de Procesamiento .
1009 1009 """
1010 1010 if p0 == 2:
1011 1011 # self.specOpnFFTpoints.setEnabled(True)
1012 1012 self.specOppairsList.setEnabled(True)
1013 1013 if p0 == 0:
1014 1014 # self.specOpnFFTpoints.setEnabled(False)
1015 1015 self.specOppairsList.setEnabled(False)
1016 1016
1017 1017 @pyqtSignature("int")
1018 1018 def on_specOpCebChannel_stateChanged(self, p0):
1019 1019 """
1020 1020 Habilita la opcion de aοΏ½adir el parοΏ½metro numero de Canales a la Unidad de Procesamiento .
1021 1021 """
1022 1022 if p0 == 2:
1023 1023 self.specOpChannel.setEnabled(True)
1024 1024 self.specOpComChannel.setEnabled(True)
1025 1025 if p0 == 0:
1026 1026 self.specOpChannel.setEnabled(False)
1027 1027 self.specOpComChannel.setEnabled(False)
1028 1028
1029 1029 @pyqtSignature("int")
1030 1030 def on_specOpCebHeights_stateChanged(self, p0):
1031 1031 """
1032 1032 Habilita la opcion de aοΏ½adir el parοΏ½metro de alturas a la Unidad de Procesamiento .
1033 1033 """
1034 1034 if p0 == 2:
1035 1035 self.specOpComHeights.setEnabled(True)
1036 1036 self.specOpHeights.setEnabled(True)
1037 1037 if p0 == 0:
1038 1038 self.specOpComHeights.setEnabled(False)
1039 1039 self.specOpHeights.setEnabled(False)
1040 1040
1041 1041
1042 1042 @pyqtSignature("int")
1043 1043 def on_specOpCebIncoherent_stateChanged(self, p0):
1044 1044 """
1045 1045 Habilita la opcion de aοΏ½adir el parοΏ½metro integraciones incoherentes a la Unidad de Procesamiento .
1046 1046 """
1047 1047 if p0 == 2:
1048 1048 self.specOpIncoherent.setEnabled(True)
1049 1049 if p0 == 0:
1050 1050 self.specOpIncoherent.setEnabled(False)
1051 1051
1052 1052 @pyqtSignature("int")
1053 1053 def on_specOpCebRemoveDC_stateChanged(self, p0):
1054 1054 """
1055 1055 Habilita la opcion de aοΏ½adir el parοΏ½metro remover DC a la Unidad de Procesamiento .
1056 1056 """
1057 1057 if p0 == 2:
1058 1058 self.specOpComRemoveDC.setEnabled(True)
1059 1059 if p0 == 0:
1060 1060 self.specOpComRemoveDC.setEnabled(False)
1061 1061
1062 1062 @pyqtSignature("int")
1063 1063 def on_specOpCebgetNoise_stateChanged(self, p0):
1064 1064 """
1065 1065 Habilita la opcion de aοΏ½adir la estimacion de ruido a la Unidad de Procesamiento .
1066 1066 """
1067 1067 if p0 == 2:
1068 1068 self.specOpgetNoise.setEnabled(True)
1069 1069
1070 1070 if p0 == 0:
1071 1071 self.specOpgetNoise.setEnabled(False)
1072 1072
1073 1073 @pyqtSignature("")
1074 1074 def on_specOpOk_clicked(self):
1075 1075 """
1076 1076 AΓ‘ADE OPERACION SPECTRA
1077 1077 """
1078 1078
1079 1079 addFTP = False
1080 1080 checkPath = False
1081 1081
1082 1082 self.actionSaveToolbar.setEnabled(False)
1083 1083 self.actionStarToolbar.setEnabled(False)
1084 1084
1085 1085 projectObj = self.getSelectedProjectObj()
1086 1086 puObj = self.getSelectedItemObj()
1087 1087
1088 1088 puObj.removeOperations()
1089 1089
1090 1090 if self.specOpCebRadarfrequency.isChecked():
1091 1091 value = self.specOpRadarfrequency.text()
1092 1092 format = 'float'
1093 1093 name_operation = 'setRadarFrequency'
1094 1094 name_parameter = 'frequency'
1095 1095 if not value == "":
1096 1096 try:
1097 1097 radarfreq = float(self.specOpRadarfrequency.text())*1e6
1098 1098 except:
1099 1099 self.console.clear()
1100 1100 self.console.append("Write the parameter Radar Frequency type float")
1101 1101 return 0
1102 1102 opObj = puObj.addOperation(name=name_operation)
1103 1103 opObj.addParameter(name=name_parameter, value=radarfreq, format=format)
1104 1104
1105 1105 inputId = puObj.getInputId()
1106 1106 inputPuObj = projectObj.getProcUnitObj(inputId)
1107 1107
1108 1108 if inputPuObj.datatype == 'Voltage' or inputPuObj.datatype == 'USRP':
1109 1109
1110 1110 try:
1111 1111 value = int(self.specOpnFFTpoints.text())
1112 1112 puObj.addParameter(name='nFFTPoints', value=value, format='int')
1113 1113 except:
1114 1114 self.console.clear()
1115 1115 self.console.append("Please write the number of FFT")
1116 1116 return 0
1117 1117
1118 1118 try:
1119 1119 value1 = int(self.specOpProfiles.text())
1120 1120 puObj.addParameter(name='nProfiles', value=value1, format='int')
1121 1121 except:
1122 1122 self.console.append("Please Write the number of Profiles")
1123 1123
1124 1124 try:
1125 1125 value2 = int(self.specOpippFactor.text())
1126 1126 puObj.addParameter(name='ippFactor' , value=value2 , format='int')
1127 1127 except:
1128 1128 self.console.append("Please Write the Number of IppFactor")
1129 1129
1130 1130
1131 1131 if self.specOpCebCrossSpectra.isChecked():
1132 1132 name_parameter = 'pairsList'
1133 1133 format = 'pairslist'
1134 1134 value2 = self.specOppairsList.text()
1135 1135
1136 1136 if value2 == "":
1137 1137 print "Please fill the pairs list field"
1138 1138 return 0
1139 1139
1140 1140 puObj.addParameter(name=name_parameter, value=value2, format=format)
1141 1141
1142 1142 if self.specOpCebHeights.isChecked():
1143 1143 value = str(self.specOpHeights.text())
1144 1144
1145 1145 if value == "":
1146 1146 print "Please fill height range"
1147 1147 return 0
1148 1148
1149 1149 valueList = value.split(',')
1150 1150 format = 'float'
1151 1151 value0 = valueList[0]
1152 1152 value1 = valueList[1]
1153 1153
1154 1154 if self.specOpComHeights.currentIndex() == 0:
1155 1155 name_operation = 'selectHeights'
1156 1156 name_parameter1 = 'minHei'
1157 1157 name_parameter2 = 'maxHei'
1158 1158 else:
1159 1159 name_operation = 'selectHeightsByIndex'
1160 1160 name_parameter1 = 'minIndex'
1161 1161 name_parameter2 = 'maxIndex'
1162 1162 opObj = puObj.addOperation(name=name_operation)
1163 1163 opObj.addParameter(name=name_parameter1, value=value0, format=format)
1164 1164 opObj.addParameter(name=name_parameter2, value=value1, format=format)
1165 1165
1166 1166 if self.specOpCebChannel.isChecked():
1167 1167 value = str(self.specOpChannel.text())
1168 1168
1169 1169 if value == "":
1170 1170 print "Please fill channel list"
1171 1171 return 0
1172 1172
1173 1173 format = 'intlist'
1174 1174 if self.specOpComChannel.currentIndex() == 0:
1175 1175 name_operation = "selectChannels"
1176 1176 name_parameter = 'channelList'
1177 1177 else:
1178 1178 name_operation = "selectChannelsByIndex"
1179 1179 name_parameter = 'channelIndexList'
1180 1180
1181 1181 opObj = puObj.addOperation(name=name_operation)
1182 1182 opObj.addParameter(name=name_parameter, value=value, format=format)
1183 1183
1184 1184 if self.specOpCebIncoherent.isChecked():
1185 1185 value = str(self.specOpIncoherent.text())
1186 1186
1187 1187 if value == "":
1188 1188 print "Please fill Incoherent integration value"
1189 1189 return 0
1190 1190
1191 1191 name_operation = 'IncohInt'
1192 1192 optype = 'other'
1193 1193 if self.specOpCobIncInt.currentIndex() == 0:
1194 1194 name_parameter = 'timeInterval'
1195 1195 format = 'float'
1196 1196 else:
1197 1197 name_parameter = 'n'
1198 1198 format = 'float'
1199 1199
1200 1200 opObj = puObj.addOperation(name=name_operation, optype=optype)
1201 1201 opObj.addParameter(name=name_parameter, value=value, format=format)
1202 1202
1203 1203 if self.specOpCebRemoveDC.isChecked():
1204 1204 name_operation = 'removeDC'
1205 1205 name_parameter = 'mode'
1206 1206 format = 'int'
1207 1207 if self.specOpComRemoveDC.currentIndex() == 0:
1208 1208 value = 1
1209 1209 else:
1210 1210 value = 2
1211 1211 opObj = puObj.addOperation(name=name_operation)
1212 1212 opObj.addParameter(name=name_parameter, value=value, format=format)
1213 1213
1214 1214 if self.specOpCebRemoveInt.isChecked():
1215 1215 name_operation = 'removeInterference'
1216 1216 opObj = puObj.addOperation(name=name_operation)
1217 1217
1218 1218
1219 1219 if self.specOpCebgetNoise.isChecked():
1220 1220 value = self.specOpgetNoise.text()
1221 1221 valueList = value.split(',')
1222 1222 format = 'float'
1223 1223 name_operation = "getNoise"
1224 1224 opObj = puObj.addOperation(name=name_operation)
1225 1225
1226 1226 if not value == '':
1227 1227 valueList = value.split(',')
1228 1228 length = len(valueList)
1229 1229 if length == 1:
1230 1230 try:
1231 1231 value1 = float(valueList[0])
1232 1232 except:
1233 1233 self.console.clear()
1234 1234 self.console.append("Please Write correct parameter Get Noise")
1235 1235 return 0
1236 1236 name1 = 'minHei'
1237 1237 opObj.addParameter(name=name1, value=value1, format=format)
1238 1238 elif length == 2:
1239 1239 try:
1240 1240 value1 = float(valueList[0])
1241 1241 value2 = float(valueList[1])
1242 1242 except:
1243 1243 self.console.clear()
1244 1244 self.console.append("Please Write corrects parameter Get Noise")
1245 1245 return 0
1246 1246 name1 = 'minHei'
1247 1247 name2 = 'maxHei'
1248 1248 opObj.addParameter(name=name1, value=value1, format=format)
1249 1249 opObj.addParameter(name=name2, value=value2, format=format)
1250 1250
1251 1251 elif length == 3:
1252 1252 try:
1253 1253 value1 = float(valueList[0])
1254 1254 value2 = float(valueList[1])
1255 1255 value3 = float(valueList[2])
1256 1256 except:
1257 1257 self.console.clear()
1258 1258 self.console.append("Please Write corrects parameter Get Noise")
1259 1259 return 0
1260 1260 name1 = 'minHei'
1261 1261 name2 = 'maxHei'
1262 1262 name3 = 'minVel'
1263 1263 opObj.addParameter(name=name1, value=value1, format=format)
1264 1264 opObj.addParameter(name=name2, value=value2, format=format)
1265 1265 opObj.addParameter(name=name3, value=value3, format=format)
1266 1266
1267 1267 elif length == 4:
1268 1268 try:
1269 1269 value1 = float(valueList[0])
1270 1270 value2 = float(valueList[1])
1271 1271 value3 = float(valueList[2])
1272 1272 value4 = float(valueList[3])
1273 1273 except:
1274 1274 self.console.clear()
1275 1275 self.console.append("Please Write corrects parameter Get Noise")
1276 1276 return 0
1277 1277 name1 = 'minHei'
1278 1278 name2 = 'maxHei'
1279 1279 name3 = 'minVel'
1280 1280 name4 = 'maxVel'
1281 1281 opObj.addParameter(name=name1, value=value1, format=format)
1282 1282 opObj.addParameter(name=name2, value=value2, format=format)
1283 1283 opObj.addParameter(name=name3, value=value3, format=format)
1284 1284 opObj.addParameter(name=name4, value=value4, format=format)
1285 1285
1286 1286 elif length > 4:
1287 1287 self.console.clear()
1288 1288 self.console.append("Get Noise Operation only accepts 4 parameters")
1289 1289 return 0
1290 1290
1291 1291 channelList = str(self.specGgraphChannelList.text()).replace(" ","")
1292 1292 vel_range = str(self.specGgraphFreq.text()).replace(" ","")
1293 1293 hei_range = str(self.specGgraphHeight.text()).replace(" ","")
1294 1294 db_range = str(self.specGgraphDbsrange.text()).replace(" ","")
1295 1295
1296 1296 trange = str(self.specGgraphTminTmax.text()).replace(" ","")
1297 1297 magrange = str(self.specGgraphmagnitud.text()).replace(" ","")
1298 1298 phaserange = str(self.specGgraphPhase.text()).replace(" ","")
1299 1299 # timerange = str(self.specGgraphTimeRange.text()).replace(" ","")
1300 1300
1301 1301 figpath = str(self.specGraphPath.text())
1302 1302 figfile = str(self.specGraphPrefix.text()).replace(" ","")
1303 1303 try:
1304 1304 wrperiod = int(str(self.specGgraphftpratio.text()).replace(" ",""))
1305 1305 except:
1306 1306 wrperiod = None
1307 1307
1308 1308 #-----Spectra Plot-----
1309 1309 if self.specGraphCebSpectraplot.isChecked():
1310 1310
1311 1311 opObj = puObj.addOperation(name='SpectraPlot', optype='other')
1312 1312 opObj.addParameter(name='id', value=opObj.id, format='int')
1313 1313
1314 1314 if not channelList == '':
1315 1315 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1316 1316
1317 1317 if not vel_range == '':
1318 1318 xvalueList = vel_range.split(',')
1319 1319 try:
1320 1320 value1 = float(xvalueList[0])
1321 1321 value2 = float(xvalueList[1])
1322 1322 except:
1323 1323 self.console.clear()
1324 1324 self.console.append("Invalid velocity/frequency range")
1325 1325 return 0
1326 1326
1327 1327 opObj.addParameter(name='xmin', value=value1, format='float')
1328 1328 opObj.addParameter(name='xmax', value=value2, format='float')
1329 1329
1330 1330 if not hei_range == '':
1331 1331 yvalueList = hei_range.split(",")
1332 1332 try:
1333 1333 value1 = float(yvalueList[0])
1334 1334 value2 = float(yvalueList[1])
1335 1335 except:
1336 1336 self.console.clear()
1337 1337 self.console.append("Invalid height range")
1338 1338 return 0
1339 1339
1340 1340 opObj.addParameter(name='ymin', value=value1, format='float')
1341 1341 opObj.addParameter(name='ymax', value=value2, format='float')
1342 1342
1343 1343 if not db_range == '':
1344 1344 zvalueList = db_range.split(",")
1345 1345 try:
1346 1346 value1 = float(zvalueList[0])
1347 1347 value2 = float(zvalueList[1])
1348 1348 except:
1349 1349 self.console.clear()
1350 1350 self.console.append("Invalid db range")
1351 1351 return 0
1352 1352
1353 1353 opObj.addParameter(name='zmin', value=value1, format='float')
1354 1354 opObj.addParameter(name='zmax', value=value2, format='float')
1355 1355
1356 1356 if self.specGraphSaveSpectra.isChecked():
1357 1357 checkPath = True
1358 1358 opObj.addParameter(name='save', value=1 , format='bool')
1359 1359 opObj.addParameter(name='figpath', value=figpath, format='str')
1360 1360 if figfile:
1361 1361 opObj.addParameter(name='figfile', value=figfile, format='str')
1362 1362 if wrperiod:
1363 1363 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1364 1364
1365 1365 if self.specGraphftpSpectra.isChecked():
1366 1366 opObj.addParameter(name='ftp', value='1', format='int')
1367 1367 self.addFTPConf2Operation(puObj, opObj)
1368 1368 addFTP = True
1369 1369
1370 1370 if self.specGraphCebCrossSpectraplot.isChecked():
1371 1371
1372 1372 opObj = puObj.addOperation(name='CrossSpectraPlot', optype='other')
1373 1373 # opObj.addParameter(name='power_cmap', value='jet', format='str')
1374 1374 # opObj.addParameter(name='coherence_cmap', value='jet', format='str')
1375 1375 # opObj.addParameter(name='phase_cmap', value='RdBu_r', format='str')
1376 1376 opObj.addParameter(name='id', value=opObj.id, format='int')
1377 1377
1378 1378 if not vel_range == '':
1379 1379 xvalueList = vel_range.split(',')
1380 1380 try:
1381 1381 value1 = float(xvalueList[0])
1382 1382 value2 = float(xvalueList[1])
1383 1383 except:
1384 1384 self.console.clear()
1385 1385 self.console.append("Invalid velocity/frequency range")
1386 1386 return 0
1387 1387
1388 1388 opObj.addParameter(name='xmin', value=value1, format='float')
1389 1389 opObj.addParameter(name='xmax', value=value2, format='float')
1390 1390
1391 1391 if not hei_range == '':
1392 1392 yvalueList = hei_range.split(",")
1393 1393 try:
1394 1394 value1 = float(yvalueList[0])
1395 1395 value2 = float(yvalueList[1])
1396 1396 except:
1397 1397 self.console.clear()
1398 1398 self.console.append("Invalid height range")
1399 1399 return 0
1400 1400
1401 1401 opObj.addParameter(name='ymin', value=value1, format='float')
1402 1402 opObj.addParameter(name='ymax', value=value2, format='float')
1403 1403
1404 1404 if not db_range == '':
1405 1405 zvalueList = db_range.split(",")
1406 1406 try:
1407 1407 value1 = float(zvalueList[0])
1408 1408 value2 = float(zvalueList[1])
1409 1409 except:
1410 1410 self.console.clear()
1411 1411 self.console.append("Invalid db range")
1412 1412 return 0
1413 1413
1414 1414 opObj.addParameter(name='zmin', value=value1, format='float')
1415 1415 opObj.addParameter(name='zmax', value=value2, format='float')
1416 1416
1417 1417 if not magrange == '':
1418 1418 zvalueList = magrange.split(",")
1419 1419 try:
1420 1420 value1 = float(zvalueList[0])
1421 1421 value2 = float(zvalueList[1])
1422 1422 except:
1423 1423 self.console.clear()
1424 1424 self.console.append("Invalid magnitude range")
1425 1425 return 0
1426 1426
1427 1427 opObj.addParameter(name='coh_min', value=value1, format='float')
1428 1428 opObj.addParameter(name='coh_max', value=value2, format='float')
1429 1429
1430 1430 if not phaserange == '':
1431 1431 zvalueList = phaserange.split(",")
1432 1432 try:
1433 1433 value1 = float(zvalueList[0])
1434 1434 value2 = float(zvalueList[1])
1435 1435 except:
1436 1436 self.console.clear()
1437 1437 self.console.append("Invalid phase range")
1438 1438 return 0
1439 1439
1440 1440 opObj.addParameter(name='phase_min', value=value1, format='float')
1441 1441 opObj.addParameter(name='phase_max', value=value2, format='float')
1442 1442
1443 1443 if self.specGraphSaveCross.isChecked():
1444 1444 checkPath = True
1445 1445 opObj.addParameter(name='save', value='1', format='bool')
1446 1446 opObj.addParameter(name='figpath', value=figpath, format='str')
1447 1447 if figfile:
1448 1448 opObj.addParameter(name='figfile', value=figfile, format='str')
1449 1449 if wrperiod:
1450 1450 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1451 1451
1452 1452 if self.specGraphftpCross.isChecked():
1453 1453 opObj.addParameter(name='ftp', value='1', format='int')
1454 1454 self.addFTPConf2Operation(puObj, opObj)
1455 1455 addFTP = True
1456 1456
1457 1457 if self.specGraphCebRTIplot.isChecked():
1458 1458
1459 1459 opObj = puObj.addOperation(name='RTIPlot', optype='other')
1460 1460 opObj.addParameter(name='id', value=opObj.id, format='int')
1461 1461
1462 1462 if not channelList == '':
1463 1463 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1464 1464
1465 1465 if not trange == '':
1466 1466 xvalueList = trange.split(',')
1467 1467 try:
1468 1468 value1 = float(xvalueList[0])
1469 1469 value2 = float(xvalueList[1])
1470 1470 except:
1471 1471 self.console.clear()
1472 1472 self.console.append("Invalid time range")
1473 1473 return 0
1474 1474
1475 1475 opObj.addParameter(name='xmin', value=value1, format='float')
1476 1476 opObj.addParameter(name='xmax', value=value2, format='float')
1477 1477
1478 1478 # if not timerange == '':
1479 1479 # try:
1480 1480 # timerange = float(timerange)
1481 1481 # except:
1482 1482 # self.console.clear()
1483 1483 # self.console.append("Invalid time range")
1484 1484 # return 0
1485 1485 #
1486 1486 # opObj.addParameter(name='timerange', value=timerange, format='float')
1487 1487
1488 1488 if not hei_range == '':
1489 1489 yvalueList = hei_range.split(",")
1490 1490 try:
1491 1491 value1 = float(yvalueList[0])
1492 1492 value2 = float(yvalueList[1])
1493 1493 except:
1494 1494 self.console.clear()
1495 1495 self.console.append("Invalid height range")
1496 1496 return 0
1497 1497
1498 1498 opObj.addParameter(name='ymin', value=value1, format='float')
1499 1499 opObj.addParameter(name='ymax', value=value2, format='float')
1500 1500
1501 1501 if not db_range == '':
1502 1502 zvalueList = db_range.split(",")
1503 1503 try:
1504 1504 value1 = float(zvalueList[0])
1505 1505 value2 = float(zvalueList[1])
1506 1506 except:
1507 1507 self.console.clear()
1508 1508 self.console.append("Invalid db range")
1509 1509 return 0
1510 1510
1511 1511 opObj.addParameter(name='zmin', value=value1, format='float')
1512 1512 opObj.addParameter(name='zmax', value=value2, format='float')
1513 1513
1514 1514 if self.specGraphSaveRTIplot.isChecked():
1515 1515 checkPath = True
1516 1516 opObj.addParameter(name='save', value='1', format='bool')
1517 1517 opObj.addParameter(name='figpath', value=figpath, format='str')
1518 1518 if figfile:
1519 1519 opObj.addParameter(name='figfile', value=value, format='str')
1520 1520 if wrperiod:
1521 1521 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1522 1522
1523 1523 if self.specGraphftpRTIplot.isChecked():
1524 1524 opObj.addParameter(name='ftp', value='1', format='int')
1525 1525 self.addFTPConf2Operation(puObj, opObj)
1526 1526 addFTP = True
1527 1527
1528 1528 if self.specGraphCebCoherencmap.isChecked():
1529 1529
1530 1530 opObj = puObj.addOperation(name='CoherenceMap', optype='other')
1531 1531 # opObj.addParameter(name=name_parameter, value=value, format=format)
1532 1532 # opObj.addParameter(name='coherence_cmap', value='jet', format='str')
1533 1533 # opObj.addParameter(name='phase_cmap', value='RdBu_r', format='str')
1534 1534 opObj.addParameter(name='id', value=opObj.id, format='int')
1535 1535
1536 1536 # if not timerange == '':
1537 1537 # try:
1538 1538 # timerange = int(timerange)
1539 1539 # except:
1540 1540 # self.console.clear()
1541 1541 # self.console.append("Invalid time range")
1542 1542 # return 0
1543 1543 #
1544 1544 # opObj.addParameter(name='timerange', value=timerange, format='int')
1545 1545
1546 1546 if not trange == '':
1547 1547 xvalueList = trange.split(',')
1548 1548 try:
1549 1549 value1 = float(xvalueList[0])
1550 1550 value2 = float(xvalueList[1])
1551 1551 except:
1552 1552 self.console.clear()
1553 1553 self.console.append("Invalid time range")
1554 1554 return 0
1555 1555
1556 1556 opObj.addParameter(name='xmin', value=value1, format='float')
1557 1557 opObj.addParameter(name='xmax', value=value2, format='float')
1558 1558
1559 1559 if not hei_range == '':
1560 1560 yvalueList = hei_range.split(",")
1561 1561 try:
1562 1562 value1 = float(yvalueList[0])
1563 1563 value2 = float(yvalueList[1])
1564 1564 except:
1565 1565 self.console.clear()
1566 1566 self.console.append("Invalid height range")
1567 1567 return 0
1568 1568
1569 1569 opObj.addParameter(name='ymin', value=value1, format='float')
1570 1570 opObj.addParameter(name='ymax', value=value2, format='float')
1571 1571
1572 1572 if not magrange == '':
1573 1573 zvalueList = magrange.split(",")
1574 1574 try:
1575 1575 value1 = float(zvalueList[0])
1576 1576 value2 = float(zvalueList[1])
1577 1577 except:
1578 1578 self.console.clear()
1579 1579 self.console.append("Invalid magnitude range")
1580 1580 return 0
1581 1581
1582 1582 opObj.addParameter(name='zmin', value=value1, format='float')
1583 1583 opObj.addParameter(name='zmax', value=value2, format='float')
1584 1584
1585 1585 if not phaserange == '':
1586 1586 zvalueList = phaserange.split(",")
1587 1587 try:
1588 1588 value1 = float(zvalueList[0])
1589 1589 value2 = float(zvalueList[1])
1590 1590 except:
1591 1591 self.console.clear()
1592 1592 self.console.append("Invalid phase range")
1593 1593 return 0
1594 1594
1595 1595 opObj.addParameter(name='phase_min', value=value1, format='float')
1596 1596 opObj.addParameter(name='phase_max', value=value2, format='float')
1597 1597
1598 1598 if self.specGraphSaveCoherencemap.isChecked():
1599 1599 checkPath = True
1600 1600 opObj.addParameter(name='save', value='1', format='bool')
1601 1601 opObj.addParameter(name='figpath', value=figpath, format='str')
1602 1602 if figfile:
1603 1603 opObj.addParameter(name='figfile', value=value, format='str')
1604 1604 if wrperiod:
1605 1605 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1606 1606
1607 1607 if self.specGraphftpCoherencemap.isChecked():
1608 1608 opObj.addParameter(name='ftp', value='1', format='int')
1609 1609 self.addFTPConf2Operation(puObj, opObj)
1610 1610 addFTP = True
1611 1611
1612 1612 if self.specGraphPowerprofile.isChecked():
1613 1613
1614 1614 opObj = puObj.addOperation(name='PowerProfilePlot', optype='other')
1615 1615 opObj.addParameter(name='id', value=opObj.id, format='int')
1616 1616
1617 1617 if not channelList == '':
1618 1618 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1619 1619
1620 1620 if not db_range == '':
1621 1621 xvalueList = db_range.split(',')
1622 1622 try:
1623 1623 value1 = float(xvalueList[0])
1624 1624 value2 = float(xvalueList[1])
1625 1625 except:
1626 1626 self.console.clear()
1627 1627 self.console.append("Invalid db range")
1628 1628 return 0
1629 1629
1630 1630 opObj.addParameter(name='xmin', value=value1, format='float')
1631 1631 opObj.addParameter(name='xmax', value=value2, format='float')
1632 1632
1633 1633 if not hei_range == '':
1634 1634 yvalueList = hei_range.split(",")
1635 1635 try:
1636 1636 value1 = float(yvalueList[0])
1637 1637 value2 = float(yvalueList[1])
1638 1638 except:
1639 1639 self.console.clear()
1640 1640 self.console.append("Invalid height range")
1641 1641 return 0
1642 1642
1643 1643 opObj.addParameter(name='ymin', value=value1, format='float')
1644 1644 opObj.addParameter(name='ymax', value=value2, format='float')
1645 1645
1646 1646 if self.specGraphSavePowerprofile.isChecked():
1647 1647 checkPath = True
1648 1648 opObj.addParameter(name='save', value='1', format='bool')
1649 1649 opObj.addParameter(name='figpath', value=figpath, format='str')
1650 1650 if figfile:
1651 1651 opObj.addParameter(name='figfile', value=value, format='str')
1652 1652 if wrperiod:
1653 1653 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1654 1654
1655 1655 if self.specGraphftpPowerprofile.isChecked():
1656 1656 opObj.addParameter(name='ftp', value='1', format='int')
1657 1657 self.addFTPConf2Operation(puObj, opObj)
1658 1658 addFTP = True
1659 1659 # rti noise
1660 1660
1661 1661 if self.specGraphCebRTInoise.isChecked():
1662 1662
1663 1663 opObj = puObj.addOperation(name='Noise', optype='other')
1664 1664 opObj.addParameter(name='id', value=opObj.id, format='int')
1665 1665
1666 1666 if not channelList == '':
1667 1667 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1668 1668
1669 1669 # if not timerange == '':
1670 1670 # try:
1671 1671 # timerange = float(timerange)
1672 1672 # except:
1673 1673 # self.console.clear()
1674 1674 # self.console.append("Invalid time range")
1675 1675 # return 0
1676 1676 #
1677 1677 # opObj.addParameter(name='timerange', value=timerange, format='float')
1678 1678
1679 1679 if not trange == '':
1680 1680 xvalueList = trange.split(',')
1681 1681 try:
1682 1682 value1 = float(xvalueList[0])
1683 1683 value2 = float(xvalueList[1])
1684 1684 except:
1685 1685 self.console.clear()
1686 1686 self.console.append("Invalid time range")
1687 1687 return 0
1688 1688
1689 1689 opObj.addParameter(name='xmin', value=value1, format='float')
1690 1690 opObj.addParameter(name='xmax', value=value2, format='float')
1691 1691
1692 1692 if not db_range == '':
1693 1693 yvalueList = db_range.split(",")
1694 1694 try:
1695 1695 value1 = float(yvalueList[0])
1696 1696 value2 = float(yvalueList[1])
1697 1697 except:
1698 1698 self.console.clear()
1699 1699 self.console.append("Invalid db range")
1700 1700 return 0
1701 1701
1702 1702 opObj.addParameter(name='ymin', value=value1, format='float')
1703 1703 opObj.addParameter(name='ymax', value=value2, format='float')
1704 1704
1705 1705 if self.specGraphSaveRTInoise.isChecked():
1706 1706 checkPath = True
1707 1707 opObj.addParameter(name='save', value='1', format='bool')
1708 1708 opObj.addParameter(name='figpath', value=figpath, format='str')
1709 1709 if figfile:
1710 1710 opObj.addParameter(name='figfile', value=value, format='str')
1711 1711 if wrperiod:
1712 1712 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1713 1713
1714 1714 # test_ftp
1715 1715 if self.specGraphftpRTInoise.isChecked():
1716 1716 opObj.addParameter(name='ftp', value='1', format='int')
1717 1717 self.addFTPConf2Operation(puObj, opObj)
1718 1718 addFTP = True
1719 1719
1720 1720 if checkPath:
1721 1721 if not figpath:
1722 1722 self.console.clear()
1723 1723 self.console.append("Graphic path should be defined")
1724 1724 return 0
1725 1725
1726 1726 if addFTP and not figpath:
1727 1727 self.console.clear()
1728 1728 self.console.append("You have to save the plots before sending them to FTP Server")
1729 1729 return 0
1730 1730
1731 1731 # if something happend
1732 1732 parms_ok, output_path, blocksperfile, profilesperblock = self.checkInputsPUSave(datatype='Spectra')
1733 1733 if parms_ok:
1734 1734 opObj = puObj.addOperation(name='SpectraWriter', optype='other')
1735 1735 opObj.addParameter(name='path', value=output_path)
1736 1736 opObj.addParameter(name='blocksPerFile', value=blocksperfile, format='int')
1737 1737 opObj.addParameter(name='profilesPerBlock', value=profilesperblock, format='int')
1738 1738
1739 1739 self.console.clear()
1740 1740 try:
1741 1741 self.refreshPUProperties(puObj)
1742 1742 except:
1743 1743 self.console.append("Check input parameters")
1744 1744 return 0
1745 1745
1746 1746 self.console.append("If you want to save your project")
1747 1747 self.console.append("click on your project name in the Tree Project Explorer")
1748 1748
1749 1749 self.actionSaveToolbar.setEnabled(True)
1750 1750 self.actionStarToolbar.setEnabled(True)
1751 1751
1752 1752 return 1
1753 1753
1754 1754 """
1755 1755 Spectra Graph
1756 1756 """
1757 1757 @pyqtSignature("int")
1758 1758 def on_specGraphCebSpectraplot_stateChanged(self, p0):
1759 1759
1760 1760 self.__checkSpecGraphFilters()
1761 1761
1762 1762
1763 1763 @pyqtSignature("int")
1764 1764 def on_specGraphCebCrossSpectraplot_stateChanged(self, p0):
1765 1765
1766 1766 self.__checkSpecGraphFilters()
1767 1767
1768 1768 @pyqtSignature("int")
1769 1769 def on_specGraphCebRTIplot_stateChanged(self, p0):
1770 1770
1771 1771 self.__checkSpecGraphFilters()
1772 1772
1773 1773
1774 1774 @pyqtSignature("int")
1775 1775 def on_specGraphCebRTInoise_stateChanged(self, p0):
1776 1776
1777 1777 self.__checkSpecGraphFilters()
1778 1778
1779 1779
1780 1780 @pyqtSignature("int")
1781 1781 def on_specGraphCebCoherencmap_stateChanged(self, p0):
1782 1782
1783 1783 self.__checkSpecGraphFilters()
1784 1784
1785 1785 @pyqtSignature("int")
1786 1786 def on_specGraphPowerprofile_stateChanged(self, p0):
1787 1787
1788 1788 self.__checkSpecGraphFilters()
1789 1789
1790 1790 @pyqtSignature("int")
1791 1791 def on_specGraphPhase_stateChanged(self, p0):
1792 1792
1793 1793 self.__checkSpecGraphFilters()
1794 1794
1795 1795 @pyqtSignature("int")
1796 1796 def on_specGraphSaveSpectra_stateChanged(self, p0):
1797 1797 """
1798 1798 """
1799 1799 self.__checkSpecGraphSaving()
1800 1800
1801 1801 @pyqtSignature("int")
1802 1802 def on_specGraphSaveCross_stateChanged(self, p0):
1803 1803
1804 1804 self.__checkSpecGraphSaving()
1805 1805
1806 1806 @pyqtSignature("int")
1807 1807 def on_specGraphSaveRTIplot_stateChanged(self, p0):
1808 1808
1809 1809 self.__checkSpecGraphSaving()
1810 1810
1811 1811 @pyqtSignature("int")
1812 1812 def on_specGraphSaveRTInoise_stateChanged(self, p0):
1813 1813
1814 1814 self.__checkSpecGraphSaving()
1815 1815
1816 1816 @pyqtSignature("int")
1817 1817 def on_specGraphSaveCoherencemap_stateChanged(self, p0):
1818 1818
1819 1819 self.__checkSpecGraphSaving()
1820 1820
1821 1821 @pyqtSignature("int")
1822 1822 def on_specGraphSavePowerprofile_stateChanged(self, p0):
1823 1823
1824 1824 self.__checkSpecGraphSaving()
1825 1825
1826 1826 @pyqtSignature("int")
1827 1827 def on_specGraphftpSpectra_stateChanged(self, p0):
1828 1828 """
1829 1829 """
1830 1830 self.__checkSpecGraphFTP()
1831 1831
1832 1832
1833 1833 @pyqtSignature("int")
1834 1834 def on_specGraphftpCross_stateChanged(self, p0):
1835 1835
1836 1836 self.__checkSpecGraphFTP()
1837 1837
1838 1838 @pyqtSignature("int")
1839 1839 def on_specGraphftpRTIplot_stateChanged(self, p0):
1840 1840
1841 1841 self.__checkSpecGraphFTP()
1842 1842
1843 1843 @pyqtSignature("int")
1844 1844 def on_specGraphftpRTInoise_stateChanged(self, p0):
1845 1845
1846 1846 self.__checkSpecGraphFTP()
1847 1847
1848 1848 @pyqtSignature("int")
1849 1849 def on_specGraphftpCoherencemap_stateChanged(self, p0):
1850 1850
1851 1851 self.__checkSpecGraphFTP()
1852 1852
1853 1853 @pyqtSignature("int")
1854 1854 def on_specGraphftpPowerprofile_stateChanged(self, p0):
1855 1855
1856 1856 self.__checkSpecGraphFTP()
1857 1857
1858 1858 @pyqtSignature("")
1859 1859 def on_specGraphToolPath_clicked(self):
1860 1860 """
1861 1861 """
1862 1862 self.savePath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
1863 1863 self.specGraphPath.setText(self.savePath)
1864 1864 if not os.path.exists(self.savePath):
1865 1865 self.console.clear()
1866 1866 self.console.append("Write a correct a path")
1867 1867 return
1868 1868
1869 1869 @pyqtSignature("")
1870 1870 def on_specGraphClear_clicked(self):
1871 1871 return
1872 1872
1873 1873 @pyqtSignature("")
1874 1874 def on_specHeisGraphToolPath_clicked(self):
1875 1875 """
1876 1876 """
1877 1877 self.savePath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
1878 1878 self.specHeisGraphPath.setText(self.savePath)
1879 1879 if not os.path.exists(self.savePath):
1880 1880 self.console.clear()
1881 1881 self.console.append("Write a correct a path")
1882 1882 return
1883 1883
1884 1884 @pyqtSignature("int")
1885 1885 def on_specHeisOpCebIncoherent_stateChanged(self, p0):
1886 1886 """
1887 1887 Habilita la opcion de aοΏ½adir el parοΏ½metro integraciones incoherentes a la Unidad de Procesamiento .
1888 1888 """
1889 1889 if p0 == 2:
1890 1890 self.specHeisOpIncoherent.setEnabled(True)
1891 1891 self.specHeisOpCobIncInt.setEnabled(True)
1892 1892 if p0 == 0:
1893 1893 self.specHeisOpIncoherent.setEnabled(False)
1894 1894 self.specHeisOpCobIncInt.setEnabled(False)
1895 1895
1896 1896 @pyqtSignature("")
1897 1897 def on_specHeisOpOk_clicked(self):
1898 1898 """
1899 1899 AΓ‘ADE OPERACION SPECTRAHEIS
1900 1900 """
1901 1901 addFTP = False
1902 1902 checkPath = False
1903 1903
1904 1904 self.actionSaveToolbar.setEnabled(False)
1905 1905 self.actionStarToolbar.setEnabled(False)
1906 1906
1907 1907 puObj = self.getSelectedItemObj()
1908 1908 puObj.removeOperations()
1909 1909
1910 1910 if self.specHeisOpCebIncoherent.isChecked():
1911 1911 value = self.specHeisOpIncoherent.text()
1912 1912 name_operation = 'IncohInt4SpectraHeis'
1913 1913 optype = 'other'
1914 1914 if self.specOpCobIncInt.currentIndex() == 0:
1915 1915 name_parameter = 'timeInterval'
1916 1916 format = 'float'
1917 1917 opObj = puObj.addOperation(name=name_operation, optype=optype)
1918 1918 opObj.addParameter(name=name_parameter, value=value, format=format)
1919 1919
1920 1920 # ---- Spectra Plot-----
1921 1921 if self.specHeisGraphCebSpectraplot.isChecked():
1922 1922 name_operation = 'SpectraHeisScope'
1923 1923 optype = 'other'
1924 1924 name_parameter = 'type'
1925 1925 value = 'SpectraHeisScope'
1926 1926 format = 'str'
1927 1927 if self.idImagspectraHeis == 0:
1928 1928 self.idImagspectraHeis = 800
1929 1929 else:
1930 1930 self.idImagspectraHeis = self.idImagspectraHeis + 1
1931 1931 name_parameter1 = 'id'
1932 1932 value1 = int(self.idImagspectraHeis)
1933 1933 format1 = 'int'
1934 1934
1935 1935 format = 'str'
1936 1936
1937 1937 channelList = self.specHeisGgraphChannelList.text()
1938 1938 xvalue = self.specHeisGgraphXminXmax.text()
1939 1939 yvalue = self.specHeisGgraphYminYmax.text()
1940 1940 opObj = puObj.addOperation(name=name_operation, optype=optype)
1941 1941 # opObj.addParameter(name=name_parameter, value=value, format=format)
1942 1942 opObj.addParameter(name=name_parameter1, value=value1, format=format1)
1943 1943
1944 1944 if not channelList == '':
1945 1945 name_parameter = 'channelList'
1946 1946 format = 'intlist'
1947 1947 opObj.addParameter(name=name_parameter, value=channelList, format=format)
1948 1948
1949 1949 if not xvalue == '':
1950 1950 xvalueList = xvalue.split(',')
1951 1951 try:
1952 1952 value1 = float(xvalueList[0])
1953 1953 value2 = float(xvalueList[1])
1954 1954 except:
1955 1955 self.console.clear()
1956 1956 self.console.append("Please Write corrects parameter xmin-xmax")
1957 1957 return 0
1958 1958 name1 = 'xmin'
1959 1959 name2 = 'xmax'
1960 1960 format = 'float'
1961 1961 opObj.addParameter(name=name1, value=value1, format=format)
1962 1962 opObj.addParameter(name=name2, value=value2, format=format)
1963 1963 #------specHeisGgraphYmin-Ymax---
1964 1964 if not yvalue == '':
1965 1965 yvalueList = yvalue.split(",")
1966 1966 try:
1967 1967 value1 = float(yvalueList[0])
1968 1968 value2 = float(yvalueList[1])
1969 1969 except:
1970 1970 self.console.clear()
1971 1971 self.console.append("Please Write corrects parameter Ymix-Ymax")
1972 1972 return 0
1973 1973 name1 = 'ymin'
1974 1974 name2 = 'ymax'
1975 1975 format = 'float'
1976 1976 opObj.addParameter(name=name1, value=value1, format=format)
1977 1977 opObj.addParameter(name=name2, value=value2, format=format)
1978 1978
1979 1979 if self.specHeisGraphSaveSpectra.isChecked():
1980 1980 checkPath = True
1981 1981 name_parameter1 = 'save'
1982 1982 name_parameter2 = 'figpath'
1983 1983 name_parameter3 = 'figfile'
1984 1984 value1 = '1'
1985 1985 value2 = self.specHeisGraphPath.text()
1986 1986 value3 = self.specHeisGraphPrefix.text()
1987 1987 format1 = 'bool'
1988 1988 format2 = 'str'
1989 1989 opObj.addParameter(name=name_parameter1, value=value1 , format=format1)
1990 1990 opObj.addParameter(name=name_parameter2, value=value2, format=format2)
1991 1991 if not value3 == "":
1992 1992 try:
1993 1993 value3 = str(self.specHeisGraphPrefix.text())
1994 1994 except:
1995 1995 self.console.clear()
1996 1996 self.console.append("Please Write prefix")
1997 1997 return 0
1998 1998 opObj.addParameter(name='figfile', value=self.specHeisGraphPrefix.text(), format='str')
1999 1999
2000 2000 # opObj.addParameter(name=name_parameter3, value=value3, format=format2)
2001 2001 # opObj.addParameter(name='wr_period', value='5',format='int')
2002 2002
2003 2003 if self.specHeisGraphftpSpectra.isChecked():
2004 2004 opObj.addParameter(name='ftp', value='1', format='int')
2005 2005 self.addFTPConf2Operation(puObj, opObj)
2006 2006 addFTP = True
2007 2007
2008 2008 if self.specHeisGraphCebRTIplot.isChecked():
2009 2009 name_operation = 'RTIfromSpectraHeis'
2010 2010 optype = 'other'
2011 2011 name_parameter = 'type'
2012 2012 value = 'RTIfromSpectraHeis'
2013 2013 format = 'str'
2014 2014
2015 2015 if self.idImagrtiHeis == 0:
2016 2016 self.idImagrtiHeis = 900
2017 2017 else:
2018 2018 self.idImagrtiHeis = self.idImagrtiHeis + 1
2019 2019
2020 2020 name_parameter1 = 'id'
2021 2021 value1 = int(self.idImagrtiHeis)
2022 2022 format1 = 'int'
2023 2023
2024 2024 format = 'str'
2025 2025
2026 2026 opObj = puObj.addOperation(name=name_operation, optype=optype)
2027 2027 # opObj.addParameter(name=name_parameter, value=value, format=format)
2028 2028 opObj.addParameter(name=name_parameter1, value=value1, format=format1)
2029 2029
2030 2030 channelList = self.specHeisGgraphChannelList.text()
2031 2031 xvalue = self.specHeisGgraphTminTmax.text()
2032 2032 yvalue = self.specHeisGgraphYminYmax.text()
2033 2033 timerange = self.specHeisGgraphTimeRange.text()
2034 2034
2035 2035 if not channelList == '':
2036 2036 opObj.addParameter(name='channelList', value=channelList, format='intlist')
2037 2037
2038 2038 if not xvalue == '':
2039 2039 xvalueList = xvalue.split(',')
2040 2040 try:
2041 2041 value = float(xvalueList[0])
2042 2042 value = float(xvalueList[1])
2043 2043 except:
2044 2044 return 0
2045 2045 format = 'float'
2046 2046 opObj.addParameter(name='xmin', value=xvalueList[0], format=format)
2047 2047 opObj.addParameter(name='xmax', value=xvalueList[1], format=format)
2048 2048
2049 2049 if not timerange == '':
2050 2050 format = 'int'
2051 2051 try:
2052 2052 timerange = int(timerange)
2053 2053 except:
2054 2054 return 0
2055 2055 opObj.addParameter(name='timerange', value=timerange, format=format)
2056 2056
2057 2057
2058 2058 if not yvalue == '':
2059 2059 yvalueList = yvalue.split(",")
2060 2060 try:
2061 2061 value = float(yvalueList[0])
2062 2062 value = float(yvalueList[1])
2063 2063 except:
2064 2064 return 0
2065 2065 format = 'float'
2066 2066 opObj.addParameter(name='ymin', value=yvalueList[0], format=format)
2067 2067 opObj.addParameter(name='ymax', value=yvalueList[1], format=format)
2068 2068
2069 2069 if self.specHeisGraphSaveRTIplot.isChecked():
2070 2070 checkPath = True
2071 2071 opObj.addParameter(name='save', value='1', format='bool')
2072 2072 opObj.addParameter(name='figpath', value=self.specHeisGraphPath.text(), format='str')
2073 2073 value = self.specHeisGraphPrefix.text()
2074 2074 if not value == "":
2075 2075 try:
2076 2076 value = str(self.specHeisGraphPrefix.text())
2077 2077 except:
2078 2078 self.console.clear()
2079 2079 self.console.append("Please Write prefix")
2080 2080 return 0
2081 2081 opObj.addParameter(name='figfile', value=value, format='str')
2082 2082
2083 2083 # test_ftp
2084 2084 if self.specHeisGraphftpRTIplot.isChecked():
2085 2085 opObj.addParameter(name='ftp', value='1', format='int')
2086 2086 self.addFTPConf2Operation(puObj, opObj)
2087 2087 addFTP = True
2088 2088
2089 2089 localfolder = None
2090 2090 if checkPath:
2091 2091 localfolder = str(self.specGraphPath.text())
2092 2092 if localfolder == '':
2093 2093 self.console.clear()
2094 2094 self.console.append("Graphic path should be defined")
2095 2095 return 0
2096 2096
2097 2097 if addFTP and not localfolder:
2098 2098 self.console.clear()
2099 2099 self.console.append("You have to save the plots before sending them to FTP Server")
2100 2100 return 0
2101 2101
2102 2102 # if something happened
2103 2103 parms_ok, output_path, blocksperfile, metada = self.checkInputsPUSave(datatype='SpectraHeis')
2104 2104 if parms_ok:
2105 2105 name_operation = 'FitsWriter'
2106 2106 optype = 'other'
2107 2107 name_parameter1 = 'path'
2108 2108 name_parameter2 = 'dataBlocksPerFile'
2109 2109 name_parameter3 = 'metadatafile'
2110 2110 value1 = output_path
2111 2111 value2 = blocksperfile
2112 2112 value3 = metada
2113 2113 format2 = "int"
2114 2114 format3 = "str"
2115 2115 opObj = puObj.addOperation(name=name_operation, optype=optype)
2116 2116 opObj.addParameter(name=name_parameter1, value=value1)
2117 2117 opObj.addParameter(name=name_parameter2, value=value2, format=format2)
2118 2118 opObj.addParameter(name=name_parameter3, value=value3, format=format3)
2119 2119
2120 2120 self.console.clear()
2121 2121 try:
2122 2122 self.refreshPUProperties(puObj)
2123 2123 except:
2124 2124 self.console.append("Check input parameters")
2125 2125 return 0
2126 2126
2127 2127 self.console.append("Click on save icon ff you want to save your project")
2128 2128
2129 2129 self.actionSaveToolbar.setEnabled(True)
2130 2130 self.actionStarToolbar.setEnabled(True)
2131 2131
2132 2132 return 1
2133 2133 @pyqtSignature("int")
2134 2134 def on_specHeisGraphCebSpectraplot_stateChanged(self, p0):
2135 2135
2136 2136 if p0 == 2:
2137 2137 self.specHeisGgraphChannelList.setEnabled(True)
2138 2138 self.specHeisGgraphXminXmax.setEnabled(True)
2139 2139 self.specHeisGgraphYminYmax.setEnabled(True)
2140 2140 if p0 == 0:
2141 2141 self.specHeisGgraphXminXmax.setEnabled(False)
2142 2142 self.specHeisGgraphYminYmax.setEnabled(False)
2143 2143
2144 2144 @pyqtSignature("int")
2145 2145 def on_specHeisGraphCebRTIplot_stateChanged(self, p0):
2146 2146
2147 2147 if p0 == 2:
2148 2148 self.specHeisGgraphChannelList.setEnabled(True)
2149 2149 self.specHeisGgraphTminTmax.setEnabled(True)
2150 2150 self.specHeisGgraphYminYmax.setEnabled(True)
2151 2151 self.specHeisGgraphTimeRange.setEnabled(True)
2152 2152
2153 2153 if p0 == 0:
2154 2154 self.specHeisGgraphTminTmax.setEnabled(False)
2155 2155 self.specHeisGgraphYminYmax.setEnabled(False)
2156 2156 self.specHeisGgraphTimeRange.setEnabled(False)
2157 2157
2158 2158 @pyqtSignature("int")
2159 2159 def on_specHeisGraphSaveSpectra_stateChanged(self, p0):
2160 2160 """
2161 2161 """
2162 2162 if p0 == 2:
2163 2163 self.specHeisGraphPath.setEnabled(True)
2164 2164 self.specHeisGraphPrefix.setEnabled(True)
2165 2165 self.specHeisGraphToolPath.setEnabled(True)
2166 2166 if p0 == 0:
2167 2167 self.specHeisGraphPath.setEnabled(False)
2168 2168 self.specHeisGraphPrefix.setEnabled(False)
2169 2169 self.specHeisGraphToolPath.setEnabled(False)
2170 2170
2171 2171 @pyqtSignature("int")
2172 2172 def on_specHeisGraphSaveRTIplot_stateChanged(self, p0):
2173 2173 if p0 == 2:
2174 2174 self.specHeisGraphPath.setEnabled(True)
2175 2175 self.specHeisGraphPrefix.setEnabled(True)
2176 2176 self.specHeisGraphToolPath.setEnabled(True)
2177 2177
2178 2178 @pyqtSignature("int")
2179 2179 def on_specHeisGraphftpSpectra_stateChanged(self, p0):
2180 2180 """
2181 2181 """
2182 2182 if p0 == 2:
2183 2183 self.specHeisGgraphftpratio.setEnabled(True)
2184 2184
2185 2185 if p0 == 0:
2186 2186 self.specHeisGgraphftpratio.setEnabled(False)
2187 2187
2188 2188 @pyqtSignature("int")
2189 2189 def on_specHeisGraphftpRTIplot_stateChanged(self, p0):
2190 2190 if p0 == 2:
2191 2191 self.specHeisGgraphftpratio.setEnabled(True)
2192 2192
2193 2193 @pyqtSignature("")
2194 2194 def on_specHeisGraphClear_clicked(self):
2195 2195 pass
2196 2196
2197 2197 def __checkSpecGraphSaving(self):
2198 2198
2199 2199 enable = False
2200 2200
2201 2201 if self.specGraphSaveSpectra.checkState():
2202 2202 enable = True
2203 2203
2204 2204 if self.specGraphSaveCross.checkState():
2205 2205 enable = True
2206 2206
2207 2207 if self.specGraphSaveRTIplot.checkState():
2208 2208 enable = True
2209 2209
2210 2210 if self.specGraphSaveCoherencemap.checkState():
2211 2211 enable = True
2212 2212
2213 2213 if self.specGraphSavePowerprofile.checkState():
2214 2214 enable = True
2215 2215
2216 2216 if self.specGraphSaveRTInoise.checkState():
2217 2217 enable = True
2218 2218
2219 2219 self.specGraphPath.setEnabled(enable)
2220 2220 self.specGraphPrefix.setEnabled(enable)
2221 2221 self.specGraphToolPath.setEnabled(enable)
2222 2222
2223 2223 self.specGgraphftpratio.setEnabled(enable)
2224 2224
2225 2225 def __checkSpecGraphFTP(self):
2226 2226
2227 2227 enable = False
2228 2228
2229 2229 if self.specGraphftpSpectra.checkState():
2230 2230 enable = True
2231 2231
2232 2232 if self.specGraphftpCross.checkState():
2233 2233 enable = True
2234 2234
2235 2235 if self.specGraphftpRTIplot.checkState():
2236 2236 enable = True
2237 2237
2238 2238 if self.specGraphftpCoherencemap.checkState():
2239 2239 enable = True
2240 2240
2241 2241 if self.specGraphftpPowerprofile.checkState():
2242 2242 enable = True
2243 2243
2244 2244 if self.specGraphftpRTInoise.checkState():
2245 2245 enable = True
2246 2246
2247 2247 # self.specGgraphftpratio.setEnabled(enable)
2248 2248
2249 2249 def __checkSpecGraphFilters(self):
2250 2250
2251 2251 freq = False
2252 2252 height = False
2253 2253 db = False
2254 2254 time = False
2255 2255 magnitud = False
2256 2256 phase = False
2257 2257 channelList = False
2258 2258
2259 2259 if self.specGraphCebSpectraplot.checkState():
2260 2260 freq = True
2261 2261 height = True
2262 2262 db = True
2263 2263 channelList = True
2264 2264
2265 2265 if self.specGraphCebCrossSpectraplot.checkState():
2266 2266 freq = True
2267 2267 height = True
2268 2268 db = True
2269 2269 magnitud = True
2270 2270 phase = True
2271 2271
2272 2272 if self.specGraphCebRTIplot.checkState():
2273 2273 height = True
2274 2274 db = True
2275 2275 time = True
2276 2276 channelList = True
2277 2277
2278 2278 if self.specGraphCebCoherencmap.checkState():
2279 2279 height = True
2280 2280 time = True
2281 2281 magnitud = True
2282 2282 phase = True
2283 2283
2284 2284 if self.specGraphPowerprofile.checkState():
2285 2285 height = True
2286 2286 db = True
2287 2287 channelList = True
2288 2288
2289 2289 if self.specGraphCebRTInoise.checkState():
2290 2290 db = True
2291 2291 time = True
2292 2292 channelList = True
2293 2293
2294 2294
2295 2295 self.specGgraphFreq.setEnabled(freq)
2296 2296 self.specGgraphHeight.setEnabled(height)
2297 2297 self.specGgraphDbsrange.setEnabled(db)
2298 2298 self.specGgraphTminTmax.setEnabled(time)
2299 2299
2300 2300 self.specGgraphmagnitud.setEnabled(magnitud)
2301 2301 self.specGgraphPhase.setEnabled(phase)
2302 2302 self.specGgraphChannelList.setEnabled(channelList)
2303 2303
2304 2304 def __getParmsFromProjectWindow(self):
2305 2305 """
2306 2306 Check Inputs Project:
2307 2307 - project_name
2308 2308 - datatype
2309 2309 - ext
2310 2310 - data_path
2311 2311 - readmode
2312 2312 - delay
2313 2313 - set
2314 2314 - walk
2315 2315 """
2316 2316 parms_ok = True
2317 2317
2318 2318 project_name = str(self.proName.text())
2319 2319
2320 2320 if project_name == '' or project_name == None:
2321 2321 outputstr = "Enter a project Name"
2322 2322 self.console.append(outputstr)
2323 2323 parms_ok = False
2324 2324 project_name = None
2325 2325
2326 2326 description = str(self.proDescription.toPlainText())
2327 2327
2328 2328 datatype = str(self.proComDataType.currentText())
2329 2329
2330 2330 ext = str(self.proDataType.text())
2331 2331
2332 2332 dpath = str(self.proDataPath.text())
2333 2333
2334 2334 if dpath == '':
2335 2335 outputstr = 'Datapath is empty'
2336 2336 self.console.append(outputstr)
2337 2337 parms_ok = False
2338 2338 dpath = None
2339 2339
2340 2340 if dpath != None:
2341 2341 if not os.path.isdir(dpath):
2342 2342 outputstr = 'Datapath (%s) does not exist' % dpath
2343 2343 self.console.append(outputstr)
2344 2344 parms_ok = False
2345 2345 dpath = None
2346 2346
2347 2347 online = int(self.proComReadMode.currentIndex())
2348 2348
2349 2349 delay = None
2350 2350 if online==1:
2351 2351 try:
2352 2352 delay = int(str(self.proDelay.text()))
2353 2353 except:
2354 2354 outputstr = 'Delay value (%s) must be a integer number' %str(self.proDelay.text())
2355 2355 self.console.append(outputstr)
2356 2356 parms_ok = False
2357 2357
2358 2358
2359 2359 set = None
2360 2360 value = str(self.proSet.text())
2361 2361 try:
2362 2362 set = int(value)
2363 2363 except:
2364 2364 pass
2365 2365
2366 2366 ippKm = None
2367 2367
2368 2368 value = str(self.proIPPKm.text())
2369 2369
2370 2370 try:
2371 2371 ippKm = float(value)
2372 2372 except:
2373 2373 if datatype=="USRP":
2374 2374 outputstr = 'IPP value (%s) must be a float number' % str(self.proIPPKm.text())
2375 2375 self.console.append(outputstr)
2376 2376 parms_ok = False
2377 2377
2378 2378 walk = int(self.proComWalk.currentIndex())
2379 2379
2380 2380 startDate = str(self.proComStartDate.currentText())
2381 2381 endDate = str(self.proComEndDate.currentText())
2382 2382
2383 2383 # startDateList = startDate.split("/")
2384 2384 # endDateList = endDate.split("/")
2385 2385 #
2386 2386 # startDate = datetime.date(int(startDateList[0]), int(startDateList[1]), int(startDateList[2]))
2387 2387 # endDate = datetime.date(int(endDateList[0]), int(endDateList[1]), int(endDateList[2]))
2388 2388
2389 2389 startTime = self.proStartTime.time()
2390 2390 endTime = self.proEndTime.time()
2391 2391
2392 2392 startTime = str(startTime.toString("H:m:s"))
2393 2393 endTime = str(endTime.toString("H:m:s"))
2394 2394
2395 2395 projectParms = ProjectParms()
2396 2396
2397 2397 projectParms.name = project_name
2398 2398 projectParms.description = description
2399 2399 projectParms.datatype = datatype
2400 2400 projectParms.ext = ext
2401 2401 projectParms.dpath = dpath
2402 2402 projectParms.online = online
2403 2403 projectParms.startDate = startDate
2404 2404 projectParms.endDate = endDate
2405 2405 projectParms.startTime = startTime
2406 2406 projectParms.endTime = endTime
2407 2407 projectParms.delay=delay
2408 2408 projectParms.walk=walk
2409 2409 projectParms.set=set
2410 2410 projectParms.ippKm=ippKm
2411 2411 projectParms.parmsOk=parms_ok
2412 2412
2413 2413 return projectParms
2414 2414
2415 2415
2416 2416 def __getParmsFromProjectObj(self, projectObjView):
2417 2417
2418 2418 parms_ok = True
2419 2419
2420 2420 project_name, description = projectObjView.name, projectObjView.description
2421 2421
2422 2422 readUnitObj = projectObjView.getReadUnitObj()
2423 2423 datatype = readUnitObj.datatype
2424 2424
2425 2425 operationObj = readUnitObj.getOperationObj(name='run')
2426 2426
2427 2427 dpath = operationObj.getParameterValue(parameterName='path')
2428 2428 startDate = operationObj.getParameterValue(parameterName='startDate')
2429 2429 endDate = operationObj.getParameterValue(parameterName='endDate')
2430 2430
2431 2431 startDate = startDate.strftime("%Y/%m/%d")
2432 2432 endDate = endDate.strftime("%Y/%m/%d")
2433 2433
2434 2434 startTime = operationObj.getParameterValue(parameterName='startTime')
2435 2435 endTime = operationObj.getParameterValue(parameterName='endTime')
2436 2436
2437 2437 startTime = startTime.strftime("%H:%M:%S")
2438 2438 endTime = endTime.strftime("%H:%M:%S")
2439 2439
2440 2440 online = 0
2441 2441 try:
2442 2442 online = operationObj.getParameterValue(parameterName='online')
2443 2443 except:
2444 2444 pass
2445 2445
2446 2446 delay = ''
2447 2447 try:
2448 2448 delay = operationObj.getParameterValue(parameterName='delay')
2449 2449 except:
2450 2450 pass
2451 2451
2452 2452 walk = 0
2453 2453 try:
2454 2454 walk = operationObj.getParameterValue(parameterName='walk')
2455 2455 except:
2456 2456 pass
2457 2457
2458 2458 set = ''
2459 2459 try:
2460 2460 set = operationObj.getParameterValue(parameterName='set')
2461 2461 except:
2462 2462 pass
2463 2463
2464 2464 ippKm = ''
2465 2465 if datatype.lower() == 'usrp':
2466 2466 try:
2467 2467 ippKm = operationObj.getParameterValue(parameterName='ippKm')
2468 2468 except:
2469 2469 pass
2470 2470
2471 2471 projectParms = ProjectParms()
2472 2472
2473 2473 projectParms.name = project_name
2474 2474 projectParms.description = description
2475 2475 projectParms.datatype = datatype
2476 2476 projectParms.ext = None
2477 2477 projectParms.dpath = dpath
2478 2478 projectParms.online = online
2479 2479 projectParms.startDate = startDate
2480 2480 projectParms.endDate = endDate
2481 2481 projectParms.startTime = startTime
2482 2482 projectParms.endTime = endTime
2483 2483 projectParms.delay=delay
2484 2484 projectParms.walk=walk
2485 2485 projectParms.set=set
2486 2486 projectParms.ippKm=ippKm
2487 2487 projectParms.parmsOk=parms_ok
2488 2488
2489 2489 return projectParms
2490 2490
2491 2491 def refreshProjectWindow2(self, projectObjView):
2492 2492
2493 2493 projectParms = self.__getParmsFromProjectObj(projectObjView)
2494 2494
2495 2495 index = projectParms.getDatatypeIndex()
2496 2496
2497 2497 self.proName.setText(projectParms.name)
2498 2498 self.proDescription.clear()
2499 2499 self.proDescription.append(projectParms.description)
2500 2500
2501 2501 self.on_proComDataType_activated(index=index)
2502 2502 self.proDataPath.setText(projectParms.dpath)
2503 2503 self.proComDataType.setCurrentIndex(index)
2504 2504 self.proComReadMode.setCurrentIndex(projectParms.online)
2505 2505 self.proDelay.setText(str(projectParms.delay))
2506 2506 self.proSet.setText(str(projectParms.set))
2507 2507 self.proIPPKm.setText(str(projectParms.ippKm))
2508 2508
2509 2509 dateList = self.loadDays(data_path = projectParms.dpath,
2510 2510 ext = projectParms.getExt(),
2511 2511 walk = projectParms.walk,
2512 2512 expLabel = projectParms.expLabel)
2513 2513
2514 2514 try:
2515 2515 startDateIndex = dateList.index(projectParms.startDate)
2516 2516 except:
2517 2517 startDateIndex = 0
2518 2518
2519 2519 try:
2520 2520 endDateIndex = dateList.index(projectParms.endDate)
2521 2521 except:
2522 2522 endDateIndex = int(self.proComEndDate.count()-1)
2523 2523
2524 2524 self.proComStartDate.setCurrentIndex(startDateIndex)
2525 2525 self.proComEndDate.setCurrentIndex(endDateIndex)
2526 2526
2527 2527 startlist = projectParms.startTime.split(":")
2528 2528 endlist = projectParms.endTime.split(":")
2529 2529
2530 2530 self.time.setHMS(int(startlist[0]), int(startlist[1]), int(startlist[2]))
2531 2531 self.proStartTime.setTime(self.time)
2532 2532
2533 2533 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
2534 2534 self.proEndTime.setTime(self.time)
2535 2535
2536 2536
2537 2537 def __refreshVoltageWindow(self, puObj):
2538 2538
2539 2539 opObj = puObj.getOperationObj(name='setRadarFrequency')
2540 2540 if opObj == None:
2541 2541 self.volOpRadarfrequency.clear()
2542 2542 self.volOpCebRadarfrequency.setCheckState(0)
2543 2543 else:
2544 2544 value = opObj.getParameterValue(parameterName='frequency')
2545 2545 value = str(float(value)/1e6)
2546 2546 self.volOpRadarfrequency.setText(value)
2547 2547 self.volOpRadarfrequency.setEnabled(True)
2548 2548 self.volOpCebRadarfrequency.setCheckState(QtCore.Qt.Checked)
2549 2549
2550 2550 opObj = puObj.getOperationObj(name="selectChannels")
2551 2551
2552 2552 if opObj == None:
2553 2553 opObj = puObj.getOperationObj(name="selectChannelsByIndex")
2554 2554
2555 2555 if opObj == None:
2556 2556 self.volOpChannel.clear()
2557 2557 self.volOpCebChannels.setCheckState(0)
2558 2558 else:
2559 2559 channelEnabled = False
2560 2560 try:
2561 2561 value = opObj.getParameterValue(parameterName='channelList')
2562 2562 value = str(value)[1:-1]
2563 2563 channelEnabled = True
2564 2564 channelMode = 0
2565 2565 except:
2566 2566 pass
2567 2567 try:
2568 2568 value = opObj.getParameterValue(parameterName='channelIndexList')
2569 2569 value = str(value)[1:-1]
2570 2570 channelEnabled = True
2571 2571 channelMode = 1
2572 2572 except:
2573 2573 pass
2574 2574
2575 2575 if channelEnabled:
2576 2576 self.volOpChannel.setText(value)
2577 2577 self.volOpChannel.setEnabled(True)
2578 2578 self.volOpCebChannels.setCheckState(QtCore.Qt.Checked)
2579 2579 self.volOpComChannels.setCurrentIndex(channelMode)
2580 2580
2581 2581 opObj = puObj.getOperationObj(name="selectHeights")
2582 2582 if opObj == None:
2583 2583 self.volOpHeights.clear()
2584 2584 self.volOpCebHeights.setCheckState(0)
2585 2585 else:
2586 2586 value1 = int(opObj.getParameterValue(parameterName='minHei'))
2587 2587 value1 = str(value1)
2588 2588 value2 = int(opObj.getParameterValue(parameterName='maxHei'))
2589 2589 value2 = str(value2)
2590 2590 value = value1 + "," + value2
2591 2591 self.volOpHeights.setText(value)
2592 2592 self.volOpHeights.setEnabled(True)
2593 2593 self.volOpCebHeights.setCheckState(QtCore.Qt.Checked)
2594 2594
2595 2595 opObj = puObj.getOperationObj(name="filterByHeights")
2596 2596 if opObj == None:
2597 2597 self.volOpFilter.clear()
2598 2598 self.volOpCebFilter.setCheckState(0)
2599 2599 else:
2600 2600 value = opObj.getParameterValue(parameterName='window')
2601 2601 value = str(value)
2602 2602 self.volOpFilter.setText(value)
2603 2603 self.volOpFilter.setEnabled(True)
2604 2604 self.volOpCebFilter.setCheckState(QtCore.Qt.Checked)
2605 2605
2606 2606 opObj = puObj.getOperationObj(name="ProfileSelector")
2607 2607 if opObj == None:
2608 2608 self.volOpProfile.clear()
2609 2609 self.volOpCebProfile.setCheckState(0)
2610 2610 else:
2611 2611 for parmObj in opObj.getParameterObjList():
2612 2612
2613 2613 if parmObj.name == "profileList":
2614 2614 value = parmObj.getValue()
2615 2615 value = str(value)[1:-1]
2616 2616 self.volOpProfile.setText(value)
2617 2617 self.volOpProfile.setEnabled(True)
2618 2618 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
2619 2619 self.volOpComProfile.setCurrentIndex(0)
2620 2620
2621 2621 if parmObj.name == "profileRangeList":
2622 2622 value = parmObj.getValue()
2623 2623 value = str(value)[1:-1]
2624 2624 self.volOpProfile.setText(value)
2625 2625 self.volOpProfile.setEnabled(True)
2626 2626 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
2627 2627 self.volOpComProfile.setCurrentIndex(1)
2628 2628
2629 2629 if parmObj.name == "rangeList":
2630 2630 value = parmObj.getValue()
2631 2631 value = str(value)[1:-1]
2632 2632 self.volOpProfile.setText(value)
2633 2633 self.volOpProfile.setEnabled(True)
2634 2634 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
2635 2635 self.volOpComProfile.setCurrentIndex(2)
2636 2636
2637 2637 opObj = puObj.getOperationObj(name="Decoder")
2638 2638 self.volOpCode.setText("")
2639 2639 if opObj == None:
2640 2640 self.volOpCebDecodification.setCheckState(0)
2641 2641 else:
2642 2642 self.volOpCebDecodification.setCheckState(QtCore.Qt.Checked)
2643 2643
2644 2644 parmObj = opObj.getParameterObj('code')
2645 2645
2646 2646 if parmObj == None:
2647 2647 self.volOpComCode.setCurrentIndex(0)
2648 2648 else:
2649 2649
2650 2650 parmObj1 = opObj.getParameterObj('nCode')
2651 2651 parmObj2 = opObj.getParameterObj('nBaud')
2652 2652
2653 2653 if parmObj1 == None or parmObj2 == None:
2654 2654 self.volOpComCode.setCurrentIndex(0)
2655 2655 else:
2656 2656 code = ast.literal_eval(str(parmObj.getValue()))
2657 2657 nCode = parmObj1.getValue()
2658 2658 nBaud = parmObj2.getValue()
2659 2659
2660 2660 code = numpy.asarray(code).reshape((nCode, nBaud)).tolist()
2661 2661
2662 2662 #User defined by default
2663 2663 self.volOpComCode.setCurrentIndex(13)
2664 2664 self.volOpCode.setText(str(code))
2665 2665
2666 2666 if nCode == 1:
2667 2667 if nBaud == 3:
2668 2668 self.volOpComCode.setCurrentIndex(1)
2669 2669 if nBaud == 4:
2670 2670 self.volOpComCode.setCurrentIndex(2)
2671 2671 if nBaud == 5:
2672 2672 self.volOpComCode.setCurrentIndex(3)
2673 2673 if nBaud == 7:
2674 2674 self.volOpComCode.setCurrentIndex(4)
2675 2675 if nBaud == 11:
2676 2676 self.volOpComCode.setCurrentIndex(5)
2677 2677 if nBaud == 13:
2678 2678 self.volOpComCode.setCurrentIndex(6)
2679 2679
2680 2680 if nCode == 2:
2681 2681 if nBaud == 3:
2682 2682 self.volOpComCode.setCurrentIndex(7)
2683 2683 if nBaud == 4:
2684 2684 self.volOpComCode.setCurrentIndex(8)
2685 2685 if nBaud == 5:
2686 2686 self.volOpComCode.setCurrentIndex(9)
2687 2687 if nBaud == 7:
2688 2688 self.volOpComCode.setCurrentIndex(10)
2689 2689 if nBaud == 11:
2690 2690 self.volOpComCode.setCurrentIndex(11)
2691 2691 if nBaud == 13:
2692 2692 self.volOpComCode.setCurrentIndex(12)
2693 2693
2694 2694
2695 2695 opObj = puObj.getOperationObj(name="deFlip")
2696 2696 if opObj == None:
2697 2697 self.volOpFlip.clear()
2698 2698 self.volOpFlip.setEnabled(False)
2699 2699 self.volOpCebFlip.setCheckState(0)
2700 2700 else:
2701 2701 try:
2702 2702 value = opObj.getParameterValue(parameterName='channelList')
2703 2703 value = str(value)[1:-1]
2704 2704 except:
2705 2705 value = ""
2706 2706
2707 2707 self.volOpFlip.setText(value)
2708 2708 self.volOpFlip.setEnabled(True)
2709 2709 self.volOpCebFlip.setCheckState(QtCore.Qt.Checked)
2710 2710
2711 2711 opObj = puObj.getOperationObj(name="CohInt")
2712 2712 if opObj == None:
2713 2713 self.volOpCohInt.clear()
2714 2714 self.volOpCebCohInt.setCheckState(0)
2715 2715 else:
2716 2716 value = opObj.getParameterValue(parameterName='n')
2717 2717 self.volOpCohInt.setText(str(value))
2718 2718 self.volOpCohInt.setEnabled(True)
2719 2719 self.volOpCebCohInt.setCheckState(QtCore.Qt.Checked)
2720 2720
2721 2721 opObj = puObj.getOperationObj(name='Scope')
2722 2722 if opObj == None:
2723 2723 self.volGraphCebshow.setCheckState(0)
2724 2724 else:
2725 2725 self.volGraphCebshow.setCheckState(QtCore.Qt.Checked)
2726 2726
2727 2727 parmObj = opObj.getParameterObj(parameterName='channelList')
2728 2728
2729 2729 if parmObj == None:
2730 2730 self.volGraphChannelList.clear()
2731 2731 else:
2732 2732 value = parmObj.getValue()
2733 2733 value = str(value)
2734 2734 self.volGraphChannelList.setText(value)
2735 2735 self.volOpProfile.setEnabled(True)
2736 2736
2737 2737 parmObj1 = opObj.getParameterObj(parameterName='xmin')
2738 2738 parmObj2 = opObj.getParameterObj(parameterName='xmax')
2739 2739
2740 2740 if parmObj1 == None or parmObj2 ==None:
2741 2741 self.volGraphfreqrange.clear()
2742 2742 else:
2743 2743 value1 = parmObj1.getValue()
2744 2744 value1 = str(value1)
2745 2745 value2 = parmObj2.getValue()
2746 2746 value2 = str(value2)
2747 2747 value = value1 + "," + value2
2748 2748 self.volGraphfreqrange.setText(value)
2749 2749
2750 2750 parmObj1 = opObj.getParameterObj(parameterName='ymin')
2751 2751 parmObj2 = opObj.getParameterObj(parameterName='ymax')
2752 2752
2753 2753 if parmObj1 == None or parmObj2 ==None:
2754 2754 self.volGraphHeightrange.clear()
2755 2755 else:
2756 2756 value1 = parmObj1.getValue()
2757 2757 value1 = str(value1)
2758 2758 value2 = parmObj2.getValue()
2759 2759 value2 = str(value2)
2760 2760 value = value1 + "," + value2
2761 2761 value2 = str(value2)
2762 2762 self.volGraphHeightrange.setText(value)
2763 2763
2764 2764 parmObj = opObj.getParameterObj(parameterName='save')
2765 2765
2766 2766 if parmObj == None:
2767 2767 self.volGraphCebSave.setCheckState(QtCore.Qt.Unchecked)
2768 2768 else:
2769 2769 value = parmObj.getValue()
2770 2770 if int(value):
2771 2771 self.volGraphCebSave.setCheckState(QtCore.Qt.Checked)
2772 2772 else:
2773 2773 self.volGraphCebSave.setCheckState(QtCore.Qt.Unchecked)
2774 2774
2775 2775 parmObj = opObj.getParameterObj(parameterName='figpath')
2776 2776 if parmObj == None:
2777 2777 self.volGraphPath.clear()
2778 2778 else:
2779 2779 value = parmObj.getValue()
2780 2780 path = str(value)
2781 2781 self.volGraphPath.setText(path)
2782 2782
2783 2783 parmObj = opObj.getParameterObj(parameterName='figfile')
2784 2784 if parmObj == None:
2785 2785 self.volGraphPrefix.clear()
2786 2786 else:
2787 2787 value = parmObj.getValue()
2788 2788 figfile = str(value)
2789 2789 self.volGraphPrefix.setText(figfile)
2790 2790
2791 2791 # outputVoltageWrite
2792 2792 opObj = puObj.getOperationObj(name='VoltageWriter')
2793 2793
2794 2794 if opObj == None:
2795 2795 self.volOutputPath.clear()
2796 2796 self.volOutputblocksperfile.clear()
2797 2797 self.volOutputprofilesperblock.clear()
2798 2798 else:
2799 2799 parmObj = opObj.getParameterObj(parameterName='path')
2800 2800 if parmObj == None:
2801 2801 self.volOutputPath.clear()
2802 2802 else:
2803 2803 value = parmObj.getValue()
2804 2804 path = str(value)
2805 2805 self.volOutputPath.setText(path)
2806 2806
2807 2807 parmObj = opObj.getParameterObj(parameterName='blocksPerFile')
2808 2808 if parmObj == None:
2809 2809 self.volOutputblocksperfile.clear()
2810 2810 else:
2811 2811 value = parmObj.getValue()
2812 2812 blocksperfile = str(value)
2813 2813 self.volOutputblocksperfile.setText(blocksperfile)
2814 2814
2815 2815 parmObj = opObj.getParameterObj(parameterName='profilesPerBlock')
2816 2816 if parmObj == None:
2817 2817 self.volOutputprofilesperblock.clear()
2818 2818 else:
2819 2819 value = parmObj.getValue()
2820 2820 profilesPerBlock = str(value)
2821 2821 self.volOutputprofilesperblock.setText(profilesPerBlock)
2822 2822
2823 2823 return
2824 2824
2825 2825 def __refreshSpectraWindow(self, puObj):
2826 2826
2827 2827 inputId = puObj.getInputId()
2828 2828 inputPUObj = self.__puObjDict[inputId]
2829 2829
2830 2830 if inputPUObj.datatype == 'Voltage':
2831 2831 self.specOpnFFTpoints.setEnabled(True)
2832 2832 self.specOpProfiles.setEnabled(True)
2833 2833 self.specOpippFactor.setEnabled(True)
2834 2834 else:
2835 2835 self.specOpnFFTpoints.setEnabled(False)
2836 2836 self.specOpProfiles.setEnabled(False)
2837 2837 self.specOpippFactor.setEnabled(False)
2838 2838
2839 2839 opObj = puObj.getOperationObj(name='setRadarFrequency')
2840 2840 if opObj == None:
2841 2841 self.specOpRadarfrequency.clear()
2842 2842 self.specOpCebRadarfrequency.setCheckState(0)
2843 2843 else:
2844 2844 value = opObj.getParameterValue(parameterName='frequency')
2845 2845 value = str(float(value)/1e6)
2846 2846 self.specOpRadarfrequency.setText(value)
2847 2847 self.specOpRadarfrequency.setEnabled(True)
2848 2848 self.specOpCebRadarfrequency.setCheckState(QtCore.Qt.Checked)
2849 2849
2850 2850 opObj = puObj.getOperationObj(name="run")
2851 2851 if opObj == None:
2852 2852 self.specOpnFFTpoints.clear()
2853 2853 self.specOpProfiles.clear()
2854 2854 self.specOpippFactor.clear()
2855 2855 else:
2856 2856 parmObj = opObj.getParameterObj(parameterName='nFFTPoints')
2857 2857 if parmObj == None:
2858 2858 self.specOpnFFTpoints.clear()
2859 2859 else:
2860 2860 self.specOpnFFTpoints.setEnabled(True)
2861 2861 value = opObj.getParameterValue(parameterName='nFFTPoints')
2862 2862 self.specOpnFFTpoints.setText(str(value))
2863 2863
2864 2864 parmObj = opObj.getParameterObj(parameterName='nProfiles')
2865 2865 if parmObj == None:
2866 2866 self.specOpProfiles.clear()
2867 2867 else:
2868 2868 self.specOpProfiles.setEnabled(True)
2869 2869 value = opObj.getParameterValue(parameterName='nProfiles')
2870 2870 self.specOpProfiles.setText(str(value))
2871 2871
2872 2872 parmObj = opObj.getParameterObj(parameterName='ippFactor')
2873 2873 if parmObj == None:
2874 2874 self.specOpippFactor.clear()
2875 2875 else:
2876 2876 self.specOpippFactor.setEnabled(True)
2877 2877 value = opObj.getParameterValue(parameterName='ippFactor')
2878 2878 self.specOpippFactor.setText(str(value))
2879 2879
2880 2880 opObj = puObj.getOperationObj(name="run")
2881 2881 if opObj == None:
2882 2882 self.specOppairsList.clear()
2883 2883 self.specOpCebCrossSpectra.setCheckState(0)
2884 2884 else:
2885 2885 parmObj = opObj.getParameterObj(parameterName='pairsList')
2886 2886 if parmObj == None:
2887 2887 self.specOppairsList.clear()
2888 2888 self.specOpCebCrossSpectra.setCheckState(0)
2889 2889 else:
2890 2890 value = opObj.getParameterValue(parameterName='pairsList')
2891 2891 value = str(value)[1:-1]
2892 2892 self.specOppairsList.setText(str(value))
2893 2893 self.specOppairsList.setEnabled(True)
2894 2894 self.specOpCebCrossSpectra.setCheckState(QtCore.Qt.Checked)
2895 2895
2896 2896 opObj = puObj.getOperationObj(name="selectChannels")
2897 2897
2898 2898 if opObj == None:
2899 2899 opObj = puObj.getOperationObj(name="selectChannelsByIndex")
2900 2900
2901 2901 if opObj == None:
2902 2902 self.specOpChannel.clear()
2903 2903 self.specOpCebChannel.setCheckState(0)
2904 2904 else:
2905 2905 channelEnabled = False
2906 2906 try:
2907 2907 value = opObj.getParameterValue(parameterName='channelList')
2908 2908 value = str(value)[1:-1]
2909 2909 channelEnabled = True
2910 2910 channelMode = 0
2911 2911 except:
2912 2912 pass
2913 2913 try:
2914 2914 value = opObj.getParameterValue(parameterName='channelIndexList')
2915 2915 value = str(value)[1:-1]
2916 2916 channelEnabled = True
2917 2917 channelMode = 1
2918 2918 except:
2919 2919 pass
2920 2920
2921 2921 if channelEnabled:
2922 2922 self.specOpChannel.setText(value)
2923 2923 self.specOpChannel.setEnabled(True)
2924 2924 self.specOpCebChannel.setCheckState(QtCore.Qt.Checked)
2925 2925 self.specOpComChannel.setCurrentIndex(channelMode)
2926 2926
2927 2927 opObj = puObj.getOperationObj(name="selectHeights")
2928 2928 if opObj == None:
2929 2929 self.specOpHeights.clear()
2930 2930 self.specOpCebHeights.setCheckState(0)
2931 2931 else:
2932 2932 value1 = int(opObj.getParameterValue(parameterName='minHei'))
2933 2933 value1 = str(value1)
2934 2934 value2 = int(opObj.getParameterValue(parameterName='maxHei'))
2935 2935 value2 = str(value2)
2936 2936 value = value1 + "," + value2
2937 2937 self.specOpHeights.setText(value)
2938 2938 self.specOpHeights.setEnabled(True)
2939 2939 self.specOpCebHeights.setCheckState(QtCore.Qt.Checked)
2940 2940
2941 2941 opObj = puObj.getOperationObj(name="IncohInt")
2942 2942 if opObj == None:
2943 2943 self.specOpIncoherent.clear()
2944 2944 self.specOpCebIncoherent.setCheckState(0)
2945 2945 else:
2946 2946 for parmObj in opObj.getParameterObjList():
2947 2947 if parmObj.name == 'timeInterval':
2948 2948 value = opObj.getParameterValue(parameterName='timeInterval')
2949 2949 value = float(value)
2950 2950 self.specOpIncoherent.setText(str(value))
2951 2951 self.specOpIncoherent.setEnabled(True)
2952 2952 self.specOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
2953 2953 self.specOpCobIncInt.setCurrentIndex(0)
2954 2954
2955 2955 if parmObj.name == 'n':
2956 2956 value = opObj.getParameterValue(parameterName='n')
2957 2957 value = float(value)
2958 2958 self.specOpIncoherent.setText(str(value))
2959 2959 self.specOpIncoherent.setEnabled(True)
2960 2960 self.specOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
2961 2961 self.specOpCobIncInt.setCurrentIndex(1)
2962 2962
2963 2963 opObj = puObj.getOperationObj(name="removeDC")
2964 2964 if opObj == None:
2965 2965 self.specOpCebRemoveDC.setCheckState(0)
2966 2966 else:
2967 2967 self.specOpCebRemoveDC.setCheckState(QtCore.Qt.Checked)
2968 2968 value = opObj.getParameterValue(parameterName='mode')
2969 2969 if value == 1:
2970 2970 self.specOpComRemoveDC.setCurrentIndex(0)
2971 2971 elif value == 2:
2972 2972 self.specOpComRemoveDC.setCurrentIndex(1)
2973 2973
2974 2974 opObj = puObj.getOperationObj(name="removeInterference")
2975 2975 if opObj == None:
2976 2976 self.specOpCebRemoveInt.setCheckState(0)
2977 2977 else:
2978 2978 self.specOpCebRemoveInt.setCheckState(QtCore.Qt.Checked)
2979 2979
2980 2980 opObj = puObj.getOperationObj(name='getNoise')
2981 2981 if opObj == None:
2982 2982 self.specOpCebgetNoise.setCheckState(0)
2983 2983 self.specOpgetNoise.clear()
2984 2984 else:
2985 2985 self.specOpCebgetNoise.setCheckState(QtCore.Qt.Checked)
2986 2986 parmObj = opObj.getParameterObj(parameterName='minHei')
2987 2987 if parmObj == None:
2988 2988 self.specOpgetNoise.clear()
2989 2989 value1 = None
2990 2990 else:
2991 2991 value1 = opObj.getParameterValue(parameterName='minHei')
2992 2992 value1 = str(value1)
2993 2993 parmObj = opObj.getParameterObj(parameterName='maxHei')
2994 2994 if parmObj == None:
2995 2995 value2 = None
2996 2996 value = value1
2997 2997 self.specOpgetNoise.setText(value)
2998 2998 self.specOpgetNoise.setEnabled(True)
2999 2999 else:
3000 3000 value2 = opObj.getParameterValue(parameterName='maxHei')
3001 3001 value2 = str(value2)
3002 3002 parmObj = opObj.getParameterObj(parameterName='minVel')
3003 3003 if parmObj == None:
3004 3004 value3 = None
3005 3005 value = value1 + "," + value2
3006 3006 self.specOpgetNoise.setText(value)
3007 3007 self.specOpgetNoise.setEnabled(True)
3008 3008 else:
3009 3009 value3 = opObj.getParameterValue(parameterName='minVel')
3010 3010 value3 = str(value3)
3011 3011 parmObj = opObj.getParameterObj(parameterName='maxVel')
3012 3012 if parmObj == None:
3013 3013 value4 = None
3014 3014 value = value1 + "," + value2 + "," + value3
3015 3015 self.specOpgetNoise.setText(value)
3016 3016 self.specOpgetNoise.setEnabled(True)
3017 3017 else:
3018 3018 value4 = opObj.getParameterValue(parameterName='maxVel')
3019 3019 value4 = str(value4)
3020 3020 value = value1 + "," + value2 + "," + value3 + ',' + value4
3021 3021 self.specOpgetNoise.setText(value)
3022 3022 self.specOpgetNoise.setEnabled(True)
3023 3023
3024 3024 self.specGraphPath.clear()
3025 3025 self.specGraphPrefix.clear()
3026 3026 self.specGgraphFreq.clear()
3027 3027 self.specGgraphHeight.clear()
3028 3028 self.specGgraphDbsrange.clear()
3029 3029 self.specGgraphmagnitud.clear()
3030 3030 self.specGgraphPhase.clear()
3031 3031 self.specGgraphChannelList.clear()
3032 3032 self.specGgraphTminTmax.clear()
3033 3033 self.specGgraphTimeRange.clear()
3034 3034 self.specGgraphftpratio.clear()
3035 3035
3036 3036 opObj = puObj.getOperationObj(name='SpectraPlot')
3037 3037
3038 3038 if opObj == None:
3039 3039 self.specGraphCebSpectraplot.setCheckState(0)
3040 3040 self.specGraphSaveSpectra.setCheckState(0)
3041 3041 self.specGraphftpSpectra.setCheckState(0)
3042 3042 else:
3043 3043 operationSpectraPlot = "Enable"
3044 3044 self.specGraphCebSpectraplot.setCheckState(QtCore.Qt.Checked)
3045 3045 parmObj = opObj.getParameterObj(parameterName='channelList')
3046 3046 if parmObj == None:
3047 3047 self.specGgraphChannelList.clear()
3048 3048 else:
3049 3049 value = opObj.getParameterValue(parameterName='channelList')
3050 3050 channelListSpectraPlot = str(value)[1:-1]
3051 3051 self.specGgraphChannelList.setText(channelListSpectraPlot)
3052 3052 self.specGgraphChannelList.setEnabled(True)
3053 3053
3054 3054 parmObj = opObj.getParameterObj(parameterName='xmin')
3055 3055 if parmObj == None:
3056 3056 self.specGgraphFreq.clear()
3057 3057 else:
3058 3058 value1 = opObj.getParameterValue(parameterName='xmin')
3059 3059 value1 = str(value1)
3060 3060 value2 = opObj.getParameterValue(parameterName='xmax')
3061 3061 value2 = str(value2)
3062 3062 value = value1 + "," + value2
3063 3063 self.specGgraphFreq.setText(value)
3064 3064 self.specGgraphFreq.setEnabled(True)
3065 3065
3066 3066 parmObj = opObj.getParameterObj(parameterName='ymin')
3067 3067 if parmObj == None:
3068 3068 self.specGgraphHeight.clear()
3069 3069 else:
3070 3070 value1 = opObj.getParameterValue(parameterName='ymin')
3071 3071 value1 = str(value1)
3072 3072 value2 = opObj.getParameterValue(parameterName='ymax')
3073 3073 value2 = str(value2)
3074 3074 value = value1 + "," + value2
3075 3075 self.specGgraphHeight.setText(value)
3076 3076 self.specGgraphHeight.setEnabled(True)
3077 3077
3078 3078 parmObj = opObj.getParameterObj(parameterName='zmin')
3079 3079 if parmObj == None:
3080 3080 self.specGgraphDbsrange.clear()
3081 3081 else:
3082 3082 value1 = opObj.getParameterValue(parameterName='zmin')
3083 3083 value1 = str(value1)
3084 3084 value2 = opObj.getParameterValue(parameterName='zmax')
3085 3085 value2 = str(value2)
3086 3086 value = value1 + "," + value2
3087 3087 self.specGgraphDbsrange.setText(value)
3088 3088 self.specGgraphDbsrange.setEnabled(True)
3089 3089
3090 3090 parmObj = opObj.getParameterObj(parameterName="save")
3091 3091 if parmObj == None:
3092 3092 self.specGraphSaveSpectra.setCheckState(0)
3093 3093 else:
3094 3094 self.specGraphSaveSpectra.setCheckState(QtCore.Qt.Checked)
3095 3095
3096 3096 parmObj = opObj.getParameterObj(parameterName="ftp")
3097 3097 if parmObj == None:
3098 3098 self.specGraphftpSpectra.setCheckState(0)
3099 3099 else:
3100 3100 self.specGraphftpSpectra.setCheckState(QtCore.Qt.Checked)
3101 3101
3102 3102 parmObj = opObj.getParameterObj(parameterName="figpath")
3103 3103 if parmObj:
3104 3104 value = parmObj.getValue()
3105 3105 self.specGraphPath.setText(value)
3106 3106
3107 3107 parmObj = opObj.getParameterObj(parameterName="wr_period")
3108 3108 if parmObj:
3109 3109 value = parmObj.getValue()
3110 3110 self.specGgraphftpratio.setText(str(value))
3111 3111
3112 ########################################################
3113 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
3114 if parmObj:
3115 value = parmObj.getValue()
3116 self.temporalFTP.ftp_wei = str(value)
3117
3118 parmObj = opObj.getParameterObj(parameterName="exp_code")
3119 if parmObj:
3120 value = parmObj.getValue()
3121 self.temporalFTP.exp_code = str(value)
3122
3123 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
3124 if parmObj:
3125 value = parmObj.getValue()
3126 self.temporalFTP.sub_exp_code = str(value)
3127
3128 parmObj = opObj.getParameterObj(parameterName="plot_pos")
3129 if parmObj:
3130 value = parmObj.getValue()
3131 self.temporalFTP.plot_pos = str(value)
3132
3133 3112 opObj = puObj.getOperationObj(name='CrossSpectraPlot')
3134 3113
3135 3114 if opObj == None:
3136 3115 self.specGraphCebCrossSpectraplot.setCheckState(0)
3137 3116 self.specGraphSaveCross.setCheckState(0)
3138 3117 self.specGraphftpCross.setCheckState(0)
3139 3118 else:
3140 3119 operationCrossSpectraPlot = "Enable"
3141 3120 self.specGraphCebCrossSpectraplot.setCheckState(QtCore.Qt.Checked)
3142 3121 parmObj = opObj.getParameterObj(parameterName='xmin')
3143 3122 if parmObj == None:
3144 3123 self.specGgraphFreq.clear()
3145 3124 else:
3146 3125 value1 = opObj.getParameterValue(parameterName='xmin')
3147 3126 value1 = str(value1)
3148 3127 value2 = opObj.getParameterValue(parameterName='xmax')
3149 3128 value2 = str(value2)
3150 3129 value = value1 + "," + value2
3151 3130 self.specGgraphFreq.setText(value)
3152 3131 self.specGgraphFreq.setEnabled(True)
3153 3132
3154 3133 parmObj = opObj.getParameterObj(parameterName='ymin')
3155 3134 if parmObj == None:
3156 3135 self.specGgraphHeight.clear()
3157 3136 else:
3158 3137 value1 = opObj.getParameterValue(parameterName='ymin')
3159 3138 value1 = str(value1)
3160 3139 value2 = opObj.getParameterValue(parameterName='ymax')
3161 3140 value2 = str(value2)
3162 3141 value = value1 + "," + value2
3163 3142 self.specGgraphHeight.setText(value)
3164 3143 self.specGgraphHeight.setEnabled(True)
3165 3144
3166 3145 parmObj = opObj.getParameterObj(parameterName='zmin')
3167 3146 if parmObj == None:
3168 3147 self.specGgraphDbsrange.clear()
3169 3148 else:
3170 3149 value1 = opObj.getParameterValue(parameterName='zmin')
3171 3150 value1 = str(value1)
3172 3151 value2 = opObj.getParameterValue(parameterName='zmax')
3173 3152 value2 = str(value2)
3174 3153 value = value1 + "," + value2
3175 3154 self.specGgraphDbsrange.setText(value)
3176 3155 self.specGgraphDbsrange.setEnabled(True)
3177 3156
3178 3157 parmObj = opObj.getParameterObj(parameterName='coh_min')
3179 3158 if parmObj == None:
3180 3159 self.specGgraphmagnitud.clear()
3181 3160 else:
3182 3161 value1 = opObj.getParameterValue(parameterName='coh_min')
3183 3162 value1 = str(value1)
3184 3163 value2 = opObj.getParameterValue(parameterName='coh_max')
3185 3164 value2 = str(value2)
3186 3165 value = value1 + "," + value2
3187 3166 self.specGgraphmagnitud.setText(value)
3188 3167 self.specGgraphmagnitud.setEnabled(True)
3189 3168
3190 3169 parmObj = opObj.getParameterObj(parameterName='phase_min')
3191 3170 if parmObj == None:
3192 3171 self.specGgraphPhase.clear()
3193 3172 else:
3194 3173 value1 = opObj.getParameterValue(parameterName='phase_min')
3195 3174 value1 = str(value1)
3196 3175 value2 = opObj.getParameterValue(parameterName='phase_max')
3197 3176 value2 = str(value2)
3198 3177 value = value1 + "," + value2
3199 3178 self.specGgraphPhase.setText(value)
3200 3179 self.specGgraphPhase.setEnabled(True)
3201 3180
3202 3181 parmObj = opObj.getParameterObj(parameterName="save")
3203 3182 if parmObj == None:
3204 3183 self.specGraphSaveCross.setCheckState(0)
3205 3184 else:
3206 3185 self.specGraphSaveCross.setCheckState(QtCore.Qt.Checked)
3207 3186
3208 3187 parmObj = opObj.getParameterObj(parameterName="ftp")
3209 3188 if parmObj == None:
3210 3189 self.specGraphftpCross.setCheckState(0)
3211 3190 else:
3212 3191 self.specGraphftpCross.setCheckState(QtCore.Qt.Checked)
3213 3192
3214 3193 parmObj = opObj.getParameterObj(parameterName="figpath")
3215 3194 if parmObj:
3216 3195 value = parmObj.getValue()
3217 3196 self.specGraphPath.setText(value)
3218 3197
3219 3198 parmObj = opObj.getParameterObj(parameterName="wr_period")
3220 3199 if parmObj:
3221 3200 value = parmObj.getValue()
3222 3201 self.specGgraphftpratio.setText(str(value))
3223 3202
3224 ########################################################
3225 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
3226 if parmObj:
3227 value = parmObj.getValue()
3228 self.temporalFTP.ftp_wei = str(value)
3229
3230 parmObj = opObj.getParameterObj(parameterName="exp_code")
3231 if parmObj:
3232 value = parmObj.getValue()
3233 self.temporalFTP.exp_code = str(value)
3234
3235 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
3236 if parmObj:
3237 value = parmObj.getValue()
3238 self.temporalFTP.sub_exp_code = str(value)
3239
3240 parmObj = opObj.getParameterObj(parameterName="plot_pos")
3241 if parmObj:
3242 value = parmObj.getValue()
3243 self.temporalFTP.plot_pos = str(value)
3244
3245 3203 opObj = puObj.getOperationObj(name='RTIPlot')
3246 3204
3247 3205 if opObj == None:
3248 3206 self.specGraphCebRTIplot.setCheckState(0)
3249 3207 self.specGraphSaveRTIplot.setCheckState(0)
3250 3208 self.specGraphftpRTIplot.setCheckState(0)
3251 3209 else:
3252 3210 self.specGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
3253 3211 parmObj = opObj.getParameterObj(parameterName='channelList')
3254 3212 if parmObj == None:
3255 3213 self.specGgraphChannelList.clear()
3256 3214 else:
3257 3215 value = opObj.getParameterValue(parameterName='channelList')
3258 3216 channelListRTIPlot = str(value)[1:-1]
3259 3217 self.specGgraphChannelList.setText(channelListRTIPlot)
3260 3218 self.specGgraphChannelList.setEnabled(True)
3261 3219
3262 3220 parmObj = opObj.getParameterObj(parameterName='xmin')
3263 3221 if parmObj == None:
3264 3222 self.specGgraphTminTmax.clear()
3265 3223 else:
3266 3224 value1 = opObj.getParameterValue(parameterName='xmin')
3267 3225 value1 = str(value1)
3268 3226 value2 = opObj.getParameterValue(parameterName='xmax')
3269 3227 value2 = str(value2)
3270 3228 value = value1 + "," + value2
3271 3229 self.specGgraphTminTmax.setText(value)
3272 3230 self.specGgraphTminTmax.setEnabled(True)
3273 3231
3274 3232 parmObj = opObj.getParameterObj(parameterName='timerange')
3275 3233 if parmObj == None:
3276 3234 self.specGgraphTimeRange.clear()
3277 3235 else:
3278 3236 value1 = opObj.getParameterValue(parameterName='timerange')
3279 3237 value1 = str(value1)
3280 3238 self.specGgraphTimeRange.setText(value1)
3281 3239 self.specGgraphTimeRange.setEnabled(True)
3282 3240
3283 3241 parmObj = opObj.getParameterObj(parameterName='ymin')
3284 3242 if parmObj == None:
3285 3243 self.specGgraphHeight.clear()
3286 3244 else:
3287 3245 value1 = opObj.getParameterValue(parameterName='ymin')
3288 3246 value1 = str(value1)
3289 3247 value2 = opObj.getParameterValue(parameterName='ymax')
3290 3248 value2 = str(value2)
3291 3249 value = value1 + "," + value2
3292 3250 self.specGgraphHeight.setText(value)
3293 3251 self.specGgraphHeight.setEnabled(True)
3294 3252
3295 3253 parmObj = opObj.getParameterObj(parameterName='zmin')
3296 3254 if parmObj == None:
3297 3255 self.specGgraphDbsrange.clear()
3298 3256 else:
3299 3257 value1 = opObj.getParameterValue(parameterName='zmin')
3300 3258 value1 = str(value1)
3301 3259 value2 = opObj.getParameterValue(parameterName='zmax')
3302 3260 value2 = str(value2)
3303 3261 value = value1 + "," + value2
3304 3262 self.specGgraphDbsrange.setText(value)
3305 3263 self.specGgraphDbsrange.setEnabled(True)
3306 3264
3307 3265 parmObj = opObj.getParameterObj(parameterName="save")
3308 3266 if parmObj == None:
3309 3267 self.specGraphSaveRTIplot.setCheckState(0)
3310 3268 else:
3311 3269 self.specGraphSaveRTIplot.setCheckState(QtCore.Qt.Checked)
3312 3270
3313 3271 parmObj = opObj.getParameterObj(parameterName="ftp")
3314 3272 if parmObj == None:
3315 3273 self.specGraphftpRTIplot.setCheckState(0)
3316 3274 else:
3317 3275 self.specGraphftpRTIplot.setCheckState(QtCore.Qt.Checked)
3318 3276
3319 3277 parmObj = opObj.getParameterObj(parameterName="figpath")
3320 3278 if parmObj:
3321 3279 value = parmObj.getValue()
3322 3280 self.specGraphPath.setText(value)
3323 3281
3324 3282 parmObj = opObj.getParameterObj(parameterName="wr_period")
3325 3283 if parmObj:
3326 3284 value = parmObj.getValue()
3327 3285 self.specGgraphftpratio.setText(str(value))
3328
3329 ########################################################
3330 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
3331 if parmObj:
3332 value = parmObj.getValue()
3333 self.temporalFTP.ftp_wei = str(value)
3334
3335 parmObj = opObj.getParameterObj(parameterName="exp_code")
3336 if parmObj:
3337 value = parmObj.getValue()
3338 self.temporalFTP.exp_code = str(value)
3339
3340 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
3341 if parmObj:
3342 value = parmObj.getValue()
3343 self.temporalFTP.sub_exp_code = str(value)
3344
3345 parmObj = opObj.getParameterObj(parameterName="plot_pos")
3346 if parmObj:
3347 value = parmObj.getValue()
3348 self.temporalFTP.plot_pos = str(value)
3349 3286
3350 3287 opObj = puObj.getOperationObj(name='CoherenceMap')
3351 3288
3352 3289 if opObj == None:
3353 3290 self.specGraphCebCoherencmap.setCheckState(0)
3354 3291 self.specGraphSaveCoherencemap.setCheckState(0)
3355 3292 self.specGraphftpCoherencemap.setCheckState(0)
3356 3293 else:
3357 3294 operationCoherenceMap = "Enable"
3358 3295 self.specGraphCebCoherencmap.setCheckState(QtCore.Qt.Checked)
3359 3296 parmObj = opObj.getParameterObj(parameterName='xmin')
3360 3297 if parmObj == None:
3361 3298 self.specGgraphTminTmax.clear()
3362 3299 else:
3363 3300 value1 = opObj.getParameterValue(parameterName='xmin')
3364 3301 value1 = str(value1)
3365 3302 value2 = opObj.getParameterValue(parameterName='xmax')
3366 3303 value2 = str(value2)
3367 3304 value = value1 + "," + value2
3368 3305 self.specGgraphTminTmax.setText(value)
3369 3306 self.specGgraphTminTmax.setEnabled(True)
3370 3307
3371 3308 parmObj = opObj.getParameterObj(parameterName='timerange')
3372 3309 if parmObj == None:
3373 3310 self.specGgraphTimeRange.clear()
3374 3311 else:
3375 3312 value1 = opObj.getParameterValue(parameterName='timerange')
3376 3313 value1 = str(value1)
3377 3314 self.specGgraphTimeRange.setText(value1)
3378 3315 self.specGgraphTimeRange.setEnabled(True)
3379 3316
3380 3317 parmObj = opObj.getParameterObj(parameterName='ymin')
3381 3318 if parmObj == None:
3382 3319 self.specGgraphHeight.clear()
3383 3320 else:
3384 3321 value1 = opObj.getParameterValue(parameterName='ymin')
3385 3322 value1 = str(value1)
3386 3323 value2 = opObj.getParameterValue(parameterName='ymax')
3387 3324 value2 = str(value2)
3388 3325 value = value1 + "," + value2
3389 3326 self.specGgraphHeight.setText(value)
3390 3327 self.specGgraphHeight.setEnabled(True)
3391 3328
3392 3329 parmObj = opObj.getParameterObj(parameterName='zmin')
3393 3330 if parmObj == None:
3394 3331 self.specGgraphmagnitud.clear()
3395 3332 else:
3396 3333 value1 = opObj.getParameterValue(parameterName='zmin')
3397 3334 value1 = str(value1)
3398 3335 value2 = opObj.getParameterValue(parameterName='zmax')
3399 3336 value2 = str(value2)
3400 3337 value = value1 + "," + value2
3401 3338 self.specGgraphmagnitud.setText(value)
3402 3339 self.specGgraphmagnitud.setEnabled(True)
3403 3340
3404 3341 parmObj = opObj.getParameterObj(parameterName='coh_min')
3405 3342 if parmObj == None:
3406 3343 self.specGgraphmagnitud.clear()
3407 3344 else:
3408 3345 value1 = opObj.getParameterValue(parameterName='coh_min')
3409 3346 value1 = str(value1)
3410 3347 value2 = opObj.getParameterValue(parameterName='coh_max')
3411 3348 value2 = str(value2)
3412 3349 value = value1 + "," + value2
3413 3350 self.specGgraphmagnitud.setText(value)
3414 3351 self.specGgraphmagnitud.setEnabled(True)
3415 3352
3416 3353 parmObj = opObj.getParameterObj(parameterName='phase_min')
3417 3354 if parmObj == None:
3418 3355 self.specGgraphPhase.clear()
3419 3356 else:
3420 3357 value1 = opObj.getParameterValue(parameterName='phase_min')
3421 3358 value1 = str(value1)
3422 3359 value2 = opObj.getParameterValue(parameterName='phase_max')
3423 3360 value2 = str(value2)
3424 3361 value = value1 + "," + value2
3425 3362 self.specGgraphPhase.setText(value)
3426 3363 self.specGgraphPhase.setEnabled(True)
3427 3364
3428 3365 parmObj = opObj.getParameterObj(parameterName="save")
3429 3366 if parmObj == None:
3430 3367 self.specGraphSaveCoherencemap.setCheckState(0)
3431 3368 else:
3432 3369 self.specGraphSaveCoherencemap.setCheckState(QtCore.Qt.Checked)
3433 3370
3434 3371 parmObj = opObj.getParameterObj(parameterName="ftp")
3435 3372 if parmObj == None:
3436 3373 self.specGraphftpCoherencemap.setCheckState(0)
3437 3374 else:
3438 3375 self.specGraphftpCoherencemap.setCheckState(QtCore.Qt.Checked)
3439 3376
3440 3377 parmObj = opObj.getParameterObj(parameterName="figpath")
3441 3378 if parmObj:
3442 3379 value = parmObj.getValue()
3443 3380 self.specGraphPath.setText(value)
3444 3381
3445 3382 parmObj = opObj.getParameterObj(parameterName="wr_period")
3446 3383 if parmObj:
3447 3384 value = parmObj.getValue()
3448 3385 self.specGgraphftpratio.setText(str(value))
3449
3450 ########################################################
3451 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
3452 if parmObj:
3453 value = parmObj.getValue()
3454 self.temporalFTP.ftp_wei = str(value)
3455
3456 parmObj = opObj.getParameterObj(parameterName="exp_code")
3457 if parmObj:
3458 value = parmObj.getValue()
3459 self.temporalFTP.exp_code = str(value)
3460
3461 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
3462 if parmObj:
3463 value = parmObj.getValue()
3464 self.temporalFTP.sub_exp_code = str(value)
3465
3466 parmObj = opObj.getParameterObj(parameterName="plot_pos")
3467 if parmObj:
3468 value = parmObj.getValue()
3469 self.temporalFTP.plot_pos = str(value)
3470 3386
3471 3387 opObj = puObj.getOperationObj(name='PowerProfilePlot')
3472 3388
3473 3389 if opObj == None:
3474 3390 self.specGraphPowerprofile.setCheckState(0)
3475 3391 self.specGraphSavePowerprofile.setCheckState(0)
3476 3392 self.specGraphftpPowerprofile.setCheckState(0)
3477 3393 operationPowerProfilePlot = "Disabled"
3478 3394 channelList = None
3479 3395 freq_vel = None
3480 3396 heightsrange = None
3481 3397 else:
3482 3398 operationPowerProfilePlot = "Enable"
3483 3399 self.specGraphPowerprofile.setCheckState(QtCore.Qt.Checked)
3484 3400 parmObj = opObj.getParameterObj(parameterName='xmin')
3485 3401 if parmObj == None:
3486 3402 self.specGgraphDbsrange.clear()
3487 3403 else:
3488 3404 value1 = opObj.getParameterValue(parameterName='xmin')
3489 3405 value1 = str(value1)
3490 3406 value2 = opObj.getParameterValue(parameterName='xmax')
3491 3407 value2 = str(value2)
3492 3408 value = value1 + "," + value2
3493 3409 self.specGgraphDbsrange.setText(value)
3494 3410 self.specGgraphDbsrange.setEnabled(True)
3495 3411
3496 3412 parmObj = opObj.getParameterObj(parameterName='ymin')
3497 3413 if parmObj == None:
3498 3414 self.specGgraphHeight.clear()
3499 3415 else:
3500 3416 value1 = opObj.getParameterValue(parameterName='ymin')
3501 3417 value1 = str(value1)
3502 3418 value2 = opObj.getParameterValue(parameterName='ymax')
3503 3419 value2 = str(value2)
3504 3420 value = value1 + "," + value2
3505 3421 self.specGgraphHeight.setText(value)
3506 3422 self.specGgraphHeight.setEnabled(True)
3507 3423
3508 3424 parmObj = opObj.getParameterObj(parameterName="save")
3509 3425 if parmObj == None:
3510 3426 self.specGraphSavePowerprofile.setCheckState(0)
3511 3427 else:
3512 3428 self.specGraphSavePowerprofile.setCheckState(QtCore.Qt.Checked)
3513 3429
3514 3430 parmObj = opObj.getParameterObj(parameterName="ftp")
3515 3431 if parmObj == None:
3516 3432 self.specGraphftpPowerprofile.setCheckState(0)
3517 3433 else:
3518 3434 self.specGraphftpPowerprofile.setCheckState(QtCore.Qt.Checked)
3519 3435
3520 3436 parmObj = opObj.getParameterObj(parameterName="figpath")
3521 3437 if parmObj:
3522 3438 value = parmObj.getValue()
3523 3439 self.specGraphPath.setText(value)
3524 3440
3525 3441 parmObj = opObj.getParameterObj(parameterName="wr_period")
3526 3442 if parmObj:
3527 3443 value = parmObj.getValue()
3528 3444 self.specGgraphftpratio.setText(str(value))
3529
3530 ########################################################
3531 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
3532 if parmObj:
3533 value = parmObj.getValue()
3534 self.temporalFTP.ftp_wei = str(value)
3535
3536 parmObj = opObj.getParameterObj(parameterName="exp_code")
3537 if parmObj:
3538 value = parmObj.getValue()
3539 self.temporalFTP.exp_code = str(value)
3540
3541 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
3542 if parmObj:
3543 value = parmObj.getValue()
3544 self.temporalFTP.sub_exp_code = str(value)
3545
3546 parmObj = opObj.getParameterObj(parameterName="plot_pos")
3547 if parmObj:
3548 value = parmObj.getValue()
3549 self.temporalFTP.plot_pos = str(value)
3550 3445
3551 3446 opObj = puObj.getOperationObj(name='Noise')
3552 3447
3553 3448 if opObj == None:
3554 3449 self.specGraphCebRTInoise.setCheckState(0)
3555 3450 self.specGraphSaveRTInoise.setCheckState(0)
3556 3451 self.specGraphftpRTInoise.setCheckState(0)
3557 3452 else:
3558 3453 self.specGraphCebRTInoise.setCheckState(QtCore.Qt.Checked)
3559 3454 parmObj = opObj.getParameterObj(parameterName='channelList')
3560 3455 if parmObj == None:
3561 3456 self.specGgraphChannelList.clear()
3562 3457 else:
3563 3458 value = opObj.getParameterValue(parameterName='channelList')
3564 3459 channelListRTINoise = str(value)[1:-1]
3565 3460 self.specGgraphChannelList.setText(channelListRTINoise)
3566 3461 self.specGgraphChannelList.setEnabled(True)
3567 3462
3568 3463 parmObj = opObj.getParameterObj(parameterName='xmin')
3569 3464 if parmObj == None:
3570 3465 self.specGgraphTminTmax.clear()
3571 3466 else:
3572 3467 value1 = opObj.getParameterValue(parameterName='xmin')
3573 3468 value1 = str(value1)
3574 3469 value2 = opObj.getParameterValue(parameterName='xmax')
3575 3470 value2 = str(value2)
3576 3471 value = value1 + "," + value2
3577 3472 self.specGgraphTminTmax.setText(value)
3578 3473 self.specGgraphTminTmax.setEnabled(True)
3579 3474
3580 3475 parmObj = opObj.getParameterObj(parameterName='timerange')
3581 3476 if parmObj == None:
3582 3477 self.specGgraphTimeRange.clear()
3583 3478 else:
3584 3479 value1 = opObj.getParameterValue(parameterName='timerange')
3585 3480 value1 = str(value1)
3586 3481 self.specGgraphTimeRange.setText(value1)
3587 3482 self.specGgraphTimeRange.setEnabled(True)
3588 3483
3589 3484
3590 3485 parmObj = opObj.getParameterObj(parameterName='ymin')
3591 3486 if parmObj == None:
3592 3487 self.specGgraphDbsrange.clear()
3593 3488 else:
3594 3489 value1 = opObj.getParameterValue(parameterName='ymin')
3595 3490 value1 = str(value1)
3596 3491 value2 = opObj.getParameterValue(parameterName='ymax')
3597 3492 value2 = str(value2)
3598 3493 value = value1 + "," + value2
3599 3494 self.specGgraphDbsrange.setText(value)
3600 3495 self.specGgraphDbsrange.setEnabled(True)
3601 3496
3602 3497 parmObj = opObj.getParameterObj(parameterName="save")
3603 3498 if parmObj == None:
3604 3499 self.specGraphSaveRTInoise.setCheckState(0)
3605 3500 else:
3606 3501 self.specGraphSaveRTInoise.setCheckState(QtCore.Qt.Checked)
3607 3502
3608 3503 parmObj = opObj.getParameterObj(parameterName="ftp")
3609 3504 if parmObj == None:
3610 3505 self.specGraphftpRTInoise.setCheckState(0)
3611 3506 else:
3612 3507 self.specGraphftpRTInoise.setCheckState(QtCore.Qt.Checked)
3613 3508
3614 3509 parmObj = opObj.getParameterObj(parameterName="figpath")
3615 3510 if parmObj:
3616 3511 value = parmObj.getValue()
3617 3512 self.specGraphPath.setText(value)
3618 3513
3619 3514 parmObj = opObj.getParameterObj(parameterName="wr_period")
3620 3515 if parmObj:
3621 3516 value = parmObj.getValue()
3622 3517 self.specGgraphftpratio.setText(str(value))
3623
3624 ########################################################
3625 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
3626 if parmObj:
3627 value = parmObj.getValue()
3628 self.temporalFTP.ftp_wei = str(value)
3629
3630 parmObj = opObj.getParameterObj(parameterName="exp_code")
3631 if parmObj:
3632 value = parmObj.getValue()
3633 self.temporalFTP.exp_code = str(value)
3634
3635 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
3636 if parmObj:
3637 value = parmObj.getValue()
3638 self.temporalFTP.sub_exp_code = str(value)
3639
3640 parmObj = opObj.getParameterObj(parameterName="plot_pos")
3641 if parmObj:
3642 value = parmObj.getValue()
3643 self.temporalFTP.plot_pos = str(value)
3644 3518
3645 3519 opObj = puObj.getOperationObj(name='SpectraWriter')
3646 3520 if opObj == None:
3647 3521 self.specOutputPath.clear()
3648 3522 self.specOutputblocksperfile.clear()
3649 3523 self.specOutputprofileperblock.clear()
3650 3524 else:
3651 3525 value = opObj.getParameterObj(parameterName='path')
3652 3526 if value == None:
3653 3527 self.specOutputPath.clear()
3654 3528 else:
3655 3529 value = opObj.getParameterValue(parameterName='path')
3656 3530 path = str(value)
3657 3531 self.specOutputPath.setText(path)
3658 3532 value = opObj.getParameterObj(parameterName='blocksPerFile')
3659 3533 if value == None:
3660 3534 self.specOutputblocksperfile.clear()
3661 3535 else:
3662 3536 value = opObj.getParameterValue(parameterName='blocksPerFile')
3663 3537 blocksperfile = str(value)
3664 3538 self.specOutputblocksperfile.setText(blocksperfile)
3665 3539 value = opObj.getParameterObj(parameterName='profilesPerBlock')
3666 3540 if value == None:
3667 3541 self.specOutputprofileperblock.clear()
3668 3542 else:
3669 3543 value = opObj.getParameterValue(parameterName='profilesPerBlock')
3670 3544 profilesPerBlock = str(value)
3671 3545 self.specOutputprofileperblock.setText(profilesPerBlock)
3672 3546
3673 3547 return
3674 3548
3675 3549 def __refreshSpectraHeisWindow(self, puObj):
3676 3550
3677 3551 opObj = puObj.getOperationObj(name="IncohInt4SpectraHeis")
3678 3552 if opObj == None:
3679 3553 self.specHeisOpIncoherent.clear()
3680 3554 self.specHeisOpCebIncoherent.setCheckState(0)
3681 3555 else:
3682 3556 for parmObj in opObj.getParameterObjList():
3683 3557 if parmObj.name == 'timeInterval':
3684 3558 value = opObj.getParameterValue(parameterName='timeInterval')
3685 3559 value = float(value)
3686 3560 self.specHeisOpIncoherent.setText(str(value))
3687 3561 self.specHeisOpIncoherent.setEnabled(True)
3688 3562 self.specHeisOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
3689 3563 self.specHeisOpCobIncInt.setCurrentIndex(0)
3690 3564
3691 3565 # SpectraHeis Graph
3692 3566
3693 3567 self.specHeisGgraphXminXmax.clear()
3694 3568 self.specHeisGgraphYminYmax.clear()
3695 3569
3696 3570 self.specHeisGgraphChannelList.clear()
3697 3571 self.specHeisGgraphTminTmax.clear()
3698 3572 self.specHeisGgraphTimeRange.clear()
3699 3573 self.specHeisGgraphftpratio.clear()
3700 3574
3701 3575 opObj = puObj.getOperationObj(name='SpectraHeisScope')
3702 3576 if opObj == None:
3703 3577 self.specHeisGraphCebSpectraplot.setCheckState(0)
3704 3578 self.specHeisGraphSaveSpectra.setCheckState(0)
3705 3579 self.specHeisGraphftpSpectra.setCheckState(0)
3706 3580 else:
3707 3581 operationSpectraHeisScope = "Enable"
3708 3582 self.specHeisGraphCebSpectraplot.setCheckState(QtCore.Qt.Checked)
3709 3583
3710 3584 parmObj = opObj.getParameterObj(parameterName='channelList')
3711 3585 if parmObj == None:
3712 3586 self.specHeisGgraphChannelList.clear()
3713 3587 else:
3714 3588 value = opObj.getParameterValue(parameterName='channelList')
3715 3589 channelListSpectraHeisScope = str(value)[1:-1]
3716 3590 self.specHeisGgraphChannelList.setText(channelListSpectraHeisScope)
3717 3591 self.specHeisGgraphChannelList.setEnabled(True)
3718 3592
3719 3593 parmObj = opObj.getParameterObj(parameterName='xmin')
3720 3594 if parmObj == None:
3721 3595 self.specHeisGgraphXminXmax.clear()
3722 3596 else:
3723 3597 value1 = opObj.getParameterValue(parameterName='xmin')
3724 3598 value1 = str(value1)
3725 3599 value2 = opObj.getParameterValue(parameterName='xmax')
3726 3600 value2 = str(value2)
3727 3601 value = value1 + "," + value2
3728 3602 self.specHeisGgraphXminXmax.setText(value)
3729 3603 self.specHeisGgraphXminXmax.setEnabled(True)
3730 3604
3731 3605 parmObj = opObj.getParameterObj(parameterName='ymin')
3732 3606 if parmObj == None:
3733 3607 self.specHeisGgraphYminYmax.clear()
3734 3608 else:
3735 3609 value1 = opObj.getParameterValue(parameterName='ymin')
3736 3610 value1 = str(value1)
3737 3611 value2 = opObj.getParameterValue(parameterName='ymax')
3738 3612 value2 = str(value2)
3739 3613 value = value1 + "," + value2
3740 3614 self.specHeisGgraphYminYmax.setText(value)
3741 3615 self.specHeisGgraphYminYmax.setEnabled(True)
3742 3616
3743 3617 parmObj = opObj.getParameterObj(parameterName="save")
3744 3618 if parmObj == None:
3745 3619 self.specHeisGraphSaveSpectra.setCheckState(0)
3746 3620 else:
3747 3621 self.specHeisGraphSaveSpectra.setCheckState(QtCore.Qt.Checked)
3748 3622
3749 3623 parmObj = opObj.getParameterObj(parameterName="ftp")
3750 3624 if parmObj == None:
3751 3625 self.specHeisGraphftpSpectra.setCheckState(0)
3752 3626 else:
3753 3627 self.specHeisGraphftpSpectra.setCheckState(QtCore.Qt.Checked)
3754 3628
3755 3629 parmObj = opObj.getParameterObj(parameterName="figpath")
3756 3630 if parmObj:
3757 3631 value = parmObj.getValue()
3758 3632 self.specHeisGraphPath.setText(value)
3759 3633
3760 3634 parmObj = opObj.getParameterObj(parameterName="wr_period")
3761 3635 if parmObj:
3762 3636 value = parmObj.getValue()
3763 3637 self.specHeisGgraphftpratio.setText(str(value))
3764
3765 ########################################################
3766 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
3767 if parmObj:
3768 value = parmObj.getValue()
3769 self.temporalFTP.ftp_wei = str(value)
3770
3771 parmObj = opObj.getParameterObj(parameterName="exp_code")
3772 if parmObj:
3773 value = parmObj.getValue()
3774 self.temporalFTP.exp_code = str(value)
3775
3776 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
3777 if parmObj:
3778 value = parmObj.getValue()
3779 self.temporalFTP.sub_exp_code = str(value)
3780
3781 parmObj = opObj.getParameterObj(parameterName="plot_pos")
3782 if parmObj:
3783 value = parmObj.getValue()
3784 self.temporalFTP.plot_pos = str(value)
3785 3638
3786 3639 opObj = puObj.getOperationObj(name='RTIfromSpectraHeis')
3787 3640
3788 3641 if opObj == None:
3789 3642 self.specHeisGraphCebRTIplot.setCheckState(0)
3790 3643 self.specHeisGraphSaveRTIplot.setCheckState(0)
3791 3644 self.specHeisGraphftpRTIplot.setCheckState(0)
3792 3645 else:
3793 3646 self.specHeisGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
3794 3647 parmObj = opObj.getParameterObj(parameterName='channelList')
3795 3648 if parmObj == None:
3796 3649 self.specHeisGgraphChannelList.clear()
3797 3650 else:
3798 3651 value = opObj.getParameterValue(parameterName='channelList')
3799 3652 channelListRTIPlot = str(value)[1:-1]
3800 3653 self.specGgraphChannelList.setText(channelListRTIPlot)
3801 3654 self.specGgraphChannelList.setEnabled(True)
3802 3655
3803 3656 parmObj = opObj.getParameterObj(parameterName='xmin')
3804 3657 if parmObj == None:
3805 3658 self.specHeisGgraphTminTmax.clear()
3806 3659 else:
3807 3660 value1 = opObj.getParameterValue(parameterName='xmin')
3808 3661 value1 = str(value1)
3809 3662 value2 = opObj.getParameterValue(parameterName='xmax')
3810 3663 value2 = str(value2)
3811 3664 value = value1 + "," + value2
3812 3665 self.specHeisGgraphTminTmax.setText(value)
3813 3666 self.specHeisGgraphTminTmax.setEnabled(True)
3814 3667
3815 3668 parmObj = opObj.getParameterObj(parameterName='timerange')
3816 3669 if parmObj == None:
3817 3670 self.specGgraphTimeRange.clear()
3818 3671 else:
3819 3672 value1 = opObj.getParameterValue(parameterName='timerange')
3820 3673 value1 = str(value1)
3821 3674 self.specHeisGgraphTimeRange.setText(value1)
3822 3675 self.specHeisGgraphTimeRange.setEnabled(True)
3823 3676
3824 3677 parmObj = opObj.getParameterObj(parameterName='ymin')
3825 3678 if parmObj == None:
3826 3679 self.specHeisGgraphYminYmax.clear()
3827 3680 else:
3828 3681 value1 = opObj.getParameterValue(parameterName='ymin')
3829 3682 value1 = str(value1)
3830 3683 value2 = opObj.getParameterValue(parameterName='ymax')
3831 3684 value2 = str(value2)
3832 3685 value = value1 + "," + value2
3833 3686 self.specHeisGgraphYminYmax.setText(value)
3834 3687 self.specHeisGgraphYminYmax.setEnabled(True)
3835 3688
3836 3689 parmObj = opObj.getParameterObj(parameterName="save")
3837 3690 if parmObj == None:
3838 3691 self.specHeisGraphSaveRTIplot.setCheckState(0)
3839 3692 else:
3840 3693 self.specHeisGraphSaveRTIplot.setCheckState(QtCore.Qt.Checked)
3841 3694
3842 3695 parmObj = opObj.getParameterObj(parameterName="ftp")
3843 3696 if parmObj == None:
3844 3697 self.specHeisGraphftpRTIplot.setCheckState(0)
3845 3698 else:
3846 3699 self.specHeisGraphftpRTIplot.setCheckState(QtCore.Qt.Checked)
3847 3700
3848 3701 parmObj = opObj.getParameterObj(parameterName="figpath")
3849 3702 if parmObj:
3850 3703 value = parmObj.getValue()
3851 3704 self.specHeisGraphPath.setText(value)
3852 3705
3853 3706 parmObj = opObj.getParameterObj(parameterName="wr_period")
3854 3707 if parmObj:
3855 3708 value = parmObj.getValue()
3856 3709 self.specHeisGgraphftpratio.setText(str(value))
3857
3858 ########################################################
3859 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
3860 if parmObj:
3861 value = parmObj.getValue()
3862 self.temporalFTP.ftp_wei = str(value)
3863
3864 parmObj = opObj.getParameterObj(parameterName="exp_code")
3865 if parmObj:
3866 value = parmObj.getValue()
3867 self.temporalFTP.exp_code = str(value)
3868
3869 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
3870 if parmObj:
3871 value = parmObj.getValue()
3872 self.temporalFTP.sub_exp_code = str(value)
3873
3874 parmObj = opObj.getParameterObj(parameterName="plot_pos")
3875 if parmObj:
3876 value = parmObj.getValue()
3877 self.temporalFTP.plot_pos = str(value)
3878 3710
3879 3711 # outputSpectraHeisWrite
3880 3712 opObj = puObj.getOperationObj(name='FitsWriter')
3881 3713 if opObj == None:
3882 3714 self.specHeisOutputPath.clear()
3883 3715 self.specHeisOutputblocksperfile.clear()
3884 3716 self.specHeisOutputMetada.clear()
3885 3717 else:
3886 3718 value = opObj.getParameterObj(parameterName='path')
3887 3719 if value == None:
3888 3720 self.specHeisOutputPath.clear()
3889 3721 else:
3890 3722 value = opObj.getParameterValue(parameterName='path')
3891 3723 path = str(value)
3892 3724 self.specHeisOutputPath.setText(path)
3893 3725 value = opObj.getParameterObj(parameterName='dataBlocksPerFile')
3894 3726 if value == None:
3895 3727 self.specHeisOutputblocksperfile.clear()
3896 3728 else:
3897 3729 value = opObj.getParameterValue(parameterName='dataBlocksPerFile')
3898 3730 blocksperfile = str(value)
3899 3731 self.specHeisOutputblocksperfile.setText(blocksperfile)
3900 3732 value = opObj.getParameterObj(parameterName='metadatafile')
3901 3733 if value == None:
3902 3734 self.specHeisOutputMetada.clear()
3903 3735 else:
3904 3736 value = opObj.getParameterValue(parameterName='metadatafile')
3905 3737 metada = str(value)
3906 3738 self.specHeisOutputMetada.setText(metada)
3907 3739
3908 3740 return
3909 3741
3910 3742 def __refreshCorrelationWindow(self, puObj):
3911 3743 pass
3912 3744
3913 3745 def refreshPUWindow(self, puObj):
3914 3746
3915 3747 if puObj.datatype == 'Voltage':
3916 3748 self.__refreshVoltageWindow(puObj)
3917 3749
3918 3750 if puObj.datatype == 'Spectra':
3919 3751 self.__refreshSpectraWindow(puObj)
3920 3752
3921 3753 if puObj.datatype == 'SpectraHeis':
3922 3754 self.__refreshSpectraHeisWindow(puObj)
3923 3755
3924 3756 def refreshProjectProperties(self, projectObjView):
3925 3757
3926 3758 propertyBuffObj = PropertyBuffer()
3927 3759 name = projectObjView.name
3928 3760
3929 3761 propertyBuffObj.append("Properties", "Name", projectObjView.name),
3930 3762 propertyBuffObj.append("Properties", "Description", projectObjView.description)
3931 3763 propertyBuffObj.append("Properties", "Workspace", self.pathWorkSpace)
3932 3764
3933 3765 readUnitObj = projectObjView.getReadUnitObj()
3934 3766 runOperationObj = readUnitObj.getOperationObj(name='run')
3935 3767
3936 3768 for thisParmObj in runOperationObj.getParameterObjList():
3937 3769 propertyBuffObj.append("Reading parms", thisParmObj.name, str(thisParmObj.getValue()))
3938 3770
3939 3771 propertiesModel = propertyBuffObj.getPropertyModel()
3940 3772
3941 3773 self.treeProjectProperties.setModel(propertiesModel)
3942 3774 self.treeProjectProperties.expandAll()
3943 3775 self.treeProjectProperties.resizeColumnToContents(0)
3944 3776 self.treeProjectProperties.resizeColumnToContents(1)
3945 3777
3946 3778 def refreshPUProperties(self, puObjView):
3947 3779
3948 3780 ############ FTP CONFIG ################################
3781 #Deleting FTP Conf. This processing unit have not got any
3782 #FTP configuration by default
3949 3783 if puObjView.id in self.__puLocalFolder2FTP.keys():
3950 3784 self.__puLocalFolder2FTP.pop(puObjView.id)
3951 3785 ########################################################
3952 3786
3953 3787 propertyBuffObj = PropertyBuffer()
3954 3788
3955 3789 for thisOp in puObjView.getOperationObjList():
3956 3790
3957 3791 operationName = thisOp.name
3958 3792
3959 3793 if operationName == 'run':
3960 3794 operationName = 'Properties'
3961 3795
3962 if not thisOp.getParameterObjList():
3963 propertyBuffObj.append(operationName, '--', '--')
3964 continue
3796 else:
3797 if not thisOp.getParameterObjList():
3798 propertyBuffObj.append(operationName, '--', '--')
3799 continue
3965 3800
3966 3801 for thisParmObj in thisOp.getParameterObjList():
3967 3802 propertyBuffObj.append(operationName, thisParmObj.name, str(thisParmObj.getValue()))
3968 3803
3969 3804 ############ FTP CONFIG ################################
3805 if thisParmObj.name == "ftp_wei" and thisParmObj.getValue():
3806 value = thisParmObj.getValue()
3807 self.temporalFTP.ftp_wei = value
3808
3809 if thisParmObj.name == "exp_code" and thisParmObj.getValue():
3810 value = thisParmObj.getValue()
3811 self.temporalFTP.exp_code = value
3812
3813 if thisParmObj.name == "sub_exp_code" and thisParmObj.getValue():
3814 value = thisParmObj.getValue()
3815 self.temporalFTP.sub_exp_code = value
3816
3817 if thisParmObj.name == "plot_pos" and thisParmObj.getValue():
3818 value = thisParmObj.getValue()
3819 self.temporalFTP.plot_pos = value
3820
3970 3821 if thisParmObj.name == 'ftp' and thisParmObj.getValue():
3971 figpath = thisOp.getParameterValue('figpath')
3972 if not figpath:
3973 continue
3974 self.__puLocalFolder2FTP[puObjView.id] = figpath
3822 figpathObj = thisOp.getParameterObj('figpath')
3823 if figpathObj:
3824 self.__puLocalFolder2FTP[puObjView.id] = figpathObj.getValue()
3825
3975 3826 ########################################################
3976 3827
3977 3828 propertiesModel = propertyBuffObj.getPropertyModel()
3978 3829
3979 3830 self.treeProjectProperties.setModel(propertiesModel)
3980 3831 self.treeProjectProperties.expandAll()
3981 3832 self.treeProjectProperties.resizeColumnToContents(0)
3982 3833 self.treeProjectProperties.resizeColumnToContents(1)
3983 3834
3984 3835 def refreshGraphicsId(self):
3985 3836
3986 3837 projectObj = self.getSelectedProjectObj()
3987 3838
3988 3839 for idPU, puObj in projectObj.procUnitConfObjDict.items():
3989 3840
3990 3841 for opObj in puObj.getOperationObjList():
3991 3842
3992 3843 if opObj.name not in ('Scope', 'SpectraPlot', 'CrossSpectraPlot', 'RTIPlot', 'CoherenceMap', 'PowerProfilePlot', 'Noise', 'SpectraHeisScope', 'RTIfromSpectraHeis'):
3993 3844 continue
3994 3845
3995 3846 opObj.changeParameter(name='id', value=opObj.id, format='int')
3996 3847
3997 3848 def on_click(self, index):
3998 3849
3999 3850 self.selectedItemTree = self.projectExplorerModel.itemFromIndex(index)
4000 3851
4001 3852 projectObjView = self.getSelectedProjectObj()
4002 3853
4003 3854 if not projectObjView:
4004 3855 return
4005 3856
4006 3857 self.create = False
4007 3858 selectedObjView = self.getSelectedItemObj()
4008 3859
4009 3860 #A project has been selected
4010 3861 if projectObjView == selectedObjView:
4011 3862
4012 3863 self.refreshProjectWindow2(projectObjView)
4013 3864 self.refreshProjectProperties(projectObjView)
4014 3865
4015 3866 self.tabProject.setEnabled(True)
4016 3867 self.tabVoltage.setEnabled(False)
4017 3868 self.tabSpectra.setEnabled(False)
4018 3869 self.tabCorrelation.setEnabled(False)
4019 3870 self.tabSpectraHeis.setEnabled(False)
4020 3871 self.tabWidgetProject.setCurrentWidget(self.tabProject)
4021 3872
4022 3873 return
4023 3874
4024 3875 #A processing unit has been selected
4025 3876 voltEnable = False
4026 3877 specEnable = False
4027 3878 corrEnable = False
4028 3879 specHeisEnable = False
4029 3880 tabSelected = self.tabProject
4030 3881
4031 3882 puObj = selectedObjView
4032 3883
4033 3884 self.refreshPUWindow(puObj)
4034 3885 self.refreshPUProperties(puObj)
4035 3886 self.showtabPUCreated(puObj.datatype)
4036 3887
4037 3888 def on_right_click(self, pos):
4038 3889
4039 3890 self.menu = QtGui.QMenu()
4040 3891 quitAction0 = self.menu.addAction("Create a New Project")
4041 3892 quitAction1 = self.menu.addAction("Create a New Processing Unit")
4042 3893 quitAction2 = self.menu.addAction("Delete Item")
4043 3894 quitAction3 = self.menu.addAction("Quit")
4044 3895
4045 3896 if len(self.__itemTreeDict) == 0:
4046 3897 quitAction2.setEnabled(False)
4047 3898 else:
4048 3899 quitAction2.setEnabled(True)
4049 3900
4050 3901 action = self.menu.exec_(self.mapToGlobal(pos))
4051 3902
4052 3903 if action == quitAction0:
4053 3904 self. setInputsProject_View()
4054 3905 self.create = True
4055 3906
4056 3907 if action == quitAction1:
4057 3908 if len(self.__projectObjDict) == 0:
4058 3909 outputstr = "You need to create a Project before adding a Processing Unit"
4059 3910 self.console.clear()
4060 3911 self.console.append(outputstr)
4061 3912 return 0
4062 3913 else:
4063 3914 self.addPUWindow()
4064 3915 self.console.clear()
4065 3916 self.console.append("Please, Choose the type of Processing Unit")
4066 3917 # self.console.append("If your Datatype is rawdata, you will start with processing unit Type Voltage")
4067 3918 # self.console.append("If your Datatype is pdata, you will choose between processing unit Type Spectra or Correlation")
4068 3919 # self.console.append("If your Datatype is fits, you will start with processing unit Type SpectraHeis")
4069 3920
4070 3921 if action == quitAction2:
4071 3922 index = self.selectedItemTree
4072 3923 try:
4073 3924 index.parent()
4074 3925 except:
4075 3926 self.console.append('Please first select a Project or Processing Unit')
4076 3927 return 0
4077 3928 # print index.parent(),index
4078 3929 if index.parent() == None:
4079 3930 self.projectExplorerModel.removeRow(index.row())
4080 3931 else:
4081 3932 index.parent().removeRow(index.row())
4082 3933 self.removeItemTreeFromProject()
4083 3934 self.console.clear()
4084 3935 # for i in self.projectExplorerTree.selectionModel().selection().indexes():
4085 3936 # print i.row()
4086 3937
4087 3938 if action == quitAction3:
4088 3939 self.close()
4089 3940 return 0
4090 3941
4091 3942 def create_updating_timer(self):
4092 3943 self.comm_data_timer = QtCore.QTimer(self)
4093 3944 self.comm_data_timer.timeout.connect(self.on_comm_updating_timer)
4094 3945 self.comm_data_timer.start(1000)
4095 3946
4096 3947 def createProjectView(self, id):
4097 3948
4098 3949 # project_name, description, datatype, data_path, starDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
4099 3950 id = str(id)
4100 3951 projectParms = self.__getParmsFromProjectWindow()
4101 3952
4102 3953 if not projectParms.isValid():
4103 3954 return None
4104 3955
4105 3956 projectObjView = Project()
4106 3957 projectObjView.setup(id=id, name=projectParms.name, description=projectParms.description)
4107 3958
4108 3959 self.__projectObjDict[id] = projectObjView
4109 3960 self.addProject2ProjectExplorer(id=id, name=projectObjView.name)
4110 3961
4111 3962 self.create = False
4112 3963
4113 3964 return projectObjView
4114 3965
4115 3966 def updateProjectView(self):
4116 3967
4117 3968 # project_name, description, datatype, data_path, starDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
4118 3969
4119 3970 projectParms = self.__getParmsFromProjectWindow()
4120 3971
4121 3972 if not projectParms.isValid():
4122 3973 return None
4123 3974
4124 3975 projectObjView = self.getSelectedProjectObj()
4125 3976 projectObjView.update(name=projectParms.name, description=projectParms.description)
4126 3977
4127 3978 return projectObjView
4128 3979
4129 3980 def createReadUnitView(self, projectObjView):
4130 3981
4131 3982 # project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
4132 3983
4133 3984 projectParms = self.__getParmsFromProjectWindow()
4134 3985
4135 3986 if not projectParms.isValid():
4136 3987 return None
4137 3988
4138 3989 if projectParms.datatype in ("Voltage", "Spectra", "Fits"):
4139 3990 readUnitConfObj = projectObjView.addReadUnit(datatype=projectParms.datatype,
4140 3991 path=projectParms.dpath,
4141 3992 startDate=projectParms.startDate,
4142 3993 endDate=projectParms.endDate,
4143 3994 startTime=projectParms.startTime,
4144 3995 endTime=projectParms.endTime,
4145 3996 online=projectParms.online,
4146 3997 walk=projectParms.walk
4147 3998 )
4148 3999
4149 4000 if projectParms.set:
4150 4001 readUnitConfObj.addParameter(name="set", value=projectParms.set, format="int")
4151 4002
4152 4003 if projectParms.delay:
4153 4004 readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
4154 4005
4155 4006 if projectParms.datatype == "USRP":
4156 4007 readUnitConfObj = projectObjView.addReadUnit(datatype=projectParms.datatype,
4157 4008 path=projectParms.dpath,
4158 4009 startDate=projectParms.startDate,
4159 4010 endDate=projectParms.endDate,
4160 4011 startTime=projectParms.startTime,
4161 4012 endTime=projectParms.endTime,
4162 4013 online=projectParms.online,
4163 4014 ippKm=projectParms.ippKm
4164 4015 )
4165 4016
4166 4017 if projectParms.delay:
4167 4018 readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
4168 4019
4169 4020 return readUnitConfObj
4170 4021
4171 4022 def updateReadUnitView(self, projectObjView, idReadUnit):
4172 4023
4173 4024 # project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, walk , set = self.getParmsFromProjectWindow()
4174 4025
4175 4026 readUnitConfObj = projectObjView.getProcUnitObj(idReadUnit)
4176 4027
4177 4028 projectParms = self.__getParmsFromProjectWindow()
4178 4029
4179 4030 if not projectParms.isValid():
4180 4031 return None
4181 4032
4182 4033 if projectParms.datatype in ["Voltage", "Spectra", "Fits"]:
4183 4034 readUnitConfObj.update(datatype=projectParms.datatype,
4184 4035 path=projectParms.dpath,
4185 4036 startDate=projectParms.startDate,
4186 4037 endDate=projectParms.endDate,
4187 4038 startTime=projectParms.startTime,
4188 4039 endTime=projectParms.endTime,
4189 4040 online=projectParms.online,
4190 4041 walk=projectParms.walk
4191 4042 )
4192 4043 if projectParms.set:
4193 4044 readUnitConfObj.addParameter(name="set", value=projectParms.set, format="int")
4194 4045
4195 4046 if projectParms.delay:
4196 4047 readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
4197 4048
4198 4049 if projectParms.datatype == "USRP":
4199 4050 readUnitConfObj.update(datatype=projectParms.datatype,
4200 4051 path=projectParms.dpath,
4201 4052 startDate=projectParms.startDate,
4202 4053 endDate=projectParms.endDate,
4203 4054 startTime=projectParms.startTime,
4204 4055 endTime=projectParms.endTime,
4205 4056 online=projectParms.online,
4206 4057 ippKm=projectParms.ippKm
4207 4058 )
4208 4059
4209 4060 if projectParms.delay:
4210 4061 readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
4211 4062
4212 4063 return readUnitConfObj
4213 4064
4214 4065 def createProcUnitView(self, projectObjView, datatype, inputId):
4215 4066
4216 4067 procUnitConfObj = projectObjView.addProcUnit(datatype=datatype, inputId=inputId)
4217 4068
4218 4069 self.__puObjDict[procUnitConfObj.getId()] = procUnitConfObj
4219 4070
4220 4071 return procUnitConfObj
4221 4072
4222 4073 def updateProcUnitView(self, id):
4223 4074
4224 4075 procUnitConfObj = projectObjView.getProcUnitObj(id)
4225 4076 procUnitConfObj.removeOperations()
4226 4077
4227 4078 return procUnitConfObj
4228 4079
4229 4080 def addPUWindow(self):
4230 4081
4231 4082 self.configUPWindowObj = UnitProcessWindow(self)
4232 4083 fatherObj = self.getSelectedItemObj()
4233 4084 try:
4234 4085 fatherObj.getElementName()
4235 4086 except:
4236 4087 self.console.append("First left click on Project or Processing Unit")
4237 4088 return 0
4238 4089
4239 4090 if fatherObj.getElementName() == 'Project':
4240 4091 readUnitConfObj = fatherObj.getReadUnitObj()
4241 4092 self.configUPWindowObj.dataTypeProject = str(readUnitConfObj.datatype)
4242 4093
4243 4094 self.configUPWindowObj.getfromWindowList.append(fatherObj)
4244 4095 self.configUPWindowObj.loadTotalList()
4245 4096 self.configUPWindowObj.show()
4246 4097 self.configUPWindowObj.closed.connect(self.createPUWindow)
4247 4098
4248 4099 def createPUWindow(self):
4249 4100
4250 4101 if not self.configUPWindowObj.create:
4251 4102 return
4252 4103
4253 4104 fatherObj = self.configUPWindowObj.getFromWindow
4254 4105 datatype = self.configUPWindowObj.typeofUP
4255 4106
4256 4107 if fatherObj.getElementName() == 'Project':
4257 4108 inputId = fatherObj.getReadUnitId()
4258 4109 projectObjView = fatherObj
4259 4110 else:
4260 4111 inputId = fatherObj.getId()
4261 4112 projectObjView = self.getSelectedProjectObj()
4262 4113
4263 4114 puObj = self.createProcUnitView(projectObjView, datatype, inputId)
4264 4115
4265 4116 self.addPU2ProjectExplorer(puObj)
4266 4117
4267 4118 self.showtabPUCreated(datatype)
4268 4119
4269 4120 self.clearPUWindow(datatype)
4270 4121
4271 4122 self.showPUinitView()
4272 4123
4273 4124 def addFTPConf2Operation(self, puObj, opObj):
4274 4125
4275 4126 if not self.temporalFTP.create:
4276 4127 self.temporalFTP.setwithoutconfiguration()
4277 4128
4278 4129 # opObj.addParameter(name='server', value=self.temporalFTP.server, format='str')
4279 4130 # opObj.addParameter(name='remotefolder', value=self.temporalFTP.remotefolder, format='str')
4280 4131 # opObj.addParameter(name='username', value=self.temporalFTP.username, format='str')
4281 4132 # opObj.addParameter(name='password', value=self.temporalFTP.password, format='str')
4282 4133
4283 4134 if self.temporalFTP.ftp_wei:
4284 4135 opObj.addParameter(name='ftp_wei', value=int(self.temporalFTP.ftp_wei), format='int')
4285 4136 if self.temporalFTP.exp_code:
4286 4137 opObj.addParameter(name='exp_code', value=int(self.temporalFTP.exp_code), format='int')
4287 4138 if self.temporalFTP.sub_exp_code:
4288 4139 opObj.addParameter(name='sub_exp_code', value=int(self.temporalFTP.sub_exp_code), format='int')
4289 4140 if self.temporalFTP.plot_pos:
4290 4141 opObj.addParameter(name='plot_pos', value=int(self.temporalFTP.plot_pos), format='int')
4291 4142
4292 4143 def __checkFTPProcUnit(self, projectObj, localfolder):
4293 4144
4294 4145 puId = None
4295 4146 puObj = None
4296 4147
4297 4148 for thisPuId, thisPuObj in projectObj.procUnitItems():
4298 4149
4299 4150 if not thisPuObj.name == "SendToServer":
4300 4151 continue
4301 4152
4302 4153 opObj = thisPuObj.getOperationObj(name='run')
4303 4154
4304 4155 parmObj = opObj.getParameterObj('localfolder')
4305 4156
4306 4157 #localfolder parameter should always be set, if it is not set then ProcUnit should be removed
4307 4158 if not parmObj:
4308 4159 projectObj.removeProcUnit(thisPuId)
4309 4160 continue
4310 4161
4311 4162 thisLocalfolder = parmObj.getValue()
4312 4163
4313 4164 if localfolder != thisLocalfolder:
4314 4165 continue
4315 4166
4316 4167 puId = thisPuId
4317 4168 puObj = thisPuObj
4318 4169 break
4319 4170
4320 4171 return puObj
4321 4172
4322 def __addFTPProcUnitFrom(self, operationObj):
4323
4324 if operationObj.name != "SendByFTP":
4325 return
4326
4327 projectObj = self.getSelectedProjectObj()
4328
4329 self.removeAllFTPProcUnitView(projectObj)
4330
4331 procUnitConfObj = projectObj.addProcUnit(name="SendToServer")
4332
4333 server = operationObj.getParameterValue("server")
4334 username = operationObj.getParameterValue("username")
4335 password = operationObj.getParameterValue("pasword")
4336 localfolder = operationObj.getParameterValue("localfolder")
4337 remotefolder = operationObj.getParameterValue("remotefolder")
4338 ext = operationObj.getParameterValue("ext")
4339 period = operationObj.getParameterValue("period")
4340
4341 procUnitConfObj.addParameter(name='server', value=server, format='str')
4342 procUnitConfObj.addParameter(name='username', value=username, format='str')
4343 procUnitConfObj.addParameter(name='password', value=password, format='str')
4344 procUnitConfObj.addParameter(name='localfolder', value=localfolder, format='list')
4345 procUnitConfObj.addParameter(name='remotefolder', value=remotefolder, format='str')
4346 procUnitConfObj.addParameter(name='ext', value=ext, format='str')
4347 procUnitConfObj.addParameter(name='period', value=period, format='int')
4348
4349 self.__puObjDict[procUnitConfObj.getId()] = procUnitConfObj
4350
4351 return procUnitConfObj
4352
4353 def addFTPProcUnitView(self):
4173 def createFTPProcUnitView(self):
4354 4174
4355 4175 if not self.temporalFTP.create:
4356 4176 self.temporalFTP.setwithoutconfiguration()
4357 4177
4358 4178 projectObj = self.getSelectedProjectObj()
4359 4179
4360 4180 self.removeAllFTPProcUnitView(projectObj)
4361 4181
4362 4182 if not self.__puLocalFolder2FTP:
4363 4183 return
4364 4184
4365 4185 folderList = ""
4366 4186
4367 4187 for localfolder in self.__puLocalFolder2FTP.values():
4368 4188 folderList += str(localfolder) + ","
4369 4189
4370 4190 procUnitConfObj = projectObj.addProcUnit(name="SendToServer")
4371 4191
4372 4192 procUnitConfObj.addParameter(name='server', value=self.temporalFTP.server, format='str')
4373 4193 procUnitConfObj.addParameter(name='username', value=self.temporalFTP.username, format='str')
4374 4194 procUnitConfObj.addParameter(name='password', value=self.temporalFTP.password, format='str')
4375 4195 procUnitConfObj.addParameter(name='localfolder', value=folderList, format='list')
4376 4196 procUnitConfObj.addParameter(name='remotefolder', value=self.temporalFTP.remotefolder, format='str')
4377 4197 procUnitConfObj.addParameter(name='ext', value=self.temporalFTP.extension, format='str')
4378 4198 procUnitConfObj.addParameter(name='period', value=self.temporalFTP.period, format='int')
4379 4199 procUnitConfObj.addParameter(name='protocol', value=self.temporalFTP.protocol, format='str')
4380 4200
4381 procUnitConfObj.addParameter(name='ftp_wei', value=self.temporalFTP.ftp_wei, format='str')
4382 procUnitConfObj.addParameter(name='exp_code', value=self.temporalFTP.exp_code, format='str')
4383 procUnitConfObj.addParameter(name='sub_exp_code', value=self.temporalFTP.sub_exp_code, format='str')
4384 procUnitConfObj.addParameter(name='plot_pos', value=self.temporalFTP.plot_pos, format='str')
4201 procUnitConfObj.addParameter(name='ftp_wei', value=self.temporalFTP.ftp_wei, format='int')
4202 procUnitConfObj.addParameter(name='exp_code', value=self.temporalFTP.exp_code, format='int')
4203 procUnitConfObj.addParameter(name='sub_exp_code', value=self.temporalFTP.sub_exp_code, format='int')
4204 procUnitConfObj.addParameter(name='plot_pos', value=self.temporalFTP.plot_pos, format='int')
4385 4205
4386 4206 self.__puObjDict[procUnitConfObj.getId()] = procUnitConfObj
4387 4207
4388 4208 def removeAllFTPProcUnitView(self, projectObj):
4389 4209
4390 4210 for thisPuId, thisPuObj in projectObj.procUnitItems():
4391 4211
4392 4212 if not thisPuObj.name == "SendToServer":
4393 4213 continue
4394 4214
4395 4215 projectObj.removeProcUnit(thisPuId)
4396 4216
4397 4217 if thisPuId not in self.__puObjDict.keys():
4398 4218 continue
4399 4219
4400 4220 self.__puObjDict.pop(thisPuId)
4401 4221
4402 4222 def showPUinitView(self):
4403 4223
4404 4224 self.propertiesModel = TreeModel()
4405 4225 self.propertiesModel.initPUVoltageView()
4406 4226 self.treeProjectProperties.setModel(self.propertiesModel)
4407 4227 self.treeProjectProperties.expandAll()
4408 4228 self.treeProjectProperties.allColumnsShowFocus()
4409 4229 self.treeProjectProperties.resizeColumnToContents(1)
4230
4231 def saveFTPFromOpObj(self, operationObj):
4232
4233 if operationObj.name != "SendByFTP":
4234 return
4235
4236 server = operationObj.getParameterValue("server")
4237 username = operationObj.getParameterValue("username")
4238 password = operationObj.getParameterValue("password")
4239 localfolder = operationObj.getParameterValue("localfolder")
4240 remotefolder = operationObj.getParameterValue("remotefolder")
4241 ext = operationObj.getParameterValue("ext")
4242 period = operationObj.getParameterValue("period")
4410 4243
4411 def saveFTPvalues(self, puObj):
4244 self.temporalFTP.save(server=server,
4245 remotefolder=remotefolder,
4246 username=username,
4247 password=password,
4248 localfolder=localfolder,
4249 extension=ext)
4250
4251 return
4252
4253 def saveFTPFromProcUnitObj(self, puObj):
4412 4254
4413 4255 opObj = puObj.getOperationObj(name="run")
4414 4256
4415 4257 parmObj = opObj.getParameterObj(parameterName="server")
4416 4258 if parmObj == None:
4417 4259 server = 'jro-app.igp.gob.pe'
4418 4260 else:
4419 4261 server = parmObj.getValue()
4420 4262
4421 4263 parmObj = opObj.getParameterObj(parameterName="remotefolder")
4422 4264 if parmObj == None:
4423 4265 remotefolder = '/home/wmaster/graficos'
4424 4266 else:
4425 4267 remotefolder = parmObj.getValue()
4426 4268
4427 4269 parmObj = opObj.getParameterObj(parameterName="username")
4428 4270 if parmObj == None:
4429 4271 username = 'wmaster'
4430 4272 else:
4431 4273 username = parmObj.getValue()
4432 4274
4433 4275 parmObj = opObj.getParameterObj(parameterName="password")
4434 4276 if parmObj == None:
4435 4277 password = 'mst2010vhf'
4436 4278 else:
4437 4279 password = parmObj.getValue()
4438 4280
4439 4281 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
4440 4282 if parmObj == None:
4441 ftp_wei = '0'
4283 ftp_wei = 0
4442 4284 else:
4443 4285 ftp_wei = parmObj.getValue()
4444 4286
4445 4287 parmObj = opObj.getParameterObj(parameterName="exp_code")
4446 4288 if parmObj == None:
4447 exp_code = '0'
4289 exp_code = 0
4448 4290 else:
4449 4291 exp_code = parmObj.getValue()
4450 4292
4451 4293 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
4452 4294 if parmObj == None:
4453 sub_exp_code = '0'
4295 sub_exp_code = 0
4454 4296 else:
4455 4297 sub_exp_code = parmObj.getValue()
4456 4298
4457 4299 parmObj = opObj.getParameterObj(parameterName="plot_pos")
4458 4300 if parmObj == None:
4459 plot_pos = '0'
4301 plot_pos = 0
4460 4302 else:
4461 4303 plot_pos = parmObj.getValue()
4462 4304
4463 4305 parmObj = opObj.getParameterObj(parameterName="localfolder")
4464 4306 if parmObj == None:
4465 4307 localfolder = None
4466 4308 else:
4467 4309 localfolder = parmObj.getValue()
4468 4310
4469 parmObj = opObj.getParameterObj(parameterName="extension")
4311 parmObj = opObj.getParameterObj(parameterName="ext")
4470 4312 if parmObj == None:
4471 4313 extension = '.png'
4472 4314 else:
4473 4315 extension = parmObj.getValue()
4474 4316
4475 4317 self.temporalFTP.save(server=server,
4476 4318 remotefolder=remotefolder,
4477 4319 username=username,
4478 4320 password=password,
4479 4321 ftp_wei=ftp_wei,
4480 4322 exp_code=exp_code,
4481 4323 sub_exp_code=sub_exp_code,
4482 4324 plot_pos=plot_pos,
4483 4325 localfolder=localfolder,
4484 4326 extension=extension)
4485 4327
4486 4328 def addProject2ProjectExplorer(self, id, name):
4487 4329
4488 4330 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
4489 4331
4490 4332 parentItem = self.projectExplorerModel.invisibleRootItem()
4491 4333 parentItem.appendRow(itemTree)
4492 4334
4493 4335 self.projectExplorerTree.setCurrentIndex(itemTree.index())
4494 4336
4495 4337 self.selectedItemTree = itemTree
4496 4338
4497 4339 self.__itemTreeDict[id] = itemTree
4498 4340
4499 4341 def addPU2ProjectExplorer(self, puObj):
4500 4342
4501 4343 id, name = puObj.id, puObj.datatype
4502 4344
4503 4345 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
4504 4346
4505 4347 parentItem = self.selectedItemTree
4506 4348 parentItem.appendRow(itemTree)
4507 4349 self.projectExplorerTree.expandAll()
4508 4350
4509 4351 self.projectExplorerTree.setCurrentIndex(itemTree.index())
4510 4352
4511 4353 self.selectedItemTree = itemTree
4512 4354
4513 4355 self.__itemTreeDict[id] = itemTree
4514 4356
4515 4357 def addPU2PELoadXML(self, puObj):
4516 4358
4517 4359 id, name, inputId = puObj.id, puObj.datatype, puObj.inputId
4518 4360
4519 4361 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
4520 4362
4521 4363 if self.__itemTreeDict.has_key(inputId):
4522 4364 parentItem = self.__itemTreeDict[inputId]
4523 4365 else:
4524 4366 #If parent is a Reader object
4525 4367 parentItem = self.__itemTreeDict[id[:-1]]
4526 4368
4527 4369 parentItem.appendRow(itemTree)
4528 4370 self.projectExplorerTree.expandAll()
4529 4371 parentItem = itemTree
4530 4372 self.projectExplorerTree.setCurrentIndex(parentItem.index())
4531 4373
4532 4374 self.__itemTreeDict[id] = itemTree
4533 4375 self.selectedItemTree = itemTree
4534 4376
4535 4377 def getSelectedProjectObj(self):
4536 4378 """
4537 4379 Return the current project object selected. If a processing unit is
4538 4380 actually selected this function returns associated project.
4539 4381
4540 4382 None if any project or processing unit is selected
4541 4383 """
4542 4384 for key in self.__itemTreeDict.keys():
4543 4385 if self.__itemTreeDict[key] != self.selectedItemTree:
4544 4386 continue
4545 4387
4546 4388 if self.__projectObjDict.has_key(key):
4547 4389 projectObj = self.__projectObjDict[key]
4548 4390 return projectObj
4549 4391
4550 4392 puObj = self.__puObjDict[key]
4551 4393
4552 4394 if puObj.parentId == None:
4553 4395 projectId = puObj.getId()[0]
4554 4396 else:
4555 4397 projectId = puObj.parentId
4556 4398
4557 4399 projectObj = self.__projectObjDict[projectId]
4558 4400 return projectObj
4559 4401
4560 4402 return None
4561 4403
4562 4404 def getSelectedItemObj(self):
4563 4405 """
4564 4406 Return the current project or processing unit object selected
4565 4407
4566 4408 None if any project or processing unit is selected
4567 4409 """
4568 4410 for key in self.__itemTreeDict.keys():
4569 4411 if self.__itemTreeDict[key] != self.selectedItemTree:
4570 4412 continue
4571 4413
4572 4414 if self.__projectObjDict.has_key(key) == True:
4573 4415 fatherObj = self.__projectObjDict[key]
4574 4416 else:
4575 4417 fatherObj = self.__puObjDict[key]
4576 4418
4577 4419 return fatherObj
4578 4420
4579 4421 return None
4580 4422
4581 4423 def _WarningWindow(self, text, information):
4582 4424
4583 4425 msgBox = QtGui.QMessageBox()
4584 4426 msgBox.setText(text)
4585 4427 msgBox.setInformativeText(information)
4586 4428 msgBox.setStandardButtons(QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel)
4587 4429 msgBox.setDefaultButton(QtGui.QMessageBox.Ok)
4588 4430 ret = msgBox.exec_()
4589 4431
4590 4432 answer = False
4591 4433
4592 4434 if ret == QtGui.QMessageBox.Ok:
4593 4435 answer = True
4594 4436
4595 4437 return answer
4596 4438
4597 4439 def __getNewProjectId(self):
4598 4440
4599 4441 loadProject = False
4600 4442
4601 4443 for thisId in range(1,10):
4602 4444 newId = str(thisId)
4603 4445 if newId in self.__projectObjDict.keys():
4604 4446 continue
4605 4447
4606 4448 loadProject = True
4607 4449 projectId = newId
4608 4450 break
4609 4451
4610 4452 if not loadProject:
4611 4453 self.console.clear()
4612 4454 self.console.append("The maximum number of projects has been loaded, a new project can not be loaded")
4613 4455 return None
4614 4456
4615 4457 return projectId
4616 4458
4617 4459 def openProject(self):
4618 4460
4619 4461 self.actionStart.setEnabled(False)
4620 4462 self.actionStarToolbar.setEnabled(False)
4621 4463
4622 4464 self.create = False
4623 4465 self.frame_2.setEnabled(True)
4624 4466
4625 4467 # print self.dir
4626 4468 filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open text file", self.pathWorkSpace, self.tr("Text Files (*.xml)")))
4627 4469
4628 4470 projectObjLoad = Project()
4629 4471
4630 4472 try:
4631 4473 projectObjLoad.readXml(filename)
4632 4474 except:
4633 4475 self.console.clear()
4634 4476 self.console.append("The selected xml file could not be loaded ...")
4635 4477 return 0
4636 4478
4637 4479 self.refreshProjectWindow2(projectObjLoad)
4638 4480 self.refreshProjectProperties(projectObjLoad)
4639 4481
4640 4482 projectId = projectObjLoad.id
4641 4483
4642 4484 if projectId in self.__projectObjDict.keys():
4643 4485
4644 4486 # answer = self._WarningWindow("You already have a project loaded with the same Id",
4645 4487 # "Do you want to load the file anyway?")
4646 4488 # if not answer:
4647 4489 # return
4648 4490
4649 4491 projectId = self.__getNewProjectId()
4650 4492
4651 4493 if not projectId:
4652 4494 return
4653 4495
4654 4496 projectObjLoad.updateId(projectId)
4655 4497
4656 4498 self.__projectObjDict[projectId] = projectObjLoad
4657 4499
4658 4500 self.addProject2ProjectExplorer(id=projectId, name=projectObjLoad.name)
4659 4501
4660 4502 self.tabWidgetProject.setEnabled(True)
4661 4503 self.tabWidgetProject.setCurrentWidget(self.tabProject)
4662 4504 # Disable tabProject after finish the creation
4663 4505 self.tabProject.setEnabled(True)
4664 4506 puObjorderList = OrderedDict(sorted(projectObjLoad.procUnitConfObjDict.items(), key=lambda x: x[0]))
4665 4507
4666 4508 for puId, puObj in puObjorderList.items():
4667 4509
4668 4510 self.__puObjDict[puId] = puObj
4669 4511
4670 4512 if puObj.name == "SendToServer":
4671 self.saveFTPvalues(puObj)
4672
4513 self.saveFTPFromProcUnitObj(puObj)
4514
4515 ############## COMPATIBLE WITH OLD VERSIONS ################
4516 operationObj = puObj.getOperationObj("SendByFTP")
4517
4518 if operationObj:
4519 self.saveFTPFromOpObj(operationObj)
4520 ############################################################
4521
4673 4522 if puObj.inputId == '0':
4674 4523 continue
4675 4524
4676 4525 self.addPU2PELoadXML(puObj)
4677 4526
4678 4527 self.refreshPUWindow(puObj)
4679 4528 self.refreshPUProperties(puObj)
4680 4529 self.showtabPUCreated(datatype=puObj.datatype)
4681
4682 ############## COMPATIBLE FROM OLD VERSIONS ################
4683 operationObj = puObj.getOperationObj("SendByFTP")
4684
4685 if operationObj:
4686 send2ServerObj = self.__addFTPProcUnitFrom(operationObj)
4687 self.saveFTPvalues(send2ServerObj)
4688 ############################################################
4689 4530
4690 4531 self.console.clear()
4691 4532 self.console.append("The selected xml file has been loaded successfully")
4692 4533
4693 4534 self.actionStart.setEnabled(True)
4694 4535 self.actionStarToolbar.setEnabled(True)
4695 4536
4696 4537 def on_comm_updating_timer(self):
4697 4538 # Verifica si algun proceso ha sido inicializado y sigue ejecutandose
4698 4539
4699 4540 if not self.__initialized:
4700 4541 return
4701 4542
4702 4543 if not self.controllerObj.isAlive():
4703 4544 self.stopProject()
4704 4545
4705 4546 def playProject(self, ext=".xml", save=1):
4706 4547
4707 4548 # self.console.clear()
4708 4549 projectObj = self.getSelectedProjectObj()
4709 4550
4710 4551 if not projectObj:
4711 4552 print "Please select a project before pressing PLAY button"
4712 4553 return
4713 4554
4714 4555 if save:
4715 4556 filename = self.saveProject()
4716 4557 if filename == None:
4717 4558 self.console.append("Process did not initialize.")
4718 4559 return
4719 4560 else:
4720 4561 filename = TEMPORAL_FILE
4721 4562 projectObj.writeXml( os.path.join(self.pathWorkSpace,filename) )
4722 4563
4723 4564 self.actionStart.setEnabled(False)
4724 4565 self.actionPause.setEnabled(True)
4725 4566 self.actionStop.setEnabled(True)
4726 4567
4727 4568 self.actionStarToolbar.setEnabled(False)
4728 4569 self.actionPauseToolbar.setEnabled(True)
4729 4570 self.actionStopToolbar.setEnabled(True)
4730 4571
4731 4572 self.console.append("Please Wait...")
4732 4573
4733 4574 self.controllerObj = ControllerThread(filename)
4734 4575 self.controllerObj.start()
4735 4576 sleep(0.5)
4736 4577 self.__initialized = True
4737 4578
4738 4579 def stopProject(self):
4739 4580
4740 4581 self.__initialized = False
4741 4582
4742 4583 # self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.STOP, True))
4743 4584 self.controllerObj.stop()
4744 4585
4745 4586 self.actionStart.setEnabled(True)
4746 4587 self.actionPause.setEnabled(False)
4747 4588 self.actionStop.setEnabled(False)
4748 4589
4749 4590 self.actionStarToolbar.setEnabled(True)
4750 4591 self.actionPauseToolbar.setEnabled(False)
4751 4592 self.actionStopToolbar.setEnabled(False)
4752 4593
4753 4594 self.restorePauseIcon()
4754 4595
4755 4596 def pauseProject(self):
4756 4597
4757 4598 # self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.PAUSE, data=True))
4758 4599 self.controllerObj.pause()
4759 4600
4760 4601 self.actionStart.setEnabled(False)
4761 4602 self.actionPause.setEnabled(True)
4762 4603 self.actionStop.setEnabled(True)
4763 4604
4764 4605 self.actionStarToolbar.setEnabled(False)
4765 4606 self.actionPauseToolbar.setEnabled(True)
4766 4607 self.actionStopToolbar.setEnabled(True)
4767 4608
4768 4609 def saveProject(self, filename=None):
4769 4610
4770 4611 self.actionStart.setEnabled(False)
4771 4612 self.actionStarToolbar.setEnabled(False)
4772 4613
4773 4614 projectObj = self.getSelectedProjectObj()
4774 4615 self.refreshGraphicsId()
4775 4616
4776 4617 sts = True
4777 4618 selectedItemObj = self.getSelectedItemObj()
4778 4619
4779 4620 #A Processing Unit has been selected
4780 4621 if projectObj == selectedItemObj:
4781 4622 if not self.on_proOk_clicked():
4782 4623 return None
4783 4624
4784 4625 #A Processing Unit has been selected
4785 4626 if projectObj != selectedItemObj:
4786 4627 puObj = selectedItemObj
4787 4628
4788 4629 if puObj.name == 'VoltageProc':
4789 4630 sts = self.on_volOpOk_clicked()
4790 4631 if puObj.name == 'SpectraProc':
4791 4632 sts = self.on_specOpOk_clicked()
4792 4633 if puObj.name == 'SpectraHeisProc':
4793 4634 sts = self.on_specHeisOpOk_clicked()
4794 4635
4795 4636 if not sts:
4796 4637 return None
4797 4638
4798 self.addFTPProcUnitView()
4799
4639 self.createFTPProcUnitView()
4640
4800 4641 if not filename:
4801 4642 filename = os.path.join( str(self.pathWorkSpace), "%s%s" %(str(projectObj.name), '.xml') )
4802 4643
4803 4644 projectObj.writeXml(filename)
4804 4645 self.console.append("Now, you can press Start button")
4805 4646
4806 4647 self.actionStart.setEnabled(True)
4807 4648 self.actionStarToolbar.setEnabled(True)
4808 4649
4809 4650 return filename
4810 4651
4811 4652 def removeItemTreeFromProject(self):
4812 4653 """
4813 4654 Metodo para eliminar el proyecto en el dictionario de proyectos y en el dictionario de vista de arbol
4814 4655 """
4815 4656 for key in self.__itemTreeDict.keys():
4816 4657
4817 4658 #Check again because an item can delete multiple items (childs)
4818 4659 if key not in self.__itemTreeDict.keys():
4819 4660 continue
4820 4661
4821 4662 if self.__itemTreeDict[key] != self.selectedItemTree:
4822 4663 continue
4823 4664
4824 4665 if self.__projectObjDict.has_key(key) == True:
4825 4666
4826 4667 del self.__projectObjDict[key]
4827 4668 del self.__itemTreeDict[key]
4828 4669
4829 4670 else:
4830 4671 puObj = self.__puObjDict[key]
4831 4672 idProjectParent = puObj.parentId
4832 4673 projectObj = self.__projectObjDict[idProjectParent]
4833 4674
4834 4675 del self.__puObjDict[key]
4835 4676 del self.__itemTreeDict[key]
4836 4677 del projectObj.procUnitConfObjDict[key]
4837 4678
4838 4679 for key in projectObj.procUnitConfObjDict.keys():
4839 4680 if projectObj.procUnitConfObjDict[key].inputId != puObj.getId():
4840 4681 continue
4841 4682 del self.__puObjDict[projectObj.procUnitConfObjDict[key].getId()]
4842 4683 del self.__itemTreeDict[projectObj.procUnitConfObjDict[key].getId()]
4843 4684 del projectObj.procUnitConfObjDict[key]
4844 4685 # print projectObj.procUnitConfObjDict
4845 4686 # print self.__itemTreeDict,self.__projectObjDict,self.__puObjDict
4846 4687
4847 4688 def setInputsProject_View(self):
4848 4689
4849 4690 self.tabWidgetProject.setEnabled(True)
4850 4691 self.tabWidgetProject.setCurrentWidget(self.tabProject)
4851 4692 self.tabProject.setEnabled(True)
4852 4693 self.frame_2.setEnabled(False)
4853 4694 self.proName.clear()
4854 4695 self.proName.setFocus()
4855 4696 self.proName.setSelection(0, 0)
4856 4697 self.proName.setCursorPosition(0)
4857 4698 self.proDataType.setText('.r')
4858 4699 self.proDataPath.clear()
4859 4700 self.proComDataType.clear()
4860 4701 self.proComDataType.addItem("Voltage")
4861 4702 self.proComDataType.addItem("Spectra")
4862 4703 self.proComDataType.addItem("Fits")
4863 4704 self.proComDataType.addItem("USRP")
4864 4705
4865 4706 self.proComStartDate.clear()
4866 4707 self.proComEndDate.clear()
4867 4708
4868 4709 startTime = "00:00:00"
4869 4710 endTime = "23:59:59"
4870 4711 starlist = startTime.split(":")
4871 4712 endlist = endTime.split(":")
4872 4713 self.proDelay.setText("60")
4873 4714 self.proSet.setText("")
4874 4715
4875 4716 self.labelSet.show()
4876 4717 self.proSet.show()
4877 4718
4878 4719 self.labelIPPKm.hide()
4879 4720 self.proIPPKm.hide()
4880 4721
4881 4722 self.time.setHMS(int(starlist[0]), int(starlist[1]), int(starlist[2]))
4882 4723 self.proStartTime.setTime(self.time)
4883 4724 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
4884 4725 self.proEndTime.setTime(self.time)
4885 4726 self.proDescription.clear()
4886 4727 self.proOk.setEnabled(False)
4887 4728 # self.console.append("Please, Write a name Project")
4888 4729 # self.console.append("Introduce Project Parameters")DC
4889 4730 # self.console.append("Select data type Voltage( .rawdata) or Spectra(.pdata)")
4890 4731
4891 4732 def clearPUWindow(self, datatype):
4892 4733
4893 4734 projectObjView = self.getSelectedProjectObj()
4894 4735
4895 4736 if not projectObjView:
4896 4737 return
4897 4738
4898 4739 puObj = self.getSelectedItemObj()
4899 4740 inputId = puObj.getInputId()
4900 4741 inputPUObj = projectObjView.getProcUnitObj(inputId)
4901 4742
4902 4743 if datatype == 'Voltage':
4903 4744 self.volOpComChannels.setEnabled(False)
4904 4745 self.volOpComHeights.setEnabled(False)
4905 4746 self.volOpFilter.setEnabled(False)
4906 4747 self.volOpComProfile.setEnabled(False)
4907 4748 self.volOpComCode.setEnabled(False)
4908 4749 self.volOpCohInt.setEnabled(False)
4909 4750 self.volOpChannel.setEnabled(False)
4910 4751 self.volOpHeights.setEnabled(False)
4911 4752 self.volOpProfile.setEnabled(False)
4912 4753 self.volOpRadarfrequency.setEnabled(False)
4913 4754 self.volOpCebChannels.setCheckState(0)
4914 4755 self.volOpCebRadarfrequency.setCheckState(0)
4915 4756 self.volOpCebHeights.setCheckState(0)
4916 4757 self.volOpCebFilter.setCheckState(0)
4917 4758 self.volOpCebProfile.setCheckState(0)
4918 4759 self.volOpCebDecodification.setCheckState(0)
4919 4760 self.volOpCebCohInt.setCheckState(0)
4920 4761
4921 4762 self.volOpChannel.clear()
4922 4763 self.volOpHeights.clear()
4923 4764 self.volOpProfile.clear()
4924 4765 self.volOpFilter.clear()
4925 4766 self.volOpCohInt.clear()
4926 4767 self.volOpRadarfrequency.clear()
4927 4768
4928 4769 if datatype == 'Spectra':
4929 4770
4930 4771 if inputPUObj.datatype == 'Spectra':
4931 4772 self.specOpnFFTpoints.setEnabled(False)
4932 4773 self.specOpProfiles.setEnabled(False)
4933 4774 self.specOpippFactor.setEnabled(False)
4934 4775 else:
4935 4776 self.specOpnFFTpoints.setEnabled(True)
4936 4777 self.specOpProfiles.setEnabled(True)
4937 4778 self.specOpippFactor.setEnabled(True)
4938 4779
4939 4780 self.specOpCebCrossSpectra.setCheckState(0)
4940 4781 self.specOpCebChannel.setCheckState(0)
4941 4782 self.specOpCebHeights.setCheckState(0)
4942 4783 self.specOpCebIncoherent.setCheckState(0)
4943 4784 self.specOpCebRemoveDC.setCheckState(0)
4944 4785 self.specOpCebRemoveInt.setCheckState(0)
4945 4786 self.specOpCebgetNoise.setCheckState(0)
4946 4787 self.specOpCebRadarfrequency.setCheckState(0)
4947 4788
4948 4789 self.specOpRadarfrequency.setEnabled(False)
4949 4790 self.specOppairsList.setEnabled(False)
4950 4791 self.specOpChannel.setEnabled(False)
4951 4792 self.specOpHeights.setEnabled(False)
4952 4793 self.specOpIncoherent.setEnabled(False)
4953 4794 self.specOpgetNoise.setEnabled(False)
4954 4795
4955 4796 self.specOpRadarfrequency.clear()
4956 4797 self.specOpnFFTpoints.clear()
4957 4798 self.specOpProfiles.clear()
4958 4799 self.specOpippFactor.clear
4959 4800 self.specOppairsList.clear()
4960 4801 self.specOpChannel.clear()
4961 4802 self.specOpHeights.clear()
4962 4803 self.specOpIncoherent.clear()
4963 4804 self.specOpgetNoise.clear()
4964 4805
4965 4806 self.specGraphCebSpectraplot.setCheckState(0)
4966 4807 self.specGraphCebCrossSpectraplot.setCheckState(0)
4967 4808 self.specGraphCebRTIplot.setCheckState(0)
4968 4809 self.specGraphCebRTInoise.setCheckState(0)
4969 4810 self.specGraphCebCoherencmap.setCheckState(0)
4970 4811 self.specGraphPowerprofile.setCheckState(0)
4971 4812
4972 4813 self.specGraphSaveSpectra.setCheckState(0)
4973 4814 self.specGraphSaveCross.setCheckState(0)
4974 4815 self.specGraphSaveRTIplot.setCheckState(0)
4975 4816 self.specGraphSaveRTInoise.setCheckState(0)
4976 4817 self.specGraphSaveCoherencemap.setCheckState(0)
4977 4818 self.specGraphSavePowerprofile.setCheckState(0)
4978 4819
4979 4820 self.specGraphftpRTIplot.setCheckState(0)
4980 4821 self.specGraphftpRTInoise.setCheckState(0)
4981 4822 self.specGraphftpCoherencemap.setCheckState(0)
4982 4823
4983 4824 self.specGraphPath.clear()
4984 4825 self.specGraphPrefix.clear()
4985 4826
4986 4827 self.specGgraphftpratio.clear()
4987 4828
4988 4829 self.specGgraphChannelList.clear()
4989 4830 self.specGgraphFreq.clear()
4990 4831 self.specGgraphHeight.clear()
4991 4832 self.specGgraphDbsrange.clear()
4992 4833 self.specGgraphmagnitud.clear()
4993 4834 self.specGgraphTminTmax.clear()
4994 4835 self.specGgraphTimeRange.clear()
4995 4836
4996 4837 if datatype == 'SpectraHeis':
4997 4838 self.specHeisOpCebIncoherent.setCheckState(0)
4998 4839 self.specHeisOpIncoherent.setEnabled(False)
4999 4840 self.specHeisOpIncoherent.clear()
5000 4841
5001 4842 self.specHeisGraphCebSpectraplot.setCheckState(0)
5002 4843 self.specHeisGraphCebRTIplot.setCheckState(0)
5003 4844
5004 4845 self.specHeisGraphSaveSpectra.setCheckState(0)
5005 4846 self.specHeisGraphSaveRTIplot.setCheckState(0)
5006 4847
5007 4848 self.specHeisGraphftpSpectra.setCheckState(0)
5008 4849 self.specHeisGraphftpRTIplot.setCheckState(0)
5009 4850
5010 4851 self.specHeisGraphPath.clear()
5011 4852 self.specHeisGraphPrefix.clear()
5012 4853 self.specHeisGgraphChannelList.clear()
5013 4854 self.specHeisGgraphXminXmax.clear()
5014 4855 self.specHeisGgraphYminYmax.clear()
5015 4856 self.specHeisGgraphTminTmax.clear()
5016 4857 self.specHeisGgraphTimeRange.clear()
5017 4858 self.specHeisGgraphftpratio.clear()
5018 4859
5019 4860 def showtabPUCreated(self, datatype):
5020 4861
5021 4862 if datatype == "Voltage":
5022 4863 self.tabVoltage.setEnabled(True)
5023 4864 self.tabProject.setEnabled(False)
5024 4865 self.tabSpectra.setEnabled(False)
5025 4866 self.tabCorrelation.setEnabled(False)
5026 4867 self.tabSpectraHeis.setEnabled(False)
5027 4868 self.tabWidgetProject.setCurrentWidget(self.tabVoltage)
5028 4869
5029 4870 if datatype == "Spectra":
5030 4871 self.tabVoltage.setEnabled(False)
5031 4872 self.tabProject.setEnabled(False)
5032 4873 self.tabSpectra.setEnabled(True)
5033 4874 self.tabCorrelation.setEnabled(False)
5034 4875 self.tabSpectraHeis.setEnabled(False)
5035 4876 self.tabWidgetProject.setCurrentWidget(self.tabSpectra)
5036 4877
5037 4878 if datatype == "SpectraHeis":
5038 4879 self.tabVoltage.setEnabled(False)
5039 4880 self.tabProject.setEnabled(False)
5040 4881 self.tabSpectra.setEnabled(False)
5041 4882 self.tabCorrelation.setEnabled(False)
5042 4883 self.tabSpectraHeis.setEnabled(True)
5043 4884 self.tabWidgetProject.setCurrentWidget(self.tabSpectraHeis)
5044 4885
5045 4886 def checkInputsProject(self):
5046 4887 """
5047 4888 Check Inputs Project:
5048 4889 - project_name
5049 4890 - datatype
5050 4891 - ext
5051 4892 - data_path
5052 4893 - readmode
5053 4894 - delay
5054 4895 - set
5055 4896 - walk
5056 4897 """
5057 4898 parms_ok = True
5058 4899 project_name = str(self.proName.text())
5059 4900 if project_name == '' or project_name == None:
5060 4901 outputstr = "Enter the Project Name"
5061 4902 self.console.append(outputstr)
5062 4903 parms_ok = False
5063 4904 project_name = None
5064 4905
5065 4906 datatype = str(self.proComDataType.currentText())
5066 4907 if not(datatype in ['Voltage', 'Spectra', 'Fits', 'USRP']):
5067 4908 outputstr = 'datatype = %s, this must be either Voltage, Spectra, SpectraHeis or USRP' % datatype
5068 4909 self.console.append(outputstr)
5069 4910 parms_ok = False
5070 4911 datatype = None
5071 4912
5072 4913 ext = str(self.proDataType.text())
5073 4914 if not(ext in ['.r', '.pdata', '.fits', '.hdf5']):
5074 4915 outputstr = "extension files must be .r , .pdata, .fits or .hdf5"
5075 4916 self.console.append(outputstr)
5076 4917 parms_ok = False
5077 4918 ext = None
5078 4919
5079 4920 data_path = str(self.proDataPath.text())
5080 4921
5081 4922 if data_path == '':
5082 4923 outputstr = 'Datapath is empty'
5083 4924 self.console.append(outputstr)
5084 4925 parms_ok = False
5085 4926 data_path = None
5086 4927
5087 4928 if data_path != None:
5088 4929 if not os.path.isdir(data_path):
5089 4930 outputstr = 'Datapath:%s does not exists' % data_path
5090 4931 self.console.append(outputstr)
5091 4932 parms_ok = False
5092 4933 data_path = None
5093 4934
5094 4935 read_mode = str(self.proComReadMode.currentText())
5095 4936 if not(read_mode in ['Online', 'Offline']):
5096 4937 outputstr = 'Read Mode: %s, this must be either Online or Offline' % read_mode
5097 4938 self.console.append(outputstr)
5098 4939 parms_ok = False
5099 4940 read_mode = None
5100 4941
5101 4942 try:
5102 4943 delay = int(str(self.proDelay.text()))
5103 4944 except:
5104 4945 outputstr = 'Delay: %s, this must be a integer number' % str(self.proDelay.text())
5105 4946 self.console.append(outputstr)
5106 4947 # parms_ok = False
5107 4948 delay = None
5108 4949
5109 4950 try:
5110 4951 set = int(str(self.proSet.text()))
5111 4952 except:
5112 4953 # outputstr = 'Set: %s, this must be a integer number' % str(self.proName.text())
5113 4954 # self.console.append(outputstr)
5114 4955 # parms_ok = False
5115 4956 set = None
5116 4957
5117 4958 walk_str = str(self.proComWalk.currentText())
5118 4959 if walk_str == 'On Files':
5119 4960 walk = 0
5120 4961 elif walk_str == 'On Folder':
5121 4962 walk = 1
5122 4963 else:
5123 4964 outputstr = 'Walk: %s, this must be either On Files or On Folders' % walk_str
5124 4965 self.console.append(outputstr)
5125 4966 parms_ok = False
5126 4967 walk = None
5127 4968
5128 4969 return parms_ok, project_name, datatype, ext, data_path, read_mode, delay, walk, set
5129 4970
5130 4971 def checkInputsPUSave(self, datatype):
5131 4972 """
5132 4973 Check Inputs Spectra Save:
5133 4974 - path
5134 4975 - blocks Per File
5135 4976 - sufix
5136 4977 - dataformat
5137 4978 """
5138 4979 parms_ok = True
5139 4980
5140 4981 if datatype == "Voltage":
5141 4982 output_path = str(self.volOutputPath.text())
5142 4983 blocksperfile = str(self.volOutputblocksperfile.text())
5143 4984 profilesperblock = str(self.volOutputprofilesperblock.text())
5144 4985
5145 4986 if datatype == "Spectra":
5146 4987 output_path = str(self.specOutputPath.text())
5147 4988 blocksperfile = str(self.specOutputblocksperfile.text())
5148 4989 profilesperblock = str(self.specOutputprofileperblock.text())
5149 4990
5150 4991 if datatype == "SpectraHeis":
5151 4992 output_path = str(self.specHeisOutputPath.text())
5152 4993 blocksperfile = str(self.specHeisOutputblocksperfile.text())
5153 4994 metada = str(self.specHeisOutputMetada.text())
5154 4995
5155 4996 if output_path == '':
5156 4997 outputstr = 'Outputpath is empty'
5157 4998 self.console.append(outputstr)
5158 4999 parms_ok = False
5159 5000 data_path = None
5160 5001
5161 5002 if output_path != None:
5162 5003 if not os.path.exists(output_path):
5163 5004 outputstr = 'OutputPath:%s does not exists' % output_path
5164 5005 self.console.append(outputstr)
5165 5006 parms_ok = False
5166 5007 output_path = None
5167 5008
5168 5009
5169 5010 try:
5170 5011 profilesperblock = int(profilesperblock)
5171 5012 except:
5172 5013 if datatype == "Voltage":
5173 5014 outputstr = 'Profilesperblock: %s, this must be a integer number' % str(self.volOutputprofilesperblock.text())
5174 5015 self.console.append(outputstr)
5175 5016 parms_ok = False
5176 5017 profilesperblock = None
5177 5018
5178 5019 elif datatype == "Spectra":
5179 5020 outputstr = 'Profilesperblock: %s, this must be a integer number' % str(self.specOutputprofileperblock.text())
5180 5021 self.console.append(outputstr)
5181 5022 parms_ok = False
5182 5023 profilesperblock = None
5183 5024
5184 5025 try:
5185 5026 blocksperfile = int(blocksperfile)
5186 5027 except:
5187 5028 if datatype == "Voltage":
5188 5029 outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.volOutputblocksperfile.text())
5189 5030 elif datatype == "Spectra":
5190 5031 outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.specOutputblocksperfile.text())
5191 5032 elif datatype == "SpectraHeis":
5192 5033 outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.specHeisOutputblocksperfile.text())
5193 5034
5194 5035 self.console.append(outputstr)
5195 5036 parms_ok = False
5196 5037 blocksperfile = None
5197 5038
5198 5039 if datatype == "SpectraHeis":
5199 5040 if metada == '':
5200 5041 outputstr = 'Choose metada file'
5201 5042 self.console.append(outputstr)
5202 5043 parms_ok = False
5203 5044 if metada != None:
5204 5045 if not os.path.isfile(metada):
5205 5046 outputstr = 'Metadata:%s does not exists' % metada
5206 5047 self.console.append(outputstr)
5207 5048 parms_ok = False
5208 5049 output_path = None
5209 5050
5210 5051 if datatype == "Voltage":
5211 5052 return parms_ok, output_path, blocksperfile, profilesperblock
5212 5053
5213 5054
5214 5055 if datatype == "Spectra":
5215 5056 return parms_ok, output_path, blocksperfile, profilesperblock
5216 5057
5217 5058
5218 5059 if datatype == "SpectraHeis":
5219 5060 return parms_ok, output_path, blocksperfile, metada
5220 5061
5221 5062 def findDatafiles(self, data_path, ext, walk, expLabel=''):
5222 5063
5223 5064 dateList = []
5224 5065 fileList = []
5225 5066
5226 5067 if ext == ".r":
5227 5068 from schainpy.model.io.jroIO_base import JRODataReader
5228 5069
5229 5070 readerObj = JRODataReader()
5230 5071 dateList = readerObj.findDatafiles(path=data_path,
5231 5072 expLabel=expLabel,
5232 5073 ext=ext,
5233 5074 walk=walk)
5234 5075
5235 5076 if ext == ".pdata":
5236 5077 from schainpy.model.io.jroIO_base import JRODataReader
5237 5078
5238 5079 readerObj = JRODataReader()
5239 5080 dateList = readerObj.findDatafiles(path=data_path,
5240 5081 expLabel=expLabel,
5241 5082 ext=ext,
5242 5083 walk=walk)
5243 5084
5244 5085 if ext == ".fits":
5245 5086 from schainpy.model.io.jroIO_base import JRODataReader
5246 5087
5247 5088 readerObj = JRODataReader()
5248 5089 dateList = readerObj.findDatafiles(path=data_path,
5249 5090 expLabel=expLabel,
5250 5091 ext=ext,
5251 5092 walk=walk)
5252 5093
5253 5094 if ext == ".hdf5":
5254 5095 from schainpy.model.io.jroIO_usrp import USRPReader
5255 5096
5256 5097 readerObj = USRPReader()
5257 5098 dateList = readerObj.findDatafiles(path=data_path)
5258 5099
5259 5100 return dateList
5260 5101
5261 5102 def loadDays(self, data_path, ext, walk, expLabel=''):
5262 5103 """
5263 5104 Method to loads day
5264 5105 """
5265 5106 self.proOk.setEnabled(False)
5107 self.proComStartDate.clear()
5108 self.proComEndDate.clear()
5109
5266 5110 self.dateList = []
5267 5111
5112 if not os.path.isdir(data_path):
5113 return
5114
5268 5115 dateList = self.findDatafiles(data_path, ext=ext, walk=walk, expLabel=expLabel)
5269 5116
5270 5117 if not dateList:
5271 5118 # self.console.clear()
5272 5119 outputstr = "The path: %s is empty with file extension *%s" % (data_path, ext)
5273 5120 self.console.append(outputstr)
5274 5121 return
5275 5122
5276 self.proComStartDate.clear()
5277 self.proComEndDate.clear()
5278
5279 5123 dateStrList = []
5280 5124 for thisDate in dateList:
5281 5125 dateStr = thisDate.strftime("%Y/%m/%d")
5282 5126
5283 5127 self.proComStartDate.addItem(dateStr)
5284 5128 self.proComEndDate.addItem(dateStr)
5285 5129 dateStrList.append(dateStr)
5286 5130
5287 5131 self.proComStartDate.setCurrentIndex(0)
5288 5132 self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - 1)
5289 5133
5290 5134 self.dateList = dateStrList
5291 5135 self.proOk.setEnabled(True)
5292 5136
5293 5137 return self.dateList
5294 5138
5295 5139 def setWorkSpaceGUI(self, pathWorkSpace=None):
5296 5140
5297 5141 if pathWorkSpace == None:
5298 5142 home = os.path.expanduser("~")
5299 5143 pathWorkSpace = os.path.join(home,'schain_workspace')
5300 5144
5301 5145 self.pathWorkSpace = pathWorkSpace
5302 5146
5303 5147 """
5304 5148 Comandos Usados en Console
5305 5149 """
5306 5150 def __del__(self):
5307 5151 sys.stdout = sys.__stdout__
5308 5152 sys.stderr = sys.__stderr__
5309 5153
5310 5154 def normalOutputWritten(self, text):
5311 5155 color_black = QtGui.QColor(0,0,0)
5312 5156 self.console.setTextColor(color_black)
5313 5157 self.console.append(text)
5314 5158
5315 5159 def errorOutputWritten(self, text):
5316 5160 color_red = QtGui.QColor(255,0,0)
5317 5161 color_black = QtGui.QColor(0,0,0)
5318 5162
5319 5163 self.console.setTextColor(color_red)
5320 5164 self.console.append(text)
5321 5165 self.console.setTextColor(color_black)
5322 5166
5323 5167 def setParameter(self):
5324 5168
5325 5169 self.setWindowTitle("ROJ-Signal Chain")
5326 5170 self.setWindowIcon(QtGui.QIcon( os.path.join(FIGURES_PATH,"adn.jpg") ))
5327 5171
5328 5172 self.tabWidgetProject.setEnabled(False)
5329 5173 self.tabVoltage.setEnabled(False)
5330 5174 self.tabSpectra.setEnabled(False)
5331 5175 self.tabCorrelation.setEnabled(False)
5332 5176 self.frame_2.setEnabled(False)
5333 5177
5334 5178 self.actionCreate.setShortcut('Ctrl+N')
5335 5179 self.actionOpen.setShortcut('Ctrl+O')
5336 5180 self.actionSave.setShortcut('Ctrl+S')
5337 5181 self.actionClose.setShortcut('Ctrl+X')
5338 5182
5339 5183 self.actionStart.setShortcut('Ctrl+1')
5340 5184 self.actionPause.setShortcut('Ctrl+2')
5341 5185 self.actionStop.setShortcut('Ctrl+3')
5342 5186
5343 5187 self.actionFTP.setShortcut('Ctrl+F')
5344 5188
5345 5189 self.actionStart.setEnabled(False)
5346 5190 self.actionPause.setEnabled(False)
5347 5191 self.actionStop.setEnabled(False)
5348 5192
5349 5193 self.actionStarToolbar.setEnabled(False)
5350 5194 self.actionPauseToolbar.setEnabled(False)
5351 5195 self.actionStopToolbar.setEnabled(False)
5352 5196
5353 5197 self.proName.clear()
5354 5198 self.proDataPath.setText('')
5355 5199 self.console.setReadOnly(True)
5356 5200 self.console.append("Welcome to Signal Chain\nOpen a project or Create a new one")
5357 5201 self.proStartTime.setDisplayFormat("hh:mm:ss")
5358 5202 self.proDataType.setEnabled(False)
5359 5203 self.time = QtCore.QTime()
5360 5204 self.hour = 0
5361 5205 self.min = 0
5362 5206 self.sec = 0
5363 5207 self.proEndTime.setDisplayFormat("hh:mm:ss")
5364 5208 startTime = "00:00:00"
5365 5209 endTime = "23:59:59"
5366 5210 starlist = startTime.split(":")
5367 5211 endlist = endTime.split(":")
5368 5212 self.time.setHMS(int(starlist[0]), int(starlist[1]), int(starlist[2]))
5369 5213 self.proStartTime.setTime(self.time)
5370 5214 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
5371 5215 self.proEndTime.setTime(self.time)
5372 5216 self.proOk.setEnabled(False)
5373 5217 # set model Project Explorer
5374 5218 self.projectExplorerModel = QtGui.QStandardItemModel()
5375 5219 self.projectExplorerModel.setHorizontalHeaderLabels(("Project Explorer",))
5376 5220 layout = QtGui.QVBoxLayout()
5377 5221 layout.addWidget(self.projectExplorerTree)
5378 5222 self.projectExplorerTree.setModel(self.projectExplorerModel)
5379 5223 self.projectExplorerTree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
5380 5224 self.projectExplorerTree.customContextMenuRequested.connect(self.on_right_click)
5381 5225 self.projectExplorerTree.clicked.connect(self.on_click)
5382 5226 self.projectExplorerTree.expandAll()
5383 5227 # set model Project Properties
5384 5228
5385 5229 self.propertiesModel = TreeModel()
5386 5230 self.propertiesModel.initProjectView()
5387 5231 self.treeProjectProperties.setModel(self.propertiesModel)
5388 5232 self.treeProjectProperties.expandAll()
5389 5233 self.treeProjectProperties.allColumnsShowFocus()
5390 5234 self.treeProjectProperties.resizeColumnToContents(1)
5391 5235
5392 5236 # set Project
5393 5237 self.proDelay.setEnabled(False)
5394 5238 self.proSet.setEnabled(False)
5395 5239 self.proDataType.setReadOnly(True)
5396 5240
5397 5241 # set Operation Voltage
5398 5242 self.volOpComChannels.setEnabled(False)
5399 5243 self.volOpComHeights.setEnabled(False)
5400 5244 self.volOpFilter.setEnabled(False)
5401 5245 self.volOpComProfile.setEnabled(False)
5402 5246 self.volOpComCode.setEnabled(False)
5403 5247 self.volOpFlip.setEnabled(False)
5404 5248 self.volOpCohInt.setEnabled(False)
5405 5249 self.volOpRadarfrequency.setEnabled(False)
5406 5250
5407 5251 self.volOpChannel.setEnabled(False)
5408 5252 self.volOpHeights.setEnabled(False)
5409 5253 self.volOpProfile.setEnabled(False)
5410 5254 self.volOpComMode.setEnabled(False)
5411 5255
5412 5256 self.volGraphPath.setEnabled(False)
5413 5257 self.volGraphPrefix.setEnabled(False)
5414 5258 self.volGraphToolPath.setEnabled(False)
5415 5259
5416 5260 # set Graph Voltage
5417 5261 self.volGraphChannelList.setEnabled(False)
5418 5262 self.volGraphfreqrange.setEnabled(False)
5419 5263 self.volGraphHeightrange.setEnabled(False)
5420 5264
5421 5265 # set Operation Spectra
5422 5266 self.specOpnFFTpoints.setEnabled(False)
5423 5267 self.specOpProfiles.setEnabled(False)
5424 5268 self.specOpippFactor.setEnabled(False)
5425 5269 self.specOppairsList.setEnabled(False)
5426 5270 self.specOpComChannel.setEnabled(False)
5427 5271 self.specOpComHeights.setEnabled(False)
5428 5272 self.specOpIncoherent.setEnabled(False)
5429 5273 self.specOpgetNoise.setEnabled(False)
5430 5274 self.specOpRadarfrequency.setEnabled(False)
5431 5275
5432 5276
5433 5277 self.specOpChannel.setEnabled(False)
5434 5278 self.specOpHeights.setEnabled(False)
5435 5279 # set Graph Spectra
5436 5280 self.specGgraphChannelList.setEnabled(False)
5437 5281 self.specGgraphFreq.setEnabled(False)
5438 5282 self.specGgraphHeight.setEnabled(False)
5439 5283 self.specGgraphDbsrange.setEnabled(False)
5440 5284 self.specGgraphmagnitud.setEnabled(False)
5441 5285 self.specGgraphTminTmax.setEnabled(False)
5442 5286 self.specGgraphTimeRange.setEnabled(False)
5443 5287 self.specGraphPath.setEnabled(False)
5444 5288 self.specGraphToolPath.setEnabled(False)
5445 5289 self.specGraphPrefix.setEnabled(False)
5446 5290
5447 5291 self.specGgraphftpratio.setEnabled(False)
5448 5292 # set Operation SpectraHeis
5449 5293 self.specHeisOpIncoherent.setEnabled(False)
5450 5294 self.specHeisOpCobIncInt.setEnabled(False)
5451 5295 # set Graph SpectraHeis
5452 5296 self.specHeisGgraphChannelList.setEnabled(False)
5453 5297 self.specHeisGgraphXminXmax.setEnabled(False)
5454 5298 self.specHeisGgraphYminYmax.setEnabled(False)
5455 5299 self.specHeisGgraphTminTmax.setEnabled(False)
5456 5300 self.specHeisGgraphTimeRange.setEnabled(False)
5457 5301 self.specHeisGgraphftpratio.setEnabled(False)
5458 5302 self.specHeisGraphPath.setEnabled(False)
5459 5303 self.specHeisGraphPrefix.setEnabled(False)
5460 5304 self.specHeisGraphToolPath.setEnabled(False)
5461 5305
5462 5306
5463 5307 # tool tip gui
5464 5308 QtGui.QToolTip.setFont(QtGui.QFont('SansSerif', 10))
5465 5309 self.projectExplorerTree.setToolTip('Right clik to add Project or Unit Process')
5466 5310 # tool tip gui project
5467 5311 self.proComWalk.setToolTip('<b>On Files</b>:<i>Search file in format .r or pdata</i> <b>On Folders</b>:<i>Search file in a directory DYYYYDOY</i>')
5468 5312 self.proComWalk.setCurrentIndex(0)
5469 5313 # tool tip gui volOp
5470 5314 self.volOpChannel.setToolTip('Example: 1,2,3,4,5')
5471 5315 self.volOpHeights.setToolTip('Example: 90,180')
5472 5316 self.volOpFilter.setToolTip('Example: 2')
5473 5317 self.volOpProfile.setToolTip('Example:0,127')
5474 5318 self.volOpCohInt.setToolTip('Example: 128')
5475 5319 self.volOpFlip.setToolTip('ChannelList where flip will be applied. Example: 0,2,3')
5476 5320 self.volOpOk.setToolTip('If you have finished, please Ok ')
5477 5321 # tool tip gui volGraph
5478 5322 self.volGraphfreqrange.setToolTip('Height range. Example: 50,100')
5479 5323 self.volGraphHeightrange.setToolTip('Amplitude. Example: 0,10000')
5480 5324 # tool tip gui specOp
5481 5325 self.specOpnFFTpoints.setToolTip('Example: 128')
5482 5326 self.specOpProfiles.setToolTip('Example: 128')
5483 5327 self.specOpippFactor.setToolTip('Example:1.0')
5484 5328 self.specOpIncoherent.setToolTip('Example: 10')
5485 5329 self.specOpgetNoise.setToolTip('Example:20,180,30,120 (minHei,maxHei,minVel,maxVel)')
5486 5330
5487 5331 self.specOpChannel.setToolTip('Example: 0,1,2,3')
5488 5332 self.specOpHeights.setToolTip('Example: 90,180')
5489 5333 self.specOppairsList.setToolTip('Example: (0,1),(2,3)')
5490 5334 # tool tip gui specGraph
5491 5335
5492 5336 self.specGgraphChannelList.setToolTip('Example: 0,3,4')
5493 5337 self.specGgraphFreq.setToolTip('Example: -20,20')
5494 5338 self.specGgraphHeight.setToolTip('Example: 100,400')
5495 5339 self.specGgraphDbsrange.setToolTip('Example: 30,170')
5496 5340
5497 5341 self.specGraphPrefix.setToolTip('Example: EXPERIMENT_NAME')
5498 5342
5499 5343 sys.stdout = ShowMeConsole(textWritten=self.normalOutputWritten)
5500 5344 sys.stderr = ShowMeConsole(textWritten=self.errorOutputWritten)
5501 5345
5502 5346
5503 5347 class UnitProcessWindow(QMainWindow, Ui_UnitProcess):
5504 5348 """
5505 5349 Class documentation goes here.
5506 5350 """
5507 5351 closed = pyqtSignal()
5508 5352 create = False
5509 5353
5510 5354 def __init__(self, parent=None):
5511 5355 """
5512 5356 Constructor
5513 5357 """
5514 5358 QMainWindow.__init__(self, parent)
5515 5359 self.setupUi(self)
5516 5360 self.getFromWindow = None
5517 5361 self.getfromWindowList = []
5518 5362 self.dataTypeProject = None
5519 5363
5520 5364 self.listUP = None
5521 5365
5522 5366 @pyqtSignature("")
5523 5367 def on_unitPokbut_clicked(self):
5524 5368 """
5525 5369 Slot documentation goes here.
5526 5370 """
5527 5371 self.create = True
5528 5372 self.getFromWindow = self.getfromWindowList[int(self.comboInputBox.currentIndex())]
5529 5373 # self.nameofUP= str(self.nameUptxt.text())
5530 5374 self.typeofUP = str(self.comboTypeBox.currentText())
5531 5375 self.close()
5532 5376
5533 5377
5534 5378 @pyqtSignature("")
5535 5379 def on_unitPcancelbut_clicked(self):
5536 5380 """
5537 5381 Slot documentation goes here.
5538 5382 """
5539 5383 self.create = False
5540 5384 self.close()
5541 5385
5542 5386 def loadTotalList(self):
5543 5387 self.comboInputBox.clear()
5544 5388 for i in self.getfromWindowList:
5545 5389
5546 5390 name = i.getElementName()
5547 5391 if name == 'Project':
5548 5392 id = i.id
5549 5393 name = i.name
5550 5394 if self.dataTypeProject == 'Voltage':
5551 5395 self.comboTypeBox.clear()
5552 5396 self.comboTypeBox.addItem("Voltage")
5553 5397
5554 5398 if self.dataTypeProject == 'Spectra':
5555 5399 self.comboTypeBox.clear()
5556 5400 self.comboTypeBox.addItem("Spectra")
5557 5401 self.comboTypeBox.addItem("Correlation")
5558 5402 if self.dataTypeProject == 'Fits':
5559 5403 self.comboTypeBox.clear()
5560 5404 self.comboTypeBox.addItem("SpectraHeis")
5561 5405
5562 5406
5563 5407 if name == 'ProcUnit':
5564 5408 id = int(i.id) - 1
5565 5409 name = i.datatype
5566 5410 if name == 'Voltage':
5567 5411 self.comboTypeBox.clear()
5568 5412 self.comboTypeBox.addItem("Spectra")
5569 5413 self.comboTypeBox.addItem("SpectraHeis")
5570 5414 self.comboTypeBox.addItem("Correlation")
5571 5415 if name == 'Spectra':
5572 5416 self.comboTypeBox.clear()
5573 5417 self.comboTypeBox.addItem("Spectra")
5574 5418 self.comboTypeBox.addItem("SpectraHeis")
5575 5419 self.comboTypeBox.addItem("Correlation")
5576 5420 if name == 'SpectraHeis':
5577 5421 self.comboTypeBox.clear()
5578 5422 self.comboTypeBox.addItem("SpectraHeis")
5579 5423
5580 5424 self.comboInputBox.addItem(str(name))
5581 5425 # self.comboInputBox.addItem(str(name)+str(id))
5582 5426
5583 5427 def closeEvent(self, event):
5584 5428 self.closed.emit()
5585 5429 event.accept()
5586 5430
5587 5431 class Ftp(QMainWindow, Ui_Ftp):
5588 5432 """
5589 5433 Class documentation goes here.
5590 5434 """
5591 5435 create = False
5592 5436 closed = pyqtSignal()
5593 5437 server = None
5594 5438 remotefolder = None
5595 5439 username = None
5596 5440 password = None
5597 5441 ftp_wei = None
5598 5442 exp_code = None
5599 5443 sub_exp_code = None
5600 5444 plot_pos = None
5601 5445
5602 5446 def __init__(self, parent=None):
5603 5447 """
5604 5448 Constructor
5605 5449 """
5606 5450 QMainWindow.__init__(self, parent)
5607 5451 self.setupUi(self)
5608 5452 self.setParameter()
5609 5453
5610 5454 def setParameter(self):
5611 5455 self.setWindowTitle("ROJ-Signal Chain")
5612 5456 self.serverFTP.setToolTip('Example: jro-app.igp.gob.pe')
5613 5457 self.folderFTP.setToolTip('Example: /home/wmaster/graficos')
5614 5458 self.usernameFTP.setToolTip('Example: myusername')
5615 5459 self.passwordFTP.setToolTip('Example: mypass ')
5616 5460 self.weightFTP.setToolTip('Example: 0')
5617 5461 self.expcodeFTP.setToolTip('Example: 0')
5618 5462 self.subexpFTP.setToolTip('Example: 0')
5619 5463 self.plotposFTP.setToolTip('Example: 0')
5620 5464
5621 5465 def setParmsfromTemporal(self, server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos):
5622 5466 self.serverFTP.setText(str(server))
5623 5467 self.folderFTP.setText(str(remotefolder))
5624 5468 self.usernameFTP.setText(str(username))
5625 5469 self.passwordFTP.setText(str(password))
5626 5470 self.weightFTP.setText(str(ftp_wei))
5627 5471 self.expcodeFTP.setText(str(exp_code))
5628 5472 self.subexpFTP.setText(str(sub_exp_code))
5629 5473 self.plotposFTP.setText(str(plot_pos))
5630 5474
5631 5475 def getParmsFromFtpWindow(self):
5632 5476 """
5633 5477 Return Inputs Project:
5634 5478 - server
5635 5479 - remotefolder
5636 5480 - username
5637 5481 - password
5638 5482 - ftp_wei
5639 5483 - exp_code
5640 5484 - sub_exp_code
5641 5485 - plot_pos
5642 5486 """
5643 5487 name_server_ftp = str(self.serverFTP.text())
5644 5488 if not name_server_ftp:
5645 5489 self.console.clear()
5646 5490 self.console.append("Please Write a FTP Server")
5647 5491 return 0
5648 5492
5649 5493 folder_server_ftp = str(self.folderFTP.text())
5650 5494 if not folder_server_ftp:
5651 5495 self.console.clear()
5652 5496 self.console.append("Please Write a Folder")
5653 5497 return 0
5654 5498
5655 5499 username_ftp = str(self.usernameFTP.text())
5656 5500 if not username_ftp:
5657 5501 self.console.clear()
5658 5502 self.console.append("Please Write a User Name")
5659 5503 return 0
5660 5504
5661 5505 password_ftp = str(self.passwordFTP.text())
5662 5506 if not password_ftp:
5663 5507 self.console.clear()
5664 5508 self.console.append("Please Write a passwordFTP")
5665 5509 return 0
5666 5510
5667 ftp_wei = self.weightFTP.text()
5511 ftp_wei = str(self.weightFTP.text())
5668 5512 if not ftp_wei == "":
5669 5513 try:
5670 5514 ftp_wei = int(self.weightFTP.text())
5671 5515 except:
5672 5516 self.console.clear()
5673 5517 self.console.append("Please Write a ftp_wei number")
5674 5518 return 0
5675 5519
5676 exp_code = self.expcodeFTP.text()
5520 exp_code = str(self.expcodeFTP.text())
5677 5521 if not exp_code == "":
5678 5522 try:
5679 5523 exp_code = int(self.expcodeFTP.text())
5680 5524 except:
5681 5525 self.console.clear()
5682 5526 self.console.append("Please Write a exp_code number")
5683 5527 return 0
5684 5528
5685 5529
5686 sub_exp_code = self.subexpFTP.text()
5530 sub_exp_code = str(self.subexpFTP.text())
5687 5531 if not sub_exp_code == "":
5688 5532 try:
5689 5533 sub_exp_code = int(self.subexpFTP.text())
5690 5534 except:
5691 5535 self.console.clear()
5692 5536 self.console.append("Please Write a sub_exp_code number")
5693 5537 return 0
5694 5538
5695 plot_pos = self.plotposFTP.text()
5539 plot_pos = str(self.plotposFTP.text())
5696 5540 if not plot_pos == "":
5697 5541 try:
5698 5542 plot_pos = int(self.plotposFTP.text())
5699 5543 except:
5700 5544 self.console.clear()
5701 5545 self.console.append("Please Write a plot_pos number")
5702 5546 return 0
5703 5547
5704 5548 return name_server_ftp, folder_server_ftp, username_ftp, password_ftp, ftp_wei, exp_code, sub_exp_code, plot_pos
5705 5549
5706 5550 @pyqtSignature("")
5707 5551 def on_ftpOkButton_clicked(self):
5708 5552 server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.getParmsFromFtpWindow()
5709 5553 self.create = True
5710 5554 self.close()
5711 5555
5712 5556 @pyqtSignature("")
5713 5557 def on_ftpCancelButton_clicked(self):
5714 5558 self.create = False
5715 5559 self.close()
5716 5560
5717 5561 def closeEvent(self, event):
5718 5562 self.closed.emit()
5719 5563 event.accept()
5720 5564
5721 5565 class ftpBuffer():
5722 5566
5723 5567 server = None
5724 5568 remotefolder = None
5725 5569 username = None
5726 5570 password = None
5727 5571 ftp_wei = None
5728 5572 exp_code = None
5729 5573 sub_exp_code = None
5730 5574 plot_pos = None
5731 5575 create = False
5732 5576 withoutconfig = False
5733 5577 createforView = False
5734 5578 localfolder = None
5735 5579 extension = None
5736 5580 period = None
5737 5581 protocol = None
5738 5582
5739 5583 def __init__(self):
5740 5584
5741 5585 self.create = False
5742 5586 self.server = None
5743 5587 self.remotefolder = None
5744 5588 self.username = None
5745 5589 self.password = None
5746 5590 self.ftp_wei = None
5747 5591 self.exp_code = None
5748 5592 self.sub_exp_code = None
5749 5593 self.plot_pos = None
5750 5594 # self.create = False
5751 5595 self.localfolder = None
5752 5596 self.extension = None
5753 5597 self.period = None
5754 5598 self.protocol = None
5755 5599
5756 5600 def setwithoutconfiguration(self):
5757 5601
5758 5602 self.create = False
5759 5603 self.server = "jro-app.igp.gob.pe"
5760 5604 self.remotefolder = "/home/wmaster/graficos"
5761 5605 self.username = "wmaster"
5762 5606 self.password = "mst2010vhf"
5763 5607 self.withoutconfig = True
5764 5608 self.localfolder = './'
5765 5609 self.extension = '.png'
5766 self.period = '60'
5610 self.period = 60
5767 5611 self.protocol = 'ftp'
5768 5612 self.createforView = True
5769 5613
5770 5614 if not self.ftp_wei:
5771 self.ftp_wei = "0"
5615 self.ftp_wei = 0
5772 5616
5773 5617 if not self.exp_code:
5774 self.exp_code = "0"
5618 self.exp_code = 0
5775 5619
5776 5620 if not self.sub_exp_code:
5777 self.sub_exp_code = "0"
5621 self.sub_exp_code = 0
5778 5622
5779 5623 if not self.plot_pos:
5780 self.plot_pos = "0"
5624 self.plot_pos = 0
5781 5625
5782 def save(self, server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos, localfolder='./', extension='.png', period='60', protocol='ftp'):
5626 def save(self, server, remotefolder, username, password, ftp_wei=0, exp_code=0, sub_exp_code=0, plot_pos=0, localfolder='./', extension='.png', period=60, protocol='ftp'):
5783 5627
5784 5628 self.server = server
5785 5629 self.remotefolder = remotefolder
5786 5630 self.username = username
5787 5631 self.password = password
5788 5632 self.ftp_wei = ftp_wei
5789 5633 self.exp_code = exp_code
5790 5634 self.sub_exp_code = sub_exp_code
5791 5635 self.plot_pos = plot_pos
5792 5636 self.create = True
5793 5637 self.withoutconfig = False
5794 5638 self.createforView = True
5795 5639 self.localfolder = localfolder
5796 5640 self.extension = extension
5797 5641 self.period = period
5798 5642 self.protocol = protocol
5799 5643
5800 5644 def recover(self):
5801 5645
5802 5646 return self.server, self.remotefolder, self.username, self.password, self.ftp_wei, self.exp_code, self.sub_exp_code, self.plot_pos, self.extension, self.period, self.protocol
5803 5647
5804 5648 class ShowMeConsole(QtCore.QObject):
5805 5649 textWritten = QtCore.pyqtSignal(str)
5806 5650 def write (self, text):
5807 5651 self.textWritten.emit(str(text))
5808 5652
5809 5653 class PlotManager():
5810 5654 def __init__(self, queue):
5811 5655 self.queue = queue
5812 5656 self.objPlotDict = {}
5813 5657
5814 5658 def processIncoming(self):
5815 5659 while self.queue.qsize():
5816 5660 try:
5817 5661 dataFromQueue = self.queue.get(True)
5818 5662 if dataFromQueue == None:
5819 5663 continue
5820 5664
5821 5665 dataPlot = dataFromQueue['data']
5822 5666 kwargs = dataFromQueue['kwargs']
5823 5667 id = kwargs['id']
5824 5668 if 'channelList' in kwargs.keys():
5825 5669 channelList = kwargs['channelList']
5826 5670 else:
5827 5671 channelList = None
5828 5672 plotname = kwargs.pop('type')
5829 5673
5830 5674 if not(id in self.objPlotDict.keys()):
5831 5675 className = eval(plotname)
5832 5676 self.objPlotDict[id] = className(id, channelList, dataPlot)
5833 5677 self.objPlotDict[id].show()
5834 5678
5835 5679 self.objPlotDict[id].run(dataPlot , **kwargs)
5836 5680
5837 5681 except Queue.Empty:
5838 5682 pass
5839 5683
5840 5684
Show file before | Show file after | Hide comments
@@ -1,1451 +1,1465
1 1 '''
2 2 Created on Jul 2, 2014
3 3
4 4 @author: roj-idl71
5 5 '''
6 6 import os
7 7 import sys
8 8 import glob
9 9 import time
10 10 import numpy
11 11 import fnmatch
12 12 import time, datetime
13 13 #import h5py
14 14 import traceback
15 15
16 16 try:
17 17 from gevent import sleep
18 18 except:
19 19 from time import sleep
20 20
21 21 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
22 22
23 23 LOCALTIME = True
24 24
25 25 def isNumber(cad):
26 26 """
27 27 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
28 28
29 29 Excepciones:
30 30 Si un determinado string no puede ser convertido a numero
31 31 Input:
32 32 str, string al cual se le analiza para determinar si convertible a un numero o no
33 33
34 34 Return:
35 35 True : si el string es uno numerico
36 36 False : no es un string numerico
37 37 """
38 38 try:
39 39 float( cad )
40 40 return True
41 41 except:
42 42 return False
43 43
44 44 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
45 45 """
46 46 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
47 47
48 48 Inputs:
49 49 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
50 50
51 51 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
52 52 segundos contados desde 01/01/1970.
53 53 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
54 54 segundos contados desde 01/01/1970.
55 55
56 56 Return:
57 57 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
58 58 fecha especificado, de lo contrario retorna False.
59 59
60 60 Excepciones:
61 61 Si el archivo no existe o no puede ser abierto
62 62 Si la cabecera no puede ser leida.
63 63
64 64 """
65 65 basicHeaderObj = BasicHeader(LOCALTIME)
66 66
67 67 try:
68 68 fp = open(filename,'rb')
69 69 except IOError:
70 70 traceback.print_exc()
71 71 raise IOError, "The file %s can't be opened" %(filename)
72 72
73 73 sts = basicHeaderObj.read(fp)
74 74 fp.close()
75 75
76 76 if not(sts):
77 77 print "Skipping the file %s because it has not a valid header" %(filename)
78 78 return 0
79 79
80 80 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
81 81 return 0
82 82
83 83 return 1
84 84
85 85 def isFileinThisTime(filename, startTime, endTime):
86 86 """
87 87 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
88 88
89 89 Inputs:
90 90 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
91 91
92 92 startTime : tiempo inicial del rango seleccionado en formato datetime.time
93 93
94 94 endTime : tiempo final del rango seleccionado en formato datetime.time
95 95
96 96 Return:
97 97 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
98 98 fecha especificado, de lo contrario retorna False.
99 99
100 100 Excepciones:
101 101 Si el archivo no existe o no puede ser abierto
102 102 Si la cabecera no puede ser leida.
103 103
104 104 """
105 105
106 106
107 107 try:
108 108 fp = open(filename,'rb')
109 109 except IOError:
110 110 traceback.print_exc()
111 111 raise IOError, "The file %s can't be opened" %(filename)
112 112
113 113 basicHeaderObj = BasicHeader(LOCALTIME)
114 114 sts = basicHeaderObj.read(fp)
115 115 fp.close()
116 116
117 117 thisDatetime = basicHeaderObj.datatime
118 118 thisTime = thisDatetime.time()
119 119
120 120 if not(sts):
121 121 print "Skipping the file %s because it has not a valid header" %(filename)
122 122 return None
123 123
124 124 if not ((startTime <= thisTime) and (endTime > thisTime)):
125 125 return None
126 126
127 127 return thisDatetime
128 128
129 129 def getFileFromSet(path, ext, set):
130 130 validFilelist = []
131 131 fileList = os.listdir(path)
132 132
133 133 # 0 1234 567 89A BCDE
134 134 # H YYYY DDD SSS .ext
135 135
136 136 for thisFile in fileList:
137 137 try:
138 138 year = int(thisFile[1:5])
139 139 doy = int(thisFile[5:8])
140 140 except:
141 141 continue
142 142
143 143 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
144 144 continue
145 145
146 146 validFilelist.append(thisFile)
147 147
148 148 myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
149 149
150 150 if len(myfile)!= 0:
151 151 return myfile[0]
152 152 else:
153 153 filename = '*%4.4d%3.3d%3.3d%s'%(year,doy,set,ext.lower())
154 154 print 'the filename %s does not exist'%filename
155 155 print '...going to the last file: '
156 156
157 157 if validFilelist:
158 158 validFilelist = sorted( validFilelist, key=str.lower )
159 159 return validFilelist[-1]
160 160
161 161 return None
162 162
163 163 def getlastFileFromPath(path, ext):
164 164 """
165 165 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
166 166 al final de la depuracion devuelve el ultimo file de la lista que quedo.
167 167
168 168 Input:
169 169 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
170 170 ext : extension de los files contenidos en una carpeta
171 171
172 172 Return:
173 173 El ultimo file de una determinada carpeta, no se considera el path.
174 174 """
175 175 validFilelist = []
176 176 fileList = os.listdir(path)
177 177
178 178 # 0 1234 567 89A BCDE
179 179 # H YYYY DDD SSS .ext
180 180
181 181 for thisFile in fileList:
182 182
183 183 year = thisFile[1:5]
184 184 if not isNumber(year):
185 185 continue
186 186
187 187 doy = thisFile[5:8]
188 188 if not isNumber(doy):
189 189 continue
190 190
191 191 year = int(year)
192 192 doy = int(doy)
193 193
194 194 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
195 195 continue
196 196
197 197 validFilelist.append(thisFile)
198 198
199 199 if validFilelist:
200 200 validFilelist = sorted( validFilelist, key=str.lower )
201 201 return validFilelist[-1]
202 202
203 203 return None
204 204
205 205 def checkForRealPath(path, foldercounter, year, doy, set, ext):
206 206 """
207 207 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
208 208 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
209 209 el path exacto de un determinado file.
210 210
211 211 Example :
212 212 nombre correcto del file es .../.../D2009307/P2009307367.ext
213 213
214 214 Entonces la funcion prueba con las siguientes combinaciones
215 215 .../.../y2009307367.ext
216 216 .../.../Y2009307367.ext
217 217 .../.../x2009307/y2009307367.ext
218 218 .../.../x2009307/Y2009307367.ext
219 219 .../.../X2009307/y2009307367.ext
220 220 .../.../X2009307/Y2009307367.ext
221 221 siendo para este caso, la ultima combinacion de letras, identica al file buscado
222 222
223 223 Return:
224 224 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
225 225 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
226 226 para el filename
227 227 """
228 228 fullfilename = None
229 229 find_flag = False
230 230 filename = None
231 231
232 232 prefixDirList = [None,'d','D']
233 233 if ext.lower() == ".r": #voltage
234 234 prefixFileList = ['d','D']
235 235 elif ext.lower() == ".pdata": #spectra
236 236 prefixFileList = ['p','P']
237 237 else:
238 238 return None, filename
239 239
240 240 #barrido por las combinaciones posibles
241 241 for prefixDir in prefixDirList:
242 242 thispath = path
243 243 if prefixDir != None:
244 244 #formo el nombre del directorio xYYYYDDD (x=d o x=D)
245 245 if foldercounter == 0:
246 246 thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))
247 247 else:
248 248 thispath = os.path.join(path, "%s%04d%03d_%02d" % ( prefixDir, year, doy , foldercounter))
249 249 for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D"
250 250 filename = "%s%04d%03d%03d%s" % ( prefixFile, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
251 251 fullfilename = os.path.join( thispath, filename ) #formo el path completo
252 252
253 253 if os.path.exists( fullfilename ): #verifico que exista
254 254 find_flag = True
255 255 break
256 256 if find_flag:
257 257 break
258 258
259 259 if not(find_flag):
260 260 return None, filename
261 261
262 262 return fullfilename, filename
263 263
264 264 def isRadarFolder(folder):
265 265 try:
266 266 year = int(folder[1:5])
267 267 doy = int(folder[5:8])
268 268 except:
269 269 return 0
270 270
271 271 return 1
272 272
273 273 def isRadarFile(file):
274 274 try:
275 275 year = int(file[1:5])
276 276 doy = int(file[5:8])
277 277 set = int(file[8:11])
278 278 except:
279 279 return 0
280 280
281 281 return 1
282 282
283 283 def getDateFromRadarFile(file):
284 284 try:
285 285 year = int(file[1:5])
286 286 doy = int(file[5:8])
287 287 set = int(file[8:11])
288 288 except:
289 289 return None
290 290
291 291 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy-1)
292 292 return thisDate
293 293
294 294 class JRODataIO:
295 295
296 296 c = 3E8
297 297
298 298 isConfig = False
299 299
300 300 basicHeaderObj = None
301 301
302 302 systemHeaderObj = None
303 303
304 304 radarControllerHeaderObj = None
305 305
306 306 processingHeaderObj = None
307 307
308 308 online = 0
309 309
310 310 dtype = None
311 311
312 312 pathList = []
313 313
314 314 filenameList = []
315 315
316 316 filename = None
317 317
318 318 ext = None
319 319
320 320 flagIsNewFile = 1
321 321
322 322 flagDiscontinuousBlock = 0
323 323
324 324 flagIsNewBlock = 0
325 325
326 326 fp = None
327 327
328 328 firstHeaderSize = 0
329 329
330 330 basicHeaderSize = 24
331 331
332 332 versionFile = 1103
333 333
334 334 fileSize = None
335 335
336 336 # ippSeconds = None
337 337
338 338 fileSizeByHeader = None
339 339
340 340 fileIndex = None
341 341
342 342 profileIndex = None
343 343
344 344 blockIndex = None
345 345
346 346 nTotalBlocks = None
347 347
348 348 maxTimeStep = 30
349 349
350 350 lastUTTime = None
351 351
352 352 datablock = None
353 353
354 354 dataOut = None
355 355
356 356 blocksize = None
357 357
358 358 getByBlock = False
359 359
360 360 def __init__(self):
361 361
362 362 raise ValueError, "Not implemented"
363 363
364 364 def run(self):
365 365
366 366 raise ValueError, "Not implemented"
367 367
368 368 class JRODataReader(JRODataIO):
369 369
370 370 nReadBlocks = 0
371 371
372 372 delay = 10 #number of seconds waiting a new file
373 373
374 374 nTries = 3 #quantity tries
375 375
376 376 nFiles = 3 #number of files for searching
377 377
378 378 path = None
379 379
380 380 foldercounter = 0
381 381
382 382 flagNoMoreFiles = 0
383 383
384 384 datetimeList = []
385 385
386 386 __isFirstTimeOnline = 1
387 387
388 388 __printInfo = True
389 389
390 390 profileIndex = None
391 391
392 392 nTxs = 1
393 393
394 394 txIndex = None
395 395
396 396 def __init__(self):
397 397
398 398 """
399 399
400 400 """
401 401
402 402 # raise NotImplementedError, "This method has not been implemented"
403 403
404 404
405 405 def createObjByDefault(self):
406 406 """
407 407
408 408 """
409 409 raise NotImplementedError, "This method has not been implemented"
410 410
411 411 def getBlockDimension(self):
412 412
413 413 raise NotImplementedError, "No implemented"
414 414
415 415 def __searchFilesOffLine(self,
416 416 path,
417 417 startDate=None,
418 418 endDate=None,
419 419 startTime=datetime.time(0,0,0),
420 420 endTime=datetime.time(23,59,59),
421 421 set=None,
422 422 expLabel='',
423 423 ext='.r',
424 424 walk=True):
425 425
426 426 self.filenameList = []
427 427 self.datetimeList = []
428 428
429 429 pathList = []
430 430
431 431 if not walk:
432 432 #pathList.append(path)
433 433 multi_path = path.split(',')
434 434 for single_path in multi_path:
435
436 if not os.path.isdir(single_path):
437 continue
438
435 439 pathList.append(single_path)
436 440
437 441 else:
438 442 #dirList = []
439 443 multi_path = path.split(',')
440 444 for single_path in multi_path:
445
446 if not os.path.isdir(single_path):
447 continue
448
441 449 dirList = []
442 450 for thisPath in os.listdir(single_path):
443 451 if not os.path.isdir(os.path.join(single_path,thisPath)):
444 452 continue
445 453 if not isRadarFolder(thisPath):
446 454 continue
447 455
448 456 dirList.append(thisPath)
449 457
450 458 if not(dirList):
451 459 return None, None
452 460
453 461 if startDate and endDate:
454 462 thisDate = startDate
455 463
456 464 while(thisDate <= endDate):
457 465 year = thisDate.timetuple().tm_year
458 466 doy = thisDate.timetuple().tm_yday
459 467
460 468 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
461 469 if len(matchlist) == 0:
462 470 thisDate += datetime.timedelta(1)
463 471 continue
464 472 for match in matchlist:
465 473 pathList.append(os.path.join(single_path,match,expLabel))
466 474
467 475 thisDate += datetime.timedelta(1)
468 476 else:
469 477 for thiDir in dirList:
470 478 pathList.append(os.path.join(single_path,thiDir,expLabel))
471 479
472 480 if pathList == []:
473 481 print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
474 482 return None, None
475 483
476 484 print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
477 485
478 486 filenameList = []
479 487 datetimeList = []
480 488 pathDict = {}
481 489 filenameList_to_sort = []
482 490
483 491 for i in range(len(pathList)):
484 492
485 493 thisPath = pathList[i]
486 494
487 495 fileList = glob.glob1(thisPath, "*%s" %ext)
488 496 if len(fileList) < 1:
489 497 continue
490 498 fileList.sort()
491 499 pathDict.setdefault(fileList[0])
492 500 pathDict[fileList[0]] = i
493 501 filenameList_to_sort.append(fileList[0])
494 502
495 503 filenameList_to_sort.sort()
496 504
497 505 for file in filenameList_to_sort:
498 506 thisPath = pathList[pathDict[file]]
499 507
500 508 fileList = glob.glob1(thisPath, "*%s" %ext)
501 509 fileList.sort()
502 510
503 511 for file in fileList:
504 512
505 513 filename = os.path.join(thisPath,file)
506 514 thisDatetime = isFileinThisTime(filename, startTime, endTime)
507 515
508 516 if not(thisDatetime):
509 517 continue
510 518
511 519 filenameList.append(filename)
512 520 datetimeList.append(thisDatetime)
513 521
514 522 if not(filenameList):
515 523 print "Any file was found for the time range %s - %s" %(startTime, endTime)
516 524 return None, None
517 525
518 526 print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
519 527 print
520 528
521 529 for i in range(len(filenameList)):
522 530 print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
523 531
524 532 self.filenameList = filenameList
525 533 self.datetimeList = datetimeList
526 534
527 535 return pathList, filenameList
528 536
529 537 def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True, set=None):
530 538
531 539 """
532 540 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
533 541 devuelve el archivo encontrado ademas de otros datos.
534 542
535 543 Input:
536 544 path : carpeta donde estan contenidos los files que contiene data
537 545
538 546 expLabel : Nombre del subexperimento (subfolder)
539 547
540 548 ext : extension de los files
541 549
542 550 walk : Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
543 551
544 552 Return:
545 553 directory : eL directorio donde esta el file encontrado
546 554 filename : el ultimo file de una determinada carpeta
547 555 year : el anho
548 556 doy : el numero de dia del anho
549 557 set : el set del archivo
550 558
551 559
552 560 """
553 561 dirList = []
554 562
555 563 if not walk:
556 564 fullpath = path
557 565 foldercounter = 0
558 566 else:
559 567 #Filtra solo los directorios
560 568 for thisPath in os.listdir(path):
561 569 if not os.path.isdir(os.path.join(path,thisPath)):
562 570 continue
563 571 if not isRadarFolder(thisPath):
564 572 continue
565 573
566 574 dirList.append(thisPath)
567 575
568 576 if not(dirList):
569 577 return None, None, None, None, None, None
570 578
571 579 dirList = sorted( dirList, key=str.lower )
572 580
573 581 doypath = dirList[-1]
574 582 foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0
575 583 fullpath = os.path.join(path, doypath, expLabel)
576 584
577 585
578 586 print "%s folder was found: " %(fullpath )
579 587
580 588 if set == None:
581 589 filename = getlastFileFromPath(fullpath, ext)
582 590 else:
583 591 filename = getFileFromSet(fullpath, ext, set)
584 592
585 593 if not(filename):
586 594 return None, None, None, None, None, None
587 595
588 596 print "%s file was found" %(filename)
589 597
590 598 if not(self.__verifyFile(os.path.join(fullpath, filename))):
591 599 return None, None, None, None, None, None
592 600
593 601 year = int( filename[1:5] )
594 602 doy = int( filename[5:8] )
595 603 set = int( filename[8:11] )
596 604
597 605 return fullpath, foldercounter, filename, year, doy, set
598 606
599 607 def __setNextFileOffline(self):
600 608
601 609 idFile = self.fileIndex
602 610
603 611 while (True):
604 612 idFile += 1
605 613 if not(idFile < len(self.filenameList)):
606 614 self.flagNoMoreFiles = 1
607 615 # print "[Reading] No more Files"
608 616 return 0
609 617
610 618 filename = self.filenameList[idFile]
611 619
612 620 if not(self.__verifyFile(filename)):
613 621 continue
614 622
615 623 fileSize = os.path.getsize(filename)
616 624 fp = open(filename,'rb')
617 625 break
618 626
619 627 self.flagIsNewFile = 1
620 628 self.fileIndex = idFile
621 629 self.filename = filename
622 630 self.fileSize = fileSize
623 631 self.fp = fp
624 632
625 633 # print "[Reading] Setting the file: %s"%self.filename
626 634
627 635 return 1
628 636
629 637 def __setNextFileOnline(self):
630 638 """
631 639 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
632 640 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
633 641 siguientes.
634 642
635 643 Affected:
636 644 self.flagIsNewFile
637 645 self.filename
638 646 self.fileSize
639 647 self.fp
640 648 self.set
641 649 self.flagNoMoreFiles
642 650
643 651 Return:
644 652 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
645 653 1 : si el file fue abierto con exito y esta listo a ser leido
646 654
647 655 Excepciones:
648 656 Si un determinado file no puede ser abierto
649 657 """
650 658 nFiles = 0
651 659 fileOk_flag = False
652 660 firstTime_flag = True
653 661
654 662 self.set += 1
655 663
656 664 if self.set > 999:
657 665 self.set = 0
658 666 self.foldercounter += 1
659 667
660 668 #busca el 1er file disponible
661 669 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
662 670 if fullfilename:
663 671 if self.__verifyFile(fullfilename, False):
664 672 fileOk_flag = True
665 673
666 674 #si no encuentra un file entonces espera y vuelve a buscar
667 675 if not(fileOk_flag):
668 676 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
669 677
670 678 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
671 679 tries = self.nTries
672 680 else:
673 681 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
674 682
675 683 for nTries in range( tries ):
676 684 if firstTime_flag:
677 685 print "\t[Reading] Waiting %0.2f sec for the file \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
678 686 sleep( self.delay )
679 687 else:
680 688 print "\t[Reading] Searching the next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
681 689
682 690 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
683 691 if fullfilename:
684 692 if self.__verifyFile(fullfilename):
685 693 fileOk_flag = True
686 694 break
687 695
688 696 if fileOk_flag:
689 697 break
690 698
691 699 firstTime_flag = False
692 700
693 701 print "\t[Reading] Skipping the file \"%s\" due to this file doesn't exist" % filename
694 702 self.set += 1
695 703
696 704 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
697 705 self.set = 0
698 706 self.doy += 1
699 707 self.foldercounter = 0
700 708
701 709 if fileOk_flag:
702 710 self.fileSize = os.path.getsize( fullfilename )
703 711 self.filename = fullfilename
704 712 self.flagIsNewFile = 1
705 713 if self.fp != None: self.fp.close()
706 714 self.fp = open(fullfilename, 'rb')
707 715 self.flagNoMoreFiles = 0
708 716 # print '[Reading] Setting the file: %s' % fullfilename
709 717 else:
710 718 self.fileSize = 0
711 719 self.filename = None
712 720 self.flagIsNewFile = 0
713 721 self.fp = None
714 722 self.flagNoMoreFiles = 1
715 723 # print '[Reading] No more files to read'
716 724
717 725 return fileOk_flag
718 726
719 727 def setNextFile(self):
720 728 if self.fp != None:
721 729 self.fp.close()
722 730
723 731 if self.online:
724 732 newFile = self.__setNextFileOnline()
725 733 else:
726 734 newFile = self.__setNextFileOffline()
727 735
728 736 if not(newFile):
729 737 print '[Reading] No more files to read'
730 738 return 0
731 739
732 740 print '[Reading] Setting the file: %s' % self.filename
733 741
734 742 self.__readFirstHeader()
735 743 self.nReadBlocks = 0
736 744 return 1
737 745
738 746 def __waitNewBlock(self):
739 747 """
740 748 Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
741 749
742 750 Si el modo de lectura es OffLine siempre retorn 0
743 751 """
744 752 if not self.online:
745 753 return 0
746 754
747 755 if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
748 756 return 0
749 757
750 758 currentPointer = self.fp.tell()
751 759
752 760 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
753 761
754 762 for nTries in range( self.nTries ):
755 763
756 764 self.fp.close()
757 765 self.fp = open( self.filename, 'rb' )
758 766 self.fp.seek( currentPointer )
759 767
760 768 self.fileSize = os.path.getsize( self.filename )
761 769 currentSize = self.fileSize - currentPointer
762 770
763 771 if ( currentSize >= neededSize ):
764 772 self.basicHeaderObj.read(self.fp)
765 773 return 1
766 774
767 775 if self.fileSize == self.fileSizeByHeader:
768 776 # self.flagEoF = True
769 777 return 0
770 778
771 779 print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
772 780 sleep( self.delay )
773 781
774 782
775 783 return 0
776 784
777 785 def waitDataBlock(self,pointer_location):
778 786
779 787 currentPointer = pointer_location
780 788
781 789 neededSize = self.processingHeaderObj.blockSize #+ self.basicHeaderSize
782 790
783 791 for nTries in range( self.nTries ):
784 792 self.fp.close()
785 793 self.fp = open( self.filename, 'rb' )
786 794 self.fp.seek( currentPointer )
787 795
788 796 self.fileSize = os.path.getsize( self.filename )
789 797 currentSize = self.fileSize - currentPointer
790 798
791 799 if ( currentSize >= neededSize ):
792 800 return 1
793 801
794 802 print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
795 803 sleep( self.delay )
796 804
797 805 return 0
798 806
799 807 def __jumpToLastBlock(self):
800 808
801 809 if not(self.__isFirstTimeOnline):
802 810 return
803 811
804 812 csize = self.fileSize - self.fp.tell()
805 813 blocksize = self.processingHeaderObj.blockSize
806 814
807 815 #salta el primer bloque de datos
808 816 if csize > self.processingHeaderObj.blockSize:
809 817 self.fp.seek(self.fp.tell() + blocksize)
810 818 else:
811 819 return
812 820
813 821 csize = self.fileSize - self.fp.tell()
814 822 neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
815 823 while True:
816 824
817 825 if self.fp.tell()<self.fileSize:
818 826 self.fp.seek(self.fp.tell() + neededsize)
819 827 else:
820 828 self.fp.seek(self.fp.tell() - neededsize)
821 829 break
822 830
823 831 # csize = self.fileSize - self.fp.tell()
824 832 # neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
825 833 # factor = int(csize/neededsize)
826 834 # if factor > 0:
827 835 # self.fp.seek(self.fp.tell() + factor*neededsize)
828 836
829 837 self.flagIsNewFile = 0
830 838 self.__isFirstTimeOnline = 0
831 839
832 840 def __setNewBlock(self):
833 841
834 842 if self.fp == None:
835 843 return 0
836 844
837 845 if self.online:
838 846 self.__jumpToLastBlock()
839 847
840 848 if self.flagIsNewFile:
841 849 return 1
842 850
843 851 self.lastUTTime = self.basicHeaderObj.utc
844 852 currentSize = self.fileSize - self.fp.tell()
845 853 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
846 854
847 855 if (currentSize >= neededSize):
848 856 self.basicHeaderObj.read(self.fp)
849 857 return 1
850 858
851 859 if self.__waitNewBlock():
852 860 return 1
853 861
854 862 if not(self.setNextFile()):
855 863 return 0
856 864
857 865 deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
858 866
859 867 self.flagDiscontinuousBlock = 0
860 868
861 869 if deltaTime > self.maxTimeStep:
862 870 self.flagDiscontinuousBlock = 1
863 871
864 872 return 1
865 873
866 874 def readNextBlock(self):
867 875 if not(self.__setNewBlock()):
868 876 return 0
869 877
870 878 if not(self.readBlock()):
871 879 return 0
872 880
873 881 return 1
874 882
875 883 def __readFirstHeader(self):
876 884
877 885 self.basicHeaderObj.read(self.fp)
878 886 self.systemHeaderObj.read(self.fp)
879 887 self.radarControllerHeaderObj.read(self.fp)
880 888 self.processingHeaderObj.read(self.fp)
881 889
882 890 self.firstHeaderSize = self.basicHeaderObj.size
883 891
884 892 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
885 893 if datatype == 0:
886 894 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
887 895 elif datatype == 1:
888 896 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
889 897 elif datatype == 2:
890 898 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
891 899 elif datatype == 3:
892 900 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
893 901 elif datatype == 4:
894 902 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
895 903 elif datatype == 5:
896 904 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
897 905 else:
898 906 raise ValueError, 'Data type was not defined'
899 907
900 908 self.dtype = datatype_str
901 909 #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
902 910 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
903 911 # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
904 912 # self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
905 913 self.getBlockDimension()
906 914
907 915 def __verifyFile(self, filename, msgFlag=True):
908 916 msg = None
909 917 try:
910 918 fp = open(filename, 'rb')
911 919 currentPosition = fp.tell()
912 920 except IOError:
913 921 traceback.print_exc()
914 922 if msgFlag:
915 923 print "[Reading] The file %s can't be opened" % (filename)
916 924 return False
917 925
918 926 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
919 927
920 928 if neededSize == 0:
921 929 basicHeaderObj = BasicHeader(LOCALTIME)
922 930 systemHeaderObj = SystemHeader()
923 931 radarControllerHeaderObj = RadarControllerHeader()
924 932 processingHeaderObj = ProcessingHeader()
925 933
926 934 try:
927 935 if not( basicHeaderObj.read(fp) ): raise IOError
928 936 if not( systemHeaderObj.read(fp) ): raise IOError
929 937 if not( radarControllerHeaderObj.read(fp) ): raise IOError
930 938 if not( processingHeaderObj.read(fp) ): raise IOError
931 939 # data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
932 940
933 941 neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
934 942
935 943 except IOError:
936 944 traceback.print_exc()
937 945 if msgFlag:
938 946 print "[Reading] The file %s is empty or it hasn't enough data" % filename
939 947
940 948 fp.close()
941 949 return False
942 950 else:
943 951 msg = "[Reading] Skipping the file %s due to it hasn't enough data" %filename
944 952
945 953 fp.close()
946 954 fileSize = os.path.getsize(filename)
947 955 currentSize = fileSize - currentPosition
948 956 if currentSize < neededSize:
949 957 if msgFlag and (msg != None):
950 958 print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
951 959 return False
952 960
953 961 return True
954 962
955 963 def findDatafiles(self, path, startDate=None, endDate=None, expLabel='', ext='.r', walk=True):
956 964
957 965 dateList = []
958 966 pathList = []
959 967
960 968 if not walk:
961 969 #pathList.append(path)
962 970 multi_path = path.split(',')
963 971 for single_path in multi_path:
964 972
973 if not os.path.isdir(single_path):
974 continue
975
965 976 ok = False
966 977 fileList = glob.glob1(single_path, "*"+ext)
967 978
968 979 for thisFile in fileList:
969 980
970 981 if not os.path.isfile(os.path.join(single_path, thisFile)):
971 982 continue
972 983
973 984 if not isRadarFile(thisFile):
974 985 continue
975 986
976 987 ok = True
977 988 thisDate = getDateFromRadarFile(thisFile)
978 989
979 990 if thisDate not in dateList:
980 991 dateList.append(thisDate)
981 992
982 993 if ok:
983 994 pathList.append(single_path)
984 995
985 996 return dateList
986 997
987 998 multi_path = path.split(',')
988 999 for single_path in multi_path:
989 1000
1001 if not os.path.isdir(single_path):
1002 continue
1003
990 1004 dirList = []
991 1005
992 1006 for thisPath in os.listdir(single_path):
993 1007
994 1008 if not os.path.isdir(os.path.join(single_path,thisPath)):
995 1009 continue
996 1010
997 1011 if not isRadarFolder(thisPath):
998 1012 continue
999 1013
1000 1014 dirList.append(thisPath)
1001 1015
1002 1016 if not dirList:
1003 1017 return dateList
1004 1018
1005 1019 if startDate and endDate:
1006 1020 thisDate = startDate
1007 1021
1008 1022 while(thisDate <= endDate):
1009 1023 year = thisDate.timetuple().tm_year
1010 1024 doy = thisDate.timetuple().tm_yday
1011 1025
1012 1026 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
1013 1027 if len(matchlist) == 0:
1014 1028 thisDate += datetime.timedelta(1)
1015 1029 continue
1016 1030
1017 1031 for match in matchlist:
1018 1032 pathList.append(os.path.join(single_path,match,expLabel))
1019 1033 dateList.append(thisDate)
1020 1034
1021 1035 thisDate += datetime.timedelta(1)
1022 1036 else:
1023 1037 for thisDir in dirList:
1024 1038 year = int(thisDir[1:5])
1025 1039 doy = int(thisDir[5:8])
1026 1040 thisDate = datetime.date(year,1,1) + datetime.timedelta(doy-1)
1027 1041
1028 1042 pathList.append(os.path.join(single_path,thisDir,expLabel))
1029 1043 dateList.append(thisDate)
1030 1044
1031 1045 return dateList
1032 1046
1033 1047
1034 1048 def setup(self,
1035 1049 path=None,
1036 1050 startDate=None,
1037 1051 endDate=None,
1038 1052 startTime=datetime.time(0,0,0),
1039 1053 endTime=datetime.time(23,59,59),
1040 1054 set=None,
1041 1055 expLabel = "",
1042 1056 ext = None,
1043 1057 online = False,
1044 1058 delay = 60,
1045 1059 walk = True,
1046 1060 getblock = False,
1047 1061 nTxs = 1):
1048 1062
1049 1063 if path == None:
1050 1064 raise ValueError, "[Reading] The path is not valid"
1051 1065
1052 1066 if ext == None:
1053 1067 ext = self.ext
1054 1068
1055 1069 if online:
1056 1070 print "[Reading] Searching files in online mode..."
1057 1071
1058 1072 for nTries in range( self.nTries ):
1059 1073 fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk, set=set)
1060 1074
1061 1075 if fullpath:
1062 1076 break
1063 1077
1064 1078 print '[Reading] Waiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
1065 1079 sleep( self.delay )
1066 1080
1067 1081 if not(fullpath):
1068 1082 print "[Reading] There 'isn't any valid file in %s" % path
1069 1083 return None
1070 1084
1071 1085 self.year = year
1072 1086 self.doy = doy
1073 1087 self.set = set - 1
1074 1088 self.path = path
1075 1089 self.foldercounter = foldercounter
1076 1090 last_set = None
1077 1091
1078 1092 else:
1079 1093 print "[Reading] Searching files in offline mode ..."
1080 1094 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
1081 1095 startTime=startTime, endTime=endTime,
1082 1096 set=set, expLabel=expLabel, ext=ext,
1083 1097 walk=walk)
1084 1098
1085 1099 if not(pathList):
1086 1100 print "[Reading] No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
1087 1101 datetime.datetime.combine(startDate,startTime).ctime(),
1088 1102 datetime.datetime.combine(endDate,endTime).ctime())
1089 1103
1090 1104 sys.exit(-1)
1091 1105
1092 1106
1093 1107 self.fileIndex = -1
1094 1108 self.pathList = pathList
1095 1109 self.filenameList = filenameList
1096 1110 file_name = os.path.basename(filenameList[-1])
1097 1111 basename, ext = os.path.splitext(file_name)
1098 1112 last_set = int(basename[-3:])
1099 1113
1100 1114 self.online = online
1101 1115 self.delay = delay
1102 1116 ext = ext.lower()
1103 1117 self.ext = ext
1104 1118 self.getByBlock = getblock
1105 1119 self.nTxs = int(nTxs)
1106 1120
1107 1121 if not(self.setNextFile()):
1108 1122 if (startDate!=None) and (endDate!=None):
1109 1123 print "[Reading] No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
1110 1124 elif startDate != None:
1111 1125 print "[Reading] No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
1112 1126 else:
1113 1127 print "[Reading] No files"
1114 1128
1115 1129 sys.exit(-1)
1116 1130
1117 1131 # self.updateDataHeader()
1118 1132 if last_set != None:
1119 1133 self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
1120 1134 return
1121 1135
1122 1136 def getBasicHeader(self):
1123 1137
1124 1138 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
1125 1139
1126 1140 self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
1127 1141
1128 1142 self.dataOut.timeZone = self.basicHeaderObj.timeZone
1129 1143
1130 1144 self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
1131 1145
1132 1146 self.dataOut.errorCount = self.basicHeaderObj.errorCount
1133 1147
1134 1148 self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
1135 1149
1136 1150 self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
1137 1151
1138 1152 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
1139 1153
1140 1154
1141 1155 def getFirstHeader(self):
1142 1156
1143 1157 raise ValueError, "This method has not been implemented"
1144 1158
1145 1159 def getData(self):
1146 1160
1147 1161 raise ValueError, "This method has not been implemented"
1148 1162
1149 1163 def hasNotDataInBuffer(self):
1150 1164
1151 1165 raise ValueError, "This method has not been implemented"
1152 1166
1153 1167 def readBlock(self):
1154 1168
1155 1169 raise ValueError, "This method has not been implemented"
1156 1170
1157 1171 def isEndProcess(self):
1158 1172
1159 1173 return self.flagNoMoreFiles
1160 1174
1161 1175 def printReadBlocks(self):
1162 1176
1163 1177 print "[Reading] Number of read blocks per file %04d" %self.nReadBlocks
1164 1178
1165 1179 def printTotalBlocks(self):
1166 1180
1167 1181 print "[Reading] Number of read blocks %04d" %self.nTotalBlocks
1168 1182
1169 1183 def printNumberOfBlock(self):
1170 1184
1171 1185 if self.flagIsNewBlock:
1172 1186 print "[Reading] Block No. %04d, Total blocks %04d -> %s" %(self.basicHeaderObj.dataBlock, self.nTotalBlocks, self.dataOut.datatime.ctime())
1173 1187 self.dataOut.blocknow = self.basicHeaderObj.dataBlock
1174 1188
1175 1189 def printInfo(self):
1176 1190
1177 1191 if self.__printInfo == False:
1178 1192 return
1179 1193
1180 1194 self.basicHeaderObj.printInfo()
1181 1195 self.systemHeaderObj.printInfo()
1182 1196 self.radarControllerHeaderObj.printInfo()
1183 1197 self.processingHeaderObj.printInfo()
1184 1198
1185 1199 self.__printInfo = False
1186 1200
1187 1201
1188 1202 def run(self, **kwargs):
1189 1203
1190 1204 if not(self.isConfig):
1191 1205
1192 1206 # self.dataOut = dataOut
1193 1207 self.setup(**kwargs)
1194 1208 self.isConfig = True
1195 1209
1196 1210 self.getData()
1197 1211
1198 1212 class JRODataWriter(JRODataIO):
1199 1213
1200 1214 """
1201 1215 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
1202 1216 de los datos siempre se realiza por bloques.
1203 1217 """
1204 1218
1205 1219 blockIndex = 0
1206 1220
1207 1221 path = None
1208 1222
1209 1223 setFile = None
1210 1224
1211 1225 profilesPerBlock = None
1212 1226
1213 1227 blocksPerFile = None
1214 1228
1215 1229 nWriteBlocks = 0
1216 1230
1217 1231 def __init__(self, dataOut=None):
1218 1232 raise ValueError, "Not implemented"
1219 1233
1220 1234
1221 1235 def hasAllDataInBuffer(self):
1222 1236 raise ValueError, "Not implemented"
1223 1237
1224 1238
1225 1239 def setBlockDimension(self):
1226 1240 raise ValueError, "Not implemented"
1227 1241
1228 1242
1229 1243 def writeBlock(self):
1230 1244 raise ValueError, "No implemented"
1231 1245
1232 1246
1233 1247 def putData(self):
1234 1248 raise ValueError, "No implemented"
1235 1249
1236 1250
1237 1251 def setBasicHeader(self):
1238 1252
1239 1253 self.basicHeaderObj.size = self.basicHeaderSize #bytes
1240 1254 self.basicHeaderObj.version = self.versionFile
1241 1255 self.basicHeaderObj.dataBlock = self.nTotalBlocks
1242 1256
1243 1257 utc = numpy.floor(self.dataOut.utctime)
1244 1258 milisecond = (self.dataOut.utctime - utc)* 1000.0
1245 1259
1246 1260 self.basicHeaderObj.utc = utc
1247 1261 self.basicHeaderObj.miliSecond = milisecond
1248 1262 self.basicHeaderObj.timeZone = self.dataOut.timeZone
1249 1263 self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
1250 1264 self.basicHeaderObj.errorCount = self.dataOut.errorCount
1251 1265
1252 1266 def setFirstHeader(self):
1253 1267 """
1254 1268 Obtiene una copia del First Header
1255 1269
1256 1270 Affected:
1257 1271
1258 1272 self.basicHeaderObj
1259 1273 self.systemHeaderObj
1260 1274 self.radarControllerHeaderObj
1261 1275 self.processingHeaderObj self.
1262 1276
1263 1277 Return:
1264 1278 None
1265 1279 """
1266 1280
1267 1281 raise ValueError, "No implemented"
1268 1282
1269 1283 def __writeFirstHeader(self):
1270 1284 """
1271 1285 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1272 1286
1273 1287 Affected:
1274 1288 __dataType
1275 1289
1276 1290 Return:
1277 1291 None
1278 1292 """
1279 1293
1280 1294 # CALCULAR PARAMETROS
1281 1295
1282 1296 sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
1283 1297 self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
1284 1298
1285 1299 self.basicHeaderObj.write(self.fp)
1286 1300 self.systemHeaderObj.write(self.fp)
1287 1301 self.radarControllerHeaderObj.write(self.fp)
1288 1302 self.processingHeaderObj.write(self.fp)
1289 1303
1290 1304 self.dtype = self.dataOut.dtype
1291 1305
1292 1306 def __setNewBlock(self):
1293 1307 """
1294 1308 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1295 1309
1296 1310 Return:
1297 1311 0 : si no pudo escribir nada
1298 1312 1 : Si escribio el Basic el First Header
1299 1313 """
1300 1314 if self.fp == None:
1301 1315 self.setNextFile()
1302 1316
1303 1317 if self.flagIsNewFile:
1304 1318 return 1
1305 1319
1306 1320 if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
1307 1321 self.basicHeaderObj.write(self.fp)
1308 1322 return 1
1309 1323
1310 1324 if not( self.setNextFile() ):
1311 1325 return 0
1312 1326
1313 1327 return 1
1314 1328
1315 1329
1316 1330 def writeNextBlock(self):
1317 1331 """
1318 1332 Selecciona el bloque siguiente de datos y los escribe en un file
1319 1333
1320 1334 Return:
1321 1335 0 : Si no hizo pudo escribir el bloque de datos
1322 1336 1 : Si no pudo escribir el bloque de datos
1323 1337 """
1324 1338 if not( self.__setNewBlock() ):
1325 1339 return 0
1326 1340
1327 1341 self.writeBlock()
1328 1342
1329 1343 return 1
1330 1344
1331 1345 def setNextFile(self):
1332 1346 """
1333 1347 Determina el siguiente file que sera escrito
1334 1348
1335 1349 Affected:
1336 1350 self.filename
1337 1351 self.subfolder
1338 1352 self.fp
1339 1353 self.setFile
1340 1354 self.flagIsNewFile
1341 1355
1342 1356 Return:
1343 1357 0 : Si el archivo no puede ser escrito
1344 1358 1 : Si el archivo esta listo para ser escrito
1345 1359 """
1346 1360 ext = self.ext
1347 1361 path = self.path
1348 1362
1349 1363 if self.fp != None:
1350 1364 self.fp.close()
1351 1365
1352 1366 timeTuple = time.localtime( self.dataOut.utctime)
1353 1367 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1354 1368
1355 1369 fullpath = os.path.join( path, subfolder )
1356 1370 if not( os.path.exists(fullpath) ):
1357 1371 os.mkdir(fullpath)
1358 1372 self.setFile = -1 #inicializo mi contador de seteo
1359 1373 else:
1360 1374 filesList = os.listdir( fullpath )
1361 1375 if len( filesList ) > 0:
1362 1376 filesList = sorted( filesList, key=str.lower )
1363 1377 filen = filesList[-1]
1364 1378 # el filename debera tener el siguiente formato
1365 1379 # 0 1234 567 89A BCDE (hex)
1366 1380 # x YYYY DDD SSS .ext
1367 1381 if isNumber( filen[8:11] ):
1368 1382 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1369 1383 else:
1370 1384 self.setFile = -1
1371 1385 else:
1372 1386 self.setFile = -1 #inicializo mi contador de seteo
1373 1387
1374 1388 setFile = self.setFile
1375 1389 setFile += 1
1376 1390
1377 1391 filen = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
1378 1392 timeTuple.tm_year,
1379 1393 timeTuple.tm_yday,
1380 1394 setFile,
1381 1395 ext )
1382 1396
1383 1397 filename = os.path.join( path, subfolder, filen )
1384 1398
1385 1399 fp = open( filename,'wb' )
1386 1400
1387 1401 self.blockIndex = 0
1388 1402
1389 1403 #guardando atributos
1390 1404 self.filename = filename
1391 1405 self.subfolder = subfolder
1392 1406 self.fp = fp
1393 1407 self.setFile = setFile
1394 1408 self.flagIsNewFile = 1
1395 1409
1396 1410 self.setFirstHeader()
1397 1411
1398 1412 print '[Writing] file: %s'%self.filename
1399 1413
1400 1414 self.__writeFirstHeader()
1401 1415
1402 1416 return 1
1403 1417
1404 1418 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=0, ext=None):
1405 1419 """
1406 1420 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1407 1421
1408 1422 Inputs:
1409 1423 path : el path destino en el cual se escribiran los files a crear
1410 1424 format : formato en el cual sera salvado un file
1411 1425 set : el setebo del file
1412 1426
1413 1427 Return:
1414 1428 0 : Si no realizo un buen seteo
1415 1429 1 : Si realizo un buen seteo
1416 1430 """
1417 1431
1418 1432 if ext == None:
1419 1433 ext = self.ext
1420 1434
1421 1435 ext = ext.lower()
1422 1436
1423 1437 self.ext = ext
1424 1438
1425 1439 self.path = path
1426 1440
1427 1441 self.setFile = set - 1
1428 1442
1429 1443 self.blocksPerFile = blocksPerFile
1430 1444
1431 1445 self.profilesPerBlock = profilesPerBlock
1432 1446
1433 1447 self.dataOut = dataOut
1434 1448
1435 1449 if not(self.setNextFile()):
1436 1450 print "[Writing] There isn't a next file"
1437 1451 return 0
1438 1452
1439 1453 self.setBlockDimension()
1440 1454
1441 1455 return 1
1442 1456
1443 1457 def run(self, dataOut, **kwargs):
1444 1458
1445 1459 if not(self.isConfig):
1446 1460
1447 1461 self.setup(dataOut, **kwargs)
1448 1462 self.isConfig = True
1449 1463
1450 1464 self.putData()
1451 1465
Show file before | Show file after | Hide comments
@@ -1,583 +1,590
1 1 '''
2 2 Created on Jul 3, 2014
3 3
4 4 @author: roj-idl71
5 5 '''
6 import os
6 7 import datetime
7 8 import numpy
8 9
9 10 try:
10 11 from gevent import sleep
11 12 except:
12 13 from time import sleep
13 14
14 15 from schainpy.model.data.jroheaderIO import RadarControllerHeader, SystemHeader
15 16 from schainpy.model.data.jrodata import Voltage
16 17 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
17 18
18 19 try:
19 20 import digital_rf_hdf5
20 21 except:
21 22 print 'You should install "digital_rf_hdf5" module if you want to read USRP data'
22 23
23 24 class USRPReader(ProcessingUnit):
24 25 '''
25 26 classdocs
26 27 '''
27 28
28 29 def __init__(self):
29 30 '''
30 31 Constructor
31 32 '''
32 33
33 34 ProcessingUnit.__init__(self)
34 35
35 36 self.dataOut = Voltage()
36 37 self.__printInfo = True
37 38 self.__flagDiscontinuousBlock = False
38 39 self.__bufferIndex = 9999999
39 40
40 41 self.__ippKm = None
41 42 self.__codeType = 0
42 43 self.__nCode = None
43 44 self.__nBaud = None
44 45 self.__code = None
45 46
46 47 def __getCurrentSecond(self):
47 48
48 49 return self.__thisUnixSample/self.__sample_rate
49 50
50 51 thisSecond = property(__getCurrentSecond, "I'm the 'thisSecond' property.")
51 52
52 53 def __setFileHeader(self):
53 54 '''
54 55 In this method will be initialized every parameter of dataOut object (header, no data)
55 56 '''
56 57 nProfiles = self.__sample_rate #Number of profiles by second
57 58
58 59 self.dataOut.radarControllerHeaderObj = RadarControllerHeader(ippKm=self.__ippKm,
59 60 txA=0,
60 61 txB=0,
61 62 nWindows=1,
62 63 nHeights=self.__nSamples,
63 64 firstHeight=self.__firstHeigth,
64 65 deltaHeight=self.__deltaHeigth,
65 66 codeType=self.__codeType,
66 67 nCode=self.__nCode, nBaud=self.__nBaud,
67 68 code = self.__code)
68 69
69 70 self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
70 71 nProfiles=nProfiles,
71 72 nChannels=len(self.__channelList),
72 73 adcResolution=14)
73 74
74 75 self.dataOut.type = "Voltage"
75 76
76 77 self.dataOut.data = None
77 78
78 79 self.dataOut.dtype = numpy.dtype([('real','<i8'),('imag','<i8')])
79 80
80 81 # self.dataOut.nChannels = 0
81 82
82 83 # self.dataOut.nHeights = 0
83 84
84 85 self.dataOut.nProfiles = nProfiles
85 86
86 87 self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
87 88
88 89 self.dataOut.channelList = self.__channelList
89 90
90 91 self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights()
91 92
92 93 # self.dataOut.channelIndexList = None
93 94
94 95 self.dataOut.flagNoData = True
95 96
96 97 #Set to TRUE if the data is discontinuous
97 98 self.dataOut.flagDiscontinuousBlock = False
98 99
99 100 self.dataOut.utctime = None
100 101
101 102 self.dataOut.timeZone = self.__timezone/60 #timezone like jroheader, difference in minutes between UTC and localtime
102 103
103 104 self.dataOut.dstFlag = 0
104 105
105 106 self.dataOut.errorCount = 0
106 107
107 108 self.dataOut.nCohInt = 1
108 109
109 110 self.dataOut.flagDecodeData = False #asumo que la data esta decodificada
110 111
111 112 self.dataOut.flagDeflipData = False #asumo que la data esta sin flip
112 113
113 114 self.dataOut.flagShiftFFT = False
114 115
115 116 self.dataOut.ippSeconds = 1.0*self.__nSamples/self.__sample_rate
116 117
117 118 #Time interval between profiles
118 119 #self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
119 120
120 121 self.dataOut.frequency = self.__frequency
121 122
122 123 self.dataOut.realtime = self.__online
123 124
124 125 def findDatafiles(self, path, startDate=None, endDate=None):
125 126
127 if not os.path.isdir(path):
128 return []
129
126 130 try:
127 131 digitalReadObj = digital_rf_hdf5.read_hdf5(path, load_all_metadata=True)
128 132 except:
129 133 digitalReadObj = digital_rf_hdf5.read_hdf5(path)
130 134
131 135 channelNameList = digitalReadObj.get_channels()
132 136
133 137 if not channelNameList:
134 138 return []
135 139
136 140 metadata_dict = digitalReadObj.get_rf_file_metadata(channelNameList[0])
137 141
138 142 sample_rate = metadata_dict['sample_rate'][0]
139 143
140 144 this_metadata_file = digitalReadObj.get_metadata(channelNameList[0])
141 145
142 146 try:
143 147 timezone = this_metadata_file['timezone'].value
144 148 except:
145 149 timezone = 0
146 150
147 151 startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(channelNameList[0])/sample_rate - timezone
148 152
149 153 startDatetime = datetime.datetime.utcfromtimestamp(startUTCSecond)
150 154 endDatatime = datetime.datetime.utcfromtimestamp(endUTCSecond)
151 155
152 156 if not startDate:
153 157 startDate = startDatetime.date()
154 158
155 159 if not endDate:
156 160 endDate = endDatatime.date()
157 161
158 162 dateList = []
159 163
160 164 thisDatetime = startDatetime
161 165
162 166 while(thisDatetime<=endDatatime):
163 167
164 168 thisDate = thisDatetime.date()
165 169
166 170 if thisDate < startDate:
167 171 continue
168 172
169 173 if thisDate > endDate:
170 174 break
171 175
172 176 dateList.append(thisDate)
173 177 thisDatetime += datetime.timedelta(1)
174 178
175 179 return dateList
176 180
177 181 def setup(self, path = None,
178 182 startDate = None,
179 183 endDate = None,
180 184 startTime = datetime.time(0,0,0),
181 185 endTime = datetime.time(23,59,59),
182 186 channelList = None,
183 187 nSamples = None,
184 188 ippKm = 60,
185 189 online = False,
186 190 delay = 60,
187 191 buffer_size = None,
188 192 nbuffer = 1024,
189 193 **kwargs):
190 194 '''
191 195 In this method we should set all initial parameters.
192 196
193 197 Inputs:
194 198 path
195 199 startDate
196 200 endDate
197 201 startTime
198 202 endTime
199 203 set
200 204 expLabel
201 205 ext
202 206 online
203 207 delay
204 208 '''
205 209
206 210 if not buffer_size:
207 211 buffer_size = nbuffer
208
212
213 if not os.path.isdir(path):
214 raise ValueError, "[Reading] This path %s does not exist" %path
215
209 216 try:
210 217 self.digitalReadObj = digital_rf_hdf5.read_hdf5(path, load_all_metadata=True)
211 218 except:
212 219 self.digitalReadObj = digital_rf_hdf5.read_hdf5(path)
213 220
214 221 channelNameList = self.digitalReadObj.get_channels()
215 222
216 223 if not channelNameList:
217 224 raise IOError, "[Reading] The path doesn,t have any files .. "
218 225
219 226 if not channelList:
220 227 channelList = range(len(channelNameList))
221 228
222 229 ########## Reading metadata ######################
223 230
224 231 metadata_dict = self.digitalReadObj.get_rf_file_metadata(channelNameList[channelList[0]])
225 232
226 233 self.__sample_rate = metadata_dict['sample_rate'][0]
227 234 self.__samples_per_file = metadata_dict['samples_per_file'][0]
228 235 self.__deltaHeigth = 1e6*0.15/self.__sample_rate
229 236
230 237 this_metadata_file = self.digitalReadObj.get_metadata(channelNameList[channelList[0]])
231 238
232 239 self.__frequency = this_metadata_file['center_frequencies'].value
233 240 try:
234 241 self.__timezone = this_metadata_file['timezone'].value
235 242 except:
236 243 self.__timezone = 0
237 244
238 245 self.__firstHeigth = 0
239 246
240 247 try:
241 248 codeType = this_metadata_file['codeType'].value
242 249 except:
243 250 codeType = 0
244 251
245 252 nCode = 0
246 253 nBaud = 0
247 254 code = None
248 255
249 256 if codeType:
250 257 nCode = this_metadata_file['nCode'].value
251 258 nBaud = this_metadata_file['nBaud'].value
252 259 code = this_metadata_file['code'].value
253 260
254 261 if not ippKm:
255 262 try:
256 263 #seconds to km
257 264 ippKm = 1e6*0.15*this_metadata_file['ipp'].value
258 265 except:
259 266 ippKm = None
260 267
261 268 ####################################################
262 269 startUTCSecond = None
263 270 endUTCSecond = None
264 271
265 272 if startDate:
266 273 startDatetime = datetime.datetime.combine(startDate, startTime)
267 274 startUTCSecond = (startDatetime-datetime.datetime(1970,1,1)).total_seconds() + self.__timezone
268 275
269 276 if endDate:
270 277 endDatetime = datetime.datetime.combine(endDate, endTime)
271 278 endUTCSecond = (endDatetime-datetime.datetime(1970,1,1)).total_seconds() + self.__timezone
272 279
273 280 start_index, end_index = self.digitalReadObj.get_bounds(channelNameList[channelList[0]])
274 281
275 282 if not startUTCSecond:
276 283 startUTCSecond = start_index/self.__sample_rate
277 284
278 285 if start_index > startUTCSecond*self.__sample_rate:
279 286 startUTCSecond = start_index/self.__sample_rate
280 287
281 288 if not endUTCSecond:
282 289 endUTCSecond = end_index/self.__sample_rate
283 290
284 291 if end_index < endUTCSecond*self.__sample_rate:
285 292 endUTCSecond = end_index/self.__sample_rate
286 293
287 294 if not nSamples:
288 295 if not ippKm:
289 296 raise ValueError, "[Reading] nSamples or ippKm should be defined"
290 297
291 298 nSamples = ippKm / (1e6*0.15/self.__sample_rate)
292 299
293 300 channelBoundList = []
294 301 channelNameListFiltered = []
295 302
296 303 for thisIndexChannel in channelList:
297 304 thisChannelName = channelNameList[thisIndexChannel]
298 305 start_index, end_index = self.digitalReadObj.get_bounds(thisChannelName)
299 306 channelBoundList.append((start_index, end_index))
300 307 channelNameListFiltered.append(thisChannelName)
301 308
302 309 self.profileIndex = 0
303 310
304 311 self.__delay = delay
305 312 self.__ippKm = ippKm
306 313 self.__codeType = codeType
307 314 self.__nCode = nCode
308 315 self.__nBaud = nBaud
309 316 self.__code = code
310 317
311 318 self.__datapath = path
312 319 self.__online = online
313 320 self.__channelList = channelList
314 321 self.__channelNameList = channelNameListFiltered
315 322 self.__channelBoundList = channelBoundList
316 323 self.__nSamples = nSamples
317 324 self.__samples_to_read = buffer_size*nSamples
318 325 self.__nChannels = len(self.__channelList)
319 326
320 327 self.__startUTCSecond = startUTCSecond
321 328 self.__endUTCSecond = endUTCSecond
322 329
323 330 self.__timeInterval = 1.0 * self.__samples_to_read/self.__sample_rate #Time interval
324 331
325 332 if online:
326 333 # self.__thisUnixSample = int(endUTCSecond*self.__sample_rate - 4*self.__samples_to_read)
327 334 startUTCSecond = numpy.floor(endUTCSecond)
328 335
329 336 self.__thisUnixSample = int(startUTCSecond*self.__sample_rate) - self.__samples_to_read
330 337
331 338 self.__data_buffer = numpy.zeros((self.__nChannels, self.__samples_to_read), dtype = numpy.complex)
332 339
333 340 self.__setFileHeader()
334 341 self.isConfig = True
335 342
336 343 print "[Reading] USRP Data was found from %s to %s " %(
337 344 datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
338 345 datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
339 346 )
340 347
341 348 print "[Reading] Starting process from %s to %s" %(datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone),
342 349 datetime.datetime.utcfromtimestamp(endUTCSecond - self.__timezone)
343 350 )
344 351
345 352 def __reload(self):
346 353
347 354 if not self.__online:
348 355 return
349 356
350 357 # print
351 358 # print "%s not in range [%s, %s]" %(
352 359 # datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
353 360 # datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
354 361 # datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
355 362 # )
356 363 print "[Reading] reloading metadata ..."
357 364
358 365 try:
359 366 self.digitalReadObj.reload(complete_update=True)
360 367 except:
361 368 self.digitalReadObj.reload()
362 369
363 370 start_index, end_index = self.digitalReadObj.get_bounds(self.__channelNameList[self.__channelList[0]])
364 371
365 372 if start_index > self.__startUTCSecond*self.__sample_rate:
366 373 self.__startUTCSecond = 1.0*start_index/self.__sample_rate
367 374
368 375 if end_index > self.__endUTCSecond*self.__sample_rate:
369 376 self.__endUTCSecond = 1.0*end_index/self.__sample_rate
370 377 print
371 378 print "[Reading] New timerange found [%s, %s] " %(
372 379 datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
373 380 datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
374 381 )
375 382
376 383 return True
377 384
378 385 return False
379 386
380 387 def __readNextBlock(self, seconds=30, volt_scale = 218776):
381 388 '''
382 389 '''
383 390
384 391 #Set the next data
385 392 self.__flagDiscontinuousBlock = False
386 393 self.__thisUnixSample += self.__samples_to_read
387 394
388 395 if self.__thisUnixSample + 2*self.__samples_to_read > self.__endUTCSecond*self.__sample_rate:
389 396 print "[Reading] There are no more data into selected timerange"
390 397
391 398 self.__reload()
392 399
393 400 if self.__thisUnixSample + 2*self.__samples_to_read > self.__endUTCSecond*self.__sample_rate:
394 401 self.__thisUnixSample -= self.__samples_to_read
395 402 return False
396 403
397 404 indexChannel = 0
398 405
399 406 dataOk = False
400 407
401 408 for thisChannelName in self.__channelNameList:
402 409
403 410 try:
404 411 result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,
405 412 self.__samples_to_read,
406 413 thisChannelName)
407 414
408 415 except IOError, e:
409 416 #read next profile
410 417 self.__flagDiscontinuousBlock = True
411 418 print e
412 419 break
413 420
414 421 if result.shape[0] != self.__samples_to_read:
415 422 self.__flagDiscontinuousBlock = True
416 423 print "[Reading] %s: Too few samples were found, just %d samples" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
417 424 result.shape[0])
418 425 break
419 426
420 427 self.__data_buffer[indexChannel,:] = result*volt_scale
421 428
422 429 indexChannel += 1
423 430
424 431 dataOk = True
425 432
426 433 self.__utctime = self.__thisUnixSample/self.__sample_rate
427 434
428 435 if not dataOk:
429 436 return False
430 437
431 438 print "[Reading] %s: %d samples <> %f sec" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
432 439 self.__samples_to_read,
433 440 self.__timeInterval)
434 441
435 442 self.__bufferIndex = 0
436 443
437 444 return True
438 445
439 446 def __isBufferEmpty(self):
440 447
441 448 if self.__bufferIndex <= self.__samples_to_read - self.__nSamples:
442 449 return False
443 450
444 451 return True
445 452
446 453 def getData(self, seconds=30, nTries=5):
447 454
448 455 '''
449 456 This method gets the data from files and put the data into the dataOut object
450 457
451 458 In addition, increase el the buffer counter in one.
452 459
453 460 Return:
454 461 data : retorna un perfil de voltages (alturas * canales) copiados desde el
455 462 buffer. Si no hay mas archivos a leer retorna None.
456 463
457 464 Affected:
458 465 self.dataOut
459 466 self.profileIndex
460 467 self.flagDiscontinuousBlock
461 468 self.flagIsNewBlock
462 469 '''
463 470
464 471 err_counter = 0
465 472 self.dataOut.flagNoData = True
466 473
467 474 if self.__isBufferEmpty():
468 475
469 476 self.__flagDiscontinuousBlock = False
470 477
471 478 while True:
472 479 if self.__readNextBlock():
473 480 break
474 481
475 482 if self.__thisUnixSample > self.__endUTCSecond*self.__sample_rate:
476 483 return False
477 484
478 485 if self.__flagDiscontinuousBlock:
479 486 print '[Reading] discontinuous block found ... continue with the next block'
480 487 continue
481 488
482 489 if not self.__online:
483 490 return False
484 491
485 492 err_counter += 1
486 493 if err_counter > nTries:
487 494 return False
488 495
489 496 print '[Reading] waiting %d seconds to read a new block' %seconds
490 497 sleep(seconds)
491 498
492 499 self.dataOut.data = self.__data_buffer[:,self.__bufferIndex:self.__bufferIndex+self.__nSamples]
493 500 self.dataOut.utctime = (self.__thisUnixSample + self.__bufferIndex)/self.__sample_rate
494 501 self.dataOut.flagNoData = False
495 502 self.dataOut.flagDiscontinuousBlock = self.__flagDiscontinuousBlock
496 503
497 504 self.__bufferIndex += self.__nSamples
498 505 self.profileIndex += 1
499 506
500 507 return True
501 508
502 509 def printInfo(self):
503 510 '''
504 511 '''
505 512 if self.__printInfo == False:
506 513 return
507 514
508 515 # self.systemHeaderObj.printInfo()
509 516 # self.radarControllerHeaderObj.printInfo()
510 517
511 518 self.__printInfo = False
512 519
513 520 def printNumberOfBlock(self):
514 521 '''
515 522 '''
516 523
517 524 print self.profileIndex
518 525
519 526 def run(self, **kwargs):
520 527 '''
521 528 This method will be called many times so here you should put all your code
522 529 '''
523 530
524 531 if not self.isConfig:
525 532 self.setup(**kwargs)
526 533
527 534 self.getData(seconds=self.__delay)
528 535
529 536 return
530 537
531 538 class USRPWriter(Operation):
532 539 '''
533 540 classdocs
534 541 '''
535 542
536 543 def __init__(self):
537 544 '''
538 545 Constructor
539 546 '''
540 547 self.dataOut = None
541 548
542 549 def setup(self, dataIn, path, blocksPerFile, set=0, ext=None):
543 550 '''
544 551 In this method we should set all initial parameters.
545 552
546 553 Input:
547 554 dataIn : Input data will also be outputa data
548 555
549 556 '''
550 557 self.dataOut = dataIn
551 558
552 559
553 560
554 561
555 562
556 563 self.isConfig = True
557 564
558 565 return
559 566
560 567 def run(self, dataIn, **kwargs):
561 568 '''
562 569 This method will be called many times so here you should put all your code
563 570
564 571 Inputs:
565 572
566 573 dataIn : object with the data
567 574
568 575 '''
569 576
570 577 if not self.isConfig:
571 578 self.setup(dataIn, **kwargs)
572 579
573 580
574 581 if __name__ == '__main__':
575 582
576 583 readObj = USRPReader()
577 584
578 585 while True:
579 586 readObj.run(path='/Volumes/DATA/haystack/passive_radar/')
580 587 # readObj.printInfo()
581 588 readObj.printNumberOfBlock()
582 589
583 590 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now