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