##// END OF EJS Templates
schain-jc
RSS
Change multiSchain by MPProject
Juan C. Espinoza -
r1052:3fb7c359028f
parent child
Show More
Side by Side Unified
Context file:
r1052:3fb7c359028f Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,1324 +1,1297
1 1 '''
2 2 Created on September , 2012
3 3 @author:
4 4 '''
5 5
6 6 import sys
7 7 import ast
8 8 import datetime
9 9 import traceback
10 10 import math
11 11 import time
12 from multiprocessing import Process, Queue, cpu_count
13
14 import schainpy
15 import schainpy.admin
16 from schainpy.utils.log import logToFile
12 from multiprocessing import Process, cpu_count
17 13
18 14 from xml.etree.ElementTree import ElementTree, Element, SubElement, tostring
19 15 from xml.dom import minidom
20 16
17 import schainpy
18 import schainpy.admin
21 19 from schainpy.model import *
22 from time import sleep
23
24
25
26 def prettify(elem):
27 """Return a pretty-printed XML string for the Element.
28 """
29 rough_string = tostring(elem, 'utf-8')
30 reparsed = minidom.parseString(rough_string)
31 return reparsed.toprettyxml(indent=" ")
32
33 def multiSchain(child, nProcess=cpu_count(), startDate=None, endDate=None, by_day=False):
34 skip = 0
35 cursor = 0
36 nFiles = None
37 processes = []
38 dt1 = datetime.datetime.strptime(startDate, '%Y/%m/%d')
39 dt2 = datetime.datetime.strptime(endDate, '%Y/%m/%d')
20 from schainpy.utils import log
21
22 DTYPES = {
23 'Voltage': '.r',
24 'Spectra': '.pdata'
25 }
26
27 def MPProject(project, n=cpu_count()):
28 '''
29 Project wrapper to run schain in n processes
30 '''
31
32 rconf = project.getReadUnitObj()
33 op = rconf.getOperationObj('run')
34 dt1 = op.getParameterValue('startDate')
35 dt2 = op.getParameterValue('endDate')
40 36 days = (dt2 - dt1).days
41
37
42 38 for day in range(days+1):
43 39 skip = 0
44 40 cursor = 0
45 q = Queue()
46 41 processes = []
47 dt = (dt1 + datetime.timedelta(day)).strftime('%Y/%m/%d')
48 firstProcess = Process(target=child, args=(cursor, skip, q, dt))
49 firstProcess.start()
50 if by_day:
51 continue
52 nFiles = q.get()
53 if nFiles==0:
42 dt = dt1 + datetime.timedelta(day)
43 dt_str = dt.strftime('%Y/%m/%d')
44 reader = JRODataReader()
45 paths, files = reader.searchFilesOffLine(path=rconf.path,
46 startDate=dt,
47 endDate=dt,
48 ext=DTYPES[rconf.datatype])
49 nFiles = len(files)
50 if nFiles == 0:
54 51 continue
55 firstProcess.terminate()
56 skip = int(math.ceil(nFiles/nProcess))
57 while True:
58 processes.append(Process(target=child, args=(cursor, skip, q, dt)))
59 processes[cursor].start()
60 if nFiles < cursor*skip:
61 break
52 skip = int(math.ceil(nFiles/n))
53 while nFiles > cursor*skip:
54 rconf.update(startDate=dt_str, endDate=dt_str, cursor=cursor,
55 skip=skip)
56 p = project.clone()
57 p.start()
58 processes.append(p)
62 59 cursor += 1
63 60
64 61 def beforeExit(exctype, value, trace):
65 62 for process in processes:
66 63 process.terminate()
67 64 process.join()
68 65 print traceback.print_tb(trace)
69 66
70 67 sys.excepthook = beforeExit
71 68
72 69 for process in processes:
73 70 process.join()
74 71 process.terminate()
75 72
76 73 time.sleep(3)
77 74
78
79 75 class ParameterConf():
80 76
81 77 id = None
82 78 name = None
83 79 value = None
84 80 format = None
85 81
86 82 __formated_value = None
87 83
88 84 ELEMENTNAME = 'Parameter'
89 85
90 86 def __init__(self):
91 87
92 88 self.format = 'str'
93 89
94 90 def getElementName(self):
95 91
96 92 return self.ELEMENTNAME
97 93
98 94 def getValue(self):
99 95
100 96 value = self.value
101 97 format = self.format
102 98
103 99 if self.__formated_value != None:
104 100
105 101 return self.__formated_value
106 102
107 103 if format == 'obj':
108 104 return value
109 105
110 106 if format == 'str':
111 107 self.__formated_value = str(value)
112 108 return self.__formated_value
113 109
114 110 if value == '':
115 raise ValueError, "%s: This parameter value is empty" %self.name
111 raise ValueError, '%s: This parameter value is empty' %self.name
116 112
117 113 if format == 'list':
118 114 strList = value.split(',')
119 115
120 116 self.__formated_value = strList
121 117
122 118 return self.__formated_value
123 119
124 120 if format == 'intlist':
125 """
121 '''
126 122 Example:
127 123 value = (0,1,2)
128 """
124 '''
129 125
130 126 new_value = ast.literal_eval(value)
131 127
132 128 if type(new_value) not in (tuple, list):
133 129 new_value = [int(new_value)]
134 130
135 131 self.__formated_value = new_value
136 132
137 133 return self.__formated_value
138 134
139 135 if format == 'floatlist':
140 """
136 '''
141 137 Example:
142 138 value = (0.5, 1.4, 2.7)
143 """
139 '''
144 140
145 141 new_value = ast.literal_eval(value)
146 142
147 143 if type(new_value) not in (tuple, list):
148 144 new_value = [float(new_value)]
149 145
150 146 self.__formated_value = new_value
151 147
152 148 return self.__formated_value
153 149
154 150 if format == 'date':
155 151 strList = value.split('/')
156 152 intList = [int(x) for x in strList]
157 153 date = datetime.date(intList[0], intList[1], intList[2])
158 154
159 155 self.__formated_value = date
160 156
161 157 return self.__formated_value
162 158
163 159 if format == 'time':
164 160 strList = value.split(':')
165 161 intList = [int(x) for x in strList]
166 162 time = datetime.time(intList[0], intList[1], intList[2])
167 163
168 164 self.__formated_value = time
169 165
170 166 return self.__formated_value
171 167
172 168 if format == 'pairslist':
173 """
169 '''
174 170 Example:
175 171 value = (0,1),(1,2)
176 """
172 '''
177 173
178 174 new_value = ast.literal_eval(value)
179 175
180 176 if type(new_value) not in (tuple, list):
181 raise ValueError, "%s has to be a tuple or list of pairs" %value
177 raise ValueError, '%s has to be a tuple or list of pairs' %value
182 178
183 179 if type(new_value[0]) not in (tuple, list):
184 180 if len(new_value) != 2:
185 raise ValueError, "%s has to be a tuple or list of pairs" %value
181 raise ValueError, '%s has to be a tuple or list of pairs' %value
186 182 new_value = [new_value]
187 183
188 184 for thisPair in new_value:
189 185 if len(thisPair) != 2:
190 raise ValueError, "%s has to be a tuple or list of pairs" %value
186 raise ValueError, '%s has to be a tuple or list of pairs' %value
191 187
192 188 self.__formated_value = new_value
193 189
194 190 return self.__formated_value
195 191
196 192 if format == 'multilist':
197 """
193 '''
198 194 Example:
199 195 value = (0,1,2),(3,4,5)
200 """
196 '''
201 197 multiList = ast.literal_eval(value)
202 198
203 199 if type(multiList[0]) == int:
204 multiList = ast.literal_eval("(" + value + ")")
200 multiList = ast.literal_eval('(' + value + ')')
205 201
206 202 self.__formated_value = multiList
207 203
208 204 return self.__formated_value
209 205
210 206 if format == 'bool':
211 207 value = int(value)
212 208
213 209 if format == 'int':
214 210 value = float(value)
215 211
216 212 format_func = eval(format)
217 213
218 214 self.__formated_value = format_func(value)
219 215
220 216 return self.__formated_value
221 217
222 218 def updateId(self, new_id):
223 219
224 220 self.id = str(new_id)
225 221
226 222 def setup(self, id, name, value, format='str'):
227 223 self.id = str(id)
228 224 self.name = name
229 225 if format == 'obj':
230 226 self.value = value
231 227 else:
232 228 self.value = str(value)
233 229 self.format = str.lower(format)
234 230
235 231 self.getValue()
236 232
237 233 return 1
238 234
239 235 def update(self, name, value, format='str'):
240 236
241 237 self.name = name
242 238 self.value = str(value)
243 239 self.format = format
244 240
245 241 def makeXml(self, opElement):
246 242 if self.name not in ('queue',):
247 243 parmElement = SubElement(opElement, self.ELEMENTNAME)
248 244 parmElement.set('id', str(self.id))
249 245 parmElement.set('name', self.name)
250 246 parmElement.set('value', self.value)
251 247 parmElement.set('format', self.format)
252 248
253 249 def readXml(self, parmElement):
254 250
255 251 self.id = parmElement.get('id')
256 252 self.name = parmElement.get('name')
257 253 self.value = parmElement.get('value')
258 254 self.format = str.lower(parmElement.get('format'))
259 255
260 256 #Compatible with old signal chain version
261 257 if self.format == 'int' and self.name == 'idfigure':
262 258 self.name = 'id'
263 259
264 260 def printattr(self):
265 261
266 print "Parameter[%s]: name = %s, value = %s, format = %s" %(self.id, self.name, self.value, self.format)
262 print 'Parameter[%s]: name = %s, value = %s, format = %s' %(self.id, self.name, self.value, self.format)
267 263
268 class OperationConf():
264 class OperationConf():
269 265
270 266 id = None
271 267 name = None
272 268 priority = None
273 269 type = None
274 270
275 271 parmConfObjList = []
276 272
277 273 ELEMENTNAME = 'Operation'
278 274
279 275 def __init__(self):
280 276
281 277 self.id = '0'
282 278 self.name = None
283 279 self.priority = None
284 280 self.type = 'self'
285 281
286 282
287 283 def __getNewId(self):
288 284
289 285 return int(self.id)*10 + len(self.parmConfObjList) + 1
290 286
291 287 def updateId(self, new_id):
292 288
293 289 self.id = str(new_id)
294 290
295 291 n = 1
296 292 for parmObj in self.parmConfObjList:
297 293
298 294 idParm = str(int(new_id)*10 + n)
299 295 parmObj.updateId(idParm)
300 296
301 297 n += 1
302 298
303 299 def getElementName(self):
304 300
305 301 return self.ELEMENTNAME
306 302
307 303 def getParameterObjList(self):
308 304
309 305 return self.parmConfObjList
310 306
311 307 def getParameterObj(self, parameterName):
312 308
313 309 for parmConfObj in self.parmConfObjList:
314 310
315 311 if parmConfObj.name != parameterName:
316 312 continue
317 313
318 314 return parmConfObj
319 315
320 316 return None
321 317
322 318 def getParameterObjfromValue(self, parameterValue):
323 319
324 320 for parmConfObj in self.parmConfObjList:
325 321
326 322 if parmConfObj.getValue() != parameterValue:
327 323 continue
328 324
329 325 return parmConfObj.getValue()
330 326
331 327 return None
332 328
333 329 def getParameterValue(self, parameterName):
334 330
335 331 parameterObj = self.getParameterObj(parameterName)
336 332
337 333 # if not parameterObj:
338 334 # return None
339 335
340 336 value = parameterObj.getValue()
341 337
342 338 return value
343 339
344 340
345 341 def getKwargs(self):
346 342
347 343 kwargs = {}
348 344
349 345 for parmConfObj in self.parmConfObjList:
350 346 if self.name == 'run' and parmConfObj.name == 'datatype':
351 347 continue
352 348
353 349 kwargs[parmConfObj.name] = parmConfObj.getValue()
354 350
355 351 return kwargs
356 352
357 353 def setup(self, id, name, priority, type):
358 354
359 355 self.id = str(id)
360 356 self.name = name
361 357 self.type = type
362 358 self.priority = priority
363 359
364 360 self.parmConfObjList = []
365 361
366 362 def removeParameters(self):
367 363
368 364 for obj in self.parmConfObjList:
369 365 del obj
370 366
371 367 self.parmConfObjList = []
372 368
373 369 def addParameter(self, name, value, format='str'):
374
370
371 if value is None:
372 return None
375 373 id = self.__getNewId()
376 374
377 375 parmConfObj = ParameterConf()
378 376 if not parmConfObj.setup(id, name, value, format):
379 377 return None
380 378
381 379 self.parmConfObjList.append(parmConfObj)
382 380
383 381 return parmConfObj
384 382
385 383 def changeParameter(self, name, value, format='str'):
386 384
387 385 parmConfObj = self.getParameterObj(name)
388 386 parmConfObj.update(name, value, format)
389 387
390 388 return parmConfObj
391 389
392 390 def makeXml(self, procUnitElement):
393 391
394 392 opElement = SubElement(procUnitElement, self.ELEMENTNAME)
395 393 opElement.set('id', str(self.id))
396 394 opElement.set('name', self.name)
397 395 opElement.set('type', self.type)
398 396 opElement.set('priority', str(self.priority))
399 397
400 398 for parmConfObj in self.parmConfObjList:
401 399 parmConfObj.makeXml(opElement)
402 400
403 401 def readXml(self, opElement):
404 402
405 403 self.id = opElement.get('id')
406 404 self.name = opElement.get('name')
407 405 self.type = opElement.get('type')
408 406 self.priority = opElement.get('priority')
409 407
410 408 #Compatible with old signal chain version
411 409 #Use of 'run' method instead 'init'
412 410 if self.type == 'self' and self.name == 'init':
413 411 self.name = 'run'
414 412
415 413 self.parmConfObjList = []
416 414
417 415 parmElementList = opElement.iter(ParameterConf().getElementName())
418 416
419 417 for parmElement in parmElementList:
420 418 parmConfObj = ParameterConf()
421 419 parmConfObj.readXml(parmElement)
422 420
423 421 #Compatible with old signal chain version
424 422 #If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
425 423 if self.type != 'self' and self.name == 'Plot':
426 424 if parmConfObj.format == 'str' and parmConfObj.name == 'type':
427 425 self.name = parmConfObj.value
428 426 continue
429 427
430 428 self.parmConfObjList.append(parmConfObj)
431 429
432 430 def printattr(self):
433 431
434 print "%s[%s]: name = %s, type = %s, priority = %s" %(self.ELEMENTNAME,
432 print '%s[%s]: name = %s, type = %s, priority = %s' %(self.ELEMENTNAME,
435 433 self.id,
436 434 self.name,
437 435 self.type,
438 436 self.priority)
439 437
440 438 for parmConfObj in self.parmConfObjList:
441 439 parmConfObj.printattr()
442 440
443 441 def createObject(self, plotter_queue=None):
444 442
445 443
446 444 if self.type == 'self':
447 raise ValueError, "This operation type cannot be created"
445 raise ValueError, 'This operation type cannot be created'
448 446
449 if self.type == 'plotter':
450 #Plotter(plotter_name)
447 if self.type == 'plotter':
451 448 if not plotter_queue:
452 raise ValueError, "plotter_queue is not defined. Use:\nmyProject = Project()\nmyProject.setPlotterQueue(plotter_queue)"
449 raise ValueError, 'plotter_queue is not defined. Use:\nmyProject = Project()\nmyProject.setPlotterQueue(plotter_queue)'
453 450
454 451 opObj = Plotter(self.name, plotter_queue)
455 452
456 453 if self.type == 'external' or self.type == 'other':
457 454
458 455 className = eval(self.name)
459 456 kwargs = self.getKwargs()
460 457
461 458 opObj = className(**kwargs)
462 459
463 460 return opObj
464 461
465 462
466 463 class ProcUnitConf():
467 464
468 465 id = None
469 466 name = None
470 467 datatype = None
471 468 inputId = None
472 469 parentId = None
473 470
474 471 opConfObjList = []
475 472
476 473 procUnitObj = None
477 474 opObjList = []
478 475
479 476 ELEMENTNAME = 'ProcUnit'
480 477
481 478 def __init__(self):
482 479
483 480 self.id = None
484 481 self.datatype = None
485 482 self.name = None
486 483 self.inputId = None
487 484
488 485 self.opConfObjList = []
489 486
490 487 self.procUnitObj = None
491 488 self.opObjDict = {}
492 489
493 490 def __getPriority(self):
494 491
495 492 return len(self.opConfObjList)+1
496 493
497 494 def __getNewId(self):
498 495
499 496 return int(self.id)*10 + len(self.opConfObjList) + 1
500 497
501 498 def getElementName(self):
502 499
503 500 return self.ELEMENTNAME
504 501
505 502 def getId(self):
506 503
507 504 return self.id
508 505
509 506 def updateId(self, new_id, parentId=parentId):
510 507
511 508
512 509 new_id = int(parentId)*10 + (int(self.id) % 10)
513 510 new_inputId = int(parentId)*10 + (int(self.inputId) % 10)
514 511
515 512 #If this proc unit has not inputs
516 513 if self.inputId == '0':
517 514 new_inputId = 0
518 515
519 516 n = 1
520 517 for opConfObj in self.opConfObjList:
521 518
522 519 idOp = str(int(new_id)*10 + n)
523 520 opConfObj.updateId(idOp)
524 521
525 522 n += 1
526 523
527 524 self.parentId = str(parentId)
528 525 self.id = str(new_id)
529 526 self.inputId = str(new_inputId)
530 527
531 528
532 529 def getInputId(self):
533 530
534 531 return self.inputId
535 532
536 533 def getOperationObjList(self):
537 534
538 535 return self.opConfObjList
539 536
540 537 def getOperationObj(self, name=None):
541 538
542 539 for opConfObj in self.opConfObjList:
543 540
544 541 if opConfObj.name != name:
545 542 continue
546 543
547 544 return opConfObj
548 545
549 546 return None
550 547
551 548 def getOpObjfromParamValue(self, value=None):
552 549
553 550 for opConfObj in self.opConfObjList:
554 551 if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
555 552 continue
556 553 return opConfObj
557 554 return None
558 555
559 556 def getProcUnitObj(self):
560 557
561 558 return self.procUnitObj
562 559
563 560 def setup(self, id, name, datatype, inputId, parentId=None):
564 561
565 562 #Compatible with old signal chain version
566 563 if datatype==None and name==None:
567 raise ValueError, "datatype or name should be defined"
564 raise ValueError, 'datatype or name should be defined'
568 565
569 566 if name==None:
570 567 if 'Proc' in datatype:
571 568 name = datatype
572 569 else:
573 570 name = '%sProc' %(datatype)
574 571
575 572 if datatype==None:
576 573 datatype = name.replace('Proc','')
577 574
578 575 self.id = str(id)
579 576 self.name = name
580 577 self.datatype = datatype
581 578 self.inputId = inputId
582 579 self.parentId = parentId
583 580
584 581 self.opConfObjList = []
585 582
586 583 self.addOperation(name='run', optype='self')
587 584
588 585 def removeOperations(self):
589 586
590 587 for obj in self.opConfObjList:
591 588 del obj
592 589
593 590 self.opConfObjList = []
594 591 self.addOperation(name='run')
595 592
596 593 def addParameter(self, **kwargs):
597 594 '''
598 Add parameters to "run" operation
595 Add parameters to 'run' operation
599 596 '''
600 597 opObj = self.opConfObjList[0]
601 598
602 599 opObj.addParameter(**kwargs)
603 600
604 601 return opObj
605 602
606 603 def addOperation(self, name, optype='self'):
607 604
608 605 id = self.__getNewId()
609 606 priority = self.__getPriority()
610 607
611 608 opConfObj = OperationConf()
612 609 opConfObj.setup(id, name=name, priority=priority, type=optype)
613 610
614 611 self.opConfObjList.append(opConfObj)
615 612
616 613 return opConfObj
617 614
618 615 def makeXml(self, projectElement):
619 616
620 617 procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
621 618 procUnitElement.set('id', str(self.id))
622 619 procUnitElement.set('name', self.name)
623 620 procUnitElement.set('datatype', self.datatype)
624 621 procUnitElement.set('inputId', str(self.inputId))
625 622
626 623 for opConfObj in self.opConfObjList:
627 624 opConfObj.makeXml(procUnitElement)
628 625
629 626 def readXml(self, upElement):
630 627
631 628 self.id = upElement.get('id')
632 629 self.name = upElement.get('name')
633 630 self.datatype = upElement.get('datatype')
634 631 self.inputId = upElement.get('inputId')
635 632
636 if self.ELEMENTNAME == "ReadUnit":
637 self.datatype = self.datatype.replace("Reader", "")
633 if self.ELEMENTNAME == 'ReadUnit':
634 self.datatype = self.datatype.replace('Reader', '')
638 635
639 if self.ELEMENTNAME == "ProcUnit":
640 self.datatype = self.datatype.replace("Proc", "")
636 if self.ELEMENTNAME == 'ProcUnit':
637 self.datatype = self.datatype.replace('Proc', '')
641 638
642 639 if self.inputId == 'None':
643 640 self.inputId = '0'
644 641
645 642 self.opConfObjList = []
646 643
647 644 opElementList = upElement.iter(OperationConf().getElementName())
648 645
649 646 for opElement in opElementList:
650 647 opConfObj = OperationConf()
651 648 opConfObj.readXml(opElement)
652 649 self.opConfObjList.append(opConfObj)
653 650
654 651 def printattr(self):
655 652
656 print "%s[%s]: name = %s, datatype = %s, inputId = %s" %(self.ELEMENTNAME,
653 print '%s[%s]: name = %s, datatype = %s, inputId = %s' %(self.ELEMENTNAME,
657 654 self.id,
658 655 self.name,
659 656 self.datatype,
660 657 self.inputId)
661 658
662 659 for opConfObj in self.opConfObjList:
663 660 opConfObj.printattr()
664 661
665 662
666 663 def getKwargs(self):
667 664
668 665 opObj = self.opConfObjList[0]
669 666 kwargs = opObj.getKwargs()
670 667
671 668 return kwargs
672 669
673 670 def createObjects(self, plotter_queue=None):
674 671
675 672 className = eval(self.name)
676 673 kwargs = self.getKwargs()
677 674 procUnitObj = className(**kwargs)
678 675
679 676 for opConfObj in self.opConfObjList:
680 677
681 678 if opConfObj.type=='self' and self.name=='run':
682 679 continue
683 680 elif opConfObj.type=='self':
684 681 procUnitObj.addOperationKwargs(opConfObj.id, **opConfObj.getKwargs())
685 682 continue
686 683
687 684 opObj = opConfObj.createObject(plotter_queue)
688 685
689 686 self.opObjDict[opConfObj.id] = opObj
690 687
691 688 procUnitObj.addOperation(opObj, opConfObj.id)
692 689
693 690 self.procUnitObj = procUnitObj
694 691
695 692 return procUnitObj
696 693
697 694 def run(self):
698 695
699 696 is_ok = False
700 697
701 698 for opConfObj in self.opConfObjList:
702 699
703 700 kwargs = {}
704 701 for parmConfObj in opConfObj.getParameterObjList():
705 702 if opConfObj.name == 'run' and parmConfObj.name == 'datatype':
706 703 continue
707 704
708 705 kwargs[parmConfObj.name] = parmConfObj.getValue()
709 706
710 #ini = time.time()
711
712 #print "\tRunning the '%s' operation with %s" %(opConfObj.name, opConfObj.id)
713 707 sts = self.procUnitObj.call(opType = opConfObj.type,
714 708 opName = opConfObj.name,
715 709 opId = opConfObj.id)
716
717 # total_time = time.time() - ini
718 #
719 # if total_time > 0.002:
720 # print "%s::%s took %f seconds" %(self.name, opConfObj.name, total_time)
721 710
722 711 is_ok = is_ok or sts
723 712
724 713 return is_ok
725 714
726 715 def close(self):
727 716
728 717 for opConfObj in self.opConfObjList:
729 718 if opConfObj.type == 'self':
730 719 continue
731 720
732 721 opObj = self.procUnitObj.getOperationObj(opConfObj.id)
733 722 opObj.close()
734 723
735 724 self.procUnitObj.close()
736 725
737 726 return
738 727
739 728 class ReadUnitConf(ProcUnitConf):
740 729
741 730 path = None
742 731 startDate = None
743 732 endDate = None
744 733 startTime = None
745 734 endTime = None
746 735
747 736 ELEMENTNAME = 'ReadUnit'
748 737
749 738 def __init__(self):
750 739
751 740 self.id = None
752 741 self.datatype = None
753 742 self.name = None
754 743 self.inputId = None
755 744
756 745 self.parentId = None
757 746
758 747 self.opConfObjList = []
759 748 self.opObjList = []
760 749
761 750 def getElementName(self):
762 751
763 752 return self.ELEMENTNAME
764 753
765 def setup(self, id, name, datatype, path='', startDate="", endDate="", startTime="",
766 endTime="", parentId=None, queue=None, server=None, **kwargs):
754 def setup(self, id, name, datatype, path='', startDate='', endDate='',
755 startTime='', endTime='', parentId=None, server=None, **kwargs):
756
767 757 #Compatible with old signal chain version
768 758 if datatype==None and name==None:
769 raise ValueError, "datatype or name should be defined"
759 raise ValueError, 'datatype or name should be defined'
770 760
771 761 if name==None:
772 762 if 'Reader' in datatype:
773 763 name = datatype
774 764 else:
775 765 name = '%sReader' %(datatype)
776 766 if datatype==None:
777 767 datatype = name.replace('Reader','')
778 768
779 769 self.id = id
780 770 self.name = name
781 771 self.datatype = datatype
782 772 if path != '':
783 773 self.path = os.path.abspath(path)
784 774 self.startDate = startDate
785 775 self.endDate = endDate
786 776 self.startTime = startTime
787 777 self.endTime = endTime
788
789 778 self.inputId = '0'
790 779 self.parentId = parentId
791 self.queue = queue
792 780 self.server = server
793 781 self.addRunOperation(**kwargs)
794 782
795 def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, name=None, **kwargs):
783 def update(self, **kwargs):
796 784
797 #Compatible with old signal chain version
798 if datatype==None and name==None:
799 raise ValueError, "datatype or name should be defined"
800
801 if name==None:
785 if 'datatype' in kwargs:
786 datatype = kwargs.pop('datatype')
802 787 if 'Reader' in datatype:
803 name = datatype
788 self.name = datatype
804 789 else:
805 name = '%sReader' %(datatype)
806
807 if datatype==None:
808 datatype = name.replace('Reader','')
809
810 self.datatype = datatype
811 self.name = name
812 self.path = path
813 self.startDate = startDate
814 self.endDate = endDate
815 self.startTime = startTime
816 self.endTime = endTime
790 self.name = '%sReader' %(datatype)
791 self.datatype = self.name.replace('Reader', '')
817 792
793 attrs = ('path', 'startDate', 'endDate', 'startTime', 'endTime', 'parentId')
794
795 for attr in attrs:
796 if attr in kwargs:
797 setattr(self, attr, kwargs.pop(attr))
798
818 799 self.inputId = '0'
819 self.parentId = parentId
820
821 800 self.updateRunOperation(**kwargs)
822 801
823 802 def removeOperations(self):
824 803
825 804 for obj in self.opConfObjList:
826 805 del obj
827 806
828 807 self.opConfObjList = []
829 808
830 809 def addRunOperation(self, **kwargs):
831 810
832 811 opObj = self.addOperation(name = 'run', optype = 'self')
833 812
834 813 if self.server is None:
835 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
836 opObj.addParameter(name='path' , value=self.path, format='str')
837 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
838 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
839 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
840 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
841 opObj.addParameter(name='queue' , value=self.queue, format='obj')
814 opObj.addParameter(name='datatype', value=self.datatype, format='str')
815 opObj.addParameter(name='path', value=self.path, format='str')
816 opObj.addParameter(name='startDate', value=self.startDate, format='date')
817 opObj.addParameter(name='endDate', value=self.endDate, format='date')
818 opObj.addParameter(name='startTime', value=self.startTime, format='time')
819 opObj.addParameter(name='endTime', value=self.endTime, format='time')
820
842 821 for key, value in kwargs.items():
843 822 opObj.addParameter(name=key, value=value, format=type(value).__name__)
844 823 else:
845 824 opObj.addParameter(name='server' , value=self.server, format='str')
846 825
847 826
848 827 return opObj
849 828
850 829 def updateRunOperation(self, **kwargs):
851 830
852 opObj = self.getOperationObj(name = 'run')
831 opObj = self.getOperationObj(name='run')
853 832 opObj.removeParameters()
854 833
855 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
856 opObj.addParameter(name='path' , value=self.path, format='str')
857 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
858 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
859 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
860 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
861
834 opObj.addParameter(name='datatype', value=self.datatype, format='str')
835 opObj.addParameter(name='path', value=self.path, format='str')
836 opObj.addParameter(name='startDate', value=self.startDate, format='date')
837 opObj.addParameter(name='endDate', value=self.endDate, format='date')
838 opObj.addParameter(name='startTime', value=self.startTime, format='time')
839 opObj.addParameter(name='endTime', value=self.endTime, format='time')
840
862 841 for key, value in kwargs.items():
863 842 opObj.addParameter(name=key, value=value, format=type(value).__name__)
864 843
865 844 return opObj
866 845
867 # def makeXml(self, projectElement):
868 #
869 # procUnitElement = SubElement(projectElement, self.ELEMENTNAME)
870 # procUnitElement.set('id', str(self.id))
871 # procUnitElement.set('name', self.name)
872 # procUnitElement.set('datatype', self.datatype)
873 # procUnitElement.set('inputId', str(self.inputId))
874 #
875 # for opConfObj in self.opConfObjList:
876 # opConfObj.makeXml(procUnitElement)
877
878 846 def readXml(self, upElement):
879 847
880 848 self.id = upElement.get('id')
881 849 self.name = upElement.get('name')
882 850 self.datatype = upElement.get('datatype')
883 851 self.inputId = upElement.get('inputId')
884 852
885 if self.ELEMENTNAME == "ReadUnit":
886 self.datatype = self.datatype.replace("Reader", "")
853 if self.ELEMENTNAME == 'ReadUnit':
854 self.datatype = self.datatype.replace('Reader', '')
887 855
888 856 if self.inputId == 'None':
889 857 self.inputId = '0'
890 858
891 859 self.opConfObjList = []
892 860
893 861 opElementList = upElement.iter(OperationConf().getElementName())
894 862
895 863 for opElement in opElementList:
896 864 opConfObj = OperationConf()
897 865 opConfObj.readXml(opElement)
898 866 self.opConfObjList.append(opConfObj)
899 867
900 868 if opConfObj.name == 'run':
901 869 self.path = opConfObj.getParameterValue('path')
902 870 self.startDate = opConfObj.getParameterValue('startDate')
903 871 self.endDate = opConfObj.getParameterValue('endDate')
904 872 self.startTime = opConfObj.getParameterValue('startTime')
905 873 self.endTime = opConfObj.getParameterValue('endTime')
906 874
907 875 class Project(Process):
876
908 877 id = None
909 name = None
878 # name = None
910 879 description = None
911 880 filename = None
912 881
913 882 procUnitConfObjDict = None
914 883
915 884 ELEMENTNAME = 'Project'
916 885
917 886 plotterQueue = None
918 887
919 def __init__(self, plotter_queue=None, logfile=None):
888 def __init__(self, plotter_queue=None):
889
920 890 Process.__init__(self)
921 891 self.id = None
922 self.name = None
892 # self.name = None
923 893 self.description = None
924 if logfile is not None:
925 logToFile(logfile)
894
926 895 self.plotterQueue = plotter_queue
927 896
928 897 self.procUnitConfObjDict = {}
929
898
930 899 def __getNewId(self):
931 900
932 901 idList = self.procUnitConfObjDict.keys()
933 902
934 903 id = int(self.id)*10
935 904
936 905 while True:
937 906 id += 1
938 907
939 908 if str(id) in idList:
940 909 continue
941 910
942 911 break
943 912
944 913 return str(id)
945 914
946 915 def getElementName(self):
947 916
948 917 return self.ELEMENTNAME
949 918
950 919 def getId(self):
951 920
952 921 return self.id
953 922
954 923 def updateId(self, new_id):
955 924
956 925 self.id = str(new_id)
957 926
958 927 keyList = self.procUnitConfObjDict.keys()
959 928 keyList.sort()
960 929
961 930 n = 1
962 931 newProcUnitConfObjDict = {}
963 932
964 933 for procKey in keyList:
965 934
966 935 procUnitConfObj = self.procUnitConfObjDict[procKey]
967 936 idProcUnit = str(int(self.id)*10 + n)
968 937 procUnitConfObj.updateId(idProcUnit, parentId = self.id)
969 938
970 939 newProcUnitConfObjDict[idProcUnit] = procUnitConfObj
971 940 n += 1
972 941
973 942 self.procUnitConfObjDict = newProcUnitConfObjDict
974 943
975 def setup(self, id, name, description):
944 def setup(self, id, name='', description=''):
976 945
946 print
947 print '*'*60
948 print ' Starting SIGNAL CHAIN PROCESSING v%s ' % schainpy.__version__
949 print '*'*60
950 print
977 951 self.id = str(id)
978 self.name = name
979 952 self.description = description
980 953
981 954 def update(self, name, description):
982 955
983 self.name = name
984 956 self.description = description
985 957
958 def clone(self):
959
960 p = Project()
961 p.procUnitConfObjDict = self.procUnitConfObjDict
962 return p
963
986 964 def addReadUnit(self, id=None, datatype=None, name=None, **kwargs):
965
987 966 if id is None:
988 967 idReadUnit = self.__getNewId()
989 968 else:
990 969 idReadUnit = str(id)
991 970
992 971 readUnitConfObj = ReadUnitConf()
993 972 readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
994 973
995 974 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
996 975
997 976 return readUnitConfObj
998 977
999 978 def addProcUnit(self, inputId='0', datatype=None, name=None):
1000 979
1001 980 idProcUnit = self.__getNewId()
1002 981
1003 982 procUnitConfObj = ProcUnitConf()
1004 983 procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
1005 984
1006 985 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
1007 986
1008 987 return procUnitConfObj
1009 988
1010 989 def removeProcUnit(self, id):
1011 990
1012 991 if id in self.procUnitConfObjDict.keys():
1013 992 self.procUnitConfObjDict.pop(id)
1014 993
1015 994 def getReadUnitId(self):
1016 995
1017 996 readUnitConfObj = self.getReadUnitObj()
1018 997
1019 998 return readUnitConfObj.id
1020 999
1021 1000 def getReadUnitObj(self):
1022 1001
1023 1002 for obj in self.procUnitConfObjDict.values():
1024 if obj.getElementName() == "ReadUnit":
1003 if obj.getElementName() == 'ReadUnit':
1025 1004 return obj
1026 1005
1027 1006 return None
1028 1007
1029 1008 def getProcUnitObj(self, id=None, name=None):
1030 1009
1031 1010 if id != None:
1032 1011 return self.procUnitConfObjDict[id]
1033 1012
1034 1013 if name != None:
1035 1014 return self.getProcUnitObjByName(name)
1036 1015
1037 1016 return None
1038 1017
1039 1018 def getProcUnitObjByName(self, name):
1040 1019
1041 1020 for obj in self.procUnitConfObjDict.values():
1042 1021 if obj.name == name:
1043 1022 return obj
1044 1023
1045 1024 return None
1046 1025
1047 1026 def procUnitItems(self):
1048 1027
1049 1028 return self.procUnitConfObjDict.items()
1050 1029
1051 1030 def makeXml(self):
1052 1031
1053 1032 projectElement = Element('Project')
1054 1033 projectElement.set('id', str(self.id))
1055 1034 projectElement.set('name', self.name)
1056 1035 projectElement.set('description', self.description)
1057 1036
1058 1037 for procUnitConfObj in self.procUnitConfObjDict.values():
1059 1038 procUnitConfObj.makeXml(projectElement)
1060 1039
1061 1040 self.projectElement = projectElement
1062 1041
1063 1042 def writeXml(self, filename=None):
1064 1043
1065 1044 if filename == None:
1066 1045 if self.filename:
1067 1046 filename = self.filename
1068 1047 else:
1069 filename = "schain.xml"
1048 filename = 'schain.xml'
1070 1049
1071 1050 if not filename:
1072 print "filename has not been defined. Use setFilename(filename) for do it."
1051 print 'filename has not been defined. Use setFilename(filename) for do it.'
1073 1052 return 0
1074 1053
1075 1054 abs_file = os.path.abspath(filename)
1076 1055
1077 1056 if not os.access(os.path.dirname(abs_file), os.W_OK):
1078 print "No write permission on %s" %os.path.dirname(abs_file)
1057 print 'No write permission on %s' %os.path.dirname(abs_file)
1079 1058 return 0
1080 1059
1081 1060 if os.path.isfile(abs_file) and not(os.access(abs_file, os.W_OK)):
1082 print "File %s already exists and it could not be overwriten" %abs_file
1061 print 'File %s already exists and it could not be overwriten' %abs_file
1083 1062 return 0
1084 1063
1085 1064 self.makeXml()
1086 1065
1087 1066 ElementTree(self.projectElement).write(abs_file, method='xml')
1088 1067
1089 1068 self.filename = abs_file
1090 1069
1091 1070 return 1
1092 1071
1093 1072 def readXml(self, filename = None):
1094 1073
1095 1074 if not filename:
1096 print "filename is not defined"
1075 print 'filename is not defined'
1097 1076 return 0
1098 1077
1099 1078 abs_file = os.path.abspath(filename)
1100 1079
1101 1080 if not os.path.isfile(abs_file):
1102 print "%s file does not exist" %abs_file
1081 print '%s file does not exist' %abs_file
1103 1082 return 0
1104 1083
1105 1084 self.projectElement = None
1106 1085 self.procUnitConfObjDict = {}
1107 1086
1108 1087 try:
1109 1088 self.projectElement = ElementTree().parse(abs_file)
1110 1089 except:
1111 print "Error reading %s, verify file format" %filename
1090 print 'Error reading %s, verify file format' %filename
1112 1091 return 0
1113 1092
1114 1093 self.project = self.projectElement.tag
1115 1094
1116 1095 self.id = self.projectElement.get('id')
1117 1096 self.name = self.projectElement.get('name')
1118 1097 self.description = self.projectElement.get('description')
1119 1098
1120 1099 readUnitElementList = self.projectElement.iter(ReadUnitConf().getElementName())
1121 1100
1122 1101 for readUnitElement in readUnitElementList:
1123 1102 readUnitConfObj = ReadUnitConf()
1124 1103 readUnitConfObj.readXml(readUnitElement)
1125 1104
1126 1105 if readUnitConfObj.parentId == None:
1127 1106 readUnitConfObj.parentId = self.id
1128 1107
1129 1108 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
1130 1109
1131 1110 procUnitElementList = self.projectElement.iter(ProcUnitConf().getElementName())
1132 1111
1133 1112 for procUnitElement in procUnitElementList:
1134 1113 procUnitConfObj = ProcUnitConf()
1135 1114 procUnitConfObj.readXml(procUnitElement)
1136 1115
1137 1116 if procUnitConfObj.parentId == None:
1138 1117 procUnitConfObj.parentId = self.id
1139 1118
1140 1119 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
1141 1120
1142 1121 self.filename = abs_file
1143 1122
1144 1123 return 1
1145 1124
1146 1125 def printattr(self):
1147 1126
1148 print "Project[%s]: name = %s, description = %s" %(self.id,
1149 self.name,
1150 self.description)
1151
1127 print 'Project[%s]: name = %s, description = %s' %(self.id,
1128 self.name,
1129 self.description)
1130
1152 1131 for procUnitConfObj in self.procUnitConfObjDict.values():
1153 1132 procUnitConfObj.printattr()
1154 1133
1155 1134 def createObjects(self):
1156 1135
1157 1136 for procUnitConfObj in self.procUnitConfObjDict.values():
1158 1137 procUnitConfObj.createObjects(self.plotterQueue)
1159 1138
1160 1139 def __connect(self, objIN, thisObj):
1161 1140
1162 1141 thisObj.setInput(objIN.getOutputObj())
1163 1142
1164 1143 def connectObjects(self):
1165 1144
1166 1145 for thisPUConfObj in self.procUnitConfObjDict.values():
1167 1146
1168 1147 inputId = thisPUConfObj.getInputId()
1169 1148
1170 1149 if int(inputId) == 0:
1171 1150 continue
1172 1151
1173 1152 #Get input object
1174 1153 puConfINObj = self.procUnitConfObjDict[inputId]
1175 1154 puObjIN = puConfINObj.getProcUnitObj()
1176 1155
1177 1156 #Get current object
1178 1157 thisPUObj = thisPUConfObj.getProcUnitObj()
1179 1158
1180 1159 self.__connect(puObjIN, thisPUObj)
1181 1160
1182 def __handleError(self, procUnitConfObj, send_email=True):
1161 def __handleError(self, procUnitConfObj, send_email=False):
1183 1162
1184 1163 import socket
1185 1164
1186 1165 err = traceback.format_exception(sys.exc_info()[0],
1187 1166 sys.exc_info()[1],
1188 1167 sys.exc_info()[2])
1189 1168
1190 print "***** Error occurred in %s *****" %(procUnitConfObj.name)
1191 print "***** %s" %err[-1]
1169 print '***** Error occurred in %s *****' %(procUnitConfObj.name)
1170 print '***** %s' %err[-1]
1192 1171
1193 message = "".join(err)
1172 message = ''.join(err)
1194 1173
1195 1174 sys.stderr.write(message)
1196 1175
1197 1176 if not send_email:
1198 1177 return
1199 1178
1200 subject = "SChain v%s: Error running %s\n" %(schainpy.__version__, procUnitConfObj.name)
1179 subject = 'SChain v%s: Error running %s\n' %(schainpy.__version__, procUnitConfObj.name)
1201 1180
1202 subtitle = "%s: %s\n" %(procUnitConfObj.getElementName() ,procUnitConfObj.name)
1203 subtitle += "Hostname: %s\n" %socket.gethostbyname(socket.gethostname())
1204 subtitle += "Working directory: %s\n" %os.path.abspath("./")
1205 subtitle += "Configuration file: %s\n" %self.filename
1206 subtitle += "Time: %s\n" %str(datetime.datetime.now())
1181 subtitle = '%s: %s\n' %(procUnitConfObj.getElementName() ,procUnitConfObj.name)
1182 subtitle += 'Hostname: %s\n' %socket.gethostbyname(socket.gethostname())
1183 subtitle += 'Working directory: %s\n' %os.path.abspath('./')
1184 subtitle += 'Configuration file: %s\n' %self.filename
1185 subtitle += 'Time: %s\n' %str(datetime.datetime.now())
1207 1186
1208 1187 readUnitConfObj = self.getReadUnitObj()
1209 1188 if readUnitConfObj:
1210 subtitle += "\nInput parameters:\n"
1211 subtitle += "[Data path = %s]\n" %readUnitConfObj.path
1212 subtitle += "[Data type = %s]\n" %readUnitConfObj.datatype
1213 subtitle += "[Start date = %s]\n" %readUnitConfObj.startDate
1214 subtitle += "[End date = %s]\n" %readUnitConfObj.endDate
1215 subtitle += "[Start time = %s]\n" %readUnitConfObj.startTime
1216 subtitle += "[End time = %s]\n" %readUnitConfObj.endTime
1189 subtitle += '\nInput parameters:\n'
1190 subtitle += '[Data path = %s]\n' %readUnitConfObj.path
1191 subtitle += '[Data type = %s]\n' %readUnitConfObj.datatype
1192 subtitle += '[Start date = %s]\n' %readUnitConfObj.startDate
1193 subtitle += '[End date = %s]\n' %readUnitConfObj.endDate
1194 subtitle += '[Start time = %s]\n' %readUnitConfObj.startTime
1195 subtitle += '[End time = %s]\n' %readUnitConfObj.endTime
1217 1196
1218 1197 adminObj = schainpy.admin.SchainNotify()
1219 1198 adminObj.sendAlert(message=message,
1220 1199 subject=subject,
1221 1200 subtitle=subtitle,
1222 1201 filename=self.filename)
1223 1202
1224 1203 def isPaused(self):
1225 1204 return 0
1226 1205
1227 1206 def isStopped(self):
1228 1207 return 0
1229 1208
1230 1209 def runController(self):
1231 """
1210 '''
1232 1211 returns 0 when this process has been stopped, 1 otherwise
1233 """
1212 '''
1234 1213
1235 1214 if self.isPaused():
1236 print "Process suspended"
1215 print 'Process suspended'
1237 1216
1238 1217 while True:
1239 sleep(0.1)
1218 time.sleep(0.1)
1240 1219
1241 1220 if not self.isPaused():
1242 1221 break
1243 1222
1244 1223 if self.isStopped():
1245 1224 break
1246 1225
1247 print "Process reinitialized"
1226 print 'Process reinitialized'
1248 1227
1249 1228 if self.isStopped():
1250 print "Process stopped"
1229 print 'Process stopped'
1251 1230 return 0
1252 1231
1253 1232 return 1
1254 1233
1255 1234 def setFilename(self, filename):
1256 1235
1257 1236 self.filename = filename
1258 1237
1259 1238 def setPlotterQueue(self, plotter_queue):
1260 1239
1261 raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
1240 raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
1262 1241
1263 1242 def getPlotterQueue(self):
1264 1243
1265 raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
1244 raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
1266 1245
1267 1246 def useExternalPlotter(self):
1268 1247
1269 raise NotImplementedError, "Use schainpy.controller_api.ControllerThread instead Project class"
1248 raise NotImplementedError, 'Use schainpy.controller_api.ControllerThread instead Project class'
1270 1249
1250 def run(self):
1271 1251
1272 def run(self, filename=None):
1252 log.success('Starting {}'.format(self.name))
1273 1253
1274 # self.writeXml(filename)
1275 1254 self.createObjects()
1276 1255 self.connectObjects()
1277 1256
1278 print
1279 print "*"*60
1280 print " Starting SIGNAL CHAIN PROCESSING v%s " %schainpy.__version__
1281 print "*"*60
1282 print
1283
1284 1257 keyList = self.procUnitConfObjDict.keys()
1285 1258 keyList.sort()
1286 1259
1287 1260 while(True):
1288 1261
1289 1262 is_ok = False
1290 1263
1291 1264 for procKey in keyList:
1292 # print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
1293 1265
1294 1266 procUnitConfObj = self.procUnitConfObjDict[procKey]
1295 1267
1296 1268 try:
1297 1269 sts = procUnitConfObj.run()
1298 1270 is_ok = is_ok or sts
1299 1271 except KeyboardInterrupt:
1300 1272 is_ok = False
1301 1273 break
1302 1274 except ValueError, e:
1303 sleep(0.5)
1275 time.sleep(0.5)
1304 1276 self.__handleError(procUnitConfObj, send_email=True)
1305 1277 is_ok = False
1306 1278 break
1307 1279 except:
1308 sleep(0.5)
1280 time.sleep(0.5)
1309 1281 self.__handleError(procUnitConfObj)
1310 1282 is_ok = False
1311 1283 break
1312 1284
1313 1285 #If every process unit finished so end process
1314 1286 if not(is_ok):
1315 # print "Every process unit have finished"
1316 1287 break
1317 1288
1318 1289 if not self.runController():
1319 1290 break
1320 1291
1321 1292 #Closing every process
1322 1293 for procKey in keyList:
1323 1294 procUnitConfObj = self.procUnitConfObjDict[procKey]
1324 1295 procUnitConfObj.close()
1296
1297 log.success('{} finished'.format(self.name))
Show file before | Show file after | Hide comments
@@ -1,6220 +1,6223
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 Module implementing MainWindow.
4 4 #+++++++++++++GUI V1++++++++++++++#
5 5 @author: AlexanderValdezPortocarrero
6 6
7 7 #+++++++++++++GUI V2++++++++++++++#
8 8 @author Miguel Urco
9 9 """
10 10 import os, sys
11 11 import datetime
12 12 import numpy
13 13 import ast
14 14
15 15 from Queue import Queue
16 16
17 17 from collections import OrderedDict
18 18 from os.path import expanduser
19 19 from time import sleep
20 20
21 21 from PyQt4.QtGui import QMainWindow
22 22 from PyQt4.QtCore import pyqtSignature
23 23 from PyQt4.QtCore import pyqtSignal
24 24 from PyQt4 import QtCore
25 25 from PyQt4 import QtGui
26 26
27 27 from propertiesViewModel import TreeModel, PropertyBuffer
28 28 from parametersModel import ProjectParms
29 29
30 30 from schainpy.gui.viewer.ui_unitprocess import Ui_UnitProcess
31 31 from schainpy.gui.viewer.ui_ftp import Ui_Ftp
32 32 from schainpy.gui.viewer.ui_mainwindow import Ui_BasicWindow
33 33
34 34 from schainpy.controller_api import ControllerThread
35 35 from schainpy.controller import Project
36 36
37 37 from schainpy.model.graphics.jroplotter import PlotManager
38 38 from schainpy.gui.figures import tools
39 39
40 40 FIGURES_PATH = tools.get_path()
41 41 TEMPORAL_FILE = ".temp.xml"
42 42
43 43 def isRadarFile(file):
44 44 try:
45 45 year = int(file[1:5])
46 46 doy = int(file[5:8])
47 47 set = int(file[8:11])
48 48 except:
49 49 return 0
50 50
51 51 return 1
52 52
53 53 def isRadarPath(path):
54 54 try:
55 55 year = int(path[1:5])
56 56 doy = int(path[5:8])
57 57 except:
58 58 return 0
59 59
60 60 return 1
61 61
62 62 def isInt(cadena):
63 63
64 64 try:
65 65 int(cadena)
66 66 except:
67 67 return 0
68 68
69 69 return 1
70 70
71 71 def isFloat(cadena):
72 72
73 73 try:
74 74 float(cadena)
75 75 except:
76 76 return 0
77 77
78 78 return 1
79 79
80 80 def isList(cadena):
81 81
82 82 value = str.strip(cadena)
83 83
84 84 if not value:
85 85 return 0
86 86
87 87 try:
88 88 x = ast.literal_eval(value)
89 89 except:
90 90 return 0
91 91
92 92 if type(x) in (int, float, tuple, list):
93 93 return 1
94 94
95 95 return 0
96 96
97 97 def isIntList(cadena):
98 98
99 99 value = str.strip(cadena)
100 100
101 101 if not value:
102 102 return 0
103 103
104 104 try:
105 105 x = ast.literal_eval(value)
106 106 except:
107 107 return 0
108 108
109 109 if type(x) not in (int, tuple, list):
110 110 return 0
111 111
112 112 return 1
113 113
114 114 def isFloatRange(cadena):
115 115
116 116 value = str.strip(cadena)
117 117
118 118 if not value:
119 119 return 0
120 120
121 121 c = str.split(value, ",")
122 122
123 123 if len(c) != 2:
124 124 return 0
125 125
126 126 if not isFloat(c[0]):
127 127 return 0
128 128
129 129 if not isFloat(c[1]):
130 130 return 0
131 131
132 132 return 1
133 133
134 134 def isIntRange(cadena):
135 135
136 136 value = str.strip(cadena)
137 137
138 138 if not value:
139 139 return 0
140 140
141 141 c = str.split(value, ",")
142 142
143 143 if len(c) != 2:
144 144 return 0
145 145
146 146 if not isInt(c[0]):
147 147 return 0
148 148
149 149 if not isInt(c[1]):
150 150 return 0
151 151
152 152 def isPair(value):
153 153
154 154 if type(value) not in (tuple, list):
155 155 return 0
156 156
157 157 if len(value) != 2:
158 158 return 0
159 159
160 160 for i in value:
161 161 if type(i) not in (int,):
162 162 return 0
163 163
164 164 return 1
165 165
166 166 def isPairList(cadena):
167 167
168 168 value = str.strip(cadena)
169 169
170 170 if not value:
171 171 return 0
172 172
173 173 try:
174 174 x = ast.literal_eval(value)
175 175 except:
176 176 return 0
177 177
178 178 if type(x) not in (tuple, list):
179 179 return 0
180 180
181 181 if type(x[0]) not in (tuple, list):
182 182 #x = (0,1)
183 183 if not isPair(x):
184 184 return 0
185 185
186 186 return 1
187 187
188 188 for thisPair in x:
189 189 if not isPair(thisPair):
190 190 return 0
191 191
192 192 return 1
193 193
194 194 def isMultiList(cadena):
195 195
196 196 value = str.strip(cadena)
197 197
198 198 if not value:
199 199 return 0
200 200
201 201 try:
202 202 x = ast.literal_eval(value)
203 203 except:
204 204 return 0
205 205
206 206 if type(x) not in (tuple, list):
207 207 return 0
208 208
209 209 for thisList in x:
210 210 if type(thisList) not in (int, float, tuple, list):
211 211 return 0
212 212
213 213 return 1
214 214
215 215 def getCode(cadena):
216 216
217 217 if not isMultiList(cadena):
218 218 return None
219 219
220 220 try:
221 221 x = ast.literal_eval(cadena)
222 222 except:
223 223 return None
224 224
225 225 if type(x[0]) in (int, float):
226 226 return [x]
227 227
228 228 return x
229 229
230 230
231 231 class BasicWindow(QMainWindow, Ui_BasicWindow):
232 232 """
233 233 """
234 234 def __init__(self, parent=None):
235 235 """
236 236
237 237 """
238 238 QMainWindow.__init__(self, parent)
239 239 self.setupUi(self)
240 240 self.__puObjDict = {}
241 241 self.__itemTreeDict = {}
242 242 self.readUnitConfObjList = []
243 243 self.operObjList = []
244 244 self.projecObjView = None
245 245 self.idProject = 0
246 246 # self.idImag = 0
247 247
248 248 self.idImagscope = 0
249 249 self.idImagspectra = 0
250 250 self.idImagcross = 0
251 251 self.idImagrti = 0
252 252 self.idImagcoherence = 0
253 253 self.idImagpower = 0
254 254 self.idImagrtinoise = 0
255 255 self.idImagspectraHeis = 0
256 256 self.idImagrtiHeis = 0
257 257
258 258 self.dateList = []
259 259 self.dataPath = None
260 260 self.create = False
261 261 self.selectedItemTree = None
262 262 self.controllerThread = None
263 263 # self.commCtrlPThread = None
264 264 # self.create_figure()
265 265 self.temporalFTP = ftpBuffer()
266 266 self.projectProperCaracteristica = []
267 267 self.projectProperPrincipal = []
268 268 self.projectProperDescripcion = []
269 269 self.volProperCaracteristica = []
270 270 self.volProperPrincipal = []
271 271 self.volProperDescripcion = []
272 272 self.specProperCaracteristica = []
273 273 self.specProperPrincipal = []
274 274 self.specProperDescripcion = []
275 275
276 276 self.specHeisProperCaracteristica = []
277 277 self.specHeisProperPrincipal = []
278 278 self.specHeisProperDescripcion = []
279 279
280 280 # self.pathWorkSpace = './'
281 281
282 282 self.__projectObjDict = {}
283 283 self.__operationObjDict = {}
284 284
285 285 self.__puLocalFolder2FTP = {}
286 286 self.threadStarted = False
287 287
288 288 self.plotManager = None
289 289
290 290 # self.create_comm()
291 291 self.create_updating_timer()
292 292 self.setGUIStatus()
293 293
294 294 @pyqtSignature("")
295 295 def on_actionOpen_triggered(self):
296 296 """
297 297 Slot documentation goes here.
298 298 """
299 299 self.openProject()
300 300
301 301 @pyqtSignature("")
302 302 def on_actionCreate_triggered(self):
303 303 """
304 304 Slot documentation goes here.
305 305 """
306 306 self.setInputsProject_View()
307 307 self.create = True
308 308
309 309 @pyqtSignature("")
310 310 def on_actionSave_triggered(self):
311 311 """
312 312 Slot documentation goes here.
313 313 """
314 314 self.saveProject()
315 315
316 316 @pyqtSignature("")
317 317 def on_actionClose_triggered(self):
318 318 """
319 319 Slot documentation goes here.
320 320 """
321 321 self.close()
322 322
323 323 @pyqtSignature("")
324 324 def on_actionStart_triggered(self):
325 325 """
326 326 """
327 327 self.playProject()
328 328
329 329 @pyqtSignature("")
330 330 def on_actionPause_triggered(self):
331 331 """
332 332 """
333 333 self.pauseProject()
334 334
335 335 @pyqtSignature("")
336 336 def on_actionStop_triggered(self):
337 337 """
338 338 """
339 339 self.stopProject()
340 340
341 341 @pyqtSignature("")
342 342 def on_actionAbout_triggered(self):
343 343 """
344 344 """
345 345 self.aboutEvent()
346 346
347 347 @pyqtSignature("")
348 348 def on_actionFTP_triggered(self):
349 349 """
350 350 """
351 351 self.configFTPWindowObj = Ftp(self)
352 352
353 353 if not self.temporalFTP.create:
354 354 self.temporalFTP.setwithoutconfiguration()
355 355
356 356 self.configFTPWindowObj.setParmsfromTemporal(self.temporalFTP.server,
357 357 self.temporalFTP.remotefolder,
358 358 self.temporalFTP.username,
359 359 self.temporalFTP.password,
360 360 self.temporalFTP.ftp_wei,
361 361 self.temporalFTP.exp_code,
362 362 self.temporalFTP.sub_exp_code,
363 363 self.temporalFTP.plot_pos)
364 364
365 365 self.configFTPWindowObj.show()
366 366 self.configFTPWindowObj.closed.connect(self.createFTPConfig)
367 367
368 368 def createFTPConfig(self):
369 369
370 370 if not self.configFTPWindowObj.create:
371 371 self.console.clear()
372 372 self.console.append("There is no FTP configuration")
373 373 return
374 374
375 375 self.console.append("Push Ok in Spectra view to Add FTP Configuration")
376 376
377 377 server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.configFTPWindowObj.getParmsFromFtpWindow()
378 378 self.temporalFTP.save(server=server,
379 379 remotefolder=remotefolder,
380 380 username=username,
381 381 password=password,
382 382 ftp_wei=ftp_wei,
383 383 exp_code=exp_code,
384 384 sub_exp_code=sub_exp_code,
385 385 plot_pos=plot_pos)
386 386
387 387 @pyqtSignature("")
388 388 def on_actionOpenToolbar_triggered(self):
389 389 """
390 390 Slot documentation goes here.
391 391 """
392 392 self.openProject()
393 393
394 394 @pyqtSignature("")
395 395 def on_actionCreateToolbar_triggered(self):
396 396 """
397 397 Slot documentation goes here.
398 398 """
399 399 self.setInputsProject_View()
400 400 self.create = True
401 401
402 402 @pyqtSignature("")
403 403 def on_actionAddPU_triggered(self):
404 404
405 405 if len(self.__projectObjDict) == 0:
406 406 outputstr = "First create a Project before add any Processing Unit"
407 407 self.console.clear()
408 408 self.console.append(outputstr)
409 409 return
410 410 else:
411 411 self.addPUWindow()
412 412 self.console.clear()
413 413 self.console.append("Please, Choose the type of Processing Unit")
414 414 # self.console.append("If your Datatype is rawdata, you will start with processing unit Type Voltage")
415 415 # self.console.append("If your Datatype is pdata, you will choose between processing unit Type Spectra or Correlation")
416 416 # self.console.append("If your Datatype is fits, you will start with processing unit Type SpectraHeis")
417 417
418 418
419 419 @pyqtSignature("")
420 420 def on_actionSaveToolbar_triggered(self):
421 421 """
422 422 Slot documentation goes here.
423 423 """
424 424 self.saveProject()
425 425
426 426 @pyqtSignature("")
427 427 def on_actionStarToolbar_triggered(self):
428 428 """
429 429 Slot documentation goes here.
430 430 """
431 431 self.playProject()
432 432
433 433 @pyqtSignature("")
434 434 def on_actionPauseToolbar_triggered(self):
435 435
436 436 self.pauseProject()
437 437
438 438 @pyqtSignature("")
439 439 def on_actionStopToolbar_triggered(self):
440 440 """
441 441 Slot documentation goes here.
442 442 """
443 443 self.stopProject()
444 444
445 445 @pyqtSignature("int")
446 446 def on_proComReadMode_activated(self, index):
447 447 """
448 448 SELECCION DEL MODO DE LECTURA ON=1, OFF=0
449 449 """
450 450 if index == 0:
451 451 # self.proDelay.setText("0")
452 452 self.proSet.setEnabled(True)
453 453 self.proDelay.setEnabled(False)
454 454 elif index == 1:
455 455 self.proSet.setText("")
456 456 # self.proDelay.setText("5")
457 457 self.proSet.setEnabled(False)
458 458 self.proDelay.setEnabled(True)
459 459
460 460
461 461 def __setRawDataWindow(self):
462 462
463 463 self.__setPDataWindow()
464 464
465 465 self.frame_data.show()
466 466
467 467 self.labnTxs.show()
468 468 self.pronTxs.show()
469 469
470 470 self.labByBlock.show()
471 471 self.proComByBlock.show()
472 472
473 473 def __setPDataWindow(self):
474 474
475 475 self.labelIPPKm.hide()
476 476 self.proIPPKm.hide()
477 477
478 478 self.labelSet.show()
479 479 self.proSet.show()
480 480
481 481 self.labExpLabel.show()
482 482 self.proExpLabel.show()
483 483
484 484 self.labelWalk.show()
485 485 self.proComWalk.show()
486 486
487 487 self.frame_data.hide()
488 488
489 489 # self.labnTxs.hide()
490 490 # self.pronTxs.hide()
491 491 #
492 492 # self.labByBlock.hide()
493 493 # self.proComByBlock.hide()
494 494
495 495 def __setUSRPDataWindow(self):
496 496
497 497 self.frame_data.show()
498 498
499 499 self.labelIPPKm.show()
500 500 self.proIPPKm.show()
501 501
502 502 self.labelSet.hide()
503 503 self.proSet.hide()
504 504
505 505 self.labExpLabel.hide()
506 506 self.proExpLabel.hide()
507 507
508 508 self.labelWalk.hide()
509 509 self.proComWalk.hide()
510 510
511 511 self.labnTxs.hide()
512 512 self.pronTxs.hide()
513 513
514 514 self.labByBlock.hide()
515 515 self.proComByBlock.hide()
516 516
517 517 @pyqtSignature("int")
518 518 def on_proComDataType_activated(self, index):
519 519 """
520 520 Voltage or Spectra
521 521 """
522 522
523 523 if index == 0:
524 524 extension = '.r'
525 525 self.__setRawDataWindow()
526 526
527 527 elif index == 1:
528 528 extension = '.pdata'
529 529 self.__setPDataWindow()
530 530
531 531
532 532 elif index == 2:
533 533 extension = '.fits'
534 534 self.__setPDataWindow()
535 535
536 536 elif index == 3:
537 537 extension = '.hdf5'
538 538 self.__setUSRPDataWindow()
539 539
540 540 self.proDataType.setText(extension)
541 541
542 542 @pyqtSignature("int")
543 543 def on_proComWalk_activated(self, index):
544 544 """
545 545
546 546 """
547 547 if index == 0:
548 548 self.proExpLabel.setEnabled(False)
549 549 elif index == 1:
550 550 self.proExpLabel.setEnabled(True)
551 551
552 552 @pyqtSignature("")
553 553 def on_proToolPath_clicked(self):
554 554 """
555 555 Choose your path
556 556 """
557 557
558 558 current_dpath = './'
559 559 if self.dataPath:
560 560 current_dpath = self.dataPath
561 561
562 562 datapath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', current_dpath, QtGui.QFileDialog.ShowDirsOnly))
563 563
564 564 #If it was canceled
565 565 if not datapath:
566 566 return
567 567
568 568 #If any change was done
569 569 if datapath == self.dataPath:
570 570 return
571 571
572 572 self.proDataPath.setText(datapath)
573 573
574 574 self._disable_play_button()
575 575 self._disable_save_button()
576 576 self.proOk.setEnabled(False)
577 577
578 578 self.proComStartDate.clear()
579 579 self.proComEndDate.clear()
580 580
581 581 if not os.path.exists(datapath):
582 582
583 583 self.console.clear()
584 584 self.console.append("Write a valid path")
585 585 return
586 586
587 587 self.dataPath = datapath
588 588
589 589 self.console.clear()
590 590 self.console.append("Select the read mode and press 'load button'")
591 591
592 592
593 593 @pyqtSignature("")
594 594 def on_proLoadButton_clicked(self):
595 595
596 596 self.console.clear()
597 597
598 598 projectParms = self.__getParmsFromProjectWindow()
599 599
600 600 if not projectParms.online:
601 601 self.proComStartDate.clear()
602 602 self.proComEndDate.clear()
603 603 self.proComStartDate.setEnabled(True)
604 604 self.proComEndDate.setEnabled(True)
605 605 self.proStartTime.setEnabled(True)
606 606 self.proEndTime.setEnabled(True)
607 607 self.frame_2.setEnabled(True)
608 608
609 609 else:
610 610 self.proComStartDate.addItem("1960/01/30")
611 611 self.proComEndDate.addItem("2018/12/31")
612 612 self.proComStartDate.setEnabled(False)
613 613 self.proComEndDate.setEnabled(False)
614 614 self.proStartTime.setEnabled(False)
615 615 self.proEndTime.setEnabled(False)
616 616 self.frame_2.setEnabled(True)
617 617
618 618 if self.loadDays(projectParms.dpath, projectParms.ext, projectParms.walk, projectParms.expLabel) == []:
619 619 self._disable_save_button()
620 620 self._disable_play_button()
621 621 self.proOk.setEnabled(False)
622 622 else:
623 623 self._enable_save_button()
624 624 self._enable_play_button()
625 625 self.proOk.setEnabled(True)
626 626
627 627 @pyqtSignature("int")
628 628 def on_proComStartDate_activated(self, index):
629 629 """
630 630 SELECCION DEL RANGO DE FECHAS -START DATE
631 631 """
632 632 stopIndex = self.proComEndDate.count() - self.proComEndDate.currentIndex() - 1
633 633
634 634 self.proComEndDate.clear()
635 635 for i in self.dateList[index:]:
636 636 self.proComEndDate.addItem(i)
637 637
638 638 if self.proComEndDate.count() - stopIndex - 1 >= 0:
639 639 self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - stopIndex - 1)
640 640 else:
641 641 self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - 1)
642 642
643 643 @pyqtSignature("int")
644 644 def on_proComEndDate_activated(self, index):
645 645 """
646 646 SELECCION DEL RANGO DE FECHAS-END DATE
647 647 """
648 648 pass
649 649
650 650 @pyqtSignature("")
651 651 def on_proOk_clicked(self):
652 652 """
653 653 Añade al Obj XML de Projecto, name,datatype,date,time,readmode,wait,etc, crea el readUnitProcess del archivo xml.
654 654 Prepara la configuración del diágrama del Arbol del treeView numero 2
655 655 """
656 656
657 657 self._disable_play_button()
658 658 self._disable_save_button()
659 659
660 660 self.console.clear()
661 661
662 662 if self.create:
663 663
664 664 projectId = self.__getNewProjectId()
665 665
666 666 if not projectId:
667 667 return 0
668 668
669 669 projectObjView = self.createProjectView(projectId)
670 670
671 671 if not projectObjView:
672 672 return 0
673 673
674 674 self.create = False
675 675
676 676 readUnitObj = self.createReadUnitView(projectObjView)
677 677
678 678 if not readUnitObj:
679 679 return 0
680 680
681 681 else:
682 682 projectObjView = self.updateProjectView()
683 683
684 684 if not projectObjView:
685 685 return 0
686 686
687 687 projectId = projectObjView.getId()
688 688 idReadUnit = projectObjView.getReadUnitId()
689 689 readUnitObj = self.updateReadUnitView(projectObjView, idReadUnit)
690 690
691 691 if not readUnitObj:
692 692 return 0
693 693
694 694 self.__itemTreeDict[projectId].setText(projectObjView.name)
695 695 # Project Properties
696 696 self.refreshProjectProperties(projectObjView)
697 697 # Disable tabProject after finish the creation
698 698
699 699 self._enable_play_button()
700 700 self._enable_save_button()
701 701
702 702 self.console.clear()
703 703 self.console.append("The project parameters were validated")
704 704
705 705 return 1
706 706
707 707 @pyqtSignature("")
708 708 def on_proClear_clicked(self):
709 709
710 710 self.console.clear()
711 711
712 712 @pyqtSignature("int")
713 713 def on_volOpCebChannels_stateChanged(self, p0):
714 714 """
715 715 Check Box habilita operaciones de Selecci�n de Canales
716 716 """
717 717 if p0 == 2:
718 718 self.volOpComChannels.setEnabled(True)
719 719 self.volOpChannel.setEnabled(True)
720 720
721 721 if p0 == 0:
722 722 self.volOpComChannels.setEnabled(False)
723 723 self.volOpChannel.setEnabled(False)
724 724 # self.volOpChannel.clear()
725 725
726 726 @pyqtSignature("int")
727 727 def on_volOpCebHeights_stateChanged(self, p0):
728 728 """
729 729 Check Box habilita operaciones de Selecci�n de Alturas
730 730 """
731 731 if p0 == 2:
732 732 self.volOpHeights.setEnabled(True)
733 733 self.volOpComHeights.setEnabled(True)
734 734
735 735 if p0 == 0:
736 736 self.volOpHeights.setEnabled(False)
737 737 # self.volOpHeights.clear()
738 738 self.volOpComHeights.setEnabled(False)
739 739
740 740 @pyqtSignature("int")
741 741 def on_volOpCebSplitter_stateChanged(self, p0):
742 742 """
743 743 Name='Splitter', optype='other'
744 744 """
745 745 if p0 == 2:
746 746 self.volOpSplitter.setEnabled(True)
747 747
748 748 if p0 == 0:
749 749 self.volOpSplitter.setEnabled(False)
750 750
751 751 @pyqtSignature("int")
752 752 def on_volOpCebCombiner_stateChanged(self, p0):
753 753 """
754 754 Name='Combiner', optype='other'
755 755 """
756 756 if p0 == 2:
757 757 self.volOpCombiner.setEnabled(True)
758 758
759 759 if p0 == 0:
760 760 self.volOpCombiner.setEnabled(False)
761 761
762 762 @pyqtSignature("int")
763 763 def on_volOpCebFilter_stateChanged(self, p0):
764 764 """
765 765 Name='Decoder', optype='other'
766 766 """
767 767 if p0 == 2:
768 768 self.volOpFilter.setEnabled(True)
769 769
770 770 if p0 == 0:
771 771 self.volOpFilter.setEnabled(False)
772 772 # self.volOpFilter.clear()
773 773
774 774 @pyqtSignature("int")
775 775 def on_volOpCebProfile_stateChanged(self, p0):
776 776 """
777 777 Check Box habilita ingreso del rango de Perfiles
778 778 """
779 779 if p0 == 2:
780 780 self.volOpComProfile.setEnabled(True)
781 781 self.volOpProfile.setEnabled(True)
782 782
783 783 if p0 == 0:
784 784 self.volOpComProfile.setEnabled(False)
785 785 self.volOpProfile.setEnabled(False)
786 786 # self.volOpProfile.clear()
787 787
788 788 @pyqtSignature("int")
789 789 def on_volOpComProfile_activated(self, index):
790 790 """
791 791 Check Box habilita ingreso del rango de Perfiles
792 792 """
793 793 #Profile List
794 794 if index == 0:
795 795 self.volOpProfile.setToolTip('List of selected profiles. Example: 0, 1, 2, 3, 4, 5, 6, 7')
796 796
797 797 #Profile Range
798 798 if index == 1:
799 799 self.volOpProfile.setToolTip('Minimum and maximum profile index. Example: 0, 7')
800 800
801 801 #Profile Range List
802 802 if index == 2:
803 803 self.volOpProfile.setToolTip('List of profile ranges. Example: (0, 7), (12, 19), (100, 200)')
804 804
805 805 @pyqtSignature("int")
806 806 def on_volOpCebDecodification_stateChanged(self, p0):
807 807 """
808 808 Check Box habilita
809 809 """
810 810 if p0 == 2:
811 811 self.volOpComCode.setEnabled(True)
812 812 self.volOpComMode.setEnabled(True)
813 813 if p0 == 0:
814 814 self.volOpComCode.setEnabled(False)
815 815 self.volOpComMode.setEnabled(False)
816 816
817 817 @pyqtSignature("int")
818 818 def on_volOpComCode_activated(self, index):
819 819 """
820 820 Check Box habilita ingreso
821 821 """
822 822 if index == 13:
823 823 self.volOpCode.setEnabled(True)
824 824 else:
825 825 self.volOpCode.setEnabled(False)
826 826
827 827 if index == 0:
828 828 # code = ''
829 829 # self.volOpCode.setText(str(code))
830 830 return
831 831
832 832 if index == 1:
833 833 code = '(1,1,-1)'
834 834 nCode = '1'
835 835 nBaud = '3'
836 836 if index == 2:
837 837 code = '(1,1,-1,1)'
838 838 nCode = '1'
839 839 nBaud = '4'
840 840 if index == 3:
841 841 code = '(1,1,1,-1,1)'
842 842 nCode = '1'
843 843 nBaud = '5'
844 844 if index == 4:
845 845 code = '(1,1,1,-1,-1,1,-1)'
846 846 nCode = '1'
847 847 nBaud = '7'
848 848 if index == 5:
849 849 code = '(1,1,1,-1,-1,-1,1,-1,-1,1,-1)'
850 850 nCode = '1'
851 851 nBaud = '11'
852 852 if index == 6:
853 853 code = '(1,1,1,1,1,-1,-1,1,1,-1,1,-1,1)'
854 854 nCode = '1'
855 855 nBaud = '13'
856 856 if index == 7:
857 857 code = '(1,1,-1,-1,-1,1)'
858 858 nCode = '2'
859 859 nBaud = '3'
860 860 if index == 8:
861 861 code = '(1,1,-1,1,-1,-1,1,-1)'
862 862 nCode = '2'
863 863 nBaud = '4'
864 864 if index == 9:
865 865 code = '(1,1,1,-1,1,-1,-1,-1,1,-1)'
866 866 nCode = '2'
867 867 nBaud = '5'
868 868 if index == 10:
869 869 code = '(1,1,1,-1,-1,1,-1,-1,-1,-1,1,1,-1,1)'
870 870 nCode = '2'
871 871 nBaud = '7'
872 872 if index == 11:
873 873 code = '(1,1,1,-1,-1,-1,1,-1,-1,1,-1,-1 ,-1 ,-1 ,1 ,1,1,-1 ,1 ,1 ,-1 ,1)'
874 874 nCode = '2'
875 875 nBaud = '11'
876 876 if index == 12:
877 877 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)'
878 878 nCode = '2'
879 879 nBaud = '13'
880 880
881 881 code = ast.literal_eval(code)
882 882 nCode = int(nCode)
883 883 nBaud = int(nBaud)
884 884
885 885 code = numpy.asarray(code).reshape((nCode, nBaud)).tolist()
886 886
887 887 self.volOpCode.setText(str(code))
888 888
889 889 @pyqtSignature("int")
890 890 def on_volOpCebFlip_stateChanged(self, p0):
891 891 """
892 892 Check Box habilita ingresode del numero de Integraciones a realizar
893 893 """
894 894 if p0 == 2:
895 895 self.volOpFlip.setEnabled(True)
896 896 if p0 == 0:
897 897 self.volOpFlip.setEnabled(False)
898 898 # self.volOpFlip.clear()
899 899
900 900 @pyqtSignature("int")
901 901 def on_volOpCebCohInt_stateChanged(self, p0):
902 902 """
903 903 Check Box habilita ingresode del numero de Integraciones a realizar
904 904 """
905 905 if p0 == 2:
906 906 self.volOpCohInt.setEnabled(True)
907 907 if p0 == 0:
908 908 self.volOpCohInt.setEnabled(False)
909 909 # self.volOpCohInt.clear()
910 910
911 911 @pyqtSignature("int")
912 912 def on_volOpCebRadarfrequency_stateChanged(self, p0):
913 913 """
914 914 Check Box habilita ingresode del numero de Integraciones a realizar
915 915 """
916 916 if p0 == 2:
917 917 self.volOpRadarfrequency.setEnabled(True)
918 918 if p0 == 0:
919 919 self.volOpRadarfrequency.clear()
920 920 self.volOpRadarfrequency.setEnabled(False)
921 921
922 922 @pyqtSignature("")
923 923 def on_volOutputToolPath_clicked(self):
924 924 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
925 925 self.volOutputPath.setText(dirOutPath)
926 926
927 927 @pyqtSignature("")
928 928 def on_specOutputToolPath_clicked(self):
929 929 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
930 930 self.specOutputPath.setText(dirOutPath)
931 931
932 932 @pyqtSignature("")
933 933 def on_specHeisOutputToolPath_clicked(self):
934 934 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
935 935 self.specHeisOutputPath.setText(dirOutPath)
936 936
937 937 @pyqtSignature("")
938 938 def on_specHeisOutputMetadaToolPath_clicked(self):
939 939
940 940 filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open text file", self.pathWorkSpace, self.tr("Text Files (*.xml)")))
941 941 self.specHeisOutputMetada.setText(filename)
942 942
943 943 @pyqtSignature("")
944 944 def on_volOpOk_clicked(self):
945 945 """
946 946 BUSCA EN LA LISTA DE OPERACIONES DEL TIPO VOLTAJE Y LES A�ADE EL PARAMETRO ADECUADO ESPERANDO LA ACEPTACION DEL USUARIO
947 947 PARA AGREGARLO AL ARCHIVO DE CONFIGURACION XML
948 948 """
949 949
950 950 checkPath = False
951 951
952 952 self._disable_play_button()
953 953 self._disable_save_button()
954 954
955 955 self.console.clear()
956 956 self.console.append("Checking input parameters:\n")
957 957
958 958 puObj = self.getSelectedItemObj()
959 959 puObj.removeOperations()
960 960
961 961 if self.volOpCebRadarfrequency.isChecked():
962 962 value = str(self.volOpRadarfrequency.text())
963 963 format = 'float'
964 964 name_operation = 'setRadarFrequency'
965 965 name_parameter = 'frequency'
966 966
967 967 if not isFloat(value):
968 968 self.console.append("Invalid value '%s' for Radar Frequency" %value)
969 969 return 0
970 970
971 971 opObj = puObj.addOperation(name=name_operation)
972 972 opObj.addParameter(name=name_parameter, value=radarfreq, format=format)
973 973
974 974 if self.volOpCebChannels.isChecked():
975 975
976 976 format = 'intlist'
977 977 if self.volOpComChannels.currentIndex() == 0:
978 978 name_operation = "selectChannels"
979 979 name_parameter = 'channelList'
980 980 else:
981 981 name_operation = "selectChannelsByIndex"
982 982 name_parameter = 'channelIndexList'
983 983
984 984 value = str(self.volOpChannel.text())
985 985
986 986 if not isIntList(value):
987 987 self.console.append("Invalid value '%s' for %s" %(value,name_parameter))
988 988 return 0
989 989
990 990 opObj = puObj.addOperation(name=name_operation)
991 991 opObj.addParameter(name=name_parameter, value=value, format=format)
992 992
993 993 if self.volOpCebHeights.isChecked():
994 994 value = str(self.volOpHeights.text())
995 995
996 996 if not isFloatRange(value):
997 997 self.console.append("Invalid value '%s' for Height range" %value)
998 998 return 0
999 999
1000 1000 valueList = value.split(',')
1001 1001
1002 1002 if self.volOpComHeights.currentIndex() == 0:
1003 1003 format = 'float'
1004 1004 name_operation = 'selectHeights'
1005 1005 name_parameter1 = 'minHei'
1006 1006 name_parameter2 = 'maxHei'
1007 1007 else:
1008 1008 format = 'int'
1009 1009 name_operation = 'selectHeightsByIndex'
1010 1010 name_parameter1 = 'minIndex'
1011 1011 name_parameter2 = 'maxIndex'
1012 1012
1013 1013 opObj = puObj.addOperation(name=name_operation)
1014 1014 opObj.addParameter(name=name_parameter1, value=valueList[0], format=format)
1015 1015 opObj.addParameter(name=name_parameter2, value=valueList[1], format=format)
1016 1016
1017 1017 if self.volOpCebSplitter.isChecked():
1018 1018 value = str(self.volOpSplitter.text())
1019 1019
1020 1020 if not isInt(value):
1021 1021 self.console.append("Invalid value '%s' for Profile Splitter" %value)
1022 1022 return 0
1023 1023
1024 1024 opObj = puObj.addOperation(name="SplitProfiles", optype='external')
1025 1025 opObj.addParameter(name='n', value=value, format='int')
1026 1026
1027 1027 if self.volOpCebProfile.isChecked():
1028 1028 value = str(self.volOpProfile.text())
1029 1029
1030 1030 format = 'intlist'
1031 1031 optype = 'other'
1032 1032 name_operation = 'ProfileSelector'
1033 1033
1034 1034 if self.volOpComProfile.currentIndex() == 0:
1035 1035 name_parameter = 'profileList'
1036 1036 if self.volOpComProfile.currentIndex() == 1:
1037 1037 name_parameter = 'profileRangeList'
1038 1038 if self.volOpComProfile.currentIndex() == 2:
1039 1039 name_parameter = 'rangeList'
1040 1040
1041 1041 if not isIntList(value):
1042 1042 self.console.append("Invalid value '%s' for %s" %(value, name_parameter) )
1043 1043 return 0
1044 1044
1045 1045 opObj = puObj.addOperation(name='ProfileSelector', optype='other')
1046 1046 opObj.addParameter(name=name_parameter, value=value, format=format)
1047 1047
1048 1048 if self.volOpCebCombiner.isChecked():
1049 1049 value = str(self.volOpCombiner.text())
1050 1050
1051 1051 if not isInt(value):
1052 1052 self.console.append("Invalid value '%s' for Profile Combiner" %value)
1053 1053 return 0
1054 1054
1055 1055 opObj = puObj.addOperation(name="CombineProfiles", optype='external')
1056 1056 opObj.addParameter(name='n', value=value, format='int')
1057 1057
1058 1058 if self.volOpCebFilter.isChecked():
1059 1059 value = str(self.volOpFilter.text())
1060 1060
1061 1061 if not isInt(value):
1062 1062 self.console.append("Invalid value '%s' for Filter" %value)
1063 1063 return 0
1064 1064
1065 1065 format = 'int'
1066 1066 name_operation = 'filterByHeights'
1067 1067 name_parameter = 'window'
1068 1068 opObj = puObj.addOperation(name=name_operation)
1069 1069 opObj.addParameter(name=name_parameter, value=value, format=format)
1070 1070
1071 1071 if self.volOpCebDecodification.isChecked():
1072 1072 name_operation = 'Decoder'
1073 1073 opObj = puObj.addOperation(name=name_operation, optype='other')
1074 1074
1075 1075 if self.volOpComCode.currentIndex() != 0:
1076 1076
1077 1077 code = str(self.volOpCode.text())
1078 1078
1079 1079 if not isMultiList(code):
1080 1080 self.console.append("Please write a valid Code (Example: [1,1,-1], [1,-1,1])")
1081 1081 return 0
1082 1082
1083 1083 real_code = getCode(code)
1084 1084 nCode = len(real_code)
1085 1085 nBaud = len(real_code[0])
1086 1086
1087 1087 opObj.addParameter(name='code', value=code, format='intlist')
1088 1088 opObj.addParameter(name='nCode', value=nCode, format='int')
1089 1089 opObj.addParameter(name='nBaud', value=nBaud, format='int')
1090 1090
1091 1091 name_parameter = 'mode'
1092 1092 format = 'int'
1093 1093 value = str(self.volOpComMode.currentIndex())
1094 1094
1095 1095 opObj.addParameter(name=name_parameter, value=value, format=format)
1096 1096
1097 1097
1098 1098 if self.volOpCebFlip.isChecked():
1099 1099 name_operation = 'deFlip'
1100 1100 optype = 'self'
1101 1101
1102 1102 opObj = puObj.addOperation(name=name_operation, optype=optype)
1103 1103
1104 1104 value = str(self.volOpFlip.text())
1105 1105
1106 1106 if value:
1107 1107
1108 1108 name_parameter = 'channelList'
1109 1109 format = 'intlist'
1110 1110
1111 1111 if not isIntList(value):
1112 1112 self.console.append("Invalid value '%s' for '%s'" %(value,name_parameter))
1113 1113 return 0
1114 1114
1115 1115 opObj.addParameter(name=name_parameter, value=value, format=format)
1116 1116
1117 1117 if self.volOpCebCohInt.isChecked():
1118 1118 name_operation = 'CohInt'
1119 1119 optype = 'other'
1120 1120 value = str(self.volOpCohInt.text())
1121 1121
1122 1122 if not isInt(value):
1123 1123 self.console.append("Invalid value '%s' for '%s'" %(value,name_parameter))
1124 1124 return 0
1125 1125
1126 1126 name_parameter = 'n'
1127 1127 format = 'int'
1128 1128
1129 1129 opObj = puObj.addOperation(name=name_operation, optype=optype)
1130 1130 opObj.addParameter(name=name_parameter, value=value, format=format)
1131 1131
1132 1132 if self.volGraphCebshow.isChecked():
1133 1133 name_operation = 'Scope'
1134 1134 optype = 'other'
1135 1135
1136 1136 name_parameter1 = 'id'
1137 1137 format1 = 'int'
1138 1138
1139 1139 opObj = puObj.addOperation(name=name_operation, optype=optype)
1140 1140 opObj.addParameter(name=name_parameter1, value=opObj.id, format=format1)
1141 1141
1142 1142 channelList = str(self.volGraphChannelList.text()).strip()
1143 1143 xvalue = str(self.volGraphHeightrange.text()).strip()
1144 1144 yvalue = str(self.volGraphIntensityRange.text()).strip()
1145 1145 figpath = str(self.volGraphPath.text()).strip()
1146 1146 figfile = str(self.volGraphPrefix.text()).strip()
1147 1147
1148 1148 if channelList != "":
1149 1149 if not isIntList(channelList):
1150 1150 self.console.append("Invalid value '%s' for 'Graphics:ChannelList'" %(channelList))
1151 1151 return 0
1152 1152
1153 1153 if xvalue != "":
1154 1154 if not isFloatRange(xvalue):
1155 1155 self.console.append("Invalid value '%s' for 'Graphics:Height-Range'" %(xvalue))
1156 1156 return 0
1157 1157
1158 1158 if yvalue != "":
1159 1159 if not isFloatRange(yvalue):
1160 1160 self.console.append("Invalid value '%s' for 'Graphics:Amplitude-Range'" %(yvalue))
1161 1161 return 0
1162 1162
1163 1163
1164 1164 if channelList:
1165 1165 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1166 1166
1167 1167 if xvalue:
1168 1168 xvalueList = xvalue.split(',')
1169 1169
1170 1170 opObj.addParameter(name='xmin', value=xvalueList[0], format='float')
1171 1171 opObj.addParameter(name='xmax', value=xvalueList[1], format='float')
1172 1172
1173 1173 if yvalue:
1174 1174 yvalueList = yvalue.split(",")
1175 1175
1176 1176 opObj.addParameter(name='ymin', value=yvalueList[0], format='int')
1177 1177 opObj.addParameter(name='ymax', value=yvalueList[1], format='int')
1178 1178
1179 1179 plot_type = self.volComScopeType.currentIndex()
1180 1180
1181 1181 if plot_type == 0:
1182 1182 opObj.addParameter(name='type', value="iq")
1183 1183 if plot_type == 1:
1184 1184 opObj.addParameter(name='type', value="power")
1185 1185
1186 1186 if self.volGraphCebSave.isChecked():
1187 1187 checkPath = True
1188 1188
1189 1189 opObj.addParameter(name='save', value='1', format='int')
1190 1190 opObj.addParameter(name='figpath', value=figpath, format='str')
1191 1191
1192 1192 if figfile:
1193 1193 opObj.addParameter(name='figfile', value=value, format='str')
1194 1194
1195 1195 if checkPath:
1196 1196
1197 1197 if not figpath:
1198 1198 self.console.clear()
1199 1199 self.console.append("Graphic path should be defined")
1200 1200 return 0
1201 1201
1202 1202 # if os.path.isdir(figpath):
1203 1203 # self.console.clear()
1204 1204 # self.console.append("Graphic path does not exist, it has to be created")
1205 1205 # return 0
1206 1206
1207 1207 self.console.clear()
1208 1208
1209 1209 # if something happend
1210 1210 parms_ok, output_path, blocksperfile, profilesperblock = self.checkInputsPUSave(datatype='Voltage')
1211 1211 if parms_ok:
1212 1212 name_operation = 'VoltageWriter'
1213 1213 optype = 'other'
1214 1214 name_parameter1 = 'path'
1215 1215 name_parameter2 = 'blocksPerFile'
1216 1216 name_parameter3 = 'profilesPerBlock'
1217 1217 value1 = output_path
1218 1218 value2 = blocksperfile
1219 1219 value3 = profilesperblock
1220 1220 format = "int"
1221 1221 opObj = puObj.addOperation(name=name_operation, optype=optype)
1222 1222 opObj.addParameter(name=name_parameter1, value=value1)
1223 1223 opObj.addParameter(name=name_parameter2, value=value2, format=format)
1224 1224 opObj.addParameter(name=name_parameter3, value=value3, format=format)
1225 1225
1226 1226 try:
1227 1227 self.refreshPUProperties(puObj)
1228 1228 except:
1229 1229 self.console.append("An error reading input parameters was found ...Check them!")
1230 1230 return 0
1231 1231
1232 1232 self.console.append("Save your project and press Play button to start signal processing")
1233 1233
1234 1234 self._enable_play_button()
1235 1235 self._enable_save_button()
1236 1236
1237 1237 return 1
1238 1238
1239 1239 @pyqtSignature("")
1240 1240 def on_volGraphClear_clicked(self):
1241 1241
1242 1242 self.console.clear()
1243 1243
1244 1244 """
1245 1245 Voltage Graph
1246 1246 """
1247 1247 @pyqtSignature("int")
1248 1248 def on_volGraphCebSave_stateChanged(self, p0):
1249 1249 """
1250 1250 Check Box habilita ingresode del numero de Integraciones a realizar
1251 1251 """
1252 1252 if p0 == 2:
1253 1253 self.volGraphPath.setEnabled(True)
1254 1254 self.volGraphPrefix.setEnabled(True)
1255 1255 self.volGraphToolPath.setEnabled(True)
1256 1256
1257 1257 if p0 == 0:
1258 1258 self.volGraphPath.setEnabled(False)
1259 1259 self.volGraphPrefix.setEnabled(False)
1260 1260 self.volGraphToolPath.setEnabled(False)
1261 1261
1262 1262 @pyqtSignature("")
1263 1263 def on_volGraphToolPath_clicked(self):
1264 1264 """
1265 1265 Donde se guardan los DATOS
1266 1266 """
1267 1267 save_path = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
1268 1268 self.volGraphPath.setText(save_path)
1269 1269
1270 1270 if not os.path.exists(save_path):
1271 1271 self.console.clear()
1272 1272 self.console.append("Set a valid path")
1273 1273 self.volGraphOk.setEnabled(False)
1274 1274 return
1275 1275
1276 1276 @pyqtSignature("int")
1277 1277 def on_volGraphCebshow_stateChanged(self, p0):
1278 1278 """
1279 1279 Check Box habilita ingresode del numero de Integraciones a realizar
1280 1280 """
1281 1281 if p0 == 0:
1282 1282
1283 1283 self.volGraphChannelList.setEnabled(False)
1284 1284 self.volGraphIntensityRange.setEnabled(False)
1285 1285 self.volGraphHeightrange.setEnabled(False)
1286 1286 if p0 == 2:
1287 1287
1288 1288 self.volGraphChannelList.setEnabled(True)
1289 1289 self.volGraphIntensityRange.setEnabled(True)
1290 1290 self.volGraphHeightrange.setEnabled(True)
1291 1291
1292 1292 """
1293 1293 Spectra operation
1294 1294 """
1295 1295 @pyqtSignature("int")
1296 1296 def on_specOpCebRadarfrequency_stateChanged(self, p0):
1297 1297 """
1298 1298 Check Box habilita ingresode del numero de Integraciones a realizar
1299 1299 """
1300 1300 if p0 == 2:
1301 1301 self.specOpRadarfrequency.setEnabled(True)
1302 1302 if p0 == 0:
1303 1303 # self.specOpRadarfrequency.clear()
1304 1304 self.specOpRadarfrequency.setEnabled(False)
1305 1305
1306 1306
1307 1307 @pyqtSignature("int")
1308 1308 def on_specOpCebCrossSpectra_stateChanged(self, p0):
1309 1309 """
1310 1310 Habilita la opcion de a�adir el par�metro CrossSpectra a la Unidad de Procesamiento .
1311 1311 """
1312 1312 if p0 == 2:
1313 1313 # self.specOpnFFTpoints.setEnabled(True)
1314 1314 self.specOpComCrossSpectra.setEnabled(True)
1315 1315 self.specOppairsList.setEnabled(True)
1316 1316
1317 1317 if p0 == 0:
1318 1318 # self.specOpnFFTpoints.setEnabled(False)
1319 1319 self.specOpComCrossSpectra.setEnabled(False)
1320 1320 self.specOppairsList.setEnabled(False)
1321 1321
1322 1322 @pyqtSignature("int")
1323 1323 def on_specOpCebChannel_stateChanged(self, p0):
1324 1324 """
1325 1325 Habilita la opcion de a�adir el par�metro numero de Canales a la Unidad de Procesamiento .
1326 1326 """
1327 1327 if p0 == 2:
1328 1328 self.specOpChannel.setEnabled(True)
1329 1329 self.specOpComChannel.setEnabled(True)
1330 1330 if p0 == 0:
1331 1331 self.specOpChannel.setEnabled(False)
1332 1332 self.specOpComChannel.setEnabled(False)
1333 1333
1334 1334 @pyqtSignature("int")
1335 1335 def on_specOpCebHeights_stateChanged(self, p0):
1336 1336 """
1337 1337 Habilita la opcion de a�adir el par�metro de alturas a la Unidad de Procesamiento .
1338 1338 """
1339 1339 if p0 == 2:
1340 1340 self.specOpComHeights.setEnabled(True)
1341 1341 self.specOpHeights.setEnabled(True)
1342 1342 if p0 == 0:
1343 1343 self.specOpComHeights.setEnabled(False)
1344 1344 self.specOpHeights.setEnabled(False)
1345 1345
1346 1346
1347 1347 @pyqtSignature("int")
1348 1348 def on_specOpCebIncoherent_stateChanged(self, p0):
1349 1349 """
1350 1350 Habilita la opcion de a�adir el par�metro integraciones incoherentes a la Unidad de Procesamiento .
1351 1351 """
1352 1352 if p0 == 2:
1353 1353 self.specOpIncoherent.setEnabled(True)
1354 1354 if p0 == 0:
1355 1355 self.specOpIncoherent.setEnabled(False)
1356 1356
1357 1357 @pyqtSignature("int")
1358 1358 def on_specOpCebRemoveDC_stateChanged(self, p0):
1359 1359 """
1360 1360 Habilita la opcion de a�adir el par�metro remover DC a la Unidad de Procesamiento .
1361 1361 """
1362 1362 if p0 == 2:
1363 1363 self.specOpComRemoveDC.setEnabled(True)
1364 1364 if p0 == 0:
1365 1365 self.specOpComRemoveDC.setEnabled(False)
1366 1366
1367 1367 @pyqtSignature("int")
1368 1368 def on_specOpCebgetNoise_stateChanged(self, p0):
1369 1369 """
1370 1370 Habilita la opcion de a�adir la estimacion de ruido a la Unidad de Procesamiento .
1371 1371 """
1372 1372 if p0 == 2:
1373 1373 self.specOpgetNoise.setEnabled(True)
1374 1374
1375 1375 if p0 == 0:
1376 1376 self.specOpgetNoise.setEnabled(False)
1377 1377
1378 1378 @pyqtSignature("")
1379 1379 def on_specOpOk_clicked(self):
1380 1380 """
1381 1381 AÑADE OPERACION SPECTRA
1382 1382 """
1383 1383
1384 1384 addFTP = False
1385 1385 checkPath = False
1386 1386
1387 1387 self._disable_play_button()
1388 1388 self._disable_save_button()
1389 1389
1390 1390 self.console.clear()
1391 1391 self.console.append("Checking input parameters:\n")
1392 1392
1393 1393 projectObj = self.getSelectedProjectObj()
1394 1394
1395 1395 if not projectObj:
1396 1396 self.console.append("Please select a project before update it")
1397 1397 return
1398 1398
1399 1399 puObj = self.getSelectedItemObj()
1400 1400
1401 1401 puObj.removeOperations()
1402 1402
1403 1403 if self.specOpCebRadarfrequency.isChecked():
1404 1404 value = str(self.specOpRadarfrequency.text())
1405 1405 format = 'float'
1406 1406 name_operation = 'setRadarFrequency'
1407 1407 name_parameter = 'frequency'
1408 1408
1409 1409 if not isFloat(value):
1410 1410 self.console.clear()
1411 1411 self.console.append("Invalid value [%s] for '%s'" %(value, name_parameter))
1412 1412 return 0
1413 1413
1414 1414 radarfreq = float(value)*1e6
1415 1415 opObj = puObj.addOperation(name=name_operation)
1416 1416 opObj.addParameter(name=name_parameter, value=radarfreq, format=format)
1417 1417
1418 1418 inputId = puObj.getInputId()
1419 1419 inputPuObj = projectObj.getProcUnitObj(inputId)
1420 1420
1421 1421 if inputPuObj.datatype == 'Voltage' or inputPuObj.datatype == 'USRP':
1422 1422
1423 1423 value = str(self.specOpnFFTpoints.text())
1424 1424
1425 1425 if not isInt(value):
1426 1426 self.console.append("Invalid value [%s] for '%s'" %(value, 'nFFTPoints'))
1427 1427 return 0
1428 1428
1429 1429 puObj.addParameter(name='nFFTPoints', value=value, format='int')
1430 1430
1431 1431 value = str(self.specOpProfiles.text())
1432 1432 if not isInt(value):
1433 1433 self.console.append("Please write a value on Profiles field")
1434 1434 else:
1435 1435 puObj.addParameter(name='nProfiles', value=value, format='int')
1436 1436
1437 1437 value = str(self.specOpippFactor.text())
1438 1438 if not isInt(value):
1439 1439 self.console.append("Please write a value on IppFactor field")
1440 1440 else:
1441 1441 puObj.addParameter(name='ippFactor' , value=value , format='int')
1442 1442
1443 1443 if self.specOpCebCrossSpectra.isChecked():
1444 1444 name_parameter = 'pairsList'
1445 1445 format = 'pairslist'
1446 1446 value = str(self.specOppairsList.text())
1447 1447
1448 1448 if not isPairList(value):
1449 1449 self.console.append("Invalid value [%s] for '%s'" %(value, name_parameter))
1450 1450 return 0
1451 1451
1452 1452 puObj.addParameter(name=name_parameter, value=value, format=format)
1453 1453
1454 1454 if self.specOpCebHeights.isChecked():
1455 1455 value = str(self.specOpHeights.text())
1456 1456
1457 1457 if not isFloatRange(value):
1458 1458 self.console.append("Invalid value [%s] for Height range" %value)
1459 1459 return 0
1460 1460
1461 1461 valueList = value.split(',')
1462 1462 value0 = valueList[0]
1463 1463 value1 = valueList[1]
1464 1464
1465 1465 if self.specOpComHeights.currentIndex() == 0:
1466 1466 name_operation = 'selectHeights'
1467 1467 name_parameter1 = 'minHei'
1468 1468 name_parameter2 = 'maxHei'
1469 1469 else:
1470 1470 name_operation = 'selectHeightsByIndex'
1471 1471 name_parameter1 = 'minIndex'
1472 1472 name_parameter2 = 'maxIndex'
1473 1473
1474 1474 format = 'float'
1475 1475
1476 1476 opObj = puObj.addOperation(name=name_operation)
1477 1477 opObj.addParameter(name=name_parameter1, value=value0, format=format)
1478 1478 opObj.addParameter(name=name_parameter2, value=value1, format=format)
1479 1479
1480 1480 if self.specOpCebChannel.isChecked():
1481 1481
1482 1482 if self.specOpComChannel.currentIndex() == 0:
1483 1483 name_operation = "selectChannels"
1484 1484 name_parameter = 'channelList'
1485 1485 else:
1486 1486 name_operation = "selectChannelsByIndex"
1487 1487 name_parameter = 'channelIndexList'
1488 1488
1489 1489 format = 'intlist'
1490 1490 value = str(self.specOpChannel.text())
1491 1491
1492 1492 if not isIntList(value):
1493 1493 self.console.append("Invalid value [%s] for '%s'" %(value, name_parameter))
1494 1494 return 0
1495 1495
1496 1496 opObj = puObj.addOperation(name=name_operation)
1497 1497 opObj.addParameter(name=name_parameter, value=value, format=format)
1498 1498
1499 1499 if self.specOpCebIncoherent.isChecked():
1500 1500
1501 1501 name_operation = 'IncohInt'
1502 1502 optype = 'other'
1503 1503
1504 1504 if self.specOpCobIncInt.currentIndex() == 0:
1505 1505 name_parameter = 'timeInterval'
1506 1506 format = 'float'
1507 1507 else:
1508 1508 name_parameter = 'n'
1509 1509 format = 'int'
1510 1510
1511 1511 value = str(self.specOpIncoherent.text())
1512 1512
1513 1513 if not isFloat(value):
1514 1514 self.console.append("Invalid value [%s] for '%s'" %(value, name_parameter))
1515 1515 return 0
1516 1516
1517 1517 opObj = puObj.addOperation(name=name_operation, optype=optype)
1518 1518 opObj.addParameter(name=name_parameter, value=value, format=format)
1519 1519
1520 1520 if self.specOpCebRemoveDC.isChecked():
1521 1521 name_operation = 'removeDC'
1522 1522 name_parameter = 'mode'
1523 1523 format = 'int'
1524 1524
1525 1525 if self.specOpComRemoveDC.currentIndex() == 0:
1526 1526 value = 1
1527 1527 else:
1528 1528 value = 2
1529 1529
1530 1530 opObj = puObj.addOperation(name=name_operation)
1531 1531 opObj.addParameter(name=name_parameter, value=value, format=format)
1532 1532
1533 1533 if self.specOpCebRemoveInt.isChecked():
1534 1534 name_operation = 'removeInterference'
1535 1535 opObj = puObj.addOperation(name=name_operation)
1536 1536
1537 1537
1538 1538 if self.specOpCebgetNoise.isChecked():
1539 1539 value = str(self.specOpgetNoise.text())
1540 1540 valueList = value.split(',')
1541 1541 format = 'float'
1542 1542 name_operation = "getNoise"
1543 1543 opObj = puObj.addOperation(name=name_operation)
1544 1544
1545 1545 if not value == '':
1546 1546 valueList = value.split(',')
1547 1547 length = len(valueList)
1548 1548 if length == 1:
1549 1549 try:
1550 1550 value1 = float(valueList[0])
1551 1551 except:
1552 1552 self.console.clear()
1553 1553 self.console.append("Please Write correct parameter Get Noise")
1554 1554 return 0
1555 1555 name1 = 'minHei'
1556 1556 opObj.addParameter(name=name1, value=value1, format=format)
1557 1557 elif length == 2:
1558 1558 try:
1559 1559 value1 = float(valueList[0])
1560 1560 value2 = float(valueList[1])
1561 1561 except:
1562 1562 self.console.clear()
1563 1563 self.console.append("Please Write corrects parameter Get Noise")
1564 1564 return 0
1565 1565 name1 = 'minHei'
1566 1566 name2 = 'maxHei'
1567 1567 opObj.addParameter(name=name1, value=value1, format=format)
1568 1568 opObj.addParameter(name=name2, value=value2, format=format)
1569 1569
1570 1570 elif length == 3:
1571 1571 try:
1572 1572 value1 = float(valueList[0])
1573 1573 value2 = float(valueList[1])
1574 1574 value3 = float(valueList[2])
1575 1575 except:
1576 1576 self.console.clear()
1577 1577 self.console.append("Please Write corrects parameter Get Noise")
1578 1578 return 0
1579 1579 name1 = 'minHei'
1580 1580 name2 = 'maxHei'
1581 1581 name3 = 'minVel'
1582 1582 opObj.addParameter(name=name1, value=value1, format=format)
1583 1583 opObj.addParameter(name=name2, value=value2, format=format)
1584 1584 opObj.addParameter(name=name3, value=value3, format=format)
1585 1585
1586 1586 elif length == 4:
1587 1587 try:
1588 1588 value1 = float(valueList[0])
1589 1589 value2 = float(valueList[1])
1590 1590 value3 = float(valueList[2])
1591 1591 value4 = float(valueList[3])
1592 1592 except:
1593 1593 self.console.clear()
1594 1594 self.console.append("Please Write corrects parameter Get Noise")
1595 1595 return 0
1596 1596 name1 = 'minHei'
1597 1597 name2 = 'maxHei'
1598 1598 name3 = 'minVel'
1599 1599 name4 = 'maxVel'
1600 1600 opObj.addParameter(name=name1, value=value1, format=format)
1601 1601 opObj.addParameter(name=name2, value=value2, format=format)
1602 1602 opObj.addParameter(name=name3, value=value3, format=format)
1603 1603 opObj.addParameter(name=name4, value=value4, format=format)
1604 1604
1605 1605 elif length > 4:
1606 1606 self.console.clear()
1607 1607 self.console.append("Get Noise Operation only accepts 4 parameters")
1608 1608 return 0
1609 1609
1610 1610 channelList = str(self.specGgraphChannelList.text()).strip()
1611 1611 vel_range = str(self.specGgraphFreq.text()).strip()
1612 1612 hei_range = str(self.specGgraphHeight.text()).strip()
1613 1613 db_range = str(self.specGgraphDbsrange.text()).strip()
1614 1614
1615 1615 trange = str(self.specGgraphTminTmax.text()).strip()
1616 1616 magrange = str(self.specGgraphmagnitud.text()).strip()
1617 1617 phaserange = str(self.specGgraphPhase.text()).strip()
1618 1618 timerange = str(self.specGgraphTimeRange.text()).strip()
1619 1619
1620 1620 figpath = str(self.specGraphPath.text()).strip()
1621 1621 figfile = str(self.specGraphPrefix.text()).strip()
1622 1622
1623 1623 try:
1624 1624 wrperiod = int(str(self.specGgraphftpratio.text()).strip())
1625 1625 except:
1626 1626 wrperiod = None
1627 1627
1628 1628 #-----Spectra Plot-----
1629 1629 if self.specGraphCebSpectraplot.isChecked() or self.specGraphSaveSpectra.isChecked():
1630 1630
1631 1631 opObj = puObj.addOperation(name='SpectraPlot', optype='other')
1632 1632 opObj.addParameter(name='id', value=opObj.id, format='int')
1633 1633
1634 1634 if channelList:
1635 1635
1636 1636 if not isList(channelList):
1637 1637 self.console.append("Invalid value [%s] for 'Graphic:ChannelList" %(channelList))
1638 1638 return 0
1639 1639
1640 1640 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1641 1641
1642 1642 if vel_range:
1643 1643
1644 1644 if not isFloatRange(vel_range):
1645 1645 self.console.append("Invalid value [%s] for 'Graphic:Velocity-Range" %(vel_range))
1646 1646 return 0
1647 1647
1648 1648 xvalueList = vel_range.split(',')
1649 1649 value1 = float(xvalueList[0])
1650 1650 value2 = float(xvalueList[1])
1651 1651
1652 1652 opObj.addParameter(name='xmin', value=value1, format='float')
1653 1653 opObj.addParameter(name='xmax', value=value2, format='float')
1654 1654
1655 1655 if hei_range:
1656 1656
1657 1657 if not isFloatRange(hei_range):
1658 1658 self.console.append("Invalid value [%s] for 'Graphic:Height-Range" %(hei_range))
1659 1659 return 0
1660 1660
1661 1661 yvalueList = hei_range.split(",")
1662 1662 value1 = float(yvalueList[0])
1663 1663 value2 = float(yvalueList[1])
1664 1664
1665 1665 opObj.addParameter(name='ymin', value=value1, format='float')
1666 1666 opObj.addParameter(name='ymax', value=value2, format='float')
1667 1667
1668 1668 if db_range:
1669 1669
1670 1670 if not isFloatRange(db_range):
1671 1671 self.console.append("Invalid value [%s] for 'Graphic:dB-Range" %(db_range))
1672 1672 return 0
1673 1673
1674 1674 zvalueList = db_range.split(",")
1675 1675 value1 = float(zvalueList[0])
1676 1676 value2 = float(zvalueList[1])
1677 1677
1678 1678 opObj.addParameter(name='zmin', value=value1, format='float')
1679 1679 opObj.addParameter(name='zmax', value=value2, format='float')
1680 1680
1681 1681 if not self.specGraphCebSpectraplot.isChecked():
1682 1682
1683 1683 opObj.addParameter(name='show', value=0 , format='bool')
1684 1684
1685 1685 if self.specGraphSaveSpectra.isChecked():
1686 1686
1687 1687 checkPath = True
1688 1688 opObj.addParameter(name='save', value=1 , format='bool')
1689 1689 opObj.addParameter(name='figpath', value=figpath, format='str')
1690 1690 if figfile:
1691 1691 opObj.addParameter(name='figfile', value=figfile, format='str')
1692 1692 if wrperiod:
1693 1693 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1694 1694
1695 1695 if self.specGraphftpSpectra.isChecked():
1696 1696
1697 1697 opObj.addParameter(name='ftp', value='1', format='int')
1698 1698 self.addFTPConf2Operation(puObj, opObj)
1699 1699 addFTP = True
1700 1700
1701 1701 if self.specGraphCebCrossSpectraplot.isChecked() or self.specGraphSaveCross.isChecked():
1702 1702
1703 1703 opObj = puObj.addOperation(name='CrossSpectraPlot', optype='other')
1704 1704 opObj.addParameter(name='id', value=opObj.id, format='int')
1705 1705
1706 1706 if vel_range:
1707 1707
1708 1708 if not isFloatRange(vel_range):
1709 1709 self.console.append("Invalid value [%s] for 'Graphic:Velocity-Range" %(vel_range))
1710 1710 return 0
1711 1711
1712 1712 xvalueList = vel_range.split(',')
1713 1713 value1 = float(xvalueList[0])
1714 1714 value2 = float(xvalueList[1])
1715 1715
1716 1716 opObj.addParameter(name='xmin', value=value1, format='float')
1717 1717 opObj.addParameter(name='xmax', value=value2, format='float')
1718 1718
1719 1719 if hei_range:
1720 1720
1721 1721 if not isFloatRange(hei_range):
1722 1722 self.console.append("Invalid value [%s] for 'Graphic:Height-Range" %(hei_range))
1723 1723 return 0
1724 1724
1725 1725 yvalueList = hei_range.split(",")
1726 1726 value1 = float(yvalueList[0])
1727 1727 value2 = float(yvalueList[1])
1728 1728
1729 1729 opObj.addParameter(name='ymin', value=value1, format='float')
1730 1730 opObj.addParameter(name='ymax', value=value2, format='float')
1731 1731
1732 1732 if db_range:
1733 1733
1734 1734 if not isFloatRange(db_range):
1735 1735 self.console.append("Invalid value [%s] for 'Graphic:dB-Range" %(db_range))
1736 1736 return 0
1737 1737
1738 1738 zvalueList = db_range.split(",")
1739 1739 value1 = float(zvalueList[0])
1740 1740 value2 = float(zvalueList[1])
1741 1741
1742 1742 opObj.addParameter(name='zmin', value=value1, format='float')
1743 1743 opObj.addParameter(name='zmax', value=value2, format='float')
1744 1744
1745 1745 if magrange:
1746 1746
1747 1747 if not isFloatRange(magrange):
1748 1748 self.console.append("Invalid value [%s] for 'Graphic:Magnitud-Range" %(magrange))
1749 1749 return 0
1750 1750
1751 1751 zvalueList = magrange.split(",")
1752 1752 value1 = float(zvalueList[0])
1753 1753 value2 = float(zvalueList[1])
1754 1754
1755 1755 opObj.addParameter(name='coh_min', value=value1, format='float')
1756 1756 opObj.addParameter(name='coh_max', value=value2, format='float')
1757 1757
1758 1758 if phaserange:
1759 1759
1760 1760 if not isFloatRange(phaserange):
1761 1761 self.console.append("Invalid value [%s] for 'Graphic:Phase-Range" %(phaserange))
1762 1762 return 0
1763 1763
1764 1764 zvalueList = phaserange.split(",")
1765 1765 value1 = float(zvalueList[0])
1766 1766 value2 = float(zvalueList[1])
1767 1767
1768 1768 opObj.addParameter(name='phase_min', value=value1, format='float')
1769 1769 opObj.addParameter(name='phase_max', value=value2, format='float')
1770 1770
1771 1771 if not self.specGraphCebCrossSpectraplot.isChecked():
1772 1772
1773 1773 opObj.addParameter(name='show', value=0 , format='bool')
1774 1774
1775 1775 if self.specGraphSaveCross.isChecked():
1776 1776
1777 1777 checkPath = True
1778 1778 opObj.addParameter(name='save', value='1', format='bool')
1779 1779 opObj.addParameter(name='figpath', value=figpath, format='str')
1780 1780 if figfile:
1781 1781 opObj.addParameter(name='figfile', value=figfile, format='str')
1782 1782 if wrperiod:
1783 1783 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1784 1784
1785 1785 if self.specGraphftpCross.isChecked():
1786 1786
1787 1787 opObj.addParameter(name='ftp', value='1', format='int')
1788 1788 self.addFTPConf2Operation(puObj, opObj)
1789 1789 addFTP = True
1790 1790
1791 1791 if self.specGraphCebRTIplot.isChecked() or self.specGraphSaveRTIplot.isChecked():
1792 1792
1793 1793 opObj = puObj.addOperation(name='RTIPlot', optype='other')
1794 1794 opObj.addParameter(name='id', value=opObj.id, format='int')
1795 1795
1796 1796 if channelList:
1797 1797
1798 1798 if not isIntList(channelList):
1799 1799 self.console.append("Invalid value [%s] for 'Graphic:ChannelList" %(channelList))
1800 1800 return 0
1801 1801
1802 1802 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1803 1803
1804 1804 if trange:
1805 1805
1806 1806 if not isFloatRange(trange):
1807 1807 self.console.append("Invalid value [%s] for 'Graphic:Time-Range" %(trange))
1808 1808 return 0
1809 1809
1810 1810 zvalueList = trange.split(",")
1811 1811 value1 = float(zvalueList[0])
1812 1812 value2 = float(zvalueList[1])
1813 1813
1814 1814 opObj.addParameter(name='xmin', value=value1, format='float')
1815 1815 opObj.addParameter(name='xmax', value=value2, format='float')
1816 1816
1817 1817 if timerange:
1818 1818 try:
1819 1819 timerange = int(timerange)
1820 1820 except:
1821 1821 return 0
1822 1822 opObj.addParameter(name='timerange', value=timerange, format='int')
1823 1823
1824 1824 if hei_range:
1825 1825
1826 1826 if not isFloatRange(hei_range):
1827 1827 self.console.append("Invalid value [%s] for 'Graphic:Height-Range" %(hei_range))
1828 1828 return 0
1829 1829
1830 1830 yvalueList = hei_range.split(",")
1831 1831 value1 = float(yvalueList[0])
1832 1832 value2 = float(yvalueList[1])
1833 1833
1834 1834 opObj.addParameter(name='ymin', value=value1, format='float')
1835 1835 opObj.addParameter(name='ymax', value=value2, format='float')
1836 1836
1837 1837 if db_range:
1838 1838
1839 1839 if not isFloatRange(db_range):
1840 1840 self.console.append("Invalid value [%s] for 'Graphic:dB-Range" %(db_range))
1841 1841 return 0
1842 1842
1843 1843 zvalueList = db_range.split(",")
1844 1844 value1 = float(zvalueList[0])
1845 1845 value2 = float(zvalueList[1])
1846 1846
1847 1847 opObj.addParameter(name='zmin', value=value1, format='float')
1848 1848 opObj.addParameter(name='zmax', value=value2, format='float')
1849 1849
1850 1850 if not self.specGraphCebRTIplot.isChecked():
1851 1851
1852 1852 opObj.addParameter(name='show', value=0 , format='bool')
1853 1853
1854 1854 if self.specGraphSaveRTIplot.isChecked():
1855 1855
1856 1856 checkPath = True
1857 1857 opObj.addParameter(name='save', value='1', format='bool')
1858 1858 opObj.addParameter(name='figpath', value=figpath, format='str')
1859 1859 if figfile:
1860 1860 opObj.addParameter(name='figfile', value=value, format='str')
1861 1861 if wrperiod:
1862 1862 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1863 1863
1864 1864 if self.specGraphftpRTIplot.isChecked():
1865 1865
1866 1866 opObj.addParameter(name='ftp', value='1', format='int')
1867 1867 self.addFTPConf2Operation(puObj, opObj)
1868 1868 addFTP = True
1869 1869
1870 1870 if self.specGraphCebCoherencmap.isChecked() or self.specGraphSaveCoherencemap.isChecked():
1871 1871
1872 1872 opObj = puObj.addOperation(name='CoherenceMap', optype='other')
1873 1873 opObj.addParameter(name='id', value=opObj.id, format='int')
1874 1874
1875 1875 if trange:
1876 1876
1877 1877 if not isFloatRange(trange):
1878 1878 self.console.append("Invalid value [%s] for 'Graphic:Time-Range" %(trange))
1879 1879 return 0
1880 1880
1881 1881 zvalueList = trange.split(",")
1882 1882 value1 = float(zvalueList[0])
1883 1883 value2 = float(zvalueList[1])
1884 1884
1885 1885 opObj.addParameter(name='xmin', value=value1, format='float')
1886 1886 opObj.addParameter(name='xmax', value=value2, format='float')
1887 1887
1888 1888 if hei_range:
1889 1889
1890 1890 if not isFloatRange(hei_range):
1891 1891 self.console.append("Invalid value [%s] for 'Graphic:Height-Range" %(hei_range))
1892 1892 return 0
1893 1893
1894 1894 yvalueList = hei_range.split(",")
1895 1895 value1 = float(yvalueList[0])
1896 1896 value2 = float(yvalueList[1])
1897 1897
1898 1898 opObj.addParameter(name='ymin', value=value1, format='float')
1899 1899 opObj.addParameter(name='ymax', value=value2, format='float')
1900 1900
1901 1901 if magrange:
1902 1902
1903 1903 if not isFloatRange(magrange):
1904 1904 self.console.append("Invalid value [%s] for 'Graphic:Magnitud-Range" %(magrange))
1905 1905 return 0
1906 1906
1907 1907 zvalueList = magrange.split(",")
1908 1908 value1 = float(zvalueList[0])
1909 1909 value2 = float(zvalueList[1])
1910 1910
1911 1911 opObj.addParameter(name='zmin', value=value1, format='float')
1912 1912 opObj.addParameter(name='zmax', value=value2, format='float')
1913 1913
1914 1914 if phaserange:
1915 1915
1916 1916 if not isFloatRange(phaserange):
1917 1917 self.console.append("Invalid value [%s] for 'Graphic:Phase-Range" %(phaserange))
1918 1918 return 0
1919 1919
1920 1920 zvalueList = phaserange.split(",")
1921 1921 value1 = float(zvalueList[0])
1922 1922 value2 = float(zvalueList[1])
1923 1923
1924 1924 opObj.addParameter(name='phase_min', value=value1, format='float')
1925 1925 opObj.addParameter(name='phase_max', value=value2, format='float')
1926 1926
1927 1927 if not self.specGraphCebCoherencmap.isChecked():
1928 1928 opObj.addParameter(name='show', value=0 , format='bool')
1929 1929
1930 1930 if self.specGraphSaveCoherencemap.isChecked():
1931 1931 checkPath = True
1932 1932 opObj.addParameter(name='save', value='1', format='bool')
1933 1933 opObj.addParameter(name='figpath', value=figpath, format='str')
1934 1934 if figfile:
1935 1935 opObj.addParameter(name='figfile', value=value, format='str')
1936 1936 if wrperiod:
1937 1937 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1938 1938
1939 1939 if self.specGraphftpCoherencemap.isChecked():
1940 1940 opObj.addParameter(name='ftp', value='1', format='int')
1941 1941 self.addFTPConf2Operation(puObj, opObj)
1942 1942 addFTP = True
1943 1943
1944 1944 if self.specGraphPowerprofile.isChecked() or self.specGraphSavePowerprofile.isChecked():
1945 1945
1946 1946 opObj = puObj.addOperation(name='PowerProfilePlot', optype='other')
1947 1947 opObj.addParameter(name='id', value=opObj.id, format='int')
1948 1948
1949 1949 if channelList:
1950 1950
1951 1951 if not isList(channelList):
1952 1952 self.console.append("Invalid value [%s] for 'Graphic:ChannelList" %(channelList))
1953 1953 return 0
1954 1954
1955 1955 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1956 1956
1957 1957 if hei_range:
1958 1958
1959 1959 if not isFloatRange(hei_range):
1960 1960 self.console.append("Invalid value [%s] for 'Graphic:Height-Range" %(hei_range))
1961 1961 return 0
1962 1962
1963 1963 yvalueList = hei_range.split(",")
1964 1964 value1 = float(yvalueList[0])
1965 1965 value2 = float(yvalueList[1])
1966 1966
1967 1967 opObj.addParameter(name='ymin', value=value1, format='float')
1968 1968 opObj.addParameter(name='ymax', value=value2, format='float')
1969 1969
1970 1970 if db_range:
1971 1971
1972 1972 if not isFloatRange(db_range):
1973 1973 self.console.append("Invalid value [%s] for 'Graphic:dB-Range" %(db_range))
1974 1974 return 0
1975 1975
1976 1976 zvalueList = db_range.split(",")
1977 1977 value1 = float(zvalueList[0])
1978 1978 value2 = float(zvalueList[1])
1979 1979
1980 1980 opObj.addParameter(name='xmin', value=value1, format='float')
1981 1981 opObj.addParameter(name='xmax', value=value2, format='float')
1982 1982
1983 1983 if not self.specGraphPowerprofile.isChecked():
1984 1984 opObj.addParameter(name='show', value=0 , format='bool')
1985 1985
1986 1986 if self.specGraphSavePowerprofile.isChecked():
1987 1987 checkPath = True
1988 1988 opObj.addParameter(name='save', value='1', format='bool')
1989 1989 opObj.addParameter(name='figpath', value=figpath, format='str')
1990 1990 if figfile:
1991 1991 opObj.addParameter(name='figfile', value=value, format='str')
1992 1992 if wrperiod:
1993 1993 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
1994 1994
1995 1995 if self.specGraphftpPowerprofile.isChecked():
1996 1996 opObj.addParameter(name='ftp', value='1', format='int')
1997 1997 self.addFTPConf2Operation(puObj, opObj)
1998 1998 addFTP = True
1999 1999 # rti noise
2000 2000
2001 2001 if self.specGraphCebRTInoise.isChecked() or self.specGraphSaveRTInoise.isChecked():
2002 2002
2003 2003 opObj = puObj.addOperation(name='Noise', optype='other')
2004 2004 opObj.addParameter(name='id', value=opObj.id, format='int')
2005 2005
2006 2006 if channelList:
2007 2007
2008 2008 if not isList(channelList):
2009 2009 self.console.append("Invalid value [%s] for 'Graphic:ChannelList" %(channelList))
2010 2010 return 0
2011 2011
2012 2012 opObj.addParameter(name='channelList', value=channelList, format='intlist')
2013 2013
2014 2014 if trange:
2015 2015
2016 2016 if not isFloatRange(trange):
2017 2017 self.console.append("Invalid value [%s] for 'Graphic:Time-Range" %(trange))
2018 2018 return 0
2019 2019
2020 2020 zvalueList = trange.split(",")
2021 2021 value1 = float(zvalueList[0])
2022 2022 value2 = float(zvalueList[1])
2023 2023
2024 2024 opObj.addParameter(name='xmin', value=value1, format='float')
2025 2025 opObj.addParameter(name='xmax', value=value2, format='float')
2026 2026
2027 2027 if db_range:
2028 2028
2029 2029 if not isFloatRange(db_range):
2030 2030 self.console.append("Invalid value [%s] for 'Graphic:dB-Range" %(db_range))
2031 2031 return 0
2032 2032
2033 2033 zvalueList = db_range.split(",")
2034 2034 value1 = float(zvalueList[0])
2035 2035 value2 = float(zvalueList[1])
2036 2036
2037 2037 opObj.addParameter(name='ymin', value=value1, format='float')
2038 2038 opObj.addParameter(name='ymax', value=value2, format='float')
2039 2039
2040 2040 if not self.specGraphCebRTInoise.isChecked():
2041 2041 opObj.addParameter(name='show', value=0 , format='bool')
2042 2042
2043 2043 if self.specGraphSaveRTInoise.isChecked():
2044 2044 checkPath = True
2045 2045 opObj.addParameter(name='save', value='1', format='bool')
2046 2046 opObj.addParameter(name='figpath', value=figpath, format='str')
2047 2047 if figfile:
2048 2048 opObj.addParameter(name='figfile', value=value, format='str')
2049 2049 if wrperiod:
2050 2050 opObj.addParameter(name='wr_period', value=wrperiod,format='int')
2051 2051
2052 2052 # test_ftp
2053 2053 if self.specGraphftpRTInoise.isChecked():
2054 2054 opObj.addParameter(name='ftp', value='1', format='int')
2055 2055 self.addFTPConf2Operation(puObj, opObj)
2056 2056 addFTP = True
2057 2057
2058 2058 if checkPath:
2059 2059 if not figpath:
2060 2060 self.console.clear()
2061 2061 self.console.append("Graphic path should be defined")
2062 2062 return 0
2063 2063
2064 2064 if addFTP and not figpath:
2065 2065 self.console.clear()
2066 2066 self.console.append("You have to save the plots before sending them to FTP Server")
2067 2067 return 0
2068 2068
2069 2069 self.console.clear()
2070 2070
2071 2071 # if something happend
2072 2072 parms_ok, output_path, blocksperfile, profilesperblock = self.checkInputsPUSave(datatype='Spectra')
2073 2073 if parms_ok:
2074 2074 opObj = puObj.addOperation(name='SpectraWriter', optype='other')
2075 2075 opObj.addParameter(name='path', value=output_path)
2076 2076 opObj.addParameter(name='blocksPerFile', value=blocksperfile, format='int')
2077 2077
2078 2078 try:
2079 2079 self.refreshPUProperties(puObj)
2080 2080 except:
2081 2081 self.console.append("An error reading input parameters was found ... Check them!")
2082 2082 return 0
2083 2083
2084 2084 self.console.append("Save your project and press Play button to start signal processing")
2085 2085
2086 2086 self._enable_play_button()
2087 2087 self._enable_save_button()
2088 2088
2089 2089 return 1
2090 2090
2091 2091
2092 2092 @pyqtSignature("")
2093 2093 def on_specGraphClear_clicked(self):
2094 2094
2095 2095 self.console.clear()
2096 2096
2097 2097 """
2098 2098 Spectra Graph
2099 2099 """
2100 2100 @pyqtSignature("int")
2101 2101 def on_specGraphCebSpectraplot_stateChanged(self, p0):
2102 2102
2103 2103 self.__checkSpecGraphFilters()
2104 2104
2105 2105
2106 2106 @pyqtSignature("int")
2107 2107 def on_specGraphCebCrossSpectraplot_stateChanged(self, p0):
2108 2108
2109 2109 self.__checkSpecGraphFilters()
2110 2110
2111 2111 @pyqtSignature("int")
2112 2112 def on_specGraphCebRTIplot_stateChanged(self, p0):
2113 2113
2114 2114 self.__checkSpecGraphFilters()
2115 2115
2116 2116
2117 2117 @pyqtSignature("int")
2118 2118 def on_specGraphCebRTInoise_stateChanged(self, p0):
2119 2119
2120 2120 self.__checkSpecGraphFilters()
2121 2121
2122 2122
2123 2123 @pyqtSignature("int")
2124 2124 def on_specGraphCebCoherencmap_stateChanged(self, p0):
2125 2125
2126 2126 self.__checkSpecGraphFilters()
2127 2127
2128 2128 @pyqtSignature("int")
2129 2129 def on_specGraphPowerprofile_stateChanged(self, p0):
2130 2130
2131 2131 self.__checkSpecGraphFilters()
2132 2132
2133 2133 @pyqtSignature("int")
2134 2134 def on_specGraphPhase_stateChanged(self, p0):
2135 2135
2136 2136 self.__checkSpecGraphFilters()
2137 2137
2138 2138 @pyqtSignature("int")
2139 2139 def on_specGraphSaveSpectra_stateChanged(self, p0):
2140 2140 """
2141 2141 """
2142 2142 self.__checkSpecGraphFilters()
2143 2143 self.__checkSpecGraphSaving()
2144 2144
2145 2145 @pyqtSignature("int")
2146 2146 def on_specGraphSaveCross_stateChanged(self, p0):
2147 2147
2148 2148 self.__checkSpecGraphFilters()
2149 2149 self.__checkSpecGraphSaving()
2150 2150
2151 2151 @pyqtSignature("int")
2152 2152 def on_specGraphSaveRTIplot_stateChanged(self, p0):
2153 2153
2154 2154 self.__checkSpecGraphFilters()
2155 2155 self.__checkSpecGraphSaving()
2156 2156
2157 2157 @pyqtSignature("int")
2158 2158 def on_specGraphSaveRTInoise_stateChanged(self, p0):
2159 2159
2160 2160 self.__checkSpecGraphFilters()
2161 2161 self.__checkSpecGraphSaving()
2162 2162
2163 2163 @pyqtSignature("int")
2164 2164 def on_specGraphSaveCoherencemap_stateChanged(self, p0):
2165 2165
2166 2166 self.__checkSpecGraphFilters()
2167 2167 self.__checkSpecGraphSaving()
2168 2168
2169 2169 @pyqtSignature("int")
2170 2170 def on_specGraphSavePowerprofile_stateChanged(self, p0):
2171 2171
2172 2172 self.__checkSpecGraphFilters()
2173 2173 self.__checkSpecGraphSaving()
2174 2174
2175 2175 @pyqtSignature("int")
2176 2176 def on_specGraphftpSpectra_stateChanged(self, p0):
2177 2177 """
2178 2178 """
2179 2179 self.__checkSpecGraphFTP()
2180 2180
2181 2181
2182 2182 @pyqtSignature("int")
2183 2183 def on_specGraphftpCross_stateChanged(self, p0):
2184 2184
2185 2185 self.__checkSpecGraphFTP()
2186 2186
2187 2187 @pyqtSignature("int")
2188 2188 def on_specGraphftpRTIplot_stateChanged(self, p0):
2189 2189
2190 2190 self.__checkSpecGraphFTP()
2191 2191
2192 2192 @pyqtSignature("int")
2193 2193 def on_specGraphftpRTInoise_stateChanged(self, p0):
2194 2194
2195 2195 self.__checkSpecGraphFTP()
2196 2196
2197 2197 @pyqtSignature("int")
2198 2198 def on_specGraphftpCoherencemap_stateChanged(self, p0):
2199 2199
2200 2200 self.__checkSpecGraphFTP()
2201 2201
2202 2202 @pyqtSignature("int")
2203 2203 def on_specGraphftpPowerprofile_stateChanged(self, p0):
2204 2204
2205 2205 self.__checkSpecGraphFTP()
2206 2206
2207 2207 @pyqtSignature("")
2208 2208 def on_specGraphToolPath_clicked(self):
2209 2209 """
2210 2210 """
2211 2211 save_path = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
2212 2212 self.specGraphPath.setText(save_path)
2213 2213 if not os.path.exists(save_path):
2214 2214 self.console.clear()
2215 2215 self.console.append("Write a valid path")
2216 2216 return
2217 2217
2218 2218 @pyqtSignature("")
2219 2219 def on_specHeisGraphToolPath_clicked(self):
2220 2220 """
2221 2221 """
2222 2222 save_path = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
2223 2223 self.specHeisGraphPath.setText(save_path)
2224 2224 if not os.path.exists(save_path):
2225 2225 self.console.clear()
2226 2226 self.console.append("Write a valid path")
2227 2227 return
2228 2228
2229 2229 @pyqtSignature("int")
2230 2230 def on_specHeisOpCebIncoherent_stateChanged(self, p0):
2231 2231 """
2232 2232 Habilita la opcion de a�adir el par�metro integraciones incoherentes a la Unidad de Procesamiento .
2233 2233 """
2234 2234 if p0 == 2:
2235 2235 self.specHeisOpIncoherent.setEnabled(True)
2236 2236 self.specHeisOpCobIncInt.setEnabled(True)
2237 2237 if p0 == 0:
2238 2238 self.specHeisOpIncoherent.setEnabled(False)
2239 2239 self.specHeisOpCobIncInt.setEnabled(False)
2240 2240
2241 2241 @pyqtSignature("")
2242 2242 def on_specHeisOpOk_clicked(self):
2243 2243 """
2244 2244 AÑADE OPERACION SPECTRAHEIS
2245 2245 """
2246 2246 addFTP = False
2247 2247 checkPath = False
2248 2248
2249 2249 self._disable_play_button()
2250 2250 self._disable_save_button()
2251 2251
2252 2252 self.console.clear()
2253 2253 self.console.append("Checking input parameters ...")
2254 2254
2255 2255 puObj = self.getSelectedItemObj()
2256 2256 puObj.removeOperations()
2257 2257
2258 2258 if self.specHeisOpCebIncoherent.isChecked():
2259 2259 value = str(self.specHeisOpIncoherent.text())
2260 2260 name_operation = 'IncohInt4SpectraHeis'
2261 2261 optype = 'other'
2262 2262
2263 2263 name_parameter = 'timeInterval'
2264 2264 format = 'float'
2265 2265
2266 2266 if self.specOpCobIncInt.currentIndex() == 0:
2267 2267 name_parameter = 'timeInterval'
2268 2268 format = 'float'
2269 2269
2270 2270 if not isFloat(value):
2271 2271 self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
2272 2272 return 0
2273 2273
2274 2274 opObj = puObj.addOperation(name=name_operation, optype=optype)
2275 2275
2276 2276 if not opObj.addParameter(name=name_parameter, value=value, format=format):
2277 2277 self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
2278 2278 return 0
2279 2279
2280 2280 channelList = str(self.specHeisGgraphChannelList.text())
2281 2281 freq_range = str(self.specHeisGgraphXminXmax.text())
2282 2282 power_range = str(self.specHeisGgraphYminYmax.text())
2283 2283 time_range = str(self.specHeisGgraphTminTmax.text())
2284 2284 timerange = str(self.specHeisGgraphTimeRange.text())
2285 2285
2286 2286 if self.specHeisGraphCebSpectraplot.isChecked():
2287 2287
2288 2288 name_operation = 'SpectraHeisScope'
2289 2289 optype = 'other'
2290 2290 opObj = puObj.addOperation(name=name_operation, optype=optype)
2291 2291
2292 2292 name_parameter = 'id'
2293 2293 format = 'int'
2294 2294 value = opObj.id
2295 2295
2296 2296 if not opObj.addParameter(name=name_parameter, value=value, format=format):
2297 2297 self.console.append("Invalid value '%s' for '%s'" %(value, name_parameter))
2298 2298 return 0
2299 2299
2300 2300 if not (channelList == ''):
2301 2301 name_parameter = 'channelList'
2302 2302 format = 'intlist'
2303 2303
2304 2304 if not isList(channelList):
2305 2305 self.console.append("Invalid value '%s' for '%s'" %(channelList, name_parameter))
2306 2306 return 0
2307 2307
2308 2308 opObj.addParameter(name=name_parameter, value=channelList, format=format)
2309 2309
2310 2310 if not freq_range == '':
2311 2311 xvalueList = freq_range.split(',')
2312 2312
2313 2313 if len(xvalueList) != 2:
2314 2314 self.console.append("Invalid value '%s' for '%s'" %(freq_range, "xrange"))
2315 2315 return 0
2316 2316
2317 2317 value1 = xvalueList[0]
2318 2318 value2 = xvalueList[1]
2319 2319
2320 2320 if not isFloat(value1) or not isFloat(value2):
2321 2321 self.console.append("Invalid value '%s' for '%s'" %(freq_range, "xrange"))
2322 2322 return 0
2323 2323
2324 2324 name1 = 'xmin'
2325 2325 name2 = 'xmax'
2326 2326 format = 'float'
2327 2327
2328 2328 opObj.addParameter(name=name1, value=value1, format=format)
2329 2329 opObj.addParameter(name=name2, value=value2, format=format)
2330 2330
2331 2331 if not power_range == '':
2332 2332 yvalueList = power_range.split(",")
2333 2333
2334 2334 if len(yvalueList) != 2:
2335 2335 self.console.append("Invalid value '%s' for '%s'" %(power_range, "xrange"))
2336 2336 return 0
2337 2337
2338 2338 value1 = yvalueList[0]
2339 2339 value2 = yvalueList[1]
2340 2340
2341 2341 if not isFloat(value1) or not isFloat(value2):
2342 2342 self.console.append("Invalid value '%s' for '%s'" %(power_range, "yrange"))
2343 2343 return 0
2344 2344
2345 2345 name1 = 'ymin'
2346 2346 name2 = 'ymax'
2347 2347 format = 'float'
2348 2348 opObj.addParameter(name=name1, value=value1, format=format)
2349 2349 opObj.addParameter(name=name2, value=value2, format=format)
2350 2350
2351 2351 if self.specHeisGraphSaveSpectra.isChecked():
2352 2352 checkPath = True
2353 2353 name_parameter1 = 'save'
2354 2354 name_parameter2 = 'figpath'
2355 2355 name_parameter3 = 'figfile'
2356 2356 value1 = '1'
2357 2357 value2 = str(self.specHeisGraphPath.text())
2358 2358 value3 = str(self.specHeisGraphPrefix.text())
2359 2359 format1 = 'bool'
2360 2360 format2 = 'str'
2361 2361 opObj.addParameter(name=name_parameter1, value=value1 , format=format1)
2362 2362 opObj.addParameter(name=name_parameter2, value=value2, format=format2)
2363 2363 if not value3 == "":
2364 2364 try:
2365 2365 value3 = str(self.specHeisGraphPrefix.text())
2366 2366 except:
2367 2367 self.console.clear()
2368 2368 self.console.append("Please Write prefix")
2369 2369 return 0
2370 2370 opObj.addParameter(name='figfile', value=str(self.specHeisGraphPrefix.text()), format='str')
2371 2371
2372 2372 # opObj.addParameter(name=name_parameter3, value=value3, format=format2)
2373 2373 # opObj.addParameter(name='wr_period', value='5',format='int')
2374 2374
2375 2375 if self.specHeisGraphftpSpectra.isChecked():
2376 2376 opObj.addParameter(name='ftp', value='1', format='int')
2377 2377 self.addFTPConf2Operation(puObj, opObj)
2378 2378 addFTP = True
2379 2379
2380 2380 if self.specHeisGraphCebRTIplot.isChecked():
2381 2381 name_operation = 'RTIfromSpectraHeis'
2382 2382 optype = 'other'
2383 2383
2384 2384 name_parameter = 'id'
2385 2385 format = 'int'
2386 2386
2387 2387 opObj = puObj.addOperation(name=name_operation, optype=optype)
2388 2388 value = opObj.id
2389 2389 opObj.addParameter(name=name_parameter, value=value, format=format)
2390 2390
2391 2391 if not channelList == '':
2392 2392 opObj.addParameter(name='channelList', value=channelList, format='intlist')
2393 2393
2394 2394 if not time_range == '':
2395 2395 xvalueList = time_range.split(',')
2396 2396 try:
2397 2397 value = float(xvalueList[0])
2398 2398 value = float(xvalueList[1])
2399 2399 except:
2400 2400 return 0
2401 2401 format = 'float'
2402 2402 opObj.addParameter(name='xmin', value=xvalueList[0], format=format)
2403 2403 opObj.addParameter(name='xmax', value=xvalueList[1], format=format)
2404 2404
2405 2405 if not timerange == '':
2406 2406 format = 'int'
2407 2407 try:
2408 2408 timerange = int(timerange)
2409 2409 except:
2410 2410 return 0
2411 2411 opObj.addParameter(name='timerange', value=timerange, format=format)
2412 2412
2413 2413
2414 2414 if not power_range == '':
2415 2415 yvalueList = power_range.split(",")
2416 2416 try:
2417 2417 value = float(yvalueList[0])
2418 2418 value = float(yvalueList[1])
2419 2419 except:
2420 2420 return 0
2421 2421
2422 2422 format = 'float'
2423 2423 opObj.addParameter(name='ymin', value=yvalueList[0], format=format)
2424 2424 opObj.addParameter(name='ymax', value=yvalueList[1], format=format)
2425 2425
2426 2426 if self.specHeisGraphSaveRTIplot.isChecked():
2427 2427 checkPath = True
2428 2428 opObj.addParameter(name='save', value='1', format='bool')
2429 2429 opObj.addParameter(name='figpath', value=str(self.specHeisGraphPath.text()), format='str')
2430 2430 value = str(self.specHeisGraphPrefix.text())
2431 2431 if not value == "":
2432 2432 try:
2433 2433 value = str(self.specHeisGraphPrefix.text())
2434 2434 except:
2435 2435 self.console.clear()
2436 2436 self.console.append("Please Write prefix")
2437 2437 return 0
2438 2438 opObj.addParameter(name='figfile', value=value, format='str')
2439 2439
2440 2440 # test_ftp
2441 2441 if self.specHeisGraphftpRTIplot.isChecked():
2442 2442 opObj.addParameter(name='ftp', value='1', format='int')
2443 2443 self.addFTPConf2Operation(puObj, opObj)
2444 2444 addFTP = True
2445 2445
2446 2446 localfolder = None
2447 2447 if checkPath:
2448 2448 localfolder = str(self.specHeisGraphPath.text())
2449 2449 if localfolder == '':
2450 2450 self.console.clear()
2451 2451 self.console.append("Graphic path should be defined")
2452 2452 return 0
2453 2453
2454 2454 if addFTP and not localfolder:
2455 2455 self.console.clear()
2456 2456 self.console.append("You should save plots before send them to FTP Server")
2457 2457 return 0
2458 2458
2459 2459 # if something happened
2460 2460 parms_ok, output_path, blocksperfile, metadata_file = self.checkInputsPUSave(datatype='SpectraHeis')
2461 2461 if parms_ok:
2462 2462 name_operation = 'FitsWriter'
2463 2463 optype = 'other'
2464 2464 name_parameter1 = 'path'
2465 2465 name_parameter2 = 'dataBlocksPerFile'
2466 2466 name_parameter3 = 'metadatafile'
2467 2467 value1 = output_path
2468 2468 value2 = blocksperfile
2469 2469 value3 = metadata_file
2470 2470 format2 = "int"
2471 2471 format3 = "str"
2472 2472 opObj = puObj.addOperation(name=name_operation, optype=optype)
2473 2473
2474 2474 opObj.addParameter(name=name_parameter1, value=value1)
2475 2475
2476 2476 if blocksperfile:
2477 2477 opObj.addParameter(name=name_parameter2, value=value2, format=format2)
2478 2478
2479 2479 if metadata_file:
2480 2480 opObj.addParameter(name=name_parameter3, value=value3, format=format3)
2481 2481
2482 2482 self.console.clear()
2483 2483 try:
2484 2484 self.refreshPUProperties(puObj)
2485 2485 except:
2486 2486 self.console.append("An error reading input parameters was found ... Check them!")
2487 2487 return 0
2488 2488
2489 2489 self.console.append("Save your project and press Play button to start signal processing")
2490 2490
2491 2491 self._enable_save_button()
2492 2492 self._enable_play_button()
2493 2493
2494 2494 return 1
2495 2495
2496 2496 @pyqtSignature("")
2497 2497 def on_specHeisGraphClear_clicked(self):
2498 2498
2499 2499 self.console.clear()
2500 2500
2501 2501 @pyqtSignature("int")
2502 2502 def on_specHeisGraphCebSpectraplot_stateChanged(self, p0):
2503 2503
2504 2504 if p0 == 2:
2505 2505 self.specHeisGgraphChannelList.setEnabled(True)
2506 2506 self.specHeisGgraphXminXmax.setEnabled(True)
2507 2507 self.specHeisGgraphYminYmax.setEnabled(True)
2508 2508 if p0 == 0:
2509 2509 self.specHeisGgraphXminXmax.setEnabled(False)
2510 2510 self.specHeisGgraphYminYmax.setEnabled(False)
2511 2511
2512 2512 @pyqtSignature("int")
2513 2513 def on_specHeisGraphCebRTIplot_stateChanged(self, p0):
2514 2514
2515 2515 if p0 == 2:
2516 2516 self.specHeisGgraphChannelList.setEnabled(True)
2517 2517 self.specHeisGgraphTminTmax.setEnabled(True)
2518 2518 self.specHeisGgraphYminYmax.setEnabled(True)
2519 2519 self.specHeisGgraphTimeRange.setEnabled(True)
2520 2520
2521 2521 if p0 == 0:
2522 2522 self.specHeisGgraphTminTmax.setEnabled(False)
2523 2523 self.specHeisGgraphYminYmax.setEnabled(False)
2524 2524 self.specHeisGgraphTimeRange.setEnabled(False)
2525 2525
2526 2526 @pyqtSignature("int")
2527 2527 def on_specHeisGraphSaveSpectra_stateChanged(self, p0):
2528 2528 """
2529 2529 """
2530 2530 if p0 == 2:
2531 2531 self.specHeisGraphPath.setEnabled(True)
2532 2532 self.specHeisGraphPrefix.setEnabled(True)
2533 2533 self.specHeisGraphToolPath.setEnabled(True)
2534 2534 if p0 == 0:
2535 2535 self.specHeisGraphPath.setEnabled(False)
2536 2536 self.specHeisGraphPrefix.setEnabled(False)
2537 2537 self.specHeisGraphToolPath.setEnabled(False)
2538 2538
2539 2539 @pyqtSignature("int")
2540 2540 def on_specHeisGraphSaveRTIplot_stateChanged(self, p0):
2541 2541 if p0 == 2:
2542 2542 self.specHeisGraphPath.setEnabled(True)
2543 2543 self.specHeisGraphPrefix.setEnabled(True)
2544 2544 self.specHeisGraphToolPath.setEnabled(True)
2545 2545
2546 2546 @pyqtSignature("int")
2547 2547 def on_specHeisGraphftpSpectra_stateChanged(self, p0):
2548 2548 """
2549 2549 """
2550 2550 if p0 == 2:
2551 2551 self.specHeisGgraphftpratio.setEnabled(True)
2552 2552
2553 2553 if p0 == 0:
2554 2554 self.specHeisGgraphftpratio.setEnabled(False)
2555 2555
2556 2556 @pyqtSignature("int")
2557 2557 def on_specHeisGraphftpRTIplot_stateChanged(self, p0):
2558 2558 if p0 == 2:
2559 2559 self.specHeisGgraphftpratio.setEnabled(True)
2560 2560
2561 2561 def __checkSpecGraphSaving(self):
2562 2562
2563 2563 enable = False
2564 2564
2565 2565 if self.specGraphSaveSpectra.checkState():
2566 2566 enable = True
2567 2567
2568 2568 if self.specGraphSaveCross.checkState():
2569 2569 enable = True
2570 2570
2571 2571 if self.specGraphSaveRTIplot.checkState():
2572 2572 enable = True
2573 2573
2574 2574 if self.specGraphSaveCoherencemap.checkState():
2575 2575 enable = True
2576 2576
2577 2577 if self.specGraphSavePowerprofile.checkState():
2578 2578 enable = True
2579 2579
2580 2580 if self.specGraphSaveRTInoise.checkState():
2581 2581 enable = True
2582 2582
2583 2583 self.specGraphPath.setEnabled(enable)
2584 2584 self.specGraphPrefix.setEnabled(enable)
2585 2585 self.specGraphToolPath.setEnabled(enable)
2586 2586
2587 2587 self.specGgraphftpratio.setEnabled(enable)
2588 2588
2589 2589 def __checkSpecGraphFTP(self):
2590 2590
2591 2591 enable = False
2592 2592
2593 2593 if self.specGraphftpSpectra.checkState():
2594 2594 enable = True
2595 2595
2596 2596 if self.specGraphftpCross.checkState():
2597 2597 enable = True
2598 2598
2599 2599 if self.specGraphftpRTIplot.checkState():
2600 2600 enable = True
2601 2601
2602 2602 if self.specGraphftpCoherencemap.checkState():
2603 2603 enable = True
2604 2604
2605 2605 if self.specGraphftpPowerprofile.checkState():
2606 2606 enable = True
2607 2607
2608 2608 if self.specGraphftpRTInoise.checkState():
2609 2609 enable = True
2610 2610
2611 2611 # self.specGgraphftpratio.setEnabled(enable)
2612 2612
2613 2613 def __checkSpecGraphFilters(self):
2614 2614
2615 2615 freq = False
2616 2616 height = False
2617 2617 db = False
2618 2618 timerange = False
2619 2619 magnitud = False
2620 2620 phase = False
2621 2621 channelList = False
2622 2622
2623 2623 if self.specGraphCebSpectraplot.checkState() or self.specGraphSaveSpectra.checkState():
2624 2624 freq = True
2625 2625 height = True
2626 2626 db = True
2627 2627 channelList = True
2628 2628
2629 2629 if self.specGraphCebCrossSpectraplot.checkState() or self.specGraphSaveCross.checkState():
2630 2630 freq = True
2631 2631 height = True
2632 2632 db = True
2633 2633 magnitud = True
2634 2634 phase = True
2635 2635
2636 2636 if self.specGraphCebRTIplot.checkState() or self.specGraphSaveRTIplot.checkState():
2637 2637 height = True
2638 2638 db = True
2639 2639 timerange = True
2640 2640 channelList = True
2641 2641
2642 2642 if self.specGraphCebCoherencmap.checkState() or self.specGraphSaveCoherencemap.checkState():
2643 2643 height = True
2644 2644 timerange = True
2645 2645 magnitud = True
2646 2646 phase = True
2647 2647
2648 2648 if self.specGraphPowerprofile.checkState() or self.specGraphSavePowerprofile.checkState():
2649 2649 height = True
2650 2650 db = True
2651 2651 channelList = True
2652 2652
2653 2653 if self.specGraphCebRTInoise.checkState() or self.specGraphSaveRTInoise.checkState():
2654 2654 db = True
2655 2655 timerange = True
2656 2656 channelList = True
2657 2657
2658 2658
2659 2659 self.specGgraphFreq.setEnabled(freq)
2660 2660 self.specGgraphHeight.setEnabled(height)
2661 2661 self.specGgraphDbsrange.setEnabled(db)
2662 2662 self.specGgraphTminTmax.setEnabled(timerange)
2663 2663 self.specGgraphTimeRange.setEnabled(timerange)
2664 2664
2665 2665 self.specGgraphmagnitud.setEnabled(magnitud)
2666 2666 self.specGgraphPhase.setEnabled(phase)
2667 2667 self.specGgraphChannelList.setEnabled(channelList)
2668 2668
2669 2669 def __getParmsFromProjectWindow(self):
2670 2670 """
2671 2671 Check Inputs Project:
2672 2672 - project_name
2673 2673 - datatype
2674 2674 - ext
2675 2675 - data_path
2676 2676 - readmode
2677 2677 - delay
2678 2678 - set
2679 2679 - walk
2680 2680 """
2681 2681 parms_ok = True
2682 2682
2683 2683 project_name = str(self.proName.text())
2684 2684
2685 2685 if project_name == '' or project_name == None:
2686 2686 outputstr = "Enter a project Name"
2687 2687 self.console.append(outputstr)
2688 2688 parms_ok = False
2689 2689 project_name = None
2690 2690
2691 2691 description = str(self.proDescription.toPlainText())
2692 2692
2693 2693 datatype = str(self.proComDataType.currentText())
2694 2694
2695 2695 ext = str(self.proDataType.text())
2696 2696
2697 2697 dpath = str(self.proDataPath.text())
2698 2698
2699 2699 if dpath == '':
2700 2700 outputstr = 'Datapath is empty'
2701 2701 self.console.append(outputstr)
2702 2702 parms_ok = False
2703 2703 dpath = None
2704 2704
2705 2705 if dpath != None:
2706 2706 if not os.path.isdir(dpath):
2707 2707 outputstr = 'Datapath (%s) does not exist' % dpath
2708 2708 self.console.append(outputstr)
2709 2709 parms_ok = False
2710 2710 dpath = None
2711 2711
2712 2712 online = int(self.proComReadMode.currentIndex())
2713 2713
2714 2714 delay = None
2715 2715 if online==1:
2716 2716 try:
2717 2717 delay = int(str(self.proDelay.text()))
2718 2718 except:
2719 2719 outputstr = 'Delay value (%s) must be a integer number' %str(self.proDelay.text())
2720 2720 self.console.append(outputstr)
2721 2721 parms_ok = False
2722 2722
2723 2723
2724 2724 set = None
2725 2725 value = str(self.proSet.text())
2726 2726 try:
2727 2727 set = int(value)
2728 2728 except:
2729 2729 pass
2730 2730
2731 2731 ippKm = None
2732 2732
2733 2733 value = str(self.proIPPKm.text())
2734 2734
2735 2735 try:
2736 2736 ippKm = float(value)
2737 2737 except:
2738 2738 if datatype=="USRP":
2739 2739 outputstr = 'IPP value "%s" must be a float number' % str(self.proIPPKm.text())
2740 2740 self.console.append(outputstr)
2741 2741 parms_ok = False
2742 2742
2743 2743 walk = int(self.proComWalk.currentIndex())
2744 2744 expLabel = str(self.proExpLabel.text())
2745 2745
2746 2746 startDate = str(self.proComStartDate.currentText()).strip()
2747 2747 endDate = str(self.proComEndDate.currentText()).strip()
2748 2748
2749 2749 if not startDate:
2750 2750 parms_ok = False
2751 2751
2752 2752 if not endDate:
2753 2753 parms_ok = False
2754 2754
2755 2755 # startDateList = startDate.split("/")
2756 2756 # endDateList = endDate.split("/")
2757 2757 #
2758 2758 # startDate = datetime.date(int(startDateList[0]), int(startDateList[1]), int(startDateList[2]))
2759 2759 # endDate = datetime.date(int(endDateList[0]), int(endDateList[1]), int(endDateList[2]))
2760 2760
2761 2761 startTime = self.proStartTime.time()
2762 2762 endTime = self.proEndTime.time()
2763 2763
2764 2764 startTime = str(startTime.toString("H:m:s"))
2765 2765 endTime = str(endTime.toString("H:m:s"))
2766 2766
2767 2767 projectParms = ProjectParms()
2768 2768
2769 2769 projectParms.name = project_name
2770 2770 projectParms.description = description
2771 2771 projectParms.datatype = datatype
2772 2772 projectParms.ext = ext
2773 2773 projectParms.dpath = dpath
2774 2774 projectParms.online = online
2775 2775 projectParms.startDate = startDate
2776 2776 projectParms.endDate = endDate
2777 2777 projectParms.startTime = startTime
2778 2778 projectParms.endTime = endTime
2779 2779 projectParms.delay = delay
2780 2780 projectParms.walk = walk
2781 2781 projectParms.expLabel = expLabel
2782 2782 projectParms.set = set
2783 2783 projectParms.ippKm = ippKm
2784 2784 projectParms.parmsOk = parms_ok
2785 2785
2786 2786 return projectParms
2787 2787
2788 2788
2789 2789 def __getParmsFromProjectObj(self, projectObjView):
2790 2790
2791 2791 parms_ok = True
2792 2792
2793 2793 project_name, description = projectObjView.name, projectObjView.description
2794 2794
2795 2795 readUnitObj = projectObjView.getReadUnitObj()
2796 2796 datatype = readUnitObj.datatype
2797 2797
2798 2798 operationObj = readUnitObj.getOperationObj(name='run')
2799 2799
2800 2800 dpath = operationObj.getParameterValue(parameterName='path')
2801 2801 startDate = operationObj.getParameterValue(parameterName='startDate')
2802 2802 endDate = operationObj.getParameterValue(parameterName='endDate')
2803 2803
2804 2804 startDate = startDate.strftime("%Y/%m/%d")
2805 2805 endDate = endDate.strftime("%Y/%m/%d")
2806 2806
2807 2807 startTime = operationObj.getParameterValue(parameterName='startTime')
2808 2808 endTime = operationObj.getParameterValue(parameterName='endTime')
2809 2809
2810 2810 startTime = startTime.strftime("%H:%M:%S")
2811 2811 endTime = endTime.strftime("%H:%M:%S")
2812 2812
2813 2813 online = 0
2814 2814 try:
2815 2815 online = operationObj.getParameterValue(parameterName='online')
2816 2816 except:
2817 2817 pass
2818 2818
2819 2819 delay = ''
2820 2820 try:
2821 2821 delay = operationObj.getParameterValue(parameterName='delay')
2822 2822 except:
2823 2823 pass
2824 2824
2825 2825 walk = 0
2826 2826 try:
2827 2827 walk = operationObj.getParameterValue(parameterName='walk')
2828 2828 except:
2829 2829 pass
2830 2830
2831 2831 set = ''
2832 2832 try:
2833 2833 set = operationObj.getParameterValue(parameterName='set')
2834 2834 except:
2835 2835 pass
2836 2836
2837 2837 expLabel = ''
2838 2838 try:
2839 2839 expLabel = operationObj.getParameterValue(parameterName='expLabel')
2840 2840 except:
2841 2841 pass
2842 2842
2843 2843 ippKm = ''
2844 2844 if datatype.lower() == 'usrp':
2845 2845 try:
2846 2846 ippKm = operationObj.getParameterValue(parameterName='ippKm')
2847 2847 except:
2848 2848 pass
2849 2849
2850 2850 projectParms = ProjectParms()
2851 2851
2852 2852 projectParms.name = project_name
2853 2853 projectParms.description = description
2854 2854 projectParms.datatype = datatype
2855 2855 projectParms.ext = None
2856 2856 projectParms.dpath = dpath
2857 2857 projectParms.online = online
2858 2858 projectParms.startDate = startDate
2859 2859 projectParms.endDate = endDate
2860 2860 projectParms.startTime = startTime
2861 2861 projectParms.endTime = endTime
2862 2862 projectParms.delay=delay
2863 2863 projectParms.walk=walk
2864 2864 projectParms.set=set
2865 2865 projectParms.ippKm=ippKm
2866 2866 projectParms.expLabel = expLabel
2867 2867 projectParms.parmsOk=parms_ok
2868 2868
2869 2869 return projectParms
2870 2870
2871 2871 def refreshProjectWindow(self, projectObjView):
2872 2872
2873 2873 self.proOk.setEnabled(False)
2874 2874
2875 2875 projectParms = self.__getParmsFromProjectObj(projectObjView)
2876 2876
2877 2877 index = projectParms.getDatatypeIndex()
2878 2878
2879 2879 self.proName.setText(projectParms.name)
2880 2880 self.proDescription.clear()
2881 2881 self.proDescription.append(projectParms.description)
2882 2882
2883 2883 self.on_proComDataType_activated(index=index)
2884 2884 self.proDataPath.setText(projectParms.dpath)
2885 2885 self.proComDataType.setCurrentIndex(index)
2886 2886 self.proComReadMode.setCurrentIndex(projectParms.online)
2887 2887 self.proDelay.setText(str(projectParms.delay))
2888 2888 self.proSet.setText(str(projectParms.set))
2889 2889 self.proIPPKm.setText(str(projectParms.ippKm))
2890 2890 self.proComWalk.setCurrentIndex(projectParms.walk)
2891 2891 self.proExpLabel.setText(str(projectParms.expLabel).strip())
2892 2892
2893 2893 self.on_proComReadMode_activated(projectParms.online)
2894 2894 self.on_proComWalk_activated(projectParms.walk)
2895 2895
2896 2896 dateList = self.loadDays(data_path = projectParms.dpath,
2897 2897 ext = projectParms.getExt(),
2898 2898 walk = projectParms.walk,
2899 2899 expLabel = projectParms.expLabel)
2900 2900
2901 2901 if not dateList:
2902 2902 return 0
2903 2903
2904 2904 try:
2905 2905 startDateIndex = dateList.index(projectParms.startDate)
2906 2906 except:
2907 2907 startDateIndex = 0
2908 2908
2909 2909 try:
2910 2910 endDateIndex = dateList.index(projectParms.endDate)
2911 2911 except:
2912 2912 endDateIndex = int(self.proComEndDate.count()-1)
2913 2913
2914 2914 self.proComStartDate.setCurrentIndex(startDateIndex)
2915 2915 self.proComEndDate.setCurrentIndex(endDateIndex)
2916 2916
2917 2917 startlist = projectParms.startTime.split(":")
2918 2918 endlist = projectParms.endTime.split(":")
2919 2919
2920 2920 self.time.setHMS(int(startlist[0]), int(startlist[1]), int(startlist[2]))
2921 2921 self.proStartTime.setTime(self.time)
2922 2922
2923 2923 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
2924 2924 self.proEndTime.setTime(self.time)
2925 2925
2926 2926 self.proOk.setEnabled(True)
2927 2927
2928 2928 return 1
2929 2929
2930 2930 def __refreshVoltageWindow(self, puObj):
2931 2931
2932 2932 opObj = puObj.getOperationObj(name='setRadarFrequency')
2933 2933 if opObj == None:
2934 2934 self.volOpRadarfrequency.clear()
2935 2935 self.volOpCebRadarfrequency.setCheckState(0)
2936 2936 else:
2937 2937 value = opObj.getParameterValue(parameterName='frequency')
2938 2938 value = str(float(value)/1e6)
2939 2939 self.volOpRadarfrequency.setText(value)
2940 2940 self.volOpRadarfrequency.setEnabled(True)
2941 2941 self.volOpCebRadarfrequency.setCheckState(QtCore.Qt.Checked)
2942 2942
2943 2943 opObj = puObj.getOperationObj(name="selectChannels")
2944 2944
2945 2945 if opObj == None:
2946 2946 opObj = puObj.getOperationObj(name="selectChannelsByIndex")
2947 2947
2948 2948 if opObj == None:
2949 2949 self.volOpChannel.clear()
2950 2950 self.volOpCebChannels.setCheckState(0)
2951 2951 else:
2952 2952 channelEnabled = False
2953 2953 try:
2954 2954 value = opObj.getParameterValue(parameterName='channelList')
2955 2955 value = str(value)[1:-1]
2956 2956 channelEnabled = True
2957 2957 channelMode = 0
2958 2958 except:
2959 2959 pass
2960 2960 try:
2961 2961 value = opObj.getParameterValue(parameterName='channelIndexList')
2962 2962 value = str(value)[1:-1]
2963 2963 channelEnabled = True
2964 2964 channelMode = 1
2965 2965 except:
2966 2966 pass
2967 2967
2968 2968 if channelEnabled:
2969 2969 self.volOpChannel.setText(value)
2970 2970 self.volOpChannel.setEnabled(True)
2971 2971 self.volOpCebChannels.setCheckState(QtCore.Qt.Checked)
2972 2972 self.volOpComChannels.setCurrentIndex(channelMode)
2973 2973
2974 2974 opObj = puObj.getOperationObj(name="selectHeights")
2975 2975 if opObj == None:
2976 2976 self.volOpHeights.clear()
2977 2977 self.volOpCebHeights.setCheckState(0)
2978 2978 else:
2979 2979 value1 = str(opObj.getParameterValue(parameterName='minHei'))
2980 2980 value2 = str(opObj.getParameterValue(parameterName='maxHei'))
2981 2981 value = value1 + "," + value2
2982 2982 self.volOpHeights.setText(value)
2983 2983 self.volOpHeights.setEnabled(True)
2984 2984 self.volOpCebHeights.setCheckState(QtCore.Qt.Checked)
2985 2985
2986 2986 opObj = puObj.getOperationObj(name="SplitProfiles")
2987 2987 if opObj == None:
2988 2988 self.volOpSplitter.clear()
2989 2989 self.volOpCebSplitter.setCheckState(0)
2990 2990 else:
2991 2991 value = opObj.getParameterValue(parameterName='n')
2992 2992 value = str(value)
2993 2993 self.volOpSplitter.setText(value)
2994 2994 self.volOpSplitter.setEnabled(True)
2995 2995 self.volOpCebSplitter.setCheckState(QtCore.Qt.Checked)
2996 2996
2997 2997 opObj = puObj.getOperationObj(name="CombineProfiles")
2998 2998 if opObj == None:
2999 2999 self.volOpCombiner.clear()
3000 3000 self.volOpCebCombiner.setCheckState(0)
3001 3001 else:
3002 3002 value = opObj.getParameterValue(parameterName='n')
3003 3003 value = str(value)
3004 3004 self.volOpCombiner.setText(value)
3005 3005 self.volOpCombiner.setEnabled(True)
3006 3006 self.volOpCebCombiner.setCheckState(QtCore.Qt.Checked)
3007 3007
3008 3008 opObj = puObj.getOperationObj(name="filterByHeights")
3009 3009 if opObj == None:
3010 3010 self.volOpFilter.clear()
3011 3011 self.volOpCebFilter.setCheckState(0)
3012 3012 else:
3013 3013 value = opObj.getParameterValue(parameterName='window')
3014 3014 value = str(value)
3015 3015 self.volOpFilter.setText(value)
3016 3016 self.volOpFilter.setEnabled(True)
3017 3017 self.volOpCebFilter.setCheckState(QtCore.Qt.Checked)
3018 3018
3019 3019 opObj = puObj.getOperationObj(name="ProfileSelector")
3020 3020 if opObj == None:
3021 3021 self.volOpProfile.clear()
3022 3022 self.volOpCebProfile.setCheckState(0)
3023 3023 else:
3024 3024 for parmObj in opObj.getParameterObjList():
3025 3025
3026 3026 if parmObj.name == "profileList":
3027 3027 value = parmObj.getValue()
3028 3028 value = str(value)[1:-1]
3029 3029 self.volOpProfile.setText(value)
3030 3030 self.volOpProfile.setEnabled(True)
3031 3031 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
3032 3032 self.volOpComProfile.setCurrentIndex(0)
3033 3033
3034 3034 if parmObj.name == "profileRangeList":
3035 3035 value = parmObj.getValue()
3036 3036 value = str(value)[1:-1]
3037 3037 self.volOpProfile.setText(value)
3038 3038 self.volOpProfile.setEnabled(True)
3039 3039 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
3040 3040 self.volOpComProfile.setCurrentIndex(1)
3041 3041
3042 3042 if parmObj.name == "rangeList":
3043 3043 value = parmObj.getValue()
3044 3044 value = str(value)[1:-1]
3045 3045 self.volOpProfile.setText(value)
3046 3046 self.volOpProfile.setEnabled(True)
3047 3047 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
3048 3048 self.volOpComProfile.setCurrentIndex(2)
3049 3049
3050 3050 opObj = puObj.getOperationObj(name="Decoder")
3051 3051 self.volOpCode.setText("")
3052 3052 if opObj == None:
3053 3053 self.volOpCebDecodification.setCheckState(0)
3054 3054 else:
3055 3055 self.volOpCebDecodification.setCheckState(QtCore.Qt.Checked)
3056 3056
3057 3057 parmObj = opObj.getParameterObj('code')
3058 3058
3059 3059 if parmObj == None:
3060 3060 self.volOpComCode.setCurrentIndex(0)
3061 3061 else:
3062 3062
3063 3063 parmObj1 = opObj.getParameterObj('nCode')
3064 3064 parmObj2 = opObj.getParameterObj('nBaud')
3065 3065
3066 3066 if parmObj1 == None or parmObj2 == None:
3067 3067 self.volOpComCode.setCurrentIndex(0)
3068 3068 else:
3069 3069 code = ast.literal_eval(str(parmObj.getValue()))
3070 3070 nCode = parmObj1.getValue()
3071 3071 nBaud = parmObj2.getValue()
3072 3072
3073 3073 code = numpy.asarray(code).reshape((nCode, nBaud)).tolist()
3074 3074
3075 3075 #User defined by default
3076 3076 self.volOpComCode.setCurrentIndex(13)
3077 3077 self.volOpCode.setText(str(code))
3078 3078
3079 3079 if nCode == 1:
3080 3080 if nBaud == 3:
3081 3081 self.volOpComCode.setCurrentIndex(1)
3082 3082 if nBaud == 4:
3083 3083 self.volOpComCode.setCurrentIndex(2)
3084 3084 if nBaud == 5:
3085 3085 self.volOpComCode.setCurrentIndex(3)
3086 3086 if nBaud == 7:
3087 3087 self.volOpComCode.setCurrentIndex(4)
3088 3088 if nBaud == 11:
3089 3089 self.volOpComCode.setCurrentIndex(5)
3090 3090 if nBaud == 13:
3091 3091 self.volOpComCode.setCurrentIndex(6)
3092 3092
3093 3093 if nCode == 2:
3094 3094 if nBaud == 3:
3095 3095 self.volOpComCode.setCurrentIndex(7)
3096 3096 if nBaud == 4:
3097 3097 self.volOpComCode.setCurrentIndex(8)
3098 3098 if nBaud == 5:
3099 3099 self.volOpComCode.setCurrentIndex(9)
3100 3100 if nBaud == 7:
3101 3101 self.volOpComCode.setCurrentIndex(10)
3102 3102 if nBaud == 11:
3103 3103 self.volOpComCode.setCurrentIndex(11)
3104 3104 if nBaud == 13:
3105 3105 self.volOpComCode.setCurrentIndex(12)
3106 3106
3107 3107
3108 3108 opObj = puObj.getOperationObj(name="deFlip")
3109 3109 if opObj == None:
3110 3110 self.volOpFlip.clear()
3111 3111 self.volOpFlip.setEnabled(False)
3112 3112 self.volOpCebFlip.setCheckState(0)
3113 3113 else:
3114 3114 try:
3115 3115 value = opObj.getParameterValue(parameterName='channelList')
3116 3116 value = str(value)[1:-1]
3117 3117 except:
3118 3118 value = ""
3119 3119
3120 3120 self.volOpFlip.setText(value)
3121 3121 self.volOpFlip.setEnabled(True)
3122 3122 self.volOpCebFlip.setCheckState(QtCore.Qt.Checked)
3123 3123
3124 3124 opObj = puObj.getOperationObj(name="CohInt")
3125 3125 if opObj == None:
3126 3126 self.volOpCohInt.clear()
3127 3127 self.volOpCebCohInt.setCheckState(0)
3128 3128 else:
3129 3129 value = opObj.getParameterValue(parameterName='n')
3130 3130 self.volOpCohInt.setText(str(value))
3131 3131 self.volOpCohInt.setEnabled(True)
3132 3132 self.volOpCebCohInt.setCheckState(QtCore.Qt.Checked)
3133 3133
3134 3134 opObj = puObj.getOperationObj(name='Scope')
3135 3135 if opObj == None:
3136 3136 self.volGraphCebshow.setCheckState(0)
3137 3137 else:
3138 3138 self.volGraphCebshow.setCheckState(QtCore.Qt.Checked)
3139 3139
3140 3140 parmObj = opObj.getParameterObj(parameterName='channelList')
3141 3141
3142 3142 if parmObj == None:
3143 3143 self.volGraphChannelList.clear()
3144 3144 else:
3145 3145 value = parmObj.getValue()
3146 3146 value = str(value)
3147 3147 self.volGraphChannelList.setText(value)
3148 3148 # self.volOpChannel.setEnabled(True)
3149 3149
3150 3150 parmObj1 = opObj.getParameterObj(parameterName='ymin')
3151 3151 parmObj2 = opObj.getParameterObj(parameterName='ymax')
3152 3152
3153 3153 if parmObj1 == None or parmObj2 ==None:
3154 3154 self.volGraphIntensityRange.clear()
3155 3155 else:
3156 3156 value1 = parmObj1.getValue()
3157 3157 value1 = str(value1)
3158 3158 value2 = parmObj2.getValue()
3159 3159 value2 = str(value2)
3160 3160 value = value1 + "," + value2
3161 3161 self.volGraphIntensityRange.setText(value)
3162 3162
3163 3163 parmObj1 = opObj.getParameterObj(parameterName='xmin')
3164 3164 parmObj2 = opObj.getParameterObj(parameterName='xmax')
3165 3165
3166 3166 if parmObj1 == None or parmObj2 ==None:
3167 3167 self.volGraphHeightrange.clear()
3168 3168 else:
3169 3169 value1 = parmObj1.getValue()
3170 3170 value1 = str(value1)
3171 3171 value2 = parmObj2.getValue()
3172 3172 value2 = str(value2)
3173 3173 value = value1 + "," + value2
3174 3174 value2 = str(value2)
3175 3175 self.volGraphHeightrange.setText(value)
3176 3176
3177 3177 parmObj = opObj.getParameterObj(parameterName='type')
3178 3178
3179 3179 if parmObj == None:
3180 3180 self.volComScopeType.setCurrentIndex(0)
3181 3181 else:
3182 3182 value = parmObj.getValue()
3183 3183 if value == "iq":
3184 3184 self.volComScopeType.setCurrentIndex(0)
3185 3185 if value == "power":
3186 3186 self.volComScopeType.setCurrentIndex(1)
3187 3187
3188 3188 parmObj = opObj.getParameterObj(parameterName='save')
3189 3189
3190 3190 if parmObj == None:
3191 3191 self.volGraphCebSave.setCheckState(QtCore.Qt.Unchecked)
3192 3192 else:
3193 3193 value = parmObj.getValue()
3194 3194 if value:
3195 3195 self.volGraphCebSave.setCheckState(QtCore.Qt.Checked)
3196 3196 else:
3197 3197 self.volGraphCebSave.setCheckState(QtCore.Qt.Unchecked)
3198 3198
3199 3199 parmObj = opObj.getParameterObj(parameterName='figpath')
3200 3200 if parmObj == None:
3201 3201 self.volGraphPath.clear()
3202 3202 else:
3203 3203 value = parmObj.getValue()
3204 3204 path = str(value)
3205 3205 self.volGraphPath.setText(path)
3206 3206
3207 3207 parmObj = opObj.getParameterObj(parameterName='figfile')
3208 3208 if parmObj == None:
3209 3209 self.volGraphPrefix.clear()
3210 3210 else:
3211 3211 value = parmObj.getValue()
3212 3212 figfile = str(value)
3213 3213 self.volGraphPrefix.setText(figfile)
3214 3214
3215 3215 # outputVoltageWrite
3216 3216 opObj = puObj.getOperationObj(name='VoltageWriter')
3217 3217
3218 3218 if opObj == None:
3219 3219 self.volOutputPath.clear()
3220 3220 self.volOutputblocksperfile.clear()
3221 3221 self.volOutputprofilesperblock.clear()
3222 3222 else:
3223 3223 parmObj = opObj.getParameterObj(parameterName='path')
3224 3224 if parmObj == None:
3225 3225 self.volOutputPath.clear()
3226 3226 else:
3227 3227 value = parmObj.getValue()
3228 3228 path = str(value)
3229 3229 self.volOutputPath.setText(path)
3230 3230
3231 3231 parmObj = opObj.getParameterObj(parameterName='blocksPerFile')
3232 3232 if parmObj == None:
3233 3233 self.volOutputblocksperfile.clear()
3234 3234 else:
3235 3235 value = parmObj.getValue()
3236 3236 blocksperfile = str(value)
3237 3237 self.volOutputblocksperfile.setText(blocksperfile)
3238 3238
3239 3239 parmObj = opObj.getParameterObj(parameterName='profilesPerBlock')
3240 3240 if parmObj == None:
3241 3241 self.volOutputprofilesperblock.clear()
3242 3242 else:
3243 3243 value = parmObj.getValue()
3244 3244 profilesPerBlock = str(value)
3245 3245 self.volOutputprofilesperblock.setText(profilesPerBlock)
3246 3246
3247 3247 return
3248 3248
3249 3249 def __refreshSpectraWindow(self, puObj):
3250 3250
3251 3251 inputId = puObj.getInputId()
3252 3252 inputPUObj = self.__puObjDict[inputId]
3253 3253
3254 3254 if inputPUObj.datatype == 'Voltage':
3255 3255 self.specOpnFFTpoints.setEnabled(True)
3256 3256 self.specOpProfiles.setEnabled(True)
3257 3257 self.specOpippFactor.setEnabled(True)
3258 3258 else:
3259 3259 self.specOpnFFTpoints.setEnabled(False)
3260 3260 self.specOpProfiles.setEnabled(False)
3261 3261 self.specOpippFactor.setEnabled(False)
3262 3262
3263 3263 opObj = puObj.getOperationObj(name='setRadarFrequency')
3264 3264 if opObj == None:
3265 3265 self.specOpRadarfrequency.clear()
3266 3266 self.specOpCebRadarfrequency.setCheckState(0)
3267 3267 else:
3268 3268 value = opObj.getParameterValue(parameterName='frequency')
3269 3269 value = str(float(value)/1e6)
3270 3270 self.specOpRadarfrequency.setText(value)
3271 3271 self.specOpRadarfrequency.setEnabled(True)
3272 3272 self.specOpCebRadarfrequency.setCheckState(QtCore.Qt.Checked)
3273 3273
3274 3274 opObj = puObj.getOperationObj(name="run")
3275 3275 if opObj == None:
3276 3276 self.specOpnFFTpoints.clear()
3277 3277 self.specOpProfiles.clear()
3278 3278 self.specOpippFactor.clear()
3279 3279 else:
3280 3280 parmObj = opObj.getParameterObj(parameterName='nFFTPoints')
3281 3281 if parmObj == None:
3282 3282 self.specOpnFFTpoints.clear()
3283 3283 else:
3284 3284 self.specOpnFFTpoints.setEnabled(True)
3285 3285 value = opObj.getParameterValue(parameterName='nFFTPoints')
3286 3286 self.specOpnFFTpoints.setText(str(value))
3287 3287
3288 3288 parmObj = opObj.getParameterObj(parameterName='nProfiles')
3289 3289 if parmObj == None:
3290 3290 self.specOpProfiles.clear()
3291 3291 else:
3292 3292 self.specOpProfiles.setEnabled(True)
3293 3293 value = opObj.getParameterValue(parameterName='nProfiles')
3294 3294 self.specOpProfiles.setText(str(value))
3295 3295
3296 3296 parmObj = opObj.getParameterObj(parameterName='ippFactor')
3297 3297 if parmObj == None:
3298 3298 self.specOpippFactor.clear()
3299 3299 else:
3300 3300 self.specOpippFactor.setEnabled(True)
3301 3301 value = opObj.getParameterValue(parameterName='ippFactor')
3302 3302 self.specOpippFactor.setText(str(value))
3303 3303
3304 3304 opObj = puObj.getOperationObj(name="run")
3305 3305 if opObj == None:
3306 3306 self.specOppairsList.clear()
3307 3307 self.specOpCebCrossSpectra.setCheckState(0)
3308 3308 else:
3309 3309 parmObj = opObj.getParameterObj(parameterName='pairsList')
3310 3310 if parmObj == None:
3311 3311 self.specOppairsList.clear()
3312 3312 self.specOpCebCrossSpectra.setCheckState(0)
3313 3313 else:
3314 3314 value = opObj.getParameterValue(parameterName='pairsList')
3315 3315 value = str(value)[1:-1]
3316 3316 self.specOppairsList.setText(str(value))
3317 3317 self.specOppairsList.setEnabled(True)
3318 3318 self.specOpCebCrossSpectra.setCheckState(QtCore.Qt.Checked)
3319 3319
3320 3320 opObj = puObj.getOperationObj(name="selectChannels")
3321 3321
3322 3322 if opObj == None:
3323 3323 opObj = puObj.getOperationObj(name="selectChannelsByIndex")
3324 3324
3325 3325 if opObj == None:
3326 3326 self.specOpChannel.clear()
3327 3327 self.specOpCebChannel.setCheckState(0)
3328 3328 else:
3329 3329 channelEnabled = False
3330 3330 try:
3331 3331 value = opObj.getParameterValue(parameterName='channelList')
3332 3332 value = str(value)[1:-1]
3333 3333 channelEnabled = True
3334 3334 channelMode = 0
3335 3335 except:
3336 3336 pass
3337 3337 try:
3338 3338 value = opObj.getParameterValue(parameterName='channelIndexList')
3339 3339 value = str(value)[1:-1]
3340 3340 channelEnabled = True
3341 3341 channelMode = 1
3342 3342 except:
3343 3343 pass
3344 3344
3345 3345 if channelEnabled:
3346 3346 self.specOpChannel.setText(value)
3347 3347 self.specOpChannel.setEnabled(True)
3348 3348 self.specOpCebChannel.setCheckState(QtCore.Qt.Checked)
3349 3349 self.specOpComChannel.setCurrentIndex(channelMode)
3350 3350
3351 3351 opObj = puObj.getOperationObj(name="selectHeights")
3352 3352 if opObj == None:
3353 3353 self.specOpHeights.clear()
3354 3354 self.specOpCebHeights.setCheckState(0)
3355 3355 else:
3356 3356 value1 = int(opObj.getParameterValue(parameterName='minHei'))
3357 3357 value1 = str(value1)
3358 3358 value2 = int(opObj.getParameterValue(parameterName='maxHei'))
3359 3359 value2 = str(value2)
3360 3360 value = value1 + "," + value2
3361 3361 self.specOpHeights.setText(value)
3362 3362 self.specOpHeights.setEnabled(True)
3363 3363 self.specOpCebHeights.setCheckState(QtCore.Qt.Checked)
3364 3364
3365 3365 opObj = puObj.getOperationObj(name="IncohInt")
3366 3366 if opObj == None:
3367 3367 self.specOpIncoherent.clear()
3368 3368 self.specOpCebIncoherent.setCheckState(0)
3369 3369 else:
3370 3370 for parmObj in opObj.getParameterObjList():
3371 3371 if parmObj.name == 'timeInterval':
3372 3372 value = opObj.getParameterValue(parameterName='timeInterval')
3373 3373 self.specOpIncoherent.setText(str(value))
3374 3374 self.specOpIncoherent.setEnabled(True)
3375 3375 self.specOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
3376 3376 self.specOpCobIncInt.setCurrentIndex(0)
3377 3377
3378 3378 if parmObj.name == 'n':
3379 3379 value = opObj.getParameterValue(parameterName='n')
3380 3380 self.specOpIncoherent.setText(str(value))
3381 3381 self.specOpIncoherent.setEnabled(True)
3382 3382 self.specOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
3383 3383 self.specOpCobIncInt.setCurrentIndex(1)
3384 3384
3385 3385 opObj = puObj.getOperationObj(name="removeDC")
3386 3386 if opObj == None:
3387 3387 self.specOpCebRemoveDC.setCheckState(0)
3388 3388 else:
3389 3389 self.specOpCebRemoveDC.setCheckState(QtCore.Qt.Checked)
3390 3390
3391 3391 parmObj = opObj.getParameterObj(parameterName='mode')
3392 3392
3393 3393 value = 1
3394 3394 if parmObj:
3395 3395 value = parmObj.getValue()
3396 3396
3397 3397 if value == 1:
3398 3398 self.specOpComRemoveDC.setCurrentIndex(0)
3399 3399 elif value == 2:
3400 3400 self.specOpComRemoveDC.setCurrentIndex(1)
3401 3401
3402 3402 opObj = puObj.getOperationObj(name="removeInterference")
3403 3403 if opObj == None:
3404 3404 self.specOpCebRemoveInt.setCheckState(0)
3405 3405 else:
3406 3406 self.specOpCebRemoveInt.setCheckState(QtCore.Qt.Checked)
3407 3407
3408 3408 opObj = puObj.getOperationObj(name='getNoise')
3409 3409 if opObj == None:
3410 3410 self.specOpCebgetNoise.setCheckState(0)
3411 3411 self.specOpgetNoise.clear()
3412 3412 else:
3413 3413 self.specOpCebgetNoise.setCheckState(QtCore.Qt.Checked)
3414 3414 parmObj = opObj.getParameterObj(parameterName='minHei')
3415 3415 if parmObj == None:
3416 3416 self.specOpgetNoise.clear()
3417 3417 value1 = None
3418 3418 else:
3419 3419 value1 = opObj.getParameterValue(parameterName='minHei')
3420 3420 value1 = str(value1)
3421 3421 parmObj = opObj.getParameterObj(parameterName='maxHei')
3422 3422 if parmObj == None:
3423 3423 value2 = None
3424 3424 value = value1
3425 3425 self.specOpgetNoise.setText(value)
3426 3426 self.specOpgetNoise.setEnabled(True)
3427 3427 else:
3428 3428 value2 = opObj.getParameterValue(parameterName='maxHei')
3429 3429 value2 = str(value2)
3430 3430 parmObj = opObj.getParameterObj(parameterName='minVel')
3431 3431 if parmObj == None:
3432 3432 value3 = None
3433 3433 value = value1 + "," + value2
3434 3434 self.specOpgetNoise.setText(value)
3435 3435 self.specOpgetNoise.setEnabled(True)
3436 3436 else:
3437 3437 value3 = opObj.getParameterValue(parameterName='minVel')
3438 3438 value3 = str(value3)
3439 3439 parmObj = opObj.getParameterObj(parameterName='maxVel')
3440 3440 if parmObj == None:
3441 3441 value4 = None
3442 3442 value = value1 + "," + value2 + "," + value3
3443 3443 self.specOpgetNoise.setText(value)
3444 3444 self.specOpgetNoise.setEnabled(True)
3445 3445 else:
3446 3446 value4 = opObj.getParameterValue(parameterName='maxVel')
3447 3447 value4 = str(value4)
3448 3448 value = value1 + "," + value2 + "," + value3 + ',' + value4
3449 3449 self.specOpgetNoise.setText(value)
3450 3450 self.specOpgetNoise.setEnabled(True)
3451 3451
3452 3452 self.specGraphPath.clear()
3453 3453 self.specGraphPrefix.clear()
3454 3454 self.specGgraphFreq.clear()
3455 3455 self.specGgraphHeight.clear()
3456 3456 self.specGgraphDbsrange.clear()
3457 3457 self.specGgraphmagnitud.clear()
3458 3458 self.specGgraphPhase.clear()
3459 3459 self.specGgraphChannelList.clear()
3460 3460 self.specGgraphTminTmax.clear()
3461 3461 self.specGgraphTimeRange.clear()
3462 3462 self.specGgraphftpratio.clear()
3463 3463
3464 3464 opObj = puObj.getOperationObj(name='SpectraPlot')
3465 3465
3466 3466 if opObj == None:
3467 3467 self.specGraphCebSpectraplot.setCheckState(0)
3468 3468 self.specGraphSaveSpectra.setCheckState(0)
3469 3469 self.specGraphftpSpectra.setCheckState(0)
3470 3470 else:
3471 3471 # operationSpectraPlot = "Enable"
3472 3472 self.specGraphCebSpectraplot.setCheckState(QtCore.Qt.Checked)
3473 3473
3474 3474 parmObj = opObj.getParameterObj(parameterName='show')
3475 3475 if parmObj:
3476 3476 if not parmObj.getValue():
3477 3477 self.specGraphCebSpectraplot.setCheckState(0)
3478 3478
3479 3479 parmObj = opObj.getParameterObj(parameterName='channelList')
3480 3480 if parmObj == None:
3481 3481 self.specGgraphChannelList.clear()
3482 3482 else:
3483 3483 value = opObj.getParameterValue(parameterName='channelList')
3484 3484 channelListSpectraPlot = str(value)[1:-1]
3485 3485 self.specGgraphChannelList.setText(channelListSpectraPlot)
3486 3486 self.specGgraphChannelList.setEnabled(True)
3487 3487
3488 3488 parmObj = opObj.getParameterObj(parameterName='xmin')
3489 3489 if parmObj == None:
3490 3490 self.specGgraphFreq.clear()
3491 3491 else:
3492 3492 value1 = opObj.getParameterValue(parameterName='xmin')
3493 3493 value1 = str(value1)
3494 3494 value2 = opObj.getParameterValue(parameterName='xmax')
3495 3495 value2 = str(value2)
3496 3496 value = value1 + "," + value2
3497 3497 self.specGgraphFreq.setText(value)
3498 3498 self.specGgraphFreq.setEnabled(True)
3499 3499
3500 3500 parmObj = opObj.getParameterObj(parameterName='ymin')
3501 3501 if parmObj == None:
3502 3502 self.specGgraphHeight.clear()
3503 3503 else:
3504 3504 value1 = opObj.getParameterValue(parameterName='ymin')
3505 3505 value1 = str(value1)
3506 3506 value2 = opObj.getParameterValue(parameterName='ymax')
3507 3507 value2 = str(value2)
3508 3508 value = value1 + "," + value2
3509 3509 self.specGgraphHeight.setText(value)
3510 3510 self.specGgraphHeight.setEnabled(True)
3511 3511
3512 3512 parmObj = opObj.getParameterObj(parameterName='zmin')
3513 3513 if parmObj == None:
3514 3514 self.specGgraphDbsrange.clear()
3515 3515 else:
3516 3516 value1 = opObj.getParameterValue(parameterName='zmin')
3517 3517 value1 = str(value1)
3518 3518 value2 = opObj.getParameterValue(parameterName='zmax')
3519 3519 value2 = str(value2)
3520 3520 value = value1 + "," + value2
3521 3521 self.specGgraphDbsrange.setText(value)
3522 3522 self.specGgraphDbsrange.setEnabled(True)
3523 3523
3524 3524 parmObj = opObj.getParameterObj(parameterName="save")
3525 3525 if parmObj == None:
3526 3526 self.specGraphSaveSpectra.setCheckState(0)
3527 3527 else:
3528 3528 self.specGraphSaveSpectra.setCheckState(QtCore.Qt.Checked)
3529 3529
3530 3530 parmObj = opObj.getParameterObj(parameterName="ftp")
3531 3531 if parmObj == None:
3532 3532 self.specGraphftpSpectra.setCheckState(0)
3533 3533 else:
3534 3534 self.specGraphftpSpectra.setCheckState(QtCore.Qt.Checked)
3535 3535
3536 3536 parmObj = opObj.getParameterObj(parameterName="figpath")
3537 3537 if parmObj:
3538 3538 value = parmObj.getValue()
3539 3539 self.specGraphPath.setText(value)
3540 3540
3541 3541 parmObj = opObj.getParameterObj(parameterName="wr_period")
3542 3542 if parmObj:
3543 3543 value = parmObj.getValue()
3544 3544 self.specGgraphftpratio.setText(str(value))
3545 3545
3546 3546 opObj = puObj.getOperationObj(name='CrossSpectraPlot')
3547 3547
3548 3548 if opObj == None:
3549 3549 self.specGraphCebCrossSpectraplot.setCheckState(0)
3550 3550 self.specGraphSaveCross.setCheckState(0)
3551 3551 self.specGraphftpCross.setCheckState(0)
3552 3552 else:
3553 3553 # operationCrossSpectraPlot = "Enable"
3554 3554 self.specGraphCebCrossSpectraplot.setCheckState(QtCore.Qt.Checked)
3555 3555
3556 3556 parmObj = opObj.getParameterObj(parameterName='show')
3557 3557 if parmObj:
3558 3558 if not parmObj.getValue():
3559 3559 self.specGraphCebCrossSpectraplot.setCheckState(0)
3560 3560
3561 3561 parmObj = opObj.getParameterObj(parameterName='xmin')
3562 3562 if parmObj == None:
3563 3563 self.specGgraphFreq.clear()
3564 3564 else:
3565 3565 value1 = opObj.getParameterValue(parameterName='xmin')
3566 3566 value1 = str(value1)
3567 3567 value2 = opObj.getParameterValue(parameterName='xmax')
3568 3568 value2 = str(value2)
3569 3569 value = value1 + "," + value2
3570 3570 self.specGgraphFreq.setText(value)
3571 3571 self.specGgraphFreq.setEnabled(True)
3572 3572
3573 3573 parmObj = opObj.getParameterObj(parameterName='ymin')
3574 3574 if parmObj == None:
3575 3575 self.specGgraphHeight.clear()
3576 3576 else:
3577 3577 value1 = opObj.getParameterValue(parameterName='ymin')
3578 3578 value1 = str(value1)
3579 3579 value2 = opObj.getParameterValue(parameterName='ymax')
3580 3580 value2 = str(value2)
3581 3581 value = value1 + "," + value2
3582 3582 self.specGgraphHeight.setText(value)
3583 3583 self.specGgraphHeight.setEnabled(True)
3584 3584
3585 3585 parmObj = opObj.getParameterObj(parameterName='zmin')
3586 3586 if parmObj == None:
3587 3587 self.specGgraphDbsrange.clear()
3588 3588 else:
3589 3589 value1 = opObj.getParameterValue(parameterName='zmin')
3590 3590 value1 = str(value1)
3591 3591 value2 = opObj.getParameterValue(parameterName='zmax')
3592 3592 value2 = str(value2)
3593 3593 value = value1 + "," + value2
3594 3594 self.specGgraphDbsrange.setText(value)
3595 3595 self.specGgraphDbsrange.setEnabled(True)
3596 3596
3597 3597 parmObj = opObj.getParameterObj(parameterName='coh_min')
3598 3598 if parmObj == None:
3599 3599 self.specGgraphmagnitud.clear()
3600 3600 else:
3601 3601 value1 = opObj.getParameterValue(parameterName='coh_min')
3602 3602 value1 = str(value1)
3603 3603 value2 = opObj.getParameterValue(parameterName='coh_max')
3604 3604 value2 = str(value2)
3605 3605 value = value1 + "," + value2
3606 3606 self.specGgraphmagnitud.setText(value)
3607 3607 self.specGgraphmagnitud.setEnabled(True)
3608 3608
3609 3609 parmObj = opObj.getParameterObj(parameterName='phase_min')
3610 3610 if parmObj == None:
3611 3611 self.specGgraphPhase.clear()
3612 3612 else:
3613 3613 value1 = opObj.getParameterValue(parameterName='phase_min')
3614 3614 value1 = str(value1)
3615 3615 value2 = opObj.getParameterValue(parameterName='phase_max')
3616 3616 value2 = str(value2)
3617 3617 value = value1 + "," + value2
3618 3618 self.specGgraphPhase.setText(value)
3619 3619 self.specGgraphPhase.setEnabled(True)
3620 3620
3621 3621 parmObj = opObj.getParameterObj(parameterName="save")
3622 3622 if parmObj == None:
3623 3623 self.specGraphSaveCross.setCheckState(0)
3624 3624 else:
3625 3625 self.specGraphSaveCross.setCheckState(QtCore.Qt.Checked)
3626 3626
3627 3627 parmObj = opObj.getParameterObj(parameterName="ftp")
3628 3628 if parmObj == None:
3629 3629 self.specGraphftpCross.setCheckState(0)
3630 3630 else:
3631 3631 self.specGraphftpCross.setCheckState(QtCore.Qt.Checked)
3632 3632
3633 3633 parmObj = opObj.getParameterObj(parameterName="figpath")
3634 3634 if parmObj:
3635 3635 value = parmObj.getValue()
3636 3636 self.specGraphPath.setText(value)
3637 3637
3638 3638 parmObj = opObj.getParameterObj(parameterName="wr_period")
3639 3639 if parmObj:
3640 3640 value = parmObj.getValue()
3641 3641 self.specGgraphftpratio.setText(str(value))
3642 3642
3643 3643 opObj = puObj.getOperationObj(name='RTIPlot')
3644 3644
3645 3645 if opObj == None:
3646 3646 self.specGraphCebRTIplot.setCheckState(0)
3647 3647 self.specGraphSaveRTIplot.setCheckState(0)
3648 3648 self.specGraphftpRTIplot.setCheckState(0)
3649 3649 else:
3650 3650 self.specGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
3651 3651
3652 3652 parmObj = opObj.getParameterObj(parameterName='show')
3653 3653 if parmObj:
3654 3654 if not parmObj.getValue():
3655 3655 self.specGraphCebRTIplot.setCheckState(0)
3656 3656
3657 3657 parmObj = opObj.getParameterObj(parameterName='channelList')
3658 3658 if parmObj == None:
3659 3659 self.specGgraphChannelList.clear()
3660 3660 else:
3661 3661 value = opObj.getParameterValue(parameterName='channelList')
3662 3662 channelListRTIPlot = str(value)[1:-1]
3663 3663 self.specGgraphChannelList.setText(channelListRTIPlot)
3664 3664 self.specGgraphChannelList.setEnabled(True)
3665 3665
3666 3666 parmObj = opObj.getParameterObj(parameterName='xmin')
3667 3667 if parmObj == None:
3668 3668 self.specGgraphTminTmax.clear()
3669 3669 else:
3670 3670 value1 = opObj.getParameterValue(parameterName='xmin')
3671 3671 value1 = str(value1)
3672 3672 value2 = opObj.getParameterValue(parameterName='xmax')
3673 3673 value2 = str(value2)
3674 3674 value = value1 + "," + value2
3675 3675 self.specGgraphTminTmax.setText(value)
3676 3676 self.specGgraphTminTmax.setEnabled(True)
3677 3677
3678 3678 parmObj = opObj.getParameterObj(parameterName='timerange')
3679 3679 if parmObj == None:
3680 3680 self.specGgraphTimeRange.clear()
3681 3681 else:
3682 3682 value1 = opObj.getParameterValue(parameterName='timerange')
3683 3683 value1 = str(value1)
3684 3684 self.specGgraphTimeRange.setText(value1)
3685 3685 self.specGgraphTimeRange.setEnabled(True)
3686 3686
3687 3687 parmObj = opObj.getParameterObj(parameterName='ymin')
3688 3688 if parmObj == None:
3689 3689 self.specGgraphHeight.clear()
3690 3690 else:
3691 3691 value1 = opObj.getParameterValue(parameterName='ymin')
3692 3692 value1 = str(value1)
3693 3693 value2 = opObj.getParameterValue(parameterName='ymax')
3694 3694 value2 = str(value2)
3695 3695 value = value1 + "," + value2
3696 3696 self.specGgraphHeight.setText(value)
3697 3697 self.specGgraphHeight.setEnabled(True)
3698 3698
3699 3699 parmObj = opObj.getParameterObj(parameterName='zmin')
3700 3700 if parmObj == None:
3701 3701 self.specGgraphDbsrange.clear()
3702 3702 else:
3703 3703 value1 = opObj.getParameterValue(parameterName='zmin')
3704 3704 value1 = str(value1)
3705 3705 value2 = opObj.getParameterValue(parameterName='zmax')
3706 3706 value2 = str(value2)
3707 3707 value = value1 + "," + value2
3708 3708 self.specGgraphDbsrange.setText(value)
3709 3709 self.specGgraphDbsrange.setEnabled(True)
3710 3710
3711 3711 parmObj = opObj.getParameterObj(parameterName="save")
3712 3712 if parmObj == None:
3713 3713 self.specGraphSaveRTIplot.setCheckState(0)
3714 3714 else:
3715 3715 self.specGraphSaveRTIplot.setCheckState(QtCore.Qt.Checked)
3716 3716
3717 3717 parmObj = opObj.getParameterObj(parameterName="ftp")
3718 3718 if parmObj == None:
3719 3719 self.specGraphftpRTIplot.setCheckState(0)
3720 3720 else:
3721 3721 self.specGraphftpRTIplot.setCheckState(QtCore.Qt.Checked)
3722 3722
3723 3723 parmObj = opObj.getParameterObj(parameterName="figpath")
3724 3724 if parmObj:
3725 3725 value = parmObj.getValue()
3726 3726 self.specGraphPath.setText(value)
3727 3727
3728 3728 parmObj = opObj.getParameterObj(parameterName="wr_period")
3729 3729 if parmObj:
3730 3730 value = parmObj.getValue()
3731 3731 self.specGgraphftpratio.setText(str(value))
3732 3732
3733 3733 opObj = puObj.getOperationObj(name='CoherenceMap')
3734 3734
3735 3735 if opObj == None:
3736 3736 self.specGraphCebCoherencmap.setCheckState(0)
3737 3737 self.specGraphSaveCoherencemap.setCheckState(0)
3738 3738 self.specGraphftpCoherencemap.setCheckState(0)
3739 3739 else:
3740 3740 # operationCoherenceMap = "Enable"
3741 3741 self.specGraphCebCoherencmap.setCheckState(QtCore.Qt.Checked)
3742 3742
3743 3743 parmObj = opObj.getParameterObj(parameterName='show')
3744 3744 if parmObj:
3745 3745 if not parmObj.getValue():
3746 3746 self.specGraphCebCoherencmap.setCheckState(0)
3747 3747
3748 3748 parmObj = opObj.getParameterObj(parameterName='xmin')
3749 3749 if parmObj == None:
3750 3750 self.specGgraphTminTmax.clear()
3751 3751 else:
3752 3752 value1 = opObj.getParameterValue(parameterName='xmin')
3753 3753 value1 = str(value1)
3754 3754 value2 = opObj.getParameterValue(parameterName='xmax')
3755 3755 value2 = str(value2)
3756 3756 value = value1 + "," + value2
3757 3757 self.specGgraphTminTmax.setText(value)
3758 3758 self.specGgraphTminTmax.setEnabled(True)
3759 3759
3760 3760 parmObj = opObj.getParameterObj(parameterName='timerange')
3761 3761 if parmObj == None:
3762 3762 self.specGgraphTimeRange.clear()
3763 3763 else:
3764 3764 value1 = opObj.getParameterValue(parameterName='timerange')
3765 3765 value1 = str(value1)
3766 3766 self.specGgraphTimeRange.setText(value1)
3767 3767 self.specGgraphTimeRange.setEnabled(True)
3768 3768
3769 3769 parmObj = opObj.getParameterObj(parameterName='ymin')
3770 3770 if parmObj == None:
3771 3771 self.specGgraphHeight.clear()
3772 3772 else:
3773 3773 value1 = opObj.getParameterValue(parameterName='ymin')
3774 3774 value1 = str(value1)
3775 3775 value2 = opObj.getParameterValue(parameterName='ymax')
3776 3776 value2 = str(value2)
3777 3777 value = value1 + "," + value2
3778 3778 self.specGgraphHeight.setText(value)
3779 3779 self.specGgraphHeight.setEnabled(True)
3780 3780
3781 3781 parmObj = opObj.getParameterObj(parameterName='zmin')
3782 3782 if parmObj == None:
3783 3783 self.specGgraphmagnitud.clear()
3784 3784 else:
3785 3785 value1 = opObj.getParameterValue(parameterName='zmin')
3786 3786 value1 = str(value1)
3787 3787 value2 = opObj.getParameterValue(parameterName='zmax')
3788 3788 value2 = str(value2)
3789 3789 value = value1 + "," + value2
3790 3790 self.specGgraphmagnitud.setText(value)
3791 3791 self.specGgraphmagnitud.setEnabled(True)
3792 3792
3793 3793 parmObj = opObj.getParameterObj(parameterName='coh_min')
3794 3794 if parmObj == None:
3795 3795 self.specGgraphmagnitud.clear()
3796 3796 else:
3797 3797 value1 = opObj.getParameterValue(parameterName='coh_min')
3798 3798 value1 = str(value1)
3799 3799 value2 = opObj.getParameterValue(parameterName='coh_max')
3800 3800 value2 = str(value2)
3801 3801 value = value1 + "," + value2
3802 3802 self.specGgraphmagnitud.setText(value)
3803 3803 self.specGgraphmagnitud.setEnabled(True)
3804 3804
3805 3805 parmObj = opObj.getParameterObj(parameterName='phase_min')
3806 3806 if parmObj == None:
3807 3807 self.specGgraphPhase.clear()
3808 3808 else:
3809 3809 value1 = opObj.getParameterValue(parameterName='phase_min')
3810 3810 value1 = str(value1)
3811 3811 value2 = opObj.getParameterValue(parameterName='phase_max')
3812 3812 value2 = str(value2)
3813 3813 value = value1 + "," + value2
3814 3814 self.specGgraphPhase.setText(value)
3815 3815 self.specGgraphPhase.setEnabled(True)
3816 3816
3817 3817 parmObj = opObj.getParameterObj(parameterName="save")
3818 3818 if parmObj == None:
3819 3819 self.specGraphSaveCoherencemap.setCheckState(0)
3820 3820 else:
3821 3821 self.specGraphSaveCoherencemap.setCheckState(QtCore.Qt.Checked)
3822 3822
3823 3823 parmObj = opObj.getParameterObj(parameterName="ftp")
3824 3824 if parmObj == None:
3825 3825 self.specGraphftpCoherencemap.setCheckState(0)
3826 3826 else:
3827 3827 self.specGraphftpCoherencemap.setCheckState(QtCore.Qt.Checked)
3828 3828
3829 3829 parmObj = opObj.getParameterObj(parameterName="figpath")
3830 3830 if parmObj:
3831 3831 value = parmObj.getValue()
3832 3832 self.specGraphPath.setText(value)
3833 3833
3834 3834 parmObj = opObj.getParameterObj(parameterName="wr_period")
3835 3835 if parmObj:
3836 3836 value = parmObj.getValue()
3837 3837 self.specGgraphftpratio.setText(str(value))
3838 3838
3839 3839 opObj = puObj.getOperationObj(name='PowerProfilePlot')
3840 3840
3841 3841 if opObj == None:
3842 3842 self.specGraphPowerprofile.setCheckState(0)
3843 3843 self.specGraphSavePowerprofile.setCheckState(0)
3844 3844 self.specGraphftpPowerprofile.setCheckState(0)
3845 3845 operationPowerProfilePlot = "Disabled"
3846 3846 channelList = None
3847 3847 freq_vel = None
3848 3848 heightsrange = None
3849 3849 else:
3850 3850 # operationPowerProfilePlot = "Enable"
3851 3851 self.specGraphPowerprofile.setCheckState(QtCore.Qt.Checked)
3852 3852
3853 3853 parmObj = opObj.getParameterObj(parameterName='show')
3854 3854 if parmObj:
3855 3855 if not parmObj.getValue():
3856 3856 self.specGraphPowerprofile.setCheckState(0)
3857 3857
3858 3858 parmObj = opObj.getParameterObj(parameterName='xmin')
3859 3859 if parmObj == None:
3860 3860 self.specGgraphDbsrange.clear()
3861 3861 else:
3862 3862 value1 = opObj.getParameterValue(parameterName='xmin')
3863 3863 value1 = str(value1)
3864 3864 value2 = opObj.getParameterValue(parameterName='xmax')
3865 3865 value2 = str(value2)
3866 3866 value = value1 + "," + value2
3867 3867 self.specGgraphDbsrange.setText(value)
3868 3868 self.specGgraphDbsrange.setEnabled(True)
3869 3869
3870 3870 parmObj = opObj.getParameterObj(parameterName='ymin')
3871 3871 if parmObj == None:
3872 3872 self.specGgraphHeight.clear()
3873 3873 else:
3874 3874 value1 = opObj.getParameterValue(parameterName='ymin')
3875 3875 value1 = str(value1)
3876 3876 value2 = opObj.getParameterValue(parameterName='ymax')
3877 3877 value2 = str(value2)
3878 3878 value = value1 + "," + value2
3879 3879 self.specGgraphHeight.setText(value)
3880 3880 self.specGgraphHeight.setEnabled(True)
3881 3881
3882 3882 parmObj = opObj.getParameterObj(parameterName="save")
3883 3883 if parmObj == None:
3884 3884 self.specGraphSavePowerprofile.setCheckState(0)
3885 3885 else:
3886 3886 self.specGraphSavePowerprofile.setCheckState(QtCore.Qt.Checked)
3887 3887
3888 3888 parmObj = opObj.getParameterObj(parameterName="ftp")
3889 3889 if parmObj == None:
3890 3890 self.specGraphftpPowerprofile.setCheckState(0)
3891 3891 else:
3892 3892 self.specGraphftpPowerprofile.setCheckState(QtCore.Qt.Checked)
3893 3893
3894 3894 parmObj = opObj.getParameterObj(parameterName="figpath")
3895 3895 if parmObj:
3896 3896 value = parmObj.getValue()
3897 3897 self.specGraphPath.setText(value)
3898 3898
3899 3899 parmObj = opObj.getParameterObj(parameterName="wr_period")
3900 3900 if parmObj:
3901 3901 value = parmObj.getValue()
3902 3902 self.specGgraphftpratio.setText(str(value))
3903 3903
3904 3904 opObj = puObj.getOperationObj(name='Noise')
3905 3905
3906 3906 if opObj == None:
3907 3907 self.specGraphCebRTInoise.setCheckState(0)
3908 3908 self.specGraphSaveRTInoise.setCheckState(0)
3909 3909 self.specGraphftpRTInoise.setCheckState(0)
3910 3910 else:
3911 3911 self.specGraphCebRTInoise.setCheckState(QtCore.Qt.Checked)
3912 3912
3913 3913 parmObj = opObj.getParameterObj(parameterName='show')
3914 3914 if parmObj:
3915 3915 if not parmObj.getValue():
3916 3916 self.specGraphCebRTInoise.setCheckState(0)
3917 3917
3918 3918 parmObj = opObj.getParameterObj(parameterName='channelList')
3919 3919 if parmObj == None:
3920 3920 self.specGgraphChannelList.clear()
3921 3921 else:
3922 3922 value = opObj.getParameterValue(parameterName='channelList')
3923 3923 channelListRTINoise = str(value)[1:-1]
3924 3924 self.specGgraphChannelList.setText(channelListRTINoise)
3925 3925 self.specGgraphChannelList.setEnabled(True)
3926 3926
3927 3927 parmObj = opObj.getParameterObj(parameterName='xmin')
3928 3928 if parmObj == None:
3929 3929 self.specGgraphTminTmax.clear()
3930 3930 else:
3931 3931 value1 = opObj.getParameterValue(parameterName='xmin')
3932 3932 value1 = str(value1)
3933 3933 value2 = opObj.getParameterValue(parameterName='xmax')
3934 3934 value2 = str(value2)
3935 3935 value = value1 + "," + value2
3936 3936 self.specGgraphTminTmax.setText(value)
3937 3937 self.specGgraphTminTmax.setEnabled(True)
3938 3938
3939 3939 parmObj = opObj.getParameterObj(parameterName='timerange')
3940 3940 if parmObj == None:
3941 3941 self.specGgraphTimeRange.clear()
3942 3942 else:
3943 3943 value1 = opObj.getParameterValue(parameterName='timerange')
3944 3944 value1 = str(value1)
3945 3945 self.specGgraphTimeRange.setText(value1)
3946 3946 self.specGgraphTimeRange.setEnabled(True)
3947 3947
3948 3948
3949 3949 parmObj = opObj.getParameterObj(parameterName='ymin')
3950 3950 if parmObj == None:
3951 3951 self.specGgraphDbsrange.clear()
3952 3952 else:
3953 3953 value1 = opObj.getParameterValue(parameterName='ymin')
3954 3954 value1 = str(value1)
3955 3955 value2 = opObj.getParameterValue(parameterName='ymax')
3956 3956 value2 = str(value2)
3957 3957 value = value1 + "," + value2
3958 3958 self.specGgraphDbsrange.setText(value)
3959 3959 self.specGgraphDbsrange.setEnabled(True)
3960 3960
3961 3961 parmObj = opObj.getParameterObj(parameterName="save")
3962 3962 if parmObj == None:
3963 3963 self.specGraphSaveRTInoise.setCheckState(0)
3964 3964 else:
3965 3965 self.specGraphSaveRTInoise.setCheckState(QtCore.Qt.Checked)
3966 3966
3967 3967 parmObj = opObj.getParameterObj(parameterName="ftp")
3968 3968 if parmObj == None:
3969 3969 self.specGraphftpRTInoise.setCheckState(0)
3970 3970 else:
3971 3971 self.specGraphftpRTInoise.setCheckState(QtCore.Qt.Checked)
3972 3972
3973 3973 parmObj = opObj.getParameterObj(parameterName="figpath")
3974 3974 if parmObj:
3975 3975 value = parmObj.getValue()
3976 3976 self.specGraphPath.setText(value)
3977 3977
3978 3978 parmObj = opObj.getParameterObj(parameterName="wr_period")
3979 3979 if parmObj:
3980 3980 value = parmObj.getValue()
3981 3981 self.specGgraphftpratio.setText(str(value))
3982 3982
3983 3983 opObj = puObj.getOperationObj(name='SpectraWriter')
3984 3984 if opObj == None:
3985 3985 self.specOutputPath.clear()
3986 3986 self.specOutputblocksperfile.clear()
3987 3987 else:
3988 3988 value = opObj.getParameterObj(parameterName='path')
3989 3989 if value == None:
3990 3990 self.specOutputPath.clear()
3991 3991 else:
3992 3992 value = opObj.getParameterValue(parameterName='path')
3993 3993 path = str(value)
3994 3994 self.specOutputPath.setText(path)
3995 3995 value = opObj.getParameterObj(parameterName='blocksPerFile')
3996 3996 if value == None:
3997 3997 self.specOutputblocksperfile.clear()
3998 3998 else:
3999 3999 value = opObj.getParameterValue(parameterName='blocksPerFile')
4000 4000 blocksperfile = str(value)
4001 4001 self.specOutputblocksperfile.setText(blocksperfile)
4002 4002
4003 4003 return
4004 4004
4005 4005 def __refreshSpectraHeisWindow(self, puObj):
4006 4006
4007 4007 opObj = puObj.getOperationObj(name="IncohInt4SpectraHeis")
4008 4008 if opObj == None:
4009 4009 self.specHeisOpIncoherent.clear()
4010 4010 self.specHeisOpCebIncoherent.setCheckState(0)
4011 4011 else:
4012 4012 for parmObj in opObj.getParameterObjList():
4013 4013 if parmObj.name == 'timeInterval':
4014 4014 value = opObj.getParameterValue(parameterName='timeInterval')
4015 4015 self.specHeisOpIncoherent.setText(str(value))
4016 4016 self.specHeisOpIncoherent.setEnabled(True)
4017 4017 self.specHeisOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
4018 4018 self.specHeisOpCobIncInt.setCurrentIndex(0)
4019 4019
4020 4020 # SpectraHeis Graph
4021 4021
4022 4022 self.specHeisGgraphXminXmax.clear()
4023 4023 self.specHeisGgraphYminYmax.clear()
4024 4024
4025 4025 self.specHeisGgraphChannelList.clear()
4026 4026 self.specHeisGgraphTminTmax.clear()
4027 4027 self.specHeisGgraphTimeRange.clear()
4028 4028 self.specHeisGgraphftpratio.clear()
4029 4029
4030 4030 opObj = puObj.getOperationObj(name='SpectraHeisScope')
4031 4031 if opObj == None:
4032 4032 self.specHeisGraphCebSpectraplot.setCheckState(0)
4033 4033 self.specHeisGraphSaveSpectra.setCheckState(0)
4034 4034 self.specHeisGraphftpSpectra.setCheckState(0)
4035 4035 else:
4036 4036 operationSpectraHeisScope = "Enable"
4037 4037 self.specHeisGraphCebSpectraplot.setCheckState(QtCore.Qt.Checked)
4038 4038
4039 4039 parmObj = opObj.getParameterObj(parameterName='channelList')
4040 4040 if parmObj == None:
4041 4041 self.specHeisGgraphChannelList.clear()
4042 4042 else:
4043 4043 value = opObj.getParameterValue(parameterName='channelList')
4044 4044 channelListSpectraHeisScope = str(value)[1:-1]
4045 4045 self.specHeisGgraphChannelList.setText(channelListSpectraHeisScope)
4046 4046 self.specHeisGgraphChannelList.setEnabled(True)
4047 4047
4048 4048 parmObj = opObj.getParameterObj(parameterName='xmin')
4049 4049 if parmObj == None:
4050 4050 self.specHeisGgraphXminXmax.clear()
4051 4051 else:
4052 4052 value1 = opObj.getParameterValue(parameterName='xmin')
4053 4053 value1 = str(value1)
4054 4054 value2 = opObj.getParameterValue(parameterName='xmax')
4055 4055 value2 = str(value2)
4056 4056 value = value1 + "," + value2
4057 4057 self.specHeisGgraphXminXmax.setText(value)
4058 4058 self.specHeisGgraphXminXmax.setEnabled(True)
4059 4059
4060 4060 parmObj = opObj.getParameterObj(parameterName='ymin')
4061 4061 if parmObj == None:
4062 4062 self.specHeisGgraphYminYmax.clear()
4063 4063 else:
4064 4064 value1 = opObj.getParameterValue(parameterName='ymin')
4065 4065 value1 = str(value1)
4066 4066 value2 = opObj.getParameterValue(parameterName='ymax')
4067 4067 value2 = str(value2)
4068 4068 value = value1 + "," + value2
4069 4069 self.specHeisGgraphYminYmax.setText(value)
4070 4070 self.specHeisGgraphYminYmax.setEnabled(True)
4071 4071
4072 4072 parmObj = opObj.getParameterObj(parameterName="save")
4073 4073 if parmObj == None:
4074 4074 self.specHeisGraphSaveSpectra.setCheckState(0)
4075 4075 else:
4076 4076 self.specHeisGraphSaveSpectra.setCheckState(QtCore.Qt.Checked)
4077 4077
4078 4078 parmObj = opObj.getParameterObj(parameterName="ftp")
4079 4079 if parmObj == None:
4080 4080 self.specHeisGraphftpSpectra.setCheckState(0)
4081 4081 else:
4082 4082 self.specHeisGraphftpSpectra.setCheckState(QtCore.Qt.Checked)
4083 4083
4084 4084 parmObj = opObj.getParameterObj(parameterName="figpath")
4085 4085 if parmObj:
4086 4086 value = parmObj.getValue()
4087 4087 self.specHeisGraphPath.setText(value)
4088 4088
4089 4089 parmObj = opObj.getParameterObj(parameterName="wr_period")
4090 4090 if parmObj:
4091 4091 value = parmObj.getValue()
4092 4092 self.specHeisGgraphftpratio.setText(str(value))
4093 4093
4094 4094 opObj = puObj.getOperationObj(name='RTIfromSpectraHeis')
4095 4095
4096 4096 if opObj == None:
4097 4097 self.specHeisGraphCebRTIplot.setCheckState(0)
4098 4098 self.specHeisGraphSaveRTIplot.setCheckState(0)
4099 4099 self.specHeisGraphftpRTIplot.setCheckState(0)
4100 4100 else:
4101 4101 self.specHeisGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
4102 4102 parmObj = opObj.getParameterObj(parameterName='channelList')
4103 4103 if parmObj == None:
4104 4104 self.specHeisGgraphChannelList.clear()
4105 4105 else:
4106 4106 value = opObj.getParameterValue(parameterName='channelList')
4107 4107 channelListRTIPlot = str(value)[1:-1]
4108 4108 self.specGgraphChannelList.setText(channelListRTIPlot)
4109 4109 self.specGgraphChannelList.setEnabled(True)
4110 4110
4111 4111 parmObj = opObj.getParameterObj(parameterName='xmin')
4112 4112 if parmObj == None:
4113 4113 self.specHeisGgraphTminTmax.clear()
4114 4114 else:
4115 4115 value1 = opObj.getParameterValue(parameterName='xmin')
4116 4116 value1 = str(value1)
4117 4117 value2 = opObj.getParameterValue(parameterName='xmax')
4118 4118 value2 = str(value2)
4119 4119 value = value1 + "," + value2
4120 4120 self.specHeisGgraphTminTmax.setText(value)
4121 4121 self.specHeisGgraphTminTmax.setEnabled(True)
4122 4122
4123 4123 parmObj = opObj.getParameterObj(parameterName='timerange')
4124 4124 if parmObj == None:
4125 4125 self.specGgraphTimeRange.clear()
4126 4126 else:
4127 4127 value1 = opObj.getParameterValue(parameterName='timerange')
4128 4128 value1 = str(value1)
4129 4129 self.specHeisGgraphTimeRange.setText(value1)
4130 4130 self.specHeisGgraphTimeRange.setEnabled(True)
4131 4131
4132 4132 parmObj = opObj.getParameterObj(parameterName='ymin')
4133 4133 if parmObj == None:
4134 4134 self.specHeisGgraphYminYmax.clear()
4135 4135 else:
4136 4136 value1 = opObj.getParameterValue(parameterName='ymin')
4137 4137 value1 = str(value1)
4138 4138 value2 = opObj.getParameterValue(parameterName='ymax')
4139 4139 value2 = str(value2)
4140 4140 value = value1 + "," + value2
4141 4141 self.specHeisGgraphYminYmax.setText(value)
4142 4142 self.specHeisGgraphYminYmax.setEnabled(True)
4143 4143
4144 4144 parmObj = opObj.getParameterObj(parameterName="save")
4145 4145 if parmObj == None:
4146 4146 self.specHeisGraphSaveRTIplot.setCheckState(0)
4147 4147 else:
4148 4148 self.specHeisGraphSaveRTIplot.setCheckState(QtCore.Qt.Checked)
4149 4149
4150 4150 parmObj = opObj.getParameterObj(parameterName="ftp")
4151 4151 if parmObj == None:
4152 4152 self.specHeisGraphftpRTIplot.setCheckState(0)
4153 4153 else:
4154 4154 self.specHeisGraphftpRTIplot.setCheckState(QtCore.Qt.Checked)
4155 4155
4156 4156 parmObj = opObj.getParameterObj(parameterName="figpath")
4157 4157 if parmObj:
4158 4158 value = parmObj.getValue()
4159 4159 self.specHeisGraphPath.setText(value)
4160 4160
4161 4161 parmObj = opObj.getParameterObj(parameterName="wr_period")
4162 4162 if parmObj:
4163 4163 value = parmObj.getValue()
4164 4164 self.specHeisGgraphftpratio.setText(str(value))
4165 4165
4166 4166 # outputSpectraHeisWrite
4167 4167 opObj = puObj.getOperationObj(name='FitsWriter')
4168 4168 if opObj == None:
4169 4169 self.specHeisOutputPath.clear()
4170 4170 self.specHeisOutputblocksperfile.clear()
4171 4171 self.specHeisOutputMetada.clear()
4172 4172 else:
4173 4173 value = opObj.getParameterObj(parameterName='path')
4174 4174 if value == None:
4175 4175 self.specHeisOutputPath.clear()
4176 4176 else:
4177 4177 value = opObj.getParameterValue(parameterName='path')
4178 4178 path = str(value)
4179 4179 self.specHeisOutputPath.setText(path)
4180 4180 value = opObj.getParameterObj(parameterName='dataBlocksPerFile')
4181 4181 if value == None:
4182 4182 self.specHeisOutputblocksperfile.clear()
4183 4183 else:
4184 4184 value = opObj.getParameterValue(parameterName='dataBlocksPerFile')
4185 4185 blocksperfile = str(value)
4186 4186 self.specHeisOutputblocksperfile.setText(blocksperfile)
4187 4187 value = opObj.getParameterObj(parameterName='metadatafile')
4188 4188 if value == None:
4189 4189 self.specHeisOutputMetada.clear()
4190 4190 else:
4191 4191 value = opObj.getParameterValue(parameterName='metadatafile')
4192 4192 metadata_file = str(value)
4193 4193 self.specHeisOutputMetada.setText(metadata_file)
4194 4194
4195 4195 return
4196 4196
4197 4197 def __refreshCorrelationWindow(self, puObj):
4198 4198 pass
4199 4199
4200 4200 def refreshPUWindow(self, puObj):
4201 4201
4202 4202 if puObj.datatype == 'Voltage':
4203 4203 self.__refreshVoltageWindow(puObj)
4204 4204
4205 4205 if puObj.datatype == 'Spectra':
4206 4206 self.__refreshSpectraWindow(puObj)
4207 4207
4208 4208 if puObj.datatype == 'SpectraHeis':
4209 4209 self.__refreshSpectraHeisWindow(puObj)
4210 4210
4211 4211 def refreshProjectProperties(self, projectObjView):
4212 4212
4213 4213 propertyBuffObj = PropertyBuffer()
4214 4214 name = projectObjView.name
4215 4215
4216 4216 propertyBuffObj.append("Properties", "Name", projectObjView.name),
4217 4217 propertyBuffObj.append("Properties", "Description", projectObjView.description)
4218 4218 propertyBuffObj.append("Properties", "Workspace", self.pathWorkSpace)
4219 4219
4220 4220 readUnitObj = projectObjView.getReadUnitObj()
4221 4221 runOperationObj = readUnitObj.getOperationObj(name='run')
4222 4222
4223 4223 for thisParmObj in runOperationObj.getParameterObjList():
4224 4224 propertyBuffObj.append("Reading parms", thisParmObj.name, str(thisParmObj.getValue()))
4225 4225
4226 4226 propertiesModel = propertyBuffObj.getPropertyModel()
4227 4227
4228 4228 self.treeProjectProperties.setModel(propertiesModel)
4229 4229 self.treeProjectProperties.expandAll()
4230 4230 self.treeProjectProperties.resizeColumnToContents(0)
4231 4231 self.treeProjectProperties.resizeColumnToContents(1)
4232 4232
4233 4233 def refreshPUProperties(self, puObjView):
4234 4234
4235 4235 ############ FTP CONFIG ################################
4236 4236 #Deleting FTP Conf. This processing unit have not got any
4237 4237 #FTP configuration by default
4238 4238 if puObjView.id in self.__puLocalFolder2FTP.keys():
4239 4239 self.__puLocalFolder2FTP.pop(puObjView.id)
4240 4240 ########################################################
4241 4241
4242 4242 propertyBuffObj = PropertyBuffer()
4243 4243
4244 4244 for thisOp in puObjView.getOperationObjList():
4245 4245
4246 4246 operationName = thisOp.name
4247 4247
4248 4248 if operationName == 'run':
4249 4249 operationName = 'Properties'
4250 4250
4251 4251 else:
4252 4252 if not thisOp.getParameterObjList():
4253 4253 propertyBuffObj.append(operationName, '--', '--')
4254 4254 continue
4255 4255
4256 4256 for thisParmObj in thisOp.getParameterObjList():
4257 4257 propertyBuffObj.append(operationName, thisParmObj.name, str(thisParmObj.getValue()))
4258 4258
4259 4259 ############ FTP CONFIG ################################
4260 4260 if thisParmObj.name == "ftp_wei" and thisParmObj.getValue():
4261 4261 value = thisParmObj.getValue()
4262 4262 self.temporalFTP.ftp_wei = value
4263 4263
4264 4264 if thisParmObj.name == "exp_code" and thisParmObj.getValue():
4265 4265 value = thisParmObj.getValue()
4266 4266 self.temporalFTP.exp_code = value
4267 4267
4268 4268 if thisParmObj.name == "sub_exp_code" and thisParmObj.getValue():
4269 4269 value = thisParmObj.getValue()
4270 4270 self.temporalFTP.sub_exp_code = value
4271 4271
4272 4272 if thisParmObj.name == "plot_pos" and thisParmObj.getValue():
4273 4273 value = thisParmObj.getValue()
4274 4274 self.temporalFTP.plot_pos = value
4275 4275
4276 4276 if thisParmObj.name == 'ftp' and thisParmObj.getValue():
4277 4277 figpathObj = thisOp.getParameterObj('figpath')
4278 4278 if figpathObj:
4279 4279 self.__puLocalFolder2FTP[puObjView.id] = figpathObj.getValue()
4280 4280
4281 4281 ########################################################
4282 4282
4283 4283 propertiesModel = propertyBuffObj.getPropertyModel()
4284 4284
4285 4285 self.treeProjectProperties.setModel(propertiesModel)
4286 4286 self.treeProjectProperties.expandAll()
4287 4287 self.treeProjectProperties.resizeColumnToContents(0)
4288 4288 self.treeProjectProperties.resizeColumnToContents(1)
4289 4289
4290 4290 def refreshGraphicsId(self):
4291 4291
4292 4292 projectObj = self.getSelectedProjectObj()
4293 4293
4294 4294 if not projectObj:
4295 4295 return
4296 4296
4297 4297 for idPU, puObj in projectObj.procUnitConfObjDict.items():
4298 4298
4299 4299 for opObj in puObj.getOperationObjList():
4300 4300
4301 4301 if opObj.name not in ('Scope', 'SpectraPlot', 'CrossSpectraPlot', 'RTIPlot', 'CoherenceMap', 'PowerProfilePlot', 'Noise', 'SpectraHeisScope', 'RTIfromSpectraHeis'):
4302 4302 continue
4303 4303
4304 4304 opObj.changeParameter(name='id', value=opObj.id, format='int')
4305 4305
4306 4306 def on_click(self, index):
4307 4307
4308 4308 self._disable_save_button()
4309 4309 self._disable_play_button()
4310 4310
4311 4311 self.console.clear()
4312 4312
4313 4313 self.selectedItemTree = self.projectExplorerModel.itemFromIndex(index)
4314 4314
4315 4315 projectObjView = self.getSelectedProjectObj()
4316 4316
4317 4317 if not projectObjView:
4318 4318 return
4319 4319
4320 4320 self.create = False
4321 4321 selectedObjView = self.getSelectedItemObj()
4322 4322
4323 4323 self.refreshProjectWindow(projectObjView)
4324 4324 self.refreshProjectProperties(projectObjView)
4325 4325
4326 4326 #A project has been selected
4327 4327 if projectObjView == selectedObjView:
4328 4328
4329 4329 self.tabProject.setEnabled(True)
4330 4330 self.tabVoltage.setEnabled(False)
4331 4331 self.tabSpectra.setEnabled(False)
4332 4332 self.tabCorrelation.setEnabled(False)
4333 4333 self.tabSpectraHeis.setEnabled(False)
4334 4334 self.tabWidgetProject.setCurrentWidget(self.tabProject)
4335 4335
4336 4336 if self.dateList:
4337 4337 self._enable_save_button()
4338 4338 self._enable_play_button()
4339 4339
4340 4340 return
4341 4341
4342 4342 #A processing unit has been selected
4343 4343 voltEnable = False
4344 4344 specEnable = False
4345 4345 corrEnable = False
4346 4346 specHeisEnable = False
4347 4347 tabSelected = self.tabProject
4348 4348
4349 4349 puObj = selectedObjView
4350 4350
4351 4351 self.refreshPUWindow(puObj)
4352 4352 self.refreshPUProperties(puObj)
4353 4353 self.showtabPUCreated(puObj.datatype)
4354 4354
4355 4355 if self.dateList:
4356 4356 self._enable_save_button()
4357 4357 self._enable_play_button()
4358 4358
4359 4359 def on_right_click(self, pos):
4360 4360
4361 4361 self.menu = QtGui.QMenu()
4362 4362 quitAction0 = self.menu.addAction("Create a New Project")
4363 4363 quitAction1 = self.menu.addAction("Create a New Processing Unit")
4364 4364 quitAction2 = self.menu.addAction("Delete Item")
4365 4365 quitAction3 = self.menu.addAction("Quit")
4366 4366
4367 4367 if len(self.__itemTreeDict) == 0:
4368 4368 quitAction2.setEnabled(False)
4369 4369 else:
4370 4370 quitAction2.setEnabled(True)
4371 4371
4372 4372 action = self.menu.exec_(self.mapToGlobal(pos))
4373 4373
4374 4374 if action == quitAction0:
4375 4375 self. setInputsProject_View()
4376 4376 self.create = True
4377 4377
4378 4378 if action == quitAction1:
4379 4379 if len(self.__projectObjDict) == 0:
4380 4380 outputstr = "You need to create a Project before adding a Processing Unit"
4381 4381 self.console.clear()
4382 4382 self.console.append(outputstr)
4383 4383 return 0
4384 4384 else:
4385 4385 self.addPUWindow()
4386 4386 self.console.clear()
4387 4387 self.console.append("Please, Choose the type of Processing Unit")
4388 4388 # self.console.append("If your Datatype is rawdata, you will start with processing unit Type Voltage")
4389 4389 # self.console.append("If your Datatype is pdata, you will choose between processing unit Type Spectra or Correlation")
4390 4390 # self.console.append("If your Datatype is fits, you will start with processing unit Type SpectraHeis")
4391 4391
4392 4392 if action == quitAction2:
4393 4393 index = self.selectedItemTree
4394 4394 try:
4395 4395 index.parent()
4396 4396 except:
4397 4397 self.console.append('Please, first at all select a Project or Processing Unit')
4398 4398 return 0
4399 4399 # print index.parent(),index
4400 4400 if index.parent() == None:
4401 4401 self.projectExplorerModel.removeRow(index.row())
4402 4402 else:
4403 4403 index.parent().removeRow(index.row())
4404 4404 self.removeItemTreeFromProject()
4405 4405 self.console.clear()
4406 4406 # for i in self.projectExplorerTree.selectionModel().selection().indexes():
4407 4407 # print i.row()
4408 4408
4409 4409 if action == quitAction3:
4410 4410 self.close()
4411 4411 return 0
4412 4412
4413 4413 def createProjectView(self, id):
4414 4414
4415 4415 # project_name, description, datatype, data_path, starDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
4416 4416 id = str(id)
4417 4417 projectParms = self.__getParmsFromProjectWindow()
4418 4418
4419 4419 if not projectParms.isValid():
4420 4420 return None
4421 4421
4422 4422 projectObjView = Project()
4423 4423 projectObjView.setup(id=id, name=projectParms.name, description=projectParms.description)
4424 4424
4425 4425 self.__projectObjDict[id] = projectObjView
4426 4426 self.addProject2ProjectExplorer(id=id, name=projectObjView.name)
4427 4427
4428 4428 return projectObjView
4429 4429
4430 4430 def updateProjectView(self):
4431 4431
4432 4432 # project_name, description, datatype, data_path, starDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
4433 4433
4434 4434 projectParms = self.__getParmsFromProjectWindow()
4435 4435
4436 4436 if not projectParms.isValid():
4437 4437 return None
4438 4438
4439 4439 projectObjView = self.getSelectedProjectObj()
4440 4440
4441 4441 if not projectObjView:
4442 4442 self.console.append("Please select a project before update it")
4443 4443 return None
4444 4444
4445 4445 projectObjView.update(name=projectParms.name, description=projectParms.description)
4446 4446
4447 4447 return projectObjView
4448 4448
4449 4449 def createReadUnitView(self, projectObjView, idReadUnit=None):
4450 4450
4451 4451 projectParms = self.__getParmsFromProjectWindow()
4452 4452
4453 4453 if not projectParms.isValid():
4454 4454 return None
4455 4455
4456 4456 if projectParms.datatype in ("Voltage", "Spectra", "Fits"):
4457 4457 readUnitConfObj = projectObjView.addReadUnit(id=idReadUnit,
4458 4458 datatype=projectParms.datatype,
4459 4459 path=projectParms.dpath,
4460 4460 startDate=projectParms.startDate,
4461 4461 endDate=projectParms.endDate,
4462 4462 startTime=projectParms.startTime,
4463 4463 endTime=projectParms.endTime,
4464 4464 online=projectParms.online,
4465 4465 walk=projectParms.walk
4466 4466 )
4467 4467
4468 4468 if projectParms.set:
4469 4469 readUnitConfObj.addParameter(name="set", value=projectParms.set, format="int")
4470 4470
4471 4471 if projectParms.delay:
4472 4472 readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
4473 4473
4474 4474 if projectParms.expLabel:
4475 4475 readUnitConfObj.addParameter(name="expLabel", value=projectParms.expLabel)
4476 4476
4477 4477 readUnitConfObj.addOperation(name="printInfo")
4478 4478
4479 4479 if projectParms.datatype == "USRP":
4480 4480 readUnitConfObj = projectObjView.addReadUnit(id=idReadUnit,
4481 4481 datatype=projectParms.datatype,
4482 4482 path=projectParms.dpath,
4483 4483 startDate=projectParms.startDate,
4484 4484 endDate=projectParms.endDate,
4485 4485 startTime=projectParms.startTime,
4486 4486 endTime=projectParms.endTime,
4487 4487 online=projectParms.online,
4488 4488 ippKm=projectParms.ippKm
4489 4489 )
4490 4490
4491 4491 if projectParms.delay:
4492 4492 readUnitConfObj.addParameter(name="delay", value=projectParms.delay, format="int")
4493 4493
4494 4494 return readUnitConfObj
4495 4495
4496 4496 def updateReadUnitView(self, projectObjView, idReadUnit):
4497 4497
4498 4498 projectObjView.removeProcUnit(idReadUnit)
4499 4499
4500 4500 readUnitConfObj = self.createReadUnitView(projectObjView, idReadUnit)
4501 4501
4502 4502 return readUnitConfObj
4503 4503
4504 4504 def createProcUnitView(self, projectObjView, datatype, inputId):
4505 4505
4506 4506 procUnitConfObj = projectObjView.addProcUnit(datatype=datatype, inputId=inputId)
4507 4507
4508 4508 self.__puObjDict[procUnitConfObj.getId()] = procUnitConfObj
4509 4509
4510 4510 return procUnitConfObj
4511 4511
4512 4512 def updateProcUnitView(self, id):
4513 4513
4514 4514 pass
4515 4515
4516 4516 def addPUWindow(self):
4517 4517
4518 4518 self.configUPWindowObj = UnitProcessWindow(self)
4519 4519 fatherObj = self.getSelectedItemObj()
4520 4520 try:
4521 4521 fatherObj.getElementName()
4522 4522 except:
4523 4523 self.console.append("First left click on Project or Processing Unit")
4524 4524 return 0
4525 4525
4526 4526 if fatherObj.getElementName() == 'Project':
4527 4527 readUnitConfObj = fatherObj.getReadUnitObj()
4528 4528 self.configUPWindowObj.dataTypeProject = str(readUnitConfObj.datatype)
4529 4529
4530 4530 self.configUPWindowObj.getfromWindowList.append(fatherObj)
4531 4531 self.configUPWindowObj.loadTotalList()
4532 4532 self.configUPWindowObj.show()
4533 4533 self.configUPWindowObj.closed.connect(self.createPUWindow)
4534 4534
4535 4535 def createPUWindow(self):
4536 4536
4537 4537 if not self.configUPWindowObj.create:
4538 4538 return
4539 4539
4540 4540 fatherObj = self.configUPWindowObj.getFromWindow
4541 4541 datatype = self.configUPWindowObj.typeofUP
4542 4542
4543 4543 if fatherObj.getElementName() == 'Project':
4544 4544 inputId = fatherObj.getReadUnitId()
4545 4545 projectObjView = fatherObj
4546 4546 else:
4547 4547 inputId = fatherObj.getId()
4548 4548 projectObjView = self.getSelectedProjectObj()
4549 4549
4550 4550 if not projectObjView:
4551 4551 return
4552 4552
4553 4553 puObj = self.createProcUnitView(projectObjView, datatype, inputId)
4554 4554
4555 4555 self.addPU2ProjectExplorer(puObj)
4556 4556
4557 4557 self.showtabPUCreated(datatype)
4558 4558
4559 4559 self.clearPUWindow(datatype)
4560 4560
4561 4561 self.showPUinitView()
4562 4562
4563 4563 def addFTPConf2Operation(self, puObj, opObj):
4564 4564
4565 4565 if not self.temporalFTP.create:
4566 4566 self.temporalFTP.setwithoutconfiguration()
4567 4567
4568 4568 # opObj.addParameter(name='server', value=self.temporalFTP.server, format='str')
4569 4569 # opObj.addParameter(name='remotefolder', value=self.temporalFTP.remotefolder, format='str')
4570 4570 # opObj.addParameter(name='username', value=self.temporalFTP.username, format='str')
4571 4571 # opObj.addParameter(name='password', value=self.temporalFTP.password, format='str')
4572 4572
4573 4573 if self.temporalFTP.ftp_wei:
4574 4574 opObj.addParameter(name='ftp_wei', value=int(self.temporalFTP.ftp_wei), format='int')
4575 4575 if self.temporalFTP.exp_code:
4576 4576 opObj.addParameter(name='exp_code', value=int(self.temporalFTP.exp_code), format='int')
4577 4577 if self.temporalFTP.sub_exp_code:
4578 4578 opObj.addParameter(name='sub_exp_code', value=int(self.temporalFTP.sub_exp_code), format='int')
4579 4579 if self.temporalFTP.plot_pos:
4580 4580 opObj.addParameter(name='plot_pos', value=int(self.temporalFTP.plot_pos), format='int')
4581 4581
4582 4582 # def __checkFTPProcUnit(self, projectObj, localfolder):
4583 4583 #
4584 4584 # puId = None
4585 4585 # puObj = None
4586 4586 #
4587 4587 # for thisPuId, thisPuObj in projectObj.procUnitItems():
4588 4588 #
4589 4589 # if not thisPuObj.name == "SendToServer":
4590 4590 # continue
4591 4591 #
4592 4592 # opObj = thisPuObj.getOperationObj(name='run')
4593 4593 #
4594 4594 # parmObj = opObj.getParameterObj('localfolder')
4595 4595 #
4596 4596 # #localfolder parameter should always be set, if it is not set then ProcUnit should be removed
4597 4597 # if not parmObj:
4598 4598 # projectObj.removeProcUnit(thisPuId)
4599 4599 # continue
4600 4600 #
4601 4601 # thisLocalfolder = parmObj.getValue()
4602 4602 #
4603 4603 # if localfolder != thisLocalfolder:
4604 4604 # continue
4605 4605 #
4606 4606 # puId = thisPuId
4607 4607 # puObj = thisPuObj
4608 4608 # break
4609 4609 #
4610 4610 # return puObj
4611 4611
4612 4612 def createFTPProcUnitView(self):
4613 4613
4614 4614 if not self.temporalFTP.create:
4615 4615 self.temporalFTP.setwithoutconfiguration()
4616 4616
4617 4617 projectObj = self.getSelectedProjectObj()
4618 4618
4619 4619 if not projectObj:
4620 4620 return
4621 4621
4622 4622 self.removeAllFTPProcUnitView(projectObj)
4623 4623
4624 4624 if not self.__puLocalFolder2FTP:
4625 4625 return
4626 4626
4627 4627 folderList = ",".join(self.__puLocalFolder2FTP.values())
4628 4628
4629 4629 procUnitConfObj = projectObj.addProcUnit(name="SendToServer")
4630 4630
4631 4631 procUnitConfObj.addParameter(name='server', value=self.temporalFTP.server, format='str')
4632 4632 procUnitConfObj.addParameter(name='username', value=self.temporalFTP.username, format='str')
4633 4633 procUnitConfObj.addParameter(name='password', value=self.temporalFTP.password, format='str')
4634 4634 procUnitConfObj.addParameter(name='localfolder', value=folderList, format='list')
4635 4635 procUnitConfObj.addParameter(name='remotefolder', value=self.temporalFTP.remotefolder, format='str')
4636 4636 procUnitConfObj.addParameter(name='ext', value=self.temporalFTP.extension, format='str')
4637 4637 procUnitConfObj.addParameter(name='period', value=self.temporalFTP.period, format='int')
4638 4638 procUnitConfObj.addParameter(name='protocol', value=self.temporalFTP.protocol, format='str')
4639 4639
4640 4640 procUnitConfObj.addParameter(name='ftp_wei', value=self.temporalFTP.ftp_wei, format='int')
4641 4641 procUnitConfObj.addParameter(name='exp_code', value=self.temporalFTP.exp_code, format='int')
4642 4642 procUnitConfObj.addParameter(name='sub_exp_code', value=self.temporalFTP.sub_exp_code, format='int')
4643 4643 procUnitConfObj.addParameter(name='plot_pos', value=self.temporalFTP.plot_pos, format='int')
4644 4644
4645 4645 self.__puObjDict[procUnitConfObj.getId()] = procUnitConfObj
4646 4646
4647 4647 def removeAllFTPProcUnitView(self, projectObj):
4648 4648
4649 4649 for thisPuId, thisPuObj in projectObj.procUnitItems():
4650 4650
4651 4651 if not thisPuObj.name == "SendToServer":
4652 4652 continue
4653 4653
4654 4654 projectObj.removeProcUnit(thisPuId)
4655 4655
4656 4656 if thisPuId not in self.__puObjDict.keys():
4657 4657 continue
4658 4658
4659 4659 self.__puObjDict.pop(thisPuId)
4660 4660
4661 4661 def showPUinitView(self):
4662 4662
4663 4663 self.propertiesModel = TreeModel()
4664 4664 self.propertiesModel.initPUVoltageView()
4665 4665 self.treeProjectProperties.setModel(self.propertiesModel)
4666 4666 self.treeProjectProperties.expandAll()
4667 4667 self.treeProjectProperties.allColumnsShowFocus()
4668 4668 self.treeProjectProperties.resizeColumnToContents(1)
4669 4669
4670 4670 def saveFTPFromOpObj(self, operationObj):
4671 4671
4672 4672 if operationObj.name != "SendByFTP":
4673 4673 return
4674 4674
4675 4675 server = operationObj.getParameterValue("server")
4676 4676 username = operationObj.getParameterValue("username")
4677 4677 password = operationObj.getParameterValue("password")
4678 4678 localfolder = operationObj.getParameterValue("localfolder")
4679 4679 remotefolder = operationObj.getParameterValue("remotefolder")
4680 4680 ext = operationObj.getParameterValue("ext")
4681 4681 period = operationObj.getParameterValue("period")
4682 4682
4683 4683 self.temporalFTP.save(server=server,
4684 4684 remotefolder=remotefolder,
4685 4685 username=username,
4686 4686 password=password,
4687 4687 localfolder=localfolder,
4688 4688 extension=ext)
4689 4689
4690 4690 return
4691 4691
4692 4692 def saveFTPFromProcUnitObj(self, puObj):
4693 4693
4694 4694 opObj = puObj.getOperationObj(name="run")
4695 4695
4696 4696 parmObj = opObj.getParameterObj(parameterName="server")
4697 4697 if parmObj == None:
4698 4698 server = 'jro-app.igp.gob.pe'
4699 4699 else:
4700 4700 server = parmObj.getValue()
4701 4701
4702 4702 parmObj = opObj.getParameterObj(parameterName="remotefolder")
4703 4703 if parmObj == None:
4704 4704 remotefolder = '/home/wmaster/graficos'
4705 4705 else:
4706 4706 remotefolder = parmObj.getValue()
4707 4707
4708 4708 parmObj = opObj.getParameterObj(parameterName="username")
4709 4709 if parmObj == None:
4710 4710 username = 'wmaster'
4711 4711 else:
4712 4712 username = parmObj.getValue()
4713 4713
4714 4714 parmObj = opObj.getParameterObj(parameterName="password")
4715 4715 if parmObj == None:
4716 4716 password = 'mst2010vhf'
4717 4717 else:
4718 4718 password = parmObj.getValue()
4719 4719
4720 4720 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
4721 4721 if parmObj == None:
4722 4722 ftp_wei = 0
4723 4723 else:
4724 4724 ftp_wei = parmObj.getValue()
4725 4725
4726 4726 parmObj = opObj.getParameterObj(parameterName="exp_code")
4727 4727 if parmObj == None:
4728 4728 exp_code = 0
4729 4729 else:
4730 4730 exp_code = parmObj.getValue()
4731 4731
4732 4732 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
4733 4733 if parmObj == None:
4734 4734 sub_exp_code = 0
4735 4735 else:
4736 4736 sub_exp_code = parmObj.getValue()
4737 4737
4738 4738 parmObj = opObj.getParameterObj(parameterName="plot_pos")
4739 4739 if parmObj == None:
4740 4740 plot_pos = 0
4741 4741 else:
4742 4742 plot_pos = parmObj.getValue()
4743 4743
4744 4744 parmObj = opObj.getParameterObj(parameterName="localfolder")
4745 4745 if parmObj == None:
4746 4746 localfolder = None
4747 4747 else:
4748 4748 localfolder = parmObj.getValue()
4749 4749
4750 4750 parmObj = opObj.getParameterObj(parameterName="ext")
4751 4751 if parmObj == None:
4752 4752 extension = '.png'
4753 4753 else:
4754 4754 extension = parmObj.getValue()
4755 4755
4756 4756 self.temporalFTP.save(server=server,
4757 4757 remotefolder=remotefolder,
4758 4758 username=username,
4759 4759 password=password,
4760 4760 ftp_wei=ftp_wei,
4761 4761 exp_code=exp_code,
4762 4762 sub_exp_code=sub_exp_code,
4763 4763 plot_pos=plot_pos,
4764 4764 localfolder=localfolder,
4765 4765 extension=extension)
4766 4766
4767 4767 def addProject2ProjectExplorer(self, id, name):
4768 4768
4769 4769 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
4770 4770
4771 4771 parentItem = self.projectExplorerModel.invisibleRootItem()
4772 4772 parentItem.appendRow(itemTree)
4773 4773
4774 4774 self.projectExplorerTree.setCurrentIndex(itemTree.index())
4775 4775
4776 4776 self.selectedItemTree = itemTree
4777 4777
4778 4778 self.__itemTreeDict[id] = itemTree
4779 4779
4780 4780 def addPU2ProjectExplorer(self, puObj):
4781 4781
4782 4782 id, name = puObj.id, puObj.datatype
4783 4783
4784 4784 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
4785 4785
4786 4786 parentItem = self.selectedItemTree
4787 4787 parentItem.appendRow(itemTree)
4788 4788 self.projectExplorerTree.expandAll()
4789 4789
4790 4790 self.projectExplorerTree.setCurrentIndex(itemTree.index())
4791 4791
4792 4792 self.selectedItemTree = itemTree
4793 4793
4794 4794 self.__itemTreeDict[id] = itemTree
4795 4795
4796 4796 def addPU2PELoadXML(self, puObj):
4797 4797
4798 4798 id, name, inputId = puObj.id, puObj.datatype, puObj.inputId
4799 4799
4800 4800 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
4801 4801
4802 4802 if self.__itemTreeDict.has_key(inputId):
4803 4803 parentItem = self.__itemTreeDict[inputId]
4804 4804 else:
4805 4805 #If parent is a Reader object
4806 4806 parentItem = self.__itemTreeDict[id[:-1]]
4807 4807
4808 4808 parentItem.appendRow(itemTree)
4809 4809 self.projectExplorerTree.expandAll()
4810 4810 parentItem = itemTree
4811 4811 self.projectExplorerTree.setCurrentIndex(parentItem.index())
4812 4812
4813 4813 self.__itemTreeDict[id] = itemTree
4814 4814 self.selectedItemTree = itemTree
4815 4815
4816 4816 def getSelectedProjectObj(self):
4817 4817 """
4818 4818 Return the current project object selected. If a processing unit is
4819 4819 actually selected this function returns associated project.
4820 4820
4821 4821 None if any project or processing unit is selected
4822 4822 """
4823 4823 for key in self.__itemTreeDict.keys():
4824 4824 if self.__itemTreeDict[key] != self.selectedItemTree:
4825 4825 continue
4826 4826
4827 4827 if self.__projectObjDict.has_key(key):
4828 4828 projectObj = self.__projectObjDict[key]
4829 4829 return projectObj
4830 4830
4831 4831 puObj = self.__puObjDict[key]
4832 4832
4833 4833 if puObj.parentId == None:
4834 4834 projectId = puObj.getId()[0]
4835 4835 else:
4836 4836 projectId = puObj.parentId
4837 4837
4838 4838 projectObj = self.__projectObjDict[projectId]
4839 4839 return projectObj
4840 4840
4841 4841 return None
4842 4842
4843 4843 def getSelectedItemObj(self):
4844 4844 """
4845 4845 Return the current project or processing unit object selected
4846 4846
4847 4847 None if any project or processing unit is selected
4848 4848 """
4849 4849 for key in self.__itemTreeDict.keys():
4850 4850 if self.__itemTreeDict[key] != self.selectedItemTree:
4851 4851 continue
4852 4852
4853 4853 if self.__projectObjDict.has_key(key) == True:
4854 4854 fatherObj = self.__projectObjDict[key]
4855 4855 else:
4856 4856 fatherObj = self.__puObjDict[key]
4857 4857
4858 4858 return fatherObj
4859 4859
4860 4860 return None
4861 4861
4862 4862 def _WarningWindow(self, text, information):
4863 4863
4864 4864 msgBox = QtGui.QMessageBox()
4865 4865 msgBox.setText(text)
4866 4866 msgBox.setInformativeText(information)
4867 4867 msgBox.setStandardButtons(QtGui.QMessageBox.Ok | QtGui.QMessageBox.Cancel)
4868 4868 msgBox.setDefaultButton(QtGui.QMessageBox.Ok)
4869 4869 ret = msgBox.exec_()
4870 4870
4871 4871 answer = False
4872 4872
4873 4873 if ret == QtGui.QMessageBox.Ok:
4874 4874 answer = True
4875 4875
4876 4876 return answer
4877 4877
4878 4878 def __getNewProjectId(self):
4879 4879
4880 4880 loadProject = False
4881 4881
4882 4882 for thisId in range(1,10):
4883 4883 newId = str(thisId)
4884 4884 if newId in self.__projectObjDict.keys():
4885 4885 continue
4886 4886
4887 4887 loadProject = True
4888 4888 projectId = newId
4889 4889 break
4890 4890
4891 4891 if not loadProject:
4892 4892 self.console.clear()
4893 4893 self.console.append("The maximum number of projects has been loaded, a new project can not be loaded")
4894 4894 return None
4895 4895
4896 4896 return projectId
4897 4897
4898 4898 def openProject(self):
4899 4899
4900 4900 self._disable_save_button()
4901 4901 self._disable_play_button()
4902 4902
4903 4903 self.console.clear()
4904 4904
4905 4905 self.frame_2.setEnabled(True)
4906 4906
4907 4907 # print self.dir
4908 4908 filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open a project file", self.pathWorkSpace, self.tr("Html Files (*.xml)")))
4909 4909
4910 4910 projectObjLoad = Project()
4911 4911
4912 4912 if not projectObjLoad.readXml(filename):
4913 4913 self.console.append("The selected xml file could not be loaded ...")
4914 4914 return 0
4915 4915
4916 4916 self.create = False
4917 4917 self.refreshProjectWindow(projectObjLoad)
4918 4918 self.refreshProjectProperties(projectObjLoad)
4919 4919
4920 4920 projectId = projectObjLoad.id
4921 4921
4922 4922 if projectId in self.__projectObjDict.keys():
4923 4923
4924 4924 projectId = self.__getNewProjectId()
4925 4925
4926 4926 if not projectId:
4927 4927 return 0
4928 4928
4929 4929 projectObjLoad.updateId(projectId)
4930 4930
4931 4931 self.__projectObjDict[projectId] = projectObjLoad
4932 4932
4933 4933 self.addProject2ProjectExplorer(id=projectId, name=projectObjLoad.name)
4934 4934
4935 4935 self.tabWidgetProject.setEnabled(True)
4936 4936 self.tabWidgetProject.setCurrentWidget(self.tabProject)
4937 4937 # Disable tabProject after finish the creation
4938 4938 self.tabProject.setEnabled(True)
4939 4939 puObjorderList = OrderedDict(sorted(projectObjLoad.procUnitConfObjDict.items(), key=lambda x: x[0]))
4940 4940
4941 4941 for puId, puObj in puObjorderList.items():
4942 4942
4943 4943 self.__puObjDict[puId] = puObj
4944 4944
4945 4945 if puObj.name == "SendToServer":
4946 4946 self.saveFTPFromProcUnitObj(puObj)
4947 4947
4948 4948 ############## COMPATIBLE WITH OLD VERSIONS ################
4949 4949 operationObj = puObj.getOperationObj("SendByFTP")
4950 4950
4951 4951 if operationObj:
4952 4952 self.saveFTPFromOpObj(operationObj)
4953 4953 ############################################################
4954 4954
4955 4955 if puObj.inputId == '0':
4956 4956 continue
4957 4957
4958 4958 self.addPU2PELoadXML(puObj)
4959 4959
4960 4960 self.refreshPUWindow(puObj)
4961 4961 self.refreshPUProperties(puObj)
4962 4962 self.showtabPUCreated(datatype=puObj.datatype)
4963 4963
4964 4964 # self.console.clear()
4965 4965 self.console.append("\nThe selected xml file has been loaded successfully")
4966 4966
4967 4967 if self.dateList:
4968 4968 self._disable_save_button()
4969 4969 self._enable_play_button()
4970 4970
4971 4971 def create_updating_timer(self):
4972 4972
4973 4973 self.comm_data_timer = QtCore.QTimer(self)
4974 4974 self.comm_data_timer.timeout.connect(self.on_comm_updating_timer)
4975 4975 self.comm_data_timer.start(1000)
4976 4976
4977 4977 def on_comm_updating_timer(self):
4978 4978 # Verifica si algun proceso ha sido inicializado y sigue ejecutandose
4979 4979 # Si el proceso se ha parado actualizar el GUI (stopProject)
4980 4980 if not self.threadStarted:
4981 4981 return
4982 4982
4983 4983 if self.controllerThread.isFinished():
4984 4984 self.stopProject()
4985 4985 return
4986 4986
4987 4987 def use_plotmanager(self, controllerThread):
4988 4988
4989 4989 self.plotManager = controllerThread.useExternalPlotter()
4990 4990
4991 4991 self.plot_timer = QtCore.QTimer()
4992 4992 self.plot_timer.timeout.connect(self.on_plotmanager_timer)
4993 4993 self.plot_timer.start(10)
4994 4994
4995 4995 def on_plotmanager_timer(self):
4996 4996
4997 4997 if not self.plotManager:
4998 4998 return
4999 4999
5000 5000 self.plotManager.run()
5001 5001
5002 5002 if self.plotManager.isErrorDetected():
5003 5003 self.stopProject()
5004 5004 return
5005 5005
5006 5006 def playProject(self, ext=".xml", save=1):
5007 5007
5008 5008 self._disable_play_button()
5009 5009 self._disable_save_button()
5010 5010
5011 5011 if self.controllerThread:
5012 5012 if self.controllerThread.isRunning():
5013 5013 self.console.append("There is already another process running")
5014 5014 self._enable_stop_button()
5015 5015 return
5016 5016
5017 5017 if not self.dateList:
5018 5018 self.console.append("No data found, check datapath")
5019 5019
5020 5020 projectObj = self.getSelectedProjectObj()
5021 5021
5022 5022 if not projectObj:
5023 5023 self.console.append("Please, select a project to start it")
5024 5024 return
5025 5025
5026 5026 if save:
5027 5027 filename = self.saveProject()
5028 5028 if filename == None:
5029 5029 self.console.append("Process not initialized.")
5030 5030 return
5031 5031 else:
5032 5032 filename = TEMPORAL_FILE
5033 5033 projectObj.writeXml( os.path.join(self.pathWorkSpace,filename) )
5034 5034
5035 5035 self.console.clear()
5036 5036 self.console.append("Please wait...")
5037 5037
5038 5038 self.controllerThread = ControllerThread()
5039 5039 self.controllerThread.readXml(filename)
5040 5040
5041 5041 self.use_plotmanager(self.controllerThread)
5042 5042
5043 5043 self.console.clear()
5044 5044
5045 5045 self.controllerThread.start()
5046 5046
5047 5047 sleep(0.5)
5048 5048
5049 5049
5050 5050 self.threadStarted = True
5051 5051
5052 5052 self._disable_play_button()
5053 5053 self._disable_save_button()
5054 5054 self._enable_stop_button()
5055 5055
5056 5056 def stopProject(self):
5057 5057
5058 5058 self.threadStarted = False
5059 5059 self.controllerThread.stop()
5060 5060 self.plot_timer.stop()
5061 5061
5062 5062 self.plotManager.join()
5063 5063 self.plotManager = None
5064 5064
5065 5065 while self.controllerThread.isRunning():
5066 5066 sleep(0.5)
5067 5067
5068 5068 self._disable_stop_button()
5069 5069 self._enable_play_button()
5070 5070
5071 5071 def pauseProject(self):
5072 5072
5073 5073 # self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.PAUSE, data=True))
5074 5074 paused = self.controllerThread.pause()
5075 5075
5076 5076 self.changePauseIcon(paused)
5077 5077
5078 5078 def saveProject(self, filename=None):
5079 5079
5080 5080 self._disable_save_button()
5081 5081 self._disable_play_button()
5082 5082
5083 5083 projectObj = self.getSelectedProjectObj()
5084 5084
5085 5085 if not projectObj:
5086 5086
5087 5087 if self.create:
5088 5088 self.console.append("Please press Ok before save it")
5089 5089 else:
5090 5090 self.console.append("Please select a project before save it")
5091 5091 return
5092 5092
5093 5093 self.refreshGraphicsId()
5094 5094
5095 5095 sts = True
5096 5096 selectedItemObj = self.getSelectedItemObj()
5097 5097
5098 5098 #A Processing Unit has been selected
5099 5099 if projectObj == selectedItemObj:
5100 5100 if not self.on_proOk_clicked():
5101 5101 return None
5102 5102
5103 5103 #A Processing Unit has been selected
5104 5104 if projectObj != selectedItemObj:
5105 5105 puObj = selectedItemObj
5106 5106
5107 5107 if puObj.name == 'VoltageProc':
5108 5108 sts = self.on_volOpOk_clicked()
5109 5109 if puObj.name == 'SpectraProc':
5110 5110 sts = self.on_specOpOk_clicked()
5111 5111 if puObj.name == 'SpectraHeisProc':
5112 5112 sts = self.on_specHeisOpOk_clicked()
5113 5113
5114 5114 if not sts:
5115 5115 return None
5116 5116
5117 5117 self.createFTPProcUnitView()
5118 5118
5119 5119 if not filename:
5120 5120 filename = os.path.join( str(self.pathWorkSpace), "%s%s" %(str(projectObj.name), '.xml') )
5121 5121
5122 5122 projectObj.writeXml(filename)
5123 5123 self.console.clear()
5124 5124 self.console.append("Project saved")
5125 5125 self.console.append("Press Play button to start data processing ...")
5126 5126
5127 5127 self._disable_save_button()
5128 5128 self._enable_play_button()
5129 5129
5130 5130 return filename
5131 5131
5132 5132 def removeItemTreeFromProject(self):
5133 5133 """
5134 5134 Metodo para eliminar el proyecto en el dictionario de proyectos y en el dictionario de vista de arbol
5135 5135 """
5136 5136 for key in self.__itemTreeDict.keys():
5137 5137
5138 5138 #Check again because an item can delete multiple items (childs)
5139 5139 if key not in self.__itemTreeDict.keys():
5140 5140 continue
5141 5141
5142 5142 if self.__itemTreeDict[key] != self.selectedItemTree:
5143 5143 continue
5144 5144
5145 5145 if self.__projectObjDict.has_key(key) == True:
5146 5146
5147 5147 del self.__projectObjDict[key]
5148 5148 del self.__itemTreeDict[key]
5149 5149
5150 5150 else:
5151 5151 puObj = self.__puObjDict[key]
5152 5152 idProjectParent = puObj.parentId
5153 5153 projectObj = self.__projectObjDict[idProjectParent]
5154 5154
5155 5155 del self.__puObjDict[key]
5156 5156 del self.__itemTreeDict[key]
5157 5157 del projectObj.procUnitConfObjDict[key]
5158 5158
5159 5159 for key in projectObj.procUnitConfObjDict.keys():
5160 5160 if projectObj.procUnitConfObjDict[key].inputId != puObj.getId():
5161 5161 continue
5162 5162 del self.__puObjDict[projectObj.procUnitConfObjDict[key].getId()]
5163 5163 del self.__itemTreeDict[projectObj.procUnitConfObjDict[key].getId()]
5164 5164 del projectObj.procUnitConfObjDict[key]
5165 5165 # print projectObj.procUnitConfObjDict
5166 5166 # print self.__itemTreeDict,self.__projectObjDict,self.__puObjDict
5167 5167
5168 5168 def setInputsProject_View(self):
5169 5169
5170 5170 self.tabWidgetProject.setEnabled(True)
5171 5171 self.tabWidgetProject.setCurrentWidget(self.tabProject)
5172 5172 self.tabProject.setEnabled(True)
5173 5173 self.frame_2.setEnabled(False)
5174 5174 self.proName.clear()
5175 5175 self.proName.setFocus()
5176 5176 self.proName.setSelection(0, 0)
5177 5177 self.proName.setCursorPosition(0)
5178 5178 self.proDataType.setText('.r')
5179 5179 self.proDataPath.clear()
5180 5180 self.proComDataType.clear()
5181 5181 self.proComDataType.addItem("Voltage")
5182 5182 self.proComDataType.addItem("Spectra")
5183 5183 self.proComDataType.addItem("Fits")
5184 5184 self.proComDataType.addItem("USRP")
5185 5185
5186 5186 self.proComStartDate.clear()
5187 5187 self.proComEndDate.clear()
5188 5188
5189 5189 startTime = "00:00:00"
5190 5190 endTime = "23:59:59"
5191 5191 starlist = startTime.split(":")
5192 5192 endlist = endTime.split(":")
5193 5193 self.proDelay.setText("60")
5194 5194 self.proSet.setText("")
5195 5195
5196 5196 self.labelSet.show()
5197 5197 self.proSet.show()
5198 5198
5199 5199 self.labelIPPKm.hide()
5200 5200 self.proIPPKm.hide()
5201 5201
5202 5202 self.time.setHMS(int(starlist[0]), int(starlist[1]), int(starlist[2]))
5203 5203 self.proStartTime.setTime(self.time)
5204 5204 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
5205 5205 self.proEndTime.setTime(self.time)
5206 5206 self.proDescription.clear()
5207 5207 self.proOk.setEnabled(False)
5208 5208 # self.console.append("Please, Write a name Project")
5209 5209 # self.console.append("Introduce Project Parameters")DC
5210 5210 # self.console.append("Select data type Voltage( .rawdata) or Spectra(.pdata)")
5211 5211
5212 5212 def clearPUWindow(self, datatype):
5213 5213
5214 5214 projectObjView = self.getSelectedProjectObj()
5215 5215
5216 5216 if not projectObjView:
5217 5217 return
5218 5218
5219 5219 puObj = self.getSelectedItemObj()
5220 5220 inputId = puObj.getInputId()
5221 5221 inputPUObj = projectObjView.getProcUnitObj(inputId)
5222 5222
5223 5223 if datatype == 'Voltage':
5224 5224 self.volOpComChannels.setEnabled(False)
5225 5225 self.volOpComHeights.setEnabled(False)
5226 5226 self.volOpFilter.setEnabled(False)
5227 5227 self.volOpComProfile.setEnabled(False)
5228 5228 self.volOpComCode.setEnabled(False)
5229 5229 self.volOpCohInt.setEnabled(False)
5230 5230 self.volOpChannel.setEnabled(False)
5231 5231 self.volOpHeights.setEnabled(False)
5232 5232 self.volOpProfile.setEnabled(False)
5233 5233 self.volOpRadarfrequency.setEnabled(False)
5234 5234 self.volOpSplitter.setEnabled(False)
5235 5235 self.volOpCombiner.setEnabled(False)
5236 5236
5237 5237 self.volOpCebChannels.setCheckState(0)
5238 5238 self.volOpCebRadarfrequency.setCheckState(0)
5239 5239 self.volOpCebHeights.setCheckState(0)
5240 5240 self.volOpCebFilter.setCheckState(0)
5241 5241 self.volOpCebProfile.setCheckState(0)
5242 5242 self.volOpCebDecodification.setCheckState(0)
5243 5243 self.volOpCebCohInt.setCheckState(0)
5244 5244 self.volOpCebSplitter.setCheckState(0)
5245 5245 self.volOpCebCombiner.setCheckState(0)
5246 5246
5247 5247 self.volOpChannel.clear()
5248 5248 self.volOpHeights.clear()
5249 5249 self.volOpProfile.clear()
5250 5250 self.volOpFilter.clear()
5251 5251 self.volOpCohInt.clear()
5252 5252 self.volOpRadarfrequency.clear()
5253 5253 self.volOpSplitter.clear()
5254 5254 self.volOpCombiner.clear()
5255 5255
5256 5256 if datatype == 'Spectra':
5257 5257
5258 5258 if inputPUObj.datatype == 'Spectra':
5259 5259 self.specOpnFFTpoints.setEnabled(False)
5260 5260 self.specOpProfiles.setEnabled(False)
5261 5261 self.specOpippFactor.setEnabled(False)
5262 5262 else:
5263 5263 self.specOpnFFTpoints.setEnabled(True)
5264 5264 self.specOpProfiles.setEnabled(True)
5265 5265 self.specOpippFactor.setEnabled(True)
5266 5266
5267 5267 self.specOpCebCrossSpectra.setCheckState(0)
5268 5268 self.specOpCebChannel.setCheckState(0)
5269 5269 self.specOpCebHeights.setCheckState(0)
5270 5270 self.specOpCebIncoherent.setCheckState(0)
5271 5271 self.specOpCebRemoveDC.setCheckState(0)
5272 5272 self.specOpCebRemoveInt.setCheckState(0)
5273 5273 self.specOpCebgetNoise.setCheckState(0)
5274 5274 self.specOpCebRadarfrequency.setCheckState(0)
5275 5275
5276 5276 self.specOpRadarfrequency.setEnabled(False)
5277 5277 self.specOppairsList.setEnabled(False)
5278 5278 self.specOpChannel.setEnabled(False)
5279 5279 self.specOpHeights.setEnabled(False)
5280 5280 self.specOpIncoherent.setEnabled(False)
5281 5281 self.specOpgetNoise.setEnabled(False)
5282 5282
5283 5283 self.specOpRadarfrequency.clear()
5284 5284 self.specOpnFFTpoints.clear()
5285 5285 self.specOpProfiles.clear()
5286 5286 self.specOpippFactor.clear
5287 5287 self.specOppairsList.clear()
5288 5288 self.specOpChannel.clear()
5289 5289 self.specOpHeights.clear()
5290 5290 self.specOpIncoherent.clear()
5291 5291 self.specOpgetNoise.clear()
5292 5292
5293 5293 self.specGraphCebSpectraplot.setCheckState(0)
5294 5294 self.specGraphCebCrossSpectraplot.setCheckState(0)
5295 5295 self.specGraphCebRTIplot.setCheckState(0)
5296 5296 self.specGraphCebRTInoise.setCheckState(0)
5297 5297 self.specGraphCebCoherencmap.setCheckState(0)
5298 5298 self.specGraphPowerprofile.setCheckState(0)
5299 5299
5300 5300 self.specGraphSaveSpectra.setCheckState(0)
5301 5301 self.specGraphSaveCross.setCheckState(0)
5302 5302 self.specGraphSaveRTIplot.setCheckState(0)
5303 5303 self.specGraphSaveRTInoise.setCheckState(0)
5304 5304 self.specGraphSaveCoherencemap.setCheckState(0)
5305 5305 self.specGraphSavePowerprofile.setCheckState(0)
5306 5306
5307 5307 self.specGraphftpRTIplot.setCheckState(0)
5308 5308 self.specGraphftpRTInoise.setCheckState(0)
5309 5309 self.specGraphftpCoherencemap.setCheckState(0)
5310 5310
5311 5311 self.specGraphPath.clear()
5312 5312 self.specGraphPrefix.clear()
5313 5313
5314 5314 self.specGgraphftpratio.clear()
5315 5315
5316 5316 self.specGgraphChannelList.clear()
5317 5317 self.specGgraphFreq.clear()
5318 5318 self.specGgraphHeight.clear()
5319 5319 self.specGgraphDbsrange.clear()
5320 5320 self.specGgraphmagnitud.clear()
5321 5321 self.specGgraphTminTmax.clear()
5322 5322 self.specGgraphTimeRange.clear()
5323 5323
5324 5324 if datatype == 'SpectraHeis':
5325 5325 self.specHeisOpCebIncoherent.setCheckState(0)
5326 5326 self.specHeisOpIncoherent.setEnabled(False)
5327 5327 self.specHeisOpIncoherent.clear()
5328 5328
5329 5329 self.specHeisGraphCebSpectraplot.setCheckState(0)
5330 5330 self.specHeisGraphCebRTIplot.setCheckState(0)
5331 5331
5332 5332 self.specHeisGraphSaveSpectra.setCheckState(0)
5333 5333 self.specHeisGraphSaveRTIplot.setCheckState(0)
5334 5334
5335 5335 self.specHeisGraphftpSpectra.setCheckState(0)
5336 5336 self.specHeisGraphftpRTIplot.setCheckState(0)
5337 5337
5338 5338 self.specHeisGraphPath.clear()
5339 5339 self.specHeisGraphPrefix.clear()
5340 5340 self.specHeisGgraphChannelList.clear()
5341 5341 self.specHeisGgraphXminXmax.clear()
5342 5342 self.specHeisGgraphYminYmax.clear()
5343 5343 self.specHeisGgraphTminTmax.clear()
5344 5344 self.specHeisGgraphTimeRange.clear()
5345 5345 self.specHeisGgraphftpratio.clear()
5346 5346
5347 5347 def showtabPUCreated(self, datatype):
5348 5348
5349 5349 if datatype == "Voltage":
5350 5350 self.tabVoltage.setEnabled(True)
5351 5351 self.tabProject.setEnabled(False)
5352 5352 self.tabSpectra.setEnabled(False)
5353 5353 self.tabCorrelation.setEnabled(False)
5354 5354 self.tabSpectraHeis.setEnabled(False)
5355 5355 self.tabWidgetProject.setCurrentWidget(self.tabVoltage)
5356 5356
5357 5357 if datatype == "Spectra":
5358 5358 self.tabVoltage.setEnabled(False)
5359 5359 self.tabProject.setEnabled(False)
5360 5360 self.tabSpectra.setEnabled(True)
5361 5361 self.tabCorrelation.setEnabled(False)
5362 5362 self.tabSpectraHeis.setEnabled(False)
5363 5363 self.tabWidgetProject.setCurrentWidget(self.tabSpectra)
5364 5364
5365 5365 if datatype == "SpectraHeis":
5366 5366 self.tabVoltage.setEnabled(False)
5367 5367 self.tabProject.setEnabled(False)
5368 5368 self.tabSpectra.setEnabled(False)
5369 5369 self.tabCorrelation.setEnabled(False)
5370 5370 self.tabSpectraHeis.setEnabled(True)
5371 5371 self.tabWidgetProject.setCurrentWidget(self.tabSpectraHeis)
5372 5372
5373 5373 def checkInputsProject(self):
5374 5374 """
5375 5375 Check Inputs Project:
5376 5376 - project_name
5377 5377 - datatype
5378 5378 - ext
5379 5379 - data_path
5380 5380 - readmode
5381 5381 - delay
5382 5382 - set
5383 5383 - walk
5384 5384 """
5385 5385 parms_ok = True
5386 5386 project_name = str(self.proName.text())
5387 5387 if project_name == '' or project_name == None:
5388 5388 outputstr = "Enter the Project Name"
5389 5389 self.console.append(outputstr)
5390 5390 parms_ok = False
5391 5391 project_name = None
5392 5392
5393 5393 datatype = str(self.proComDataType.currentText())
5394 5394 if not(datatype in ['Voltage', 'Spectra', 'Fits', 'USRP']):
5395 5395 outputstr = 'datatype = %s, this must be either Voltage, Spectra, SpectraHeis or USRP' % datatype
5396 5396 self.console.append(outputstr)
5397 5397 parms_ok = False
5398 5398 datatype = None
5399 5399
5400 5400 ext = str(self.proDataType.text())
5401 5401 if not(ext in ['.r', '.pdata', '.fits', '.hdf5']):
5402 5402 outputstr = "extension files must be .r , .pdata, .fits or .hdf5"
5403 5403 self.console.append(outputstr)
5404 5404 parms_ok = False
5405 5405 ext = None
5406 5406
5407 5407 data_path = str(self.proDataPath.text())
5408 5408
5409 5409 if data_path == '':
5410 5410 outputstr = 'Datapath is empty'
5411 5411 self.console.append(outputstr)
5412 5412 parms_ok = False
5413 5413 data_path = None
5414 5414
5415 5415 if data_path != None:
5416 5416 if not os.path.isdir(data_path):
5417 5417 outputstr = 'Datapath:%s does not exist' % data_path
5418 5418 self.console.append(outputstr)
5419 5419 parms_ok = False
5420 5420 data_path = None
5421 5421
5422 5422 read_mode = str(self.proComReadMode.currentText())
5423 5423 if not(read_mode in ['Online', 'Offline']):
5424 5424 outputstr = 'Read Mode: %s, this must be either Online or Offline' % read_mode
5425 5425 self.console.append(outputstr)
5426 5426 parms_ok = False
5427 5427 read_mode = None
5428 5428
5429 5429 delay = None
5430 5430 if read_mode == "Online":
5431 5431 parms_ok = False
5432 5432 try:
5433 5433 delay = int(str(self.proDelay.text()))
5434 5434 parms_ok = True
5435 5435 except:
5436 5436 outputstr = 'Delay: %s, this must be a integer number' % str(self.proDelay.text())
5437 5437 self.console.append(outputstr)
5438 5438
5439 5439 try:
5440 5440 set = int(str(self.proSet.text()))
5441 5441 except:
5442 5442 # outputstr = 'Set: %s, this must be a integer number' % str(self.proName.text())
5443 5443 # self.console.append(outputstr)
5444 5444 # parms_ok = False
5445 5445 set = None
5446 5446
5447 5447 walk = int(self.proComWalk.currentIndex())
5448 5448 expLabel = str(self.proExpLabel.text())
5449 5449
5450 5450 return parms_ok, project_name, datatype, ext, data_path, read_mode, delay, walk, set, expLabel
5451 5451
5452 5452 def checkInputsPUSave(self, datatype):
5453 5453 """
5454 5454 Check Inputs Spectra Save:
5455 5455 - path
5456 5456 - blocks Per File
5457 5457 - sufix
5458 5458 - dataformat
5459 5459 """
5460 5460 parms_ok = True
5461 5461
5462 5462 if datatype == "Voltage":
5463 5463 output_path = str(self.volOutputPath.text())
5464 5464 blocksperfile = str(self.volOutputblocksperfile.text())
5465 5465 profilesperblock = str(self.volOutputprofilesperblock.text())
5466 5466
5467 5467 if datatype == "Spectra":
5468 5468 output_path = str(self.specOutputPath.text())
5469 5469 blocksperfile = str(self.specOutputblocksperfile.text())
5470 5470 profilesperblock = 0
5471 5471
5472 5472 if datatype == "SpectraHeis":
5473 5473 output_path = str(self.specHeisOutputPath.text())
5474 5474 blocksperfile = str(self.specHeisOutputblocksperfile.text())
5475 5475 metadata_file = str(self.specHeisOutputMetada.text())
5476 5476
5477 5477 message = ''
5478 5478
5479 5479 if not os.path.isdir(output_path):
5480 5480 message += 'OutputPath:%s does not exist\n' % output_path
5481 5481 parms_ok = False
5482 5482
5483 5483 try:
5484 5484 profilesperblock = int(profilesperblock)
5485 5485 except:
5486 5486 if datatype == "Voltage":
5487 5487 message += 'Profilesperblock: %s, this must be a integer number\n' % str(self.volOutputprofilesperblock.text())
5488 5488 parms_ok = False
5489 5489 profilesperblock = None
5490 5490
5491 5491 try:
5492 5492 blocksperfile = int(blocksperfile)
5493 5493 except:
5494 5494 if datatype == "Voltage":
5495 5495 message += 'Blocksperfile: %s, this must be a integer number\n' % str(self.volOutputblocksperfile.text())
5496 5496 elif datatype == "Spectra":
5497 5497 message += 'Blocksperfile: %s, this must be a integer number\n' % str(self.specOutputblocksperfile.text())
5498 5498 elif datatype == "SpectraHeis":
5499 5499 message += 'Blocksperfile: %s, this must be a integer number\n' % str(self.specHeisOutputblocksperfile.text())
5500 5500
5501 5501 parms_ok = False
5502 5502 blocksperfile = None
5503 5503
5504 5504 if datatype == "SpectraHeis":
5505 5505 if metadata_file != '':
5506 5506 if not os.path.isfile(metadata_file):
5507 5507 message += 'Metadata file %s does not exist\n' % metadata_file
5508 5508 parms_ok = False
5509 5509
5510 5510 if str.strip(output_path) != '':
5511 5511 self.console.append(message)
5512 5512
5513 5513 if datatype == "Voltage":
5514 5514 return parms_ok, output_path, blocksperfile, profilesperblock
5515 5515
5516 5516
5517 5517 if datatype == "Spectra":
5518 5518 return parms_ok, output_path, blocksperfile, profilesperblock
5519 5519
5520 5520
5521 5521 if datatype == "SpectraHeis":
5522 5522 return parms_ok, output_path, blocksperfile, metadata_file
5523 5523
5524 5524 def findDatafiles(self, data_path, ext, walk, expLabel=''):
5525 5525
5526 5526 dateList = []
5527 5527 fileList = []
5528 5528
5529 5529 if ext == ".r":
5530 5530 from schainpy.model.io.jroIO_base import JRODataReader
5531 5531
5532 5532 readerObj = JRODataReader()
5533 5533 dateList = readerObj.findDatafiles(path=data_path,
5534 5534 expLabel=expLabel,
5535 5535 ext=ext,
5536 5536 walk=walk)
5537 5537
5538 5538 if ext == ".pdata":
5539 5539 from schainpy.model.io.jroIO_base import JRODataReader
5540 5540
5541 5541 readerObj = JRODataReader()
5542 5542 dateList = readerObj.findDatafiles(path=data_path,
5543 5543 expLabel=expLabel,
5544 5544 ext=ext,
5545 5545 walk=walk)
5546 5546
5547 5547 if ext == ".fits":
5548 5548 from schainpy.model.io.jroIO_base import JRODataReader
5549 5549
5550 5550 readerObj = JRODataReader()
5551 5551 dateList = readerObj.findDatafiles(path=data_path,
5552 5552 expLabel=expLabel,
5553 5553 ext=ext,
5554 5554 walk=walk)
5555 5555
5556 5556 if ext == ".hdf5":
5557 5557 from schainpy.model.io.jroIO_usrp import USRPReader
5558 5558
5559 5559 readerObj = USRPReader()
5560 5560 dateList = readerObj.findDatafiles(path=data_path)
5561 5561
5562 5562 return dateList
5563 5563
5564 5564 def loadDays(self, data_path, ext, walk, expLabel=''):
5565 5565 """
5566 5566 Method to loads day
5567 5567 """
5568 5568 # self._disable_save_button()
5569 5569 # self._disable_play_button()
5570 5570 # self.proOk.setEnabled(False)
5571 5571
5572 5572 self.proComStartDate.clear()
5573 5573 self.proComEndDate.clear()
5574 5574
5575 5575 self.dateList = []
5576 5576
5577 5577 if not data_path:
5578 5578 self.console.append("Datapath has not been set")
5579 5579 return []
5580 5580
5581 5581 if not os.path.isdir(data_path):
5582 5582 self.console.append("Directory %s does not exist" %data_path)
5583 5583 return []
5584 5584
5585 5585 self.dataPath = data_path
5586 5586
5587 5587 dateList = self.findDatafiles(data_path, ext=ext, walk=walk, expLabel=expLabel)
5588 5588
5589 5589 if not dateList:
5590 5590 # self.console.clear()
5591 5591 if walk:
5592 5592 if expLabel:
5593 5593 outputstr = "No files (*%s) were found on %s/DOYPATH/%s" % (ext, data_path, expLabel)
5594 5594 else:
5595 5595 outputstr = "No files (*%s) were found on %s" % (ext, data_path)
5596 5596 else:
5597 5597 outputstr = "No files (*%s) were found on %s" % (ext, data_path)
5598 5598
5599 5599 self.console.append(outputstr)
5600 5600 return []
5601 5601
5602 5602 dateStrList = []
5603 5603 for thisDate in dateList:
5604 5604 dateStr = thisDate.strftime("%Y/%m/%d")
5605 5605
5606 5606 self.proComStartDate.addItem(dateStr)
5607 5607 self.proComEndDate.addItem(dateStr)
5608 5608 dateStrList.append(dateStr)
5609 5609
5610 5610 self.proComStartDate.setCurrentIndex(0)
5611 5611 self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - 1)
5612 5612
5613 5613 self.dateList = dateStrList
5614 5614
5615 5615 self.console.clear()
5616 5616 self.console.append("Successful load")
5617 5617
5618 5618 # self.proOk.setEnabled(True)
5619 5619 # self._enable_play_button()
5620 5620 # self._enable_save_button()
5621 5621
5622 5622 return self.dateList
5623 5623
5624 5624 def setWorkSpaceGUI(self, pathWorkSpace=None):
5625 5625
5626 5626 if pathWorkSpace == None:
5627 5627 home = os.path.expanduser("~")
5628 5628 pathWorkSpace = os.path.join(home,'schain_workspace')
5629 5629
5630 5630 self.pathWorkSpace = pathWorkSpace
5631 5631
5632 5632 """
5633 5633 Comandos Usados en Console
5634 5634 """
5635 5635 def __del__(self):
5636 5636 sys.stdout = sys.__stdout__
5637 5637 sys.stderr = sys.__stderr__
5638 5638
5639 5639 def normalOutputWritten(self, text):
5640 5640 color_black = QtGui.QColor(0,0,0)
5641 5641 self.console.setTextColor(color_black)
5642 5642 self.console.append(text)
5643 5643
5644 5644 def errorOutputWritten(self, text):
5645 5645 color_red = QtGui.QColor(255,0,0)
5646 5646 color_black = QtGui.QColor(0,0,0)
5647 5647
5648 5648 self.console.setTextColor(color_red)
5649 5649 self.console.append(text)
5650 5650 self.console.setTextColor(color_black)
5651 5651
5652 5652 def _enable_save_button(self):
5653 5653
5654 5654 self.actionSaveToolbar.setEnabled(True)
5655 5655 self.actionSave.setEnabled(True)
5656 5656
5657 5657 def _disable_save_button(self):
5658 5658
5659 5659 self.actionSaveToolbar.setEnabled(False)
5660 5660 self.actionSave.setEnabled(False)
5661 5661
5662 5662 def _enable_play_button(self):
5663 5663
5664 5664 if self.controllerThread:
5665 5665 if self.controllerThread.isRunning():
5666 5666 return
5667 5667
5668 5668 self.actionStart.setEnabled(True)
5669 5669 self.actionStarToolbar.setEnabled(True)
5670 5670
5671 5671 self.changeStartIcon(started=False)
5672 5672
5673 5673 def _disable_play_button(self):
5674 5674
5675 5675 self.actionStart.setEnabled(False)
5676 5676 self.actionStarToolbar.setEnabled(False)
5677 5677
5678 5678 self.changeStartIcon(started=True)
5679 5679
5680 5680 def _enable_stop_button(self):
5681 5681
5682 5682 self.actionPause.setEnabled(True)
5683 5683 self.actionStop.setEnabled(True)
5684 5684
5685 5685 self.actionPauseToolbar.setEnabled(True)
5686 5686 self.actionStopToolbar.setEnabled(True)
5687 5687
5688 5688 self.changePauseIcon(paused=False)
5689 5689 self.changeStopIcon(started=True)
5690 5690
5691 5691 def _disable_stop_button(self):
5692 5692
5693 5693 self.actionPause.setEnabled(False)
5694 5694 self.actionStop.setEnabled(False)
5695 5695
5696 5696 self.actionPauseToolbar.setEnabled(False)
5697 5697 self.actionStopToolbar.setEnabled(False)
5698 5698
5699 5699 self.changePauseIcon(paused=False)
5700 5700 self.changeStopIcon(started=False)
5701 5701
5702 5702 def setGUIStatus(self):
5703 5703
5704 5704 self.setWindowTitle("ROJ-Signal Chain")
5705 5705 self.setWindowIcon(QtGui.QIcon( os.path.join(FIGURES_PATH,"logo.png") ))
5706 5706
5707 5707 self.tabWidgetProject.setEnabled(False)
5708 5708 self.tabVoltage.setEnabled(False)
5709 5709 self.tabSpectra.setEnabled(False)
5710 5710 self.tabCorrelation.setEnabled(False)
5711 5711 self.frame_2.setEnabled(False)
5712 5712
5713 5713 self.actionCreate.setShortcut('Ctrl+N')
5714 5714 self.actionOpen.setShortcut('Ctrl+O')
5715 5715 self.actionSave.setShortcut('Ctrl+S')
5716 5716 self.actionClose.setShortcut('Ctrl+X')
5717 5717
5718 5718 self.actionStart.setShortcut('Ctrl+1')
5719 5719 self.actionPause.setShortcut('Ctrl+2')
5720 5720 self.actionStop.setShortcut('Ctrl+3')
5721 5721
5722 5722 self.actionFTP.setShortcut('Ctrl+F')
5723 5723
5724 5724 self.actionStart.setEnabled(False)
5725 5725 self.actionPause.setEnabled(False)
5726 5726 self.actionStop.setEnabled(False)
5727 5727
5728 5728 self.actionStarToolbar.setEnabled(False)
5729 5729 self.actionPauseToolbar.setEnabled(False)
5730 5730 self.actionStopToolbar.setEnabled(False)
5731 5731
5732 5732 self.proName.clear()
5733 5733 self.proDataPath.setText('')
5734 5734 self.console.setReadOnly(True)
5735 5735 self.console.append("Welcome to Signal Chain\n\n")
5736 5736 self.console.append("Open a project or Create a new one\n")
5737 5737 self.proStartTime.setDisplayFormat("hh:mm:ss")
5738 5738 self.proDataType.setEnabled(False)
5739 5739 self.time = QtCore.QTime()
5740 5740 self.proEndTime.setDisplayFormat("hh:mm:ss")
5741 5741 startTime = "00:00:00"
5742 5742 endTime = "23:59:59"
5743 5743 starlist = startTime.split(":")
5744 5744 endlist = endTime.split(":")
5745 5745 self.time.setHMS(int(starlist[0]), int(starlist[1]), int(starlist[2]))
5746 5746 self.proStartTime.setTime(self.time)
5747 5747 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
5748 5748 self.proEndTime.setTime(self.time)
5749 5749 self.proOk.setEnabled(False)
5750 5750 # set model Project Explorer
5751 5751 self.projectExplorerModel = QtGui.QStandardItemModel()
5752 5752 self.projectExplorerModel.setHorizontalHeaderLabels(("Project Explorer",))
5753 5753 layout = QtGui.QVBoxLayout()
5754 5754 layout.addWidget(self.projectExplorerTree)
5755 5755 self.projectExplorerTree.setModel(self.projectExplorerModel)
5756 5756 self.projectExplorerTree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
5757 5757 self.projectExplorerTree.customContextMenuRequested.connect(self.on_right_click)
5758 5758 self.projectExplorerTree.clicked.connect(self.on_click)
5759 5759 self.projectExplorerTree.expandAll()
5760 5760 # set model Project Properties
5761 5761
5762 5762 self.propertiesModel = TreeModel()
5763 5763 self.propertiesModel.initProjectView()
5764 5764 self.treeProjectProperties.setModel(self.propertiesModel)
5765 5765 self.treeProjectProperties.expandAll()
5766 5766 self.treeProjectProperties.allColumnsShowFocus()
5767 5767 self.treeProjectProperties.resizeColumnToContents(1)
5768 5768
5769 5769 # set Project
5770 5770 self.pronTxs.setEnabled(False)
5771 5771 self.proComByBlock.setEnabled(False)
5772 5772 self.proExpLabel.setEnabled(False)
5773 5773 self.proDelay.setEnabled(False)
5774 5774 self.proSet.setEnabled(True)
5775 5775 self.proDataType.setReadOnly(True)
5776 5776
5777 5777 # set Operation Voltage
5778 5778 self.volOpComChannels.setEnabled(False)
5779 5779 self.volOpComHeights.setEnabled(False)
5780 5780 self.volOpFilter.setEnabled(False)
5781 5781 self.volOpComProfile.setEnabled(False)
5782 5782 self.volOpComCode.setEnabled(False)
5783 5783 self.volOpFlip.setEnabled(False)
5784 5784 self.volOpCohInt.setEnabled(False)
5785 5785 self.volOpRadarfrequency.setEnabled(False)
5786 5786
5787 5787 self.volOpChannel.setEnabled(False)
5788 5788 self.volOpHeights.setEnabled(False)
5789 5789 self.volOpProfile.setEnabled(False)
5790 5790 self.volOpComMode.setEnabled(False)
5791 5791
5792 5792 self.volOpSplitter.setEnabled(False)
5793 5793 self.volOpCombiner.setEnabled(False)
5794 5794 self.volOpAdjustHei.setEnabled(False)
5795 5795
5796 5796 self.volOpCebAdjustHei.setEnabled(False)
5797 5797
5798 5798 self.volGraphPath.setEnabled(False)
5799 5799 self.volGraphPrefix.setEnabled(False)
5800 5800 self.volGraphToolPath.setEnabled(False)
5801 5801
5802 5802 # set Graph Voltage
5803 5803 self.volGraphChannelList.setEnabled(False)
5804 5804 self.volGraphIntensityRange.setEnabled(False)
5805 5805 self.volGraphHeightrange.setEnabled(False)
5806 5806
5807 5807 # set Operation Spectra
5808 5808 self.specOpnFFTpoints.setEnabled(False)
5809 5809 self.specOpProfiles.setEnabled(False)
5810 5810 self.specOpippFactor.setEnabled(False)
5811 5811 self.specOppairsList.setEnabled(False)
5812 5812
5813 5813 self.specOpComCrossSpectra.setEnabled(False)
5814 5814 self.specOpComChannel.setEnabled(False)
5815 5815 self.specOpComHeights.setEnabled(False)
5816 5816 self.specOpIncoherent.setEnabled(False)
5817 5817 self.specOpgetNoise.setEnabled(False)
5818 5818 self.specOpRadarfrequency.setEnabled(False)
5819 5819
5820 5820
5821 5821 self.specOpChannel.setEnabled(False)
5822 5822 self.specOpHeights.setEnabled(False)
5823 5823 # set Graph Spectra
5824 5824 self.specGgraphChannelList.setEnabled(False)
5825 5825 self.specGgraphFreq.setEnabled(False)
5826 5826 self.specGgraphHeight.setEnabled(False)
5827 5827 self.specGgraphDbsrange.setEnabled(False)
5828 5828 self.specGgraphmagnitud.setEnabled(False)
5829 5829 self.specGgraphTminTmax.setEnabled(False)
5830 5830 self.specGgraphTimeRange.setEnabled(False)
5831 5831 self.specGraphPath.setEnabled(False)
5832 5832 self.specGraphToolPath.setEnabled(False)
5833 5833 self.specGraphPrefix.setEnabled(False)
5834 5834
5835 5835 self.specGgraphftpratio.setEnabled(False)
5836 5836 # set Operation SpectraHeis
5837 5837 self.specHeisOpIncoherent.setEnabled(False)
5838 5838 self.specHeisOpCobIncInt.setEnabled(False)
5839 5839 # set Graph SpectraHeis
5840 5840 self.specHeisGgraphChannelList.setEnabled(False)
5841 5841 self.specHeisGgraphXminXmax.setEnabled(False)
5842 5842 self.specHeisGgraphYminYmax.setEnabled(False)
5843 5843 self.specHeisGgraphTminTmax.setEnabled(False)
5844 5844 self.specHeisGgraphTimeRange.setEnabled(False)
5845 5845 self.specHeisGgraphftpratio.setEnabled(False)
5846 5846 self.specHeisGraphPath.setEnabled(False)
5847 5847 self.specHeisGraphPrefix.setEnabled(False)
5848 5848 self.specHeisGraphToolPath.setEnabled(False)
5849 5849
5850 5850 self.proComWalk.setCurrentIndex(0)
5851 5851
5852 5852 # tool tip gui
5853 5853 QtGui.QToolTip.setFont(QtGui.QFont('SansSerif', 10))
5854 5854 self.projectExplorerTree.setToolTip('Right clik to add Project or Unit Process')
5855 5855 # tool tip gui project
5856 5856
5857 5857 # tool tip gui volOp
5858 5858 # self.volOpChannel.setToolTip('Example: 1,2,3,4,5')
5859 5859 # self.volOpHeights.setToolTip('Example: 90,180')
5860 5860 # self.volOpFilter.setToolTip('Example: 2')
5861 5861 # self.volOpProfile.setToolTip('Example:0,127')
5862 5862 # self.volOpCohInt.setToolTip('Example: 128')
5863 5863 # self.volOpFlip.setToolTip('ChannelList where flip will be applied. Example: 0,2,3')
5864 5864 # self.volOpOk.setToolTip('If you have finished, please Ok ')
5865 5865 # # tool tip gui volGraph
5866 5866 # self.volGraphIntensityRange.setToolTip('Height range. Example: 50,100')
5867 5867 # self.volGraphHeightrange.setToolTip('Amplitude. Example: 0,10000')
5868 5868 # tool tip gui specOp
5869 5869 # self.specOpnFFTpoints.setToolTip('Example: 128')
5870 5870 # self.specOpProfiles.setToolTip('Example: 128')
5871 5871 # self.specOpippFactor.setToolTip('Example:1.0')
5872 5872 # self.specOpIncoherent.setToolTip('Example: 10')
5873 5873 # self.specOpgetNoise.setToolTip('Example:20,180,30,120 (minHei,maxHei,minVel,maxVel)')
5874 5874 #
5875 5875 # self.specOpChannel.setToolTip('Example: 0,1,2,3')
5876 5876 # self.specOpHeights.setToolTip('Example: 90,180')
5877 5877 # self.specOppairsList.setToolTip('Example: (0,1),(2,3)')
5878 5878 # # tool tip gui specGraph
5879 5879 #
5880 5880 # self.specGgraphChannelList.setToolTip('Example: 0,3,4')
5881 5881 # self.specGgraphFreq.setToolTip('Example: -20,20')
5882 5882 # self.specGgraphHeight.setToolTip('Example: 100,400')
5883 5883 # self.specGgraphDbsrange.setToolTip('Example: 30,170')
5884 5884 #
5885 5885 # self.specGraphPrefix.setToolTip('Example: EXPERIMENT_NAME')
5886 5886 #
5887 5887 #
5888 5888 # self.specHeisOpIncoherent.setToolTip('Example: 10')
5889 5889 #
5890 5890 # self.specHeisGgraphChannelList.setToolTip('Example: 0,2,3')
5891 5891 # self.specHeisGgraphXminXmax.setToolTip('Example (Hz): -1000, 1000')
5892 5892 # self.specHeisGgraphYminYmax.setToolTip('Example (dB): 5, 35')
5893 5893 # self.specHeisGgraphTminTmax.setToolTip('Example (hours): 0, 24')
5894 5894 # self.specHeisGgraphTimeRange.setToolTip('Example (hours): 8')
5895 5895
5896 5896 self.labelSet.show()
5897 5897 self.proSet.show()
5898 5898
5899 5899 self.labelIPPKm.hide()
5900 5900 self.proIPPKm.hide()
5901 5901
5902 5902 sys.stdout = ShowMeConsole(textWritten=self.normalOutputWritten)
5903 5903 # sys.stderr = ShowMeConsole(textWritten=self.errorOutputWritten)
5904 5904
5905 5905
5906 5906 class UnitProcessWindow(QMainWindow, Ui_UnitProcess):
5907 5907 """
5908 5908 Class documentation goes here.
5909 5909 """
5910 5910 closed = pyqtSignal()
5911 5911 create = False
5912 5912
5913 5913 def __init__(self, parent=None):
5914 5914 """
5915 5915 Constructor
5916 5916 """
5917 5917 QMainWindow.__init__(self, parent)
5918 5918 self.setupUi(self)
5919 5919 self.getFromWindow = None
5920 5920 self.getfromWindowList = []
5921 5921 self.dataTypeProject = None
5922 5922
5923 5923 self.listUP = None
5924 5924
5925 5925 @pyqtSignature("")
5926 5926 def on_unitPokbut_clicked(self):
5927 5927 """
5928 5928 Slot documentation goes here.
5929 5929 """
5930 5930 self.create = True
5931 5931 self.getFromWindow = self.getfromWindowList[int(self.comboInputBox.currentIndex())]
5932 5932 # self.nameofUP= str(self.nameUptxt.text())
5933 5933 self.typeofUP = str(self.comboTypeBox.currentText())
5934 5934 self.close()
5935 5935
5936 5936
5937 5937 @pyqtSignature("")
5938 5938 def on_unitPcancelbut_clicked(self):
5939 5939 """
5940 5940 Slot documentation goes here.
5941 5941 """
5942 5942 self.create = False
5943 5943 self.close()
5944 5944
5945 5945 def loadTotalList(self):
5946 5946 self.comboInputBox.clear()
5947 5947 for i in self.getfromWindowList:
5948 5948
5949 5949 name = i.getElementName()
5950 5950 if name == 'Project':
5951 5951 id = i.id
5952 5952 name = i.name
5953 5953 if self.dataTypeProject == 'Voltage':
5954 5954 self.comboTypeBox.clear()
5955 5955 self.comboTypeBox.addItem("Voltage")
5956 5956
5957 5957 if self.dataTypeProject == 'Spectra':
5958 5958 self.comboTypeBox.clear()
5959 5959 self.comboTypeBox.addItem("Spectra")
5960 5960 self.comboTypeBox.addItem("Correlation")
5961 5961 if self.dataTypeProject == 'Fits':
5962 5962 self.comboTypeBox.clear()
5963 5963 self.comboTypeBox.addItem("SpectraHeis")
5964 5964
5965 5965
5966 5966 if name == 'ProcUnit':
5967 5967 id = int(i.id) - 1
5968 5968 name = i.datatype
5969 5969 if name == 'Voltage':
5970 5970 self.comboTypeBox.clear()
5971 5971 self.comboTypeBox.addItem("Spectra")
5972 5972 self.comboTypeBox.addItem("SpectraHeis")
5973 5973 self.comboTypeBox.addItem("Correlation")
5974 5974 if name == 'Spectra':
5975 5975 self.comboTypeBox.clear()
5976 5976 self.comboTypeBox.addItem("Spectra")
5977 5977 self.comboTypeBox.addItem("SpectraHeis")
5978 5978 self.comboTypeBox.addItem("Correlation")
5979 5979 if name == 'SpectraHeis':
5980 5980 self.comboTypeBox.clear()
5981 5981 self.comboTypeBox.addItem("SpectraHeis")
5982 5982
5983 5983 self.comboInputBox.addItem(str(name))
5984 5984 # self.comboInputBox.addItem(str(name)+str(id))
5985 5985
5986 5986 def closeEvent(self, event):
5987 5987 self.closed.emit()
5988 5988 event.accept()
5989 5989
5990 5990 class Ftp(QMainWindow, Ui_Ftp):
5991 5991 """
5992 5992 Class documentation goes here.
5993 5993 """
5994 5994 create = False
5995 5995 closed = pyqtSignal()
5996 5996 server = None
5997 5997 remotefolder = None
5998 5998 username = None
5999 5999 password = None
6000 6000 ftp_wei = None
6001 6001 exp_code = None
6002 6002 sub_exp_code = None
6003 6003 plot_pos = None
6004 6004
6005 6005 def __init__(self, parent=None):
6006 6006 """
6007 6007 Constructor
6008 6008 """
6009 6009 QMainWindow.__init__(self, parent)
6010 6010 self.setupUi(self)
6011 6011 self.setGUIStatus()
6012 6012
6013 6013 def setGUIStatus(self):
6014 6014 self.setWindowTitle("ROJ-Signal Chain")
6015 6015 self.serverFTP.setToolTip('Example: jro-app.igp.gob.pe')
6016 6016 self.folderFTP.setToolTip('Example: /home/wmaster/graficos')
6017 6017 self.usernameFTP.setToolTip('Example: myusername')
6018 6018 self.passwordFTP.setToolTip('Example: mypass ')
6019 6019 self.weightFTP.setToolTip('Example: 0')
6020 6020 self.expcodeFTP.setToolTip('Example: 0')
6021 6021 self.subexpFTP.setToolTip('Example: 0')
6022 6022 self.plotposFTP.setToolTip('Example: 0')
6023 6023
6024 6024 def setParmsfromTemporal(self, server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos):
6025 6025 self.serverFTP.setText(str(server))
6026 6026 self.folderFTP.setText(str(remotefolder))
6027 6027 self.usernameFTP.setText(str(username))
6028 6028 self.passwordFTP.setText(str(password))
6029 6029 self.weightFTP.setText(str(ftp_wei))
6030 6030 self.expcodeFTP.setText(str(exp_code))
6031 6031 self.subexpFTP.setText(str(sub_exp_code))
6032 6032 self.plotposFTP.setText(str(plot_pos))
6033 6033
6034 6034 def getParmsFromFtpWindow(self):
6035 6035 """
6036 6036 Return Inputs Project:
6037 6037 - server
6038 6038 - remotefolder
6039 6039 - username
6040 6040 - password
6041 6041 - ftp_wei
6042 6042 - exp_code
6043 6043 - sub_exp_code
6044 6044 - plot_pos
6045 6045 """
6046 6046 name_server_ftp = str(self.serverFTP.text())
6047 6047 if not name_server_ftp:
6048 6048 self.console.clear()
6049 6049 self.console.append("Please Write a FTP Server")
6050 6050 return 0
6051 6051
6052 6052 folder_server_ftp = str(self.folderFTP.text())
6053 6053 if not folder_server_ftp:
6054 6054 self.console.clear()
6055 6055 self.console.append("Please Write a Folder")
6056 6056 return 0
6057 6057
6058 6058 username_ftp = str(self.usernameFTP.text())
6059 6059 if not username_ftp:
6060 6060 self.console.clear()
6061 6061 self.console.append("Please Write a User Name")
6062 6062 return 0
6063 6063
6064 6064 password_ftp = str(self.passwordFTP.text())
6065 6065 if not password_ftp:
6066 6066 self.console.clear()
6067 6067 self.console.append("Please Write a passwordFTP")
6068 6068 return 0
6069 6069
6070 6070 ftp_wei = str(self.weightFTP.text())
6071 6071 if not ftp_wei == "":
6072 6072 try:
6073 6073 ftp_wei = int(self.weightFTP.text())
6074 6074 except:
6075 6075 self.console.clear()
6076 6076 self.console.append("Please Write a ftp_wei number")
6077 6077 return 0
6078 6078
6079 6079 exp_code = str(self.expcodeFTP.text())
6080 6080 if not exp_code == "":
6081 6081 try:
6082 6082 exp_code = int(self.expcodeFTP.text())
6083 6083 except:
6084 6084 self.console.clear()
6085 6085 self.console.append("Please Write a exp_code number")
6086 6086 return 0
6087 6087
6088 6088
6089 6089 sub_exp_code = str(self.subexpFTP.text())
6090 6090 if not sub_exp_code == "":
6091 6091 try:
6092 6092 sub_exp_code = int(self.subexpFTP.text())
6093 6093 except:
6094 6094 self.console.clear()
6095 6095 self.console.append("Please Write a sub_exp_code number")
6096 6096 return 0
6097 6097
6098 6098 plot_pos = str(self.plotposFTP.text())
6099 6099 if not plot_pos == "":
6100 6100 try:
6101 6101 plot_pos = int(self.plotposFTP.text())
6102 6102 except:
6103 6103 self.console.clear()
6104 6104 self.console.append("Please Write a plot_pos number")
6105 6105 return 0
6106 6106
6107 6107 return name_server_ftp, folder_server_ftp, username_ftp, password_ftp, ftp_wei, exp_code, sub_exp_code, plot_pos
6108 6108
6109 6109 @pyqtSignature("")
6110 6110 def on_ftpOkButton_clicked(self):
6111 6111 server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.getParmsFromFtpWindow()
6112 6112 self.create = True
6113 6113 self.close()
6114 6114
6115 6115 @pyqtSignature("")
6116 6116 def on_ftpCancelButton_clicked(self):
6117 6117 self.create = False
6118 6118 self.close()
6119 6119
6120 6120 def closeEvent(self, event):
6121 6121 self.closed.emit()
6122 6122 event.accept()
6123 6123
6124 6124 class ftpBuffer():
6125 6125
6126 6126 server = None
6127 6127 remotefolder = None
6128 6128 username = None
6129 6129 password = None
6130 6130 ftp_wei = None
6131 6131 exp_code = None
6132 6132 sub_exp_code = None
6133 6133 plot_pos = None
6134 6134 create = False
6135 6135 withoutconfig = False
6136 6136 createforView = False
6137 6137 localfolder = None
6138 6138 extension = None
6139 6139 period = None
6140 6140 protocol = None
6141 6141
6142 6142 def __init__(self):
6143 6143
6144 6144 self.create = False
6145 6145 self.server = None
6146 6146 self.remotefolder = None
6147 6147 self.username = None
6148 6148 self.password = None
6149 6149 self.ftp_wei = None
6150 6150 self.exp_code = None
6151 6151 self.sub_exp_code = None
6152 6152 self.plot_pos = None
6153 6153 # self.create = False
6154 6154 self.localfolder = None
6155 6155 self.extension = None
6156 6156 self.period = None
6157 6157 self.protocol = None
6158 6158
6159 6159 def setwithoutconfiguration(self):
6160 6160
6161 6161 self.create = False
6162 6162 self.server = "jro-app.igp.gob.pe"
6163 6163 self.remotefolder = "/home/wmaster/graficos"
6164 6164 self.username = "wmaster"
6165 6165 self.password = "mst2010vhf"
6166 6166 self.withoutconfig = True
6167 6167 self.localfolder = './'
6168 6168 self.extension = '.png'
6169 6169 self.period = 60
6170 6170 self.protocol = 'ftp'
6171 6171 self.createforView = True
6172 6172
6173 6173 if not self.ftp_wei:
6174 6174 self.ftp_wei = 0
6175 6175
6176 6176 if not self.exp_code:
6177 6177 self.exp_code = 0
6178 6178
6179 6179 if not self.sub_exp_code:
6180 6180 self.sub_exp_code = 0
6181 6181
6182 6182 if not self.plot_pos:
6183 6183 self.plot_pos = 0
6184 6184
6185 6185 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'):
6186 6186
6187 6187 self.server = server
6188 6188 self.remotefolder = remotefolder
6189 6189 self.username = username
6190 6190 self.password = password
6191 6191 self.ftp_wei = ftp_wei
6192 6192 self.exp_code = exp_code
6193 6193 self.sub_exp_code = sub_exp_code
6194 6194 self.plot_pos = plot_pos
6195 6195 self.create = True
6196 6196 self.withoutconfig = False
6197 6197 self.createforView = True
6198 6198 self.localfolder = localfolder
6199 6199 self.extension = extension
6200 6200 self.period = period
6201 6201 self.protocol = protocol
6202 6202
6203 6203 def recover(self):
6204 6204
6205 6205 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
6206 6206
6207 6207 class ShowMeConsole(QtCore.QObject):
6208 6208
6209 6209 textWritten = QtCore.pyqtSignal(str)
6210 6210
6211 6211 def write(self, text):
6212 6212
6213 6213 if len(text) == 0:
6214 6214 self.textWritten.emit("\n")
6215 6215 return
6216 6216
6217 6217 if text[-1] == "\n":
6218 6218 text = text[:-1]
6219 6219
6220 6220 self.textWritten.emit(str(text))
6221
6222 def flush(self):
6223 pass
Show file before | Show file after | Hide comments
@@ -1,692 +1,692
1 1 '''
2 2 @author: Daniel Suarez
3 3 '''
4 4
5 5 import os
6 6 import sys
7 7 import glob
8 8 import fnmatch
9 9 import datetime
10 10 import time
11 11 import re
12 12 import h5py
13 13 import numpy
14 14
15 15 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
16 16 from schainpy.model.data.jroamisr import AMISR
17 17
18 18 try:
19 19 from gevent import sleep
20 20 except:
21 21 from time import sleep
22 22
23 23 class RadacHeader():
24 24 def __init__(self, fp):
25 25 header = 'Raw11/Data/RadacHeader'
26 26 self.beamCodeByPulse = fp.get(header+'/BeamCode')
27 27 self.beamCode = fp.get('Raw11/Data/Beamcodes')
28 28 self.code = fp.get(header+'/Code')
29 29 self.frameCount = fp.get(header+'/FrameCount')
30 30 self.modeGroup = fp.get(header+'/ModeGroup')
31 31 self.nsamplesPulse = fp.get(header+'/NSamplesPulse')
32 32 self.pulseCount = fp.get(header+'/PulseCount')
33 33 self.radacTime = fp.get(header+'/RadacTime')
34 34 self.timeCount = fp.get(header+'/TimeCount')
35 35 self.timeStatus = fp.get(header+'/TimeStatus')
36 36
37 37 self.nrecords = self.pulseCount.shape[0] #nblocks
38 38 self.npulses = self.pulseCount.shape[1] #nprofile
39 39 self.nsamples = self.nsamplesPulse[0,0] #ngates
40 40 self.nbeams = self.beamCode.shape[1]
41 41
42 42
43 43 def getIndexRangeToPulse(self, idrecord=0):
44 44 #indexToZero = numpy.where(self.pulseCount.value[idrecord,:]==0)
45 45 #startPulseCountId = indexToZero[0][0]
46 46 #endPulseCountId = startPulseCountId - 1
47 47 #range1 = numpy.arange(startPulseCountId,self.npulses,1)
48 48 #range2 = numpy.arange(0,startPulseCountId,1)
49 49 #return range1, range2
50 50 zero = 0
51 51 npulse = max(self.pulseCount[0,:]+1)-1
52 52 looking_index = numpy.where(self.pulseCount.value[idrecord,:]==npulse)[0]
53 53 getLastIndex = looking_index[-1]
54 54 index_data = numpy.arange(0,getLastIndex+1,1)
55 55 index_buffer = numpy.arange(getLastIndex+1,self.npulses,1)
56 56 return index_data, index_buffer
57 57
58 58 class AMISRReader(ProcessingUnit):
59 59
60 60 path = None
61 61 startDate = None
62 62 endDate = None
63 63 startTime = None
64 64 endTime = None
65 65 walk = None
66 66 isConfig = False
67 67
68 68 def __init__(self):
69 69 self.set = None
70 70 self.subset = None
71 71 self.extension_file = '.h5'
72 72 self.dtc_str = 'dtc'
73 73 self.dtc_id = 0
74 74 self.status = True
75 75 self.isConfig = False
76 76 self.dirnameList = []
77 77 self.filenameList = []
78 78 self.fileIndex = None
79 79 self.flagNoMoreFiles = False
80 80 self.flagIsNewFile = 0
81 81 self.filename = ''
82 82 self.amisrFilePointer = None
83 83 self.radacHeaderObj = None
84 84 self.dataOut = self.__createObjByDefault()
85 85 self.datablock = None
86 86 self.rest_datablock = None
87 87 self.range = None
88 88 self.idrecord_count = 0
89 89 self.profileIndex = 0
90 90 self.index_amisr_sample = None
91 91 self.index_amisr_buffer = None
92 92 self.beamCodeByFrame = None
93 93 self.radacTimeByFrame = None
94 94 #atributos originales tal y como esta en el archivo de datos
95 95 self.beamCodesFromFile = None
96 96 self.radacTimeFromFile = None
97 97 self.rangeFromFile = None
98 98 self.dataByFrame = None
99 99 self.dataset = None
100 100
101 101 self.beamCodeDict = {}
102 102 self.beamRangeDict = {}
103 103
104 104 #experiment cgf file
105 105 self.npulsesint_fromfile = None
106 106 self.recordsperfile_fromfile = None
107 107 self.nbeamcodes_fromfile = None
108 108 self.ngates_fromfile = None
109 109 self.ippSeconds_fromfile = None
110 110 self.frequency_h5file = None
111 111
112 112
113 113 self.__firstFile = True
114 114 self.buffer_radactime = None
115 115
116 116 self.index4_schain_datablock = None
117 117 self.index4_buffer = None
118 118 self.schain_datablock = None
119 119 self.buffer = None
120 120 self.linear_pulseCount = None
121 121 self.npulseByFrame = None
122 122 self.profileIndex_offset = None
123 123 self.timezone = 'ut'
124 124
125 125 self.__waitForNewFile = 20
126 126 self.__filename_online = None
127 127
128 128 def __createObjByDefault(self):
129 129
130 130 dataObj = AMISR()
131 131
132 132 return dataObj
133 133
134 134 def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''):
135 135 self.path = path
136 136 self.startDate = startDate
137 137 self.endDate = endDate
138 138 self.startTime = startTime
139 139 self.endTime = endTime
140 140 self.walk = walk
141 141
142 142 def __checkPath(self):
143 143 if os.path.exists(self.path):
144 144 self.status = 1
145 145 else:
146 146 self.status = 0
147 147 print 'Path:%s does not exists'%self.path
148 148
149 149 return
150 150
151 151 def __selDates(self, amisr_dirname_format):
152 152 try:
153 153 year = int(amisr_dirname_format[0:4])
154 154 month = int(amisr_dirname_format[4:6])
155 155 dom = int(amisr_dirname_format[6:8])
156 156 thisDate = datetime.date(year,month,dom)
157 157
158 158 if (thisDate>=self.startDate and thisDate <= self.endDate):
159 159 return amisr_dirname_format
160 160 except:
161 161 return None
162 162
163 163 def __findDataForDates(self,online=False):
164 164
165 165
166 166
167 167 if not(self.status):
168 168 return None
169 169
170 170 pat = '\d+.\d+'
171 171 dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
172 172 dirnameList = filter(lambda x:x!=None,dirnameList)
173 173 dirnameList = [x.string for x in dirnameList]
174 174 if not(online):
175 175 dirnameList = [self.__selDates(x) for x in dirnameList]
176 176 dirnameList = filter(lambda x:x!=None,dirnameList)
177 177 if len(dirnameList)>0:
178 178 self.status = 1
179 179 self.dirnameList = dirnameList
180 180 self.dirnameList.sort()
181 181 else:
182 182 self.status = 0
183 183 return None
184 184
185 185 def __getTimeFromData(self):
186 186 startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
187 187 endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
188 188
189 189 print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader)
190 190 print '........................................'
191 191 filter_filenameList = []
192 192 self.filenameList.sort()
193 193 for i in range(len(self.filenameList)-1):
194 194 filename = self.filenameList[i]
195 195 fp = h5py.File(filename,'r')
196 196 time_str = fp.get('Time/RadacTimeString')
197 197
198 198 startDateTimeStr_File = time_str[0][0].split('.')[0]
199 199 junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
200 200 startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
201 201
202 202 endDateTimeStr_File = time_str[-1][-1].split('.')[0]
203 203 junk = time.strptime(endDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
204 204 endDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
205 205
206 206 fp.close()
207 207
208 208 if self.timezone == 'lt':
209 209 startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300)
210 210 endDateTime_File = endDateTime_File - datetime.timedelta(minutes = 300)
211 211
212 212 if (endDateTime_File>=startDateTime_Reader and endDateTime_File<endDateTime_Reader):
213 213 #self.filenameList.remove(filename)
214 214 filter_filenameList.append(filename)
215 215
216 216 filter_filenameList.sort()
217 217 self.filenameList = filter_filenameList
218 218 return 1
219 219
220 220 def __filterByGlob1(self, dirName):
221 221 filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)
222 222 filterDict = {}
223 223 filterDict.setdefault(dirName)
224 224 filterDict[dirName] = filter_files
225 225 return filterDict
226 226
227 227 def __getFilenameList(self, fileListInKeys, dirList):
228 228 for value in fileListInKeys:
229 229 dirName = value.keys()[0]
230 230 for file in value[dirName]:
231 231 filename = os.path.join(dirName, file)
232 232 self.filenameList.append(filename)
233 233
234 234
235 235 def __selectDataForTimes(self, online=False):
236 236 #aun no esta implementado el filtro for tiempo
237 237 if not(self.status):
238 238 return None
239 239
240 240 dirList = [os.path.join(self.path,x) for x in self.dirnameList]
241 241
242 242 fileListInKeys = [self.__filterByGlob1(x) for x in dirList]
243 243
244 244 self.__getFilenameList(fileListInKeys, dirList)
245 245 if not(online):
246 246 #filtro por tiempo
247 247 if not(self.all):
248 248 self.__getTimeFromData()
249 249
250 250 if len(self.filenameList)>0:
251 251 self.status = 1
252 252 self.filenameList.sort()
253 253 else:
254 254 self.status = 0
255 255 return None
256 256
257 257 else:
258 258 #get the last file - 1
259 259 self.filenameList = [self.filenameList[-2]]
260 260
261 261 new_dirnameList = []
262 262 for dirname in self.dirnameList:
263 263 junk = numpy.array([dirname in x for x in self.filenameList])
264 264 junk_sum = junk.sum()
265 265 if junk_sum > 0:
266 266 new_dirnameList.append(dirname)
267 267 self.dirnameList = new_dirnameList
268 268 return 1
269 269
270 def __searchFilesOnline(self,
270 def searchFilesOnLine(self,
271 271 path,
272 272 walk=True):
273 273
274 274 startDate = datetime.datetime.utcnow().date()
275 275 endDate = datetime.datetime.utcnow().date()
276 276
277 277 self.__setParameters(path=path, startDate=startDate, endDate=endDate, walk=walk)
278 278
279 279 self.__checkPath()
280 280
281 281 self.__findDataForDates(online=True)
282 282
283 283 self.dirnameList = [self.dirnameList[-1]]
284 284
285 285 self.__selectDataForTimes(online=True)
286 286
287 287 return
288 288
289 289
290 def __searchFilesOffline(self,
290 def searchFilesOffLine(self,
291 291 path,
292 292 startDate,
293 293 endDate,
294 294 startTime=datetime.time(0,0,0),
295 295 endTime=datetime.time(23,59,59),
296 296 walk=True):
297 297
298 298 self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
299 299
300 300 self.__checkPath()
301 301
302 302 self.__findDataForDates()
303 303
304 304 self.__selectDataForTimes()
305 305
306 306 for i in range(len(self.filenameList)):
307 307 print "%s" %(self.filenameList[i])
308 308
309 309 return
310 310
311 311 def __setNextFileOffline(self):
312 312 idFile = self.fileIndex
313 313
314 314 while (True):
315 315 idFile += 1
316 316 if not(idFile < len(self.filenameList)):
317 317 self.flagNoMoreFiles = 1
318 318 print "No more Files"
319 319 return 0
320 320
321 321 filename = self.filenameList[idFile]
322 322
323 323 amisrFilePointer = h5py.File(filename,'r')
324 324
325 325 break
326 326
327 327 self.flagIsNewFile = 1
328 328 self.fileIndex = idFile
329 329 self.filename = filename
330 330
331 331 self.amisrFilePointer = amisrFilePointer
332 332
333 333 print "Setting the file: %s"%self.filename
334 334
335 335 return 1
336 336
337 337
338 338 def __setNextFileOnline(self):
339 339 filename = self.filenameList[0]
340 340 if self.__filename_online != None:
341 341 self.__selectDataForTimes(online=True)
342 342 filename = self.filenameList[0]
343 343 while self.__filename_online == filename:
344 344 print 'waiting %d seconds to get a new file...'%(self.__waitForNewFile)
345 345 sleep(self.__waitForNewFile)
346 346 self.__selectDataForTimes(online=True)
347 347 filename = self.filenameList[0]
348 348
349 349 self.__filename_online = filename
350 350
351 351 self.amisrFilePointer = h5py.File(filename,'r')
352 352 self.flagIsNewFile = 1
353 353 self.filename = filename
354 354 print "Setting the file: %s"%self.filename
355 355 return 1
356 356
357 357
358 358 def __readHeader(self):
359 359 self.radacHeaderObj = RadacHeader(self.amisrFilePointer)
360 360
361 361 #update values from experiment cfg file
362 362 if self.radacHeaderObj.nrecords == self.recordsperfile_fromfile:
363 363 self.radacHeaderObj.nrecords = self.recordsperfile_fromfile
364 364 self.radacHeaderObj.nbeams = self.nbeamcodes_fromfile
365 365 self.radacHeaderObj.npulses = self.npulsesint_fromfile
366 366 self.radacHeaderObj.nsamples = self.ngates_fromfile
367 367
368 368 #looking index list for data
369 369 start_index = self.radacHeaderObj.pulseCount[0,:][0]
370 370 end_index = self.radacHeaderObj.npulses
371 371 range4data = range(start_index, end_index)
372 372 self.index4_schain_datablock = numpy.array(range4data)
373 373
374 374 buffer_start_index = 0
375 375 buffer_end_index = self.radacHeaderObj.pulseCount[0,:][0]
376 376 range4buffer = range(buffer_start_index, buffer_end_index)
377 377 self.index4_buffer = numpy.array(range4buffer)
378 378
379 379 self.linear_pulseCount = numpy.array(range4data + range4buffer)
380 380 self.npulseByFrame = max(self.radacHeaderObj.pulseCount[0,:]+1)
381 381
382 382 #get tuning frequency
383 383 frequency_h5file_dataset = self.amisrFilePointer.get('Rx'+'/TuningFrequency')
384 384 self.frequency_h5file = frequency_h5file_dataset[0,0]
385 385
386 386 self.flagIsNewFile = 1
387 387
388 388 def __getBeamCode(self):
389 389 self.beamCodeDict = {}
390 390 self.beamRangeDict = {}
391 391
392 392 beamCodeMap = self.amisrFilePointer.get('Setup/BeamcodeMap')
393 393
394 394 for i in range(len(self.radacHeaderObj.beamCode[0,:])):
395 395 self.beamCodeDict.setdefault(i)
396 396 self.beamRangeDict.setdefault(i)
397 397 beamcodeValue = self.radacHeaderObj.beamCode[0,i]
398 398 beamcodeIndex = numpy.where(beamCodeMap[:,0] == beamcodeValue)[0][0]
399 399 x = beamCodeMap[beamcodeIndex][1]
400 400 y = beamCodeMap[beamcodeIndex][2]
401 401 z = beamCodeMap[beamcodeIndex][3]
402 402 self.beamCodeDict[i] = [beamcodeValue, x, y, z]
403 403
404 404 just4record0 = self.radacHeaderObj.beamCodeByPulse[0,:]
405 405
406 406 for i in range(len(self.beamCodeDict.values())):
407 407 xx = numpy.where(just4record0==self.beamCodeDict.values()[i][0])
408 408 indexPulseByBeam = self.linear_pulseCount[xx[0]]
409 409 self.beamRangeDict[i] = indexPulseByBeam
410 410
411 411 def __getExpParameters(self):
412 412 if not(self.status):
413 413 return None
414 414
415 415 experimentCfgPath = os.path.join(self.path, self.dirnameList[0], 'Setup')
416 416
417 417 expFinder = glob.glob1(experimentCfgPath,'*.exp')
418 418 if len(expFinder)== 0:
419 419 self.status = 0
420 420 return None
421 421
422 422 experimentFilename = os.path.join(experimentCfgPath,expFinder[0])
423 423
424 424 f = open(experimentFilename)
425 425 lines = f.readlines()
426 426 f.close()
427 427
428 428 parmsList = ['npulsesint*','recordsperfile*','nbeamcodes*','ngates*']
429 429 filterList = [fnmatch.filter(lines, x) for x in parmsList]
430 430
431 431
432 432 values = [re.sub(r'\D',"",x[0]) for x in filterList]
433 433
434 434 self.npulsesint_fromfile = int(values[0])
435 435 self.recordsperfile_fromfile = int(values[1])
436 436 self.nbeamcodes_fromfile = int(values[2])
437 437 self.ngates_fromfile = int(values[3])
438 438
439 439 tufileFinder = fnmatch.filter(lines, 'tufile=*')
440 440 tufile = tufileFinder[0].split('=')[1].split('\n')[0]
441 441 tufile = tufile.split('\r')[0]
442 442 tufilename = os.path.join(experimentCfgPath,tufile)
443 443
444 444 f = open(tufilename)
445 445 lines = f.readlines()
446 446 f.close()
447 447 self.ippSeconds_fromfile = float(lines[1].split()[2])/1E6
448 448
449 449
450 450 self.status = 1
451 451
452 452 def __setIdsAndArrays(self):
453 453 self.dataByFrame = self.__setDataByFrame()
454 454 self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[0, :]
455 455 self.readRanges()
456 456 self.index_amisr_sample, self.index_amisr_buffer = self.radacHeaderObj.getIndexRangeToPulse(0)
457 457 self.radacTimeByFrame = numpy.zeros(self.radacHeaderObj.npulses)
458 458 if len(self.index_amisr_buffer) > 0:
459 459 self.buffer_radactime = numpy.zeros_like(self.radacTimeByFrame)
460 460
461 461
462 462 def __setNextFile(self,online=False):
463 463
464 464 if not(online):
465 465 newFile = self.__setNextFileOffline()
466 466 else:
467 467 newFile = self.__setNextFileOnline()
468 468
469 469 if not(newFile):
470 470 return 0
471 471
472 472 self.__readHeader()
473 473
474 474 if self.__firstFile:
475 475 self.__setIdsAndArrays()
476 476 self.__firstFile = False
477 477
478 478 self.__getBeamCode()
479 479 self.readDataBlock()
480 480
481 481
482 482 def setup(self,path=None,
483 483 startDate=None,
484 484 endDate=None,
485 485 startTime=datetime.time(0,0,0),
486 486 endTime=datetime.time(23,59,59),
487 487 walk=True,
488 488 timezone='ut',
489 489 all=0,
490 490 online=False):
491 491
492 492 self.timezone = timezone
493 493 self.all = all
494 494 self.online = online
495 495 if not(online):
496 496 #Busqueda de archivos offline
497 self.__searchFilesOffline(path, startDate, endDate, startTime, endTime, walk)
497 self.searchFilesOffLine(path, startDate, endDate, startTime, endTime, walk)
498 498 else:
499 self.__searchFilesOnline(path, walk)
499 self.searchFilesOnLine(path, walk)
500 500
501 501 if not(self.filenameList):
502 502 print "There is no files into the folder: %s"%(path)
503 503
504 504 sys.exit(-1)
505 505
506 506 self.__getExpParameters()
507 507
508 508 self.fileIndex = -1
509 509
510 510 self.__setNextFile(online)
511 511
512 512 # first_beamcode = self.radacHeaderObj.beamCodeByPulse[0,0]
513 513 # index = numpy.where(self.radacHeaderObj.beamCodeByPulse[0,:]!=first_beamcode)[0][0]
514 514 self.profileIndex_offset = self.radacHeaderObj.pulseCount[0,:][0]
515 515 self.profileIndex = self.profileIndex_offset
516 516
517 517 def readRanges(self):
518 518 dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Range')
519 519
520 520 self.rangeFromFile = numpy.reshape(dataset.value,(-1))
521 521 return self.rangeFromFile
522 522
523 523
524 524 def readRadacTime(self,idrecord, range1, range2):
525 525 self.radacTimeFromFile = self.radacHeaderObj.radacTime.value
526 526
527 527 radacTimeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
528 528 #radacTimeByFrame = dataset[idrecord - 1,range1]
529 529 #radacTimeByFrame = dataset[idrecord,range2]
530 530
531 531 return radacTimeByFrame
532 532
533 533 def readBeamCode(self, idrecord, range1, range2):
534 534 dataset = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode')
535 535 beamcodeByFrame = numpy.zeros((self.radacHeaderObj.npulses))
536 536 self.beamCodesFromFile = dataset.value
537 537
538 538 #beamcodeByFrame[range1] = dataset[idrecord - 1, range1]
539 539 #beamcodeByFrame[range2] = dataset[idrecord, range2]
540 540 beamcodeByFrame[range1] = dataset[idrecord, range1]
541 541 beamcodeByFrame[range2] = dataset[idrecord, range2]
542 542
543 543 return beamcodeByFrame
544 544
545 545
546 546 def __setDataByFrame(self):
547 547 ndata = 2 # porque es complejo
548 548 dataByFrame = numpy.zeros((self.radacHeaderObj.npulses, self.radacHeaderObj.nsamples, ndata))
549 549 return dataByFrame
550 550
551 551 def __readDataSet(self):
552 552 dataset = self.amisrFilePointer.get('Raw11/Data/Samples/Data')
553 553 return dataset
554 554
555 555 def __setDataBlock(self,):
556 556 real = self.dataByFrame[:,:,0] #asumo que 0 es real
557 557 imag = self.dataByFrame[:,:,1] #asumo que 1 es imaginario
558 558 datablock = real + imag*1j #armo el complejo
559 559 return datablock
560 560
561 561 def readSamples_version1(self,idrecord):
562 562 #estas tres primeras lineas solo se deben ejecutar una vez
563 563 if self.flagIsNewFile:
564 564 #reading dataset
565 565 self.dataset = self.__readDataSet()
566 566 self.flagIsNewFile = 0
567 567
568 568 if idrecord == 0:
569 569 self.dataByFrame[self.index4_schain_datablock, : ,:] = self.dataset[0, self.index_amisr_sample,:,:]
570 570 self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[0, self.index_amisr_sample]
571 571 datablock = self.__setDataBlock()
572 572 if len(self.index_amisr_buffer) > 0:
573 573 self.buffer = self.dataset[0, self.index_amisr_buffer,:,:]
574 574 self.buffer_radactime = self.radacHeaderObj.radacTime[0, self.index_amisr_buffer]
575 575
576 576 return datablock
577 577 if len(self.index_amisr_buffer) > 0:
578 578 self.dataByFrame[self.index4_buffer,:,:] = self.buffer.copy()
579 579 self.radacTimeByFrame[self.index4_buffer] = self.buffer_radactime.copy()
580 580 self.dataByFrame[self.index4_schain_datablock,:,:] = self.dataset[idrecord, self.index_amisr_sample,:,:]
581 581 self.radacTimeByFrame[self.index4_schain_datablock] = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_sample]
582 582 datablock = self.__setDataBlock()
583 583 if len(self.index_amisr_buffer) > 0:
584 584 self.buffer = self.dataset[idrecord, self.index_amisr_buffer, :, :]
585 585 self.buffer_radactime = self.radacHeaderObj.radacTime[idrecord, self.index_amisr_buffer]
586 586
587 587 return datablock
588 588
589 589
590 590 def readSamples(self,idrecord):
591 591 if self.flagIsNewFile:
592 592 self.dataByFrame = self.__setDataByFrame()
593 593 self.beamCodeByFrame = self.amisrFilePointer.get('Raw11/Data/RadacHeader/BeamCode').value[idrecord, :]
594 594
595 595 #reading ranges
596 596 self.readRanges()
597 597 #reading dataset
598 598 self.dataset = self.__readDataSet()
599 599
600 600 self.flagIsNewFile = 0
601 601 self.radacTimeByFrame = self.radacHeaderObj.radacTime.value[idrecord, :]
602 602 self.dataByFrame = self.dataset[idrecord, :, :, :]
603 603 datablock = self.__setDataBlock()
604 604 return datablock
605 605
606 606
607 607 def readDataBlock(self):
608 608
609 609 self.datablock = self.readSamples_version1(self.idrecord_count)
610 610 #self.datablock = self.readSamples(self.idrecord_count)
611 611 #print 'record:', self.idrecord_count
612 612
613 613 self.idrecord_count += 1
614 614 self.profileIndex = 0
615 615
616 616 if self.idrecord_count >= self.radacHeaderObj.nrecords:
617 617 self.idrecord_count = 0
618 618 self.flagIsNewFile = 1
619 619
620 620 def readNextBlock(self):
621 621
622 622 self.readDataBlock()
623 623
624 624 if self.flagIsNewFile:
625 625 self.__setNextFile(self.online)
626 626 pass
627 627
628 628 def __hasNotDataInBuffer(self):
629 629 #self.radacHeaderObj.npulses debe ser otra variable para considerar el numero de pulsos a tomar en el primer y ultimo record
630 630 if self.profileIndex >= self.radacHeaderObj.npulses:
631 631 return 1
632 632 return 0
633 633
634 634 def printUTC(self):
635 635 print self.dataOut.utctime
636 636 print ''
637 637
638 638 def setObjProperties(self):
639 639
640 640 self.dataOut.heightList = self.rangeFromFile/1000.0 #km
641 641 self.dataOut.nProfiles = self.radacHeaderObj.npulses
642 642 self.dataOut.nRecords = self.radacHeaderObj.nrecords
643 643 self.dataOut.nBeams = self.radacHeaderObj.nbeams
644 644 self.dataOut.ippSeconds = self.ippSeconds_fromfile
645 645 # self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
646 646 self.dataOut.frequency = self.frequency_h5file
647 647 self.dataOut.npulseByFrame = self.npulseByFrame
648 648 self.dataOut.nBaud = None
649 649 self.dataOut.nCode = None
650 650 self.dataOut.code = None
651 651
652 652 self.dataOut.beamCodeDict = self.beamCodeDict
653 653 self.dataOut.beamRangeDict = self.beamRangeDict
654 654
655 655 if self.timezone == 'lt':
656 656 self.dataOut.timeZone = time.timezone / 60. #get the timezone in minutes
657 657 else:
658 658 self.dataOut.timeZone = 0 #by default time is UTC
659 659
660 660 def getData(self):
661 661
662 662 if self.flagNoMoreFiles:
663 663 self.dataOut.flagNoData = True
664 664 print 'Process finished'
665 665 return 0
666 666
667 667 if self.__hasNotDataInBuffer():
668 668 self.readNextBlock()
669 669
670 670
671 671 if self.datablock is None: # setear esta condicion cuando no hayan datos por leers
672 672 self.dataOut.flagNoData = True
673 673 return 0
674 674
675 675 self.dataOut.data = numpy.reshape(self.datablock[self.profileIndex,:],(1,-1))
676 676
677 677 self.dataOut.utctime = self.radacTimeByFrame[self.profileIndex]
678 678 self.dataOut.profileIndex = self.profileIndex
679 679 self.dataOut.flagNoData = False
680 680
681 681 self.profileIndex += 1
682 682
683 683 return self.dataOut.data
684 684
685 685
686 686 def run(self, **kwargs):
687 687 if not(self.isConfig):
688 688 self.setup(**kwargs)
689 689 self.setObjProperties()
690 690 self.isConfig = True
691 691
692 692 self.getData()
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (543 lines changed) Show them Hide them
@@ -1,1855 +1,1794
1 1 '''
2 2 Created on Jul 2, 2014
3 3
4 4 @author: roj-idl71
5 5 '''
6 6 import os
7 7 import sys
8 8 import glob
9 9 import time
10 10 import numpy
11 11 import fnmatch
12 12 import inspect
13 13 import time, datetime
14 14 import traceback
15 15 import zmq
16 16
17 17 try:
18 18 from gevent import sleep
19 19 except:
20 20 from time import sleep
21 21
22 22 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
23 23 from schainpy.model.data.jroheaderIO import get_dtype_index, get_numpy_dtype, get_procflag_dtype, get_dtype_width
24 24
25 25 LOCALTIME = True
26 26
27 27 def isNumber(cad):
28 28 """
29 29 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
30 30
31 31 Excepciones:
32 32 Si un determinado string no puede ser convertido a numero
33 33 Input:
34 34 str, string al cual se le analiza para determinar si convertible a un numero o no
35 35
36 36 Return:
37 37 True : si el string es uno numerico
38 38 False : no es un string numerico
39 39 """
40 40 try:
41 41 float( cad )
42 42 return True
43 43 except:
44 44 return False
45 45
46 46 def isFileInEpoch(filename, startUTSeconds, endUTSeconds):
47 47 """
48 48 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
49 49
50 50 Inputs:
51 51 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
52 52
53 53 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
54 54 segundos contados desde 01/01/1970.
55 55 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
56 56 segundos contados desde 01/01/1970.
57 57
58 58 Return:
59 59 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
60 60 fecha especificado, de lo contrario retorna False.
61 61
62 62 Excepciones:
63 63 Si el archivo no existe o no puede ser abierto
64 64 Si la cabecera no puede ser leida.
65 65
66 66 """
67 67 basicHeaderObj = BasicHeader(LOCALTIME)
68 68
69 69 try:
70 70 fp = open(filename,'rb')
71 71 except IOError:
72 72 print "The file %s can't be opened" %(filename)
73 73 return 0
74 74
75 75 sts = basicHeaderObj.read(fp)
76 76 fp.close()
77 77
78 78 if not(sts):
79 79 print "Skipping the file %s because it has not a valid header" %(filename)
80 80 return 0
81 81
82 82 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
83 83 return 0
84 84
85 85 return 1
86 86
87 87 def isTimeInRange(thisTime, startTime, endTime):
88 88
89 89 if endTime >= startTime:
90 90 if (thisTime < startTime) or (thisTime > endTime):
91 91 return 0
92 92
93 93 return 1
94 94 else:
95 95 if (thisTime < startTime) and (thisTime > endTime):
96 96 return 0
97 97
98 98 return 1
99 99
100 100 def isFileInTimeRange(filename, startDate, endDate, startTime, endTime):
101 101 """
102 102 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
103 103
104 104 Inputs:
105 105 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
106 106
107 107 startDate : fecha inicial del rango seleccionado en formato datetime.date
108 108
109 109 endDate : fecha final del rango seleccionado en formato datetime.date
110 110
111 111 startTime : tiempo inicial del rango seleccionado en formato datetime.time
112 112
113 113 endTime : tiempo final del rango seleccionado en formato datetime.time
114 114
115 115 Return:
116 116 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
117 117 fecha especificado, de lo contrario retorna False.
118 118
119 119 Excepciones:
120 120 Si el archivo no existe o no puede ser abierto
121 121 Si la cabecera no puede ser leida.
122 122
123 123 """
124 124
125 125
126 126 try:
127 127 fp = open(filename,'rb')
128 128 except IOError:
129 129 print "The file %s can't be opened" %(filename)
130 130 return None
131 131
132 132 firstBasicHeaderObj = BasicHeader(LOCALTIME)
133 133 systemHeaderObj = SystemHeader()
134 134 radarControllerHeaderObj = RadarControllerHeader()
135 135 processingHeaderObj = ProcessingHeader()
136 136
137 137 lastBasicHeaderObj = BasicHeader(LOCALTIME)
138 138
139 139 sts = firstBasicHeaderObj.read(fp)
140 140
141 141 if not(sts):
142 142 print "[Reading] Skipping the file %s because it has not a valid header" %(filename)
143 143 return None
144 144
145 145 if not systemHeaderObj.read(fp):
146 146 return None
147 147
148 148 if not radarControllerHeaderObj.read(fp):
149 149 return None
150 150
151 151 if not processingHeaderObj.read(fp):
152 152 return None
153 153
154 154 filesize = os.path.getsize(filename)
155 155
156 156 offset = processingHeaderObj.blockSize + 24 #header size
157 157
158 158 if filesize <= offset:
159 159 print "[Reading] %s: This file has not enough data" %filename
160 160 return None
161 161
162 162 fp.seek(-offset, 2)
163 163
164 164 sts = lastBasicHeaderObj.read(fp)
165 165
166 166 fp.close()
167 167
168 168 thisDatetime = lastBasicHeaderObj.datatime
169 169 thisTime_last_block = thisDatetime.time()
170 170
171 171 thisDatetime = firstBasicHeaderObj.datatime
172 172 thisDate = thisDatetime.date()
173 173 thisTime_first_block = thisDatetime.time()
174 174
175 175 #General case
176 176 # o>>>>>>>>>>>>>><<<<<<<<<<<<<<o
177 177 #-----------o----------------------------o-----------
178 178 # startTime endTime
179 179
180 180 if endTime >= startTime:
181 181 if (thisTime_last_block < startTime) or (thisTime_first_block > endTime):
182 182 return None
183 183
184 184 return thisDatetime
185 185
186 186 #If endTime < startTime then endTime belongs to the next day
187 187
188 188
189 189 #<<<<<<<<<<<o o>>>>>>>>>>>
190 190 #-----------o----------------------------o-----------
191 191 # endTime startTime
192 192
193 193 if (thisDate == startDate) and (thisTime_last_block < startTime):
194 194 return None
195 195
196 196 if (thisDate == endDate) and (thisTime_first_block > endTime):
197 197 return None
198 198
199 199 if (thisTime_last_block < startTime) and (thisTime_first_block > endTime):
200 200 return None
201 201
202 202 return thisDatetime
203 203
204 204 def isFolderInDateRange(folder, startDate=None, endDate=None):
205 205 """
206 206 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
207 207
208 208 Inputs:
209 209 folder : nombre completo del directorio.
210 210 Su formato deberia ser "/path_root/?YYYYDDD"
211 211
212 212 siendo:
213 213 YYYY : Anio (ejemplo 2015)
214 214 DDD : Dia del anio (ejemplo 305)
215 215
216 216 startDate : fecha inicial del rango seleccionado en formato datetime.date
217 217
218 218 endDate : fecha final del rango seleccionado en formato datetime.date
219 219
220 220 Return:
221 221 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
222 222 fecha especificado, de lo contrario retorna False.
223 223 Excepciones:
224 224 Si el directorio no tiene el formato adecuado
225 225 """
226 226
227 227 basename = os.path.basename(folder)
228 228
229 229 if not isRadarFolder(basename):
230 230 print "The folder %s has not the rigth format" %folder
231 231 return 0
232 232
233 233 if startDate and endDate:
234 234 thisDate = getDateFromRadarFolder(basename)
235 235
236 236 if thisDate < startDate:
237 237 return 0
238 238
239 239 if thisDate > endDate:
240 240 return 0
241 241
242 242 return 1
243 243
244 244 def isFileInDateRange(filename, startDate=None, endDate=None):
245 245 """
246 246 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
247 247
248 248 Inputs:
249 249 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
250 250
251 251 Su formato deberia ser "?YYYYDDDsss"
252 252
253 253 siendo:
254 254 YYYY : Anio (ejemplo 2015)
255 255 DDD : Dia del anio (ejemplo 305)
256 256 sss : set
257 257
258 258 startDate : fecha inicial del rango seleccionado en formato datetime.date
259 259
260 260 endDate : fecha final del rango seleccionado en formato datetime.date
261 261
262 262 Return:
263 263 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
264 264 fecha especificado, de lo contrario retorna False.
265 265 Excepciones:
266 266 Si el archivo no tiene el formato adecuado
267 267 """
268 268
269 269 basename = os.path.basename(filename)
270 270
271 271 if not isRadarFile(basename):
272 272 print "The filename %s has not the rigth format" %filename
273 273 return 0
274 274
275 275 if startDate and endDate:
276 276 thisDate = getDateFromRadarFile(basename)
277 277
278 278 if thisDate < startDate:
279 279 return 0
280 280
281 281 if thisDate > endDate:
282 282 return 0
283 283
284 284 return 1
285 285
286 286 def getFileFromSet(path, ext, set):
287 287 validFilelist = []
288 288 fileList = os.listdir(path)
289 289
290 290 # 0 1234 567 89A BCDE
291 291 # H YYYY DDD SSS .ext
292 292
293 293 for thisFile in fileList:
294 294 try:
295 295 year = int(thisFile[1:5])
296 296 doy = int(thisFile[5:8])
297 297 except:
298 298 continue
299 299
300 300 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
301 301 continue
302 302
303 303 validFilelist.append(thisFile)
304 304
305 305 myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
306 306
307 307 if len(myfile)!= 0:
308 308 return myfile[0]
309 309 else:
310 310 filename = '*%4.4d%3.3d%3.3d%s'%(year,doy,set,ext.lower())
311 311 print 'the filename %s does not exist'%filename
312 312 print '...going to the last file: '
313 313
314 314 if validFilelist:
315 315 validFilelist = sorted( validFilelist, key=str.lower )
316 316 return validFilelist[-1]
317 317
318 318 return None
319 319
320 320 def getlastFileFromPath(path, ext):
321 321 """
322 322 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
323 323 al final de la depuracion devuelve el ultimo file de la lista que quedo.
324 324
325 325 Input:
326 326 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
327 327 ext : extension de los files contenidos en una carpeta
328 328
329 329 Return:
330 330 El ultimo file de una determinada carpeta, no se considera el path.
331 331 """
332 332 validFilelist = []
333 333 fileList = os.listdir(path)
334 334
335 335 # 0 1234 567 89A BCDE
336 336 # H YYYY DDD SSS .ext
337 337
338 338 for thisFile in fileList:
339 339
340 340 year = thisFile[1:5]
341 341 if not isNumber(year):
342 342 continue
343 343
344 344 doy = thisFile[5:8]
345 345 if not isNumber(doy):
346 346 continue
347 347
348 348 year = int(year)
349 349 doy = int(doy)
350 350
351 351 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
352 352 continue
353 353
354 354 validFilelist.append(thisFile)
355 355
356 356 if validFilelist:
357 357 validFilelist = sorted( validFilelist, key=str.lower )
358 358 return validFilelist[-1]
359 359
360 360 return None
361 361
362 362 def checkForRealPath(path, foldercounter, year, doy, set, ext):
363 363 """
364 364 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
365 365 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
366 366 el path exacto de un determinado file.
367 367
368 368 Example :
369 369 nombre correcto del file es .../.../D2009307/P2009307367.ext
370 370
371 371 Entonces la funcion prueba con las siguientes combinaciones
372 372 .../.../y2009307367.ext
373 373 .../.../Y2009307367.ext
374 374 .../.../x2009307/y2009307367.ext
375 375 .../.../x2009307/Y2009307367.ext
376 376 .../.../X2009307/y2009307367.ext
377 377 .../.../X2009307/Y2009307367.ext
378 378 siendo para este caso, la ultima combinacion de letras, identica al file buscado
379 379
380 380 Return:
381 381 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
382 382 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
383 383 para el filename
384 384 """
385 385 fullfilename = None
386 386 find_flag = False
387 387 filename = None
388 388
389 389 prefixDirList = [None,'d','D']
390 390 if ext.lower() == ".r": #voltage
391 391 prefixFileList = ['d','D']
392 392 elif ext.lower() == ".pdata": #spectra
393 393 prefixFileList = ['p','P']
394 394 else:
395 395 return None, filename
396 396
397 397 #barrido por las combinaciones posibles
398 398 for prefixDir in prefixDirList:
399 399 thispath = path
400 400 if prefixDir != None:
401 401 #formo el nombre del directorio xYYYYDDD (x=d o x=D)
402 402 if foldercounter == 0:
403 403 thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))
404 404 else:
405 405 thispath = os.path.join(path, "%s%04d%03d_%02d" % ( prefixDir, year, doy , foldercounter))
406 406 for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D"
407 407 filename = "%s%04d%03d%03d%s" % ( prefixFile, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
408 408 fullfilename = os.path.join( thispath, filename ) #formo el path completo
409 409
410 410 if os.path.exists( fullfilename ): #verifico que exista
411 411 find_flag = True
412 412 break
413 413 if find_flag:
414 414 break
415 415
416 416 if not(find_flag):
417 417 return None, filename
418 418
419 419 return fullfilename, filename
420 420
421 421 def isRadarFolder(folder):
422 422 try:
423 423 year = int(folder[1:5])
424 424 doy = int(folder[5:8])
425 425 except:
426 426 return 0
427 427
428 428 return 1
429 429
430 430 def isRadarFile(file):
431 431 try:
432 432 year = int(file[1:5])
433 433 doy = int(file[5:8])
434 434 set = int(file[8:11])
435 435 except:
436 436 return 0
437 437
438 438 return 1
439 439
440 440 def getDateFromRadarFile(file):
441 441 try:
442 442 year = int(file[1:5])
443 443 doy = int(file[5:8])
444 444 set = int(file[8:11])
445 445 except:
446 446 return None
447 447
448 448 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy-1)
449 449 return thisDate
450 450
451 451 def getDateFromRadarFolder(folder):
452 452 try:
453 453 year = int(folder[1:5])
454 454 doy = int(folder[5:8])
455 455 except:
456 456 return None
457 457
458 458 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy-1)
459 459 return thisDate
460 460
461 461 class JRODataIO:
462 462
463 463 c = 3E8
464 464
465 465 isConfig = False
466 466
467 467 basicHeaderObj = None
468 468
469 469 systemHeaderObj = None
470 470
471 471 radarControllerHeaderObj = None
472 472
473 473 processingHeaderObj = None
474 474
475 475 dtype = None
476 476
477 477 pathList = []
478 478
479 479 filenameList = []
480 480
481 481 filename = None
482 482
483 483 ext = None
484 484
485 485 flagIsNewFile = 1
486 486
487 487 flagDiscontinuousBlock = 0
488 488
489 489 flagIsNewBlock = 0
490 490
491 491 fp = None
492 492
493 493 firstHeaderSize = 0
494 494
495 495 basicHeaderSize = 24
496 496
497 497 versionFile = 1103
498 498
499 499 fileSize = None
500 500
501 501 # ippSeconds = None
502 502
503 503 fileSizeByHeader = None
504 504
505 505 fileIndex = None
506 506
507 507 profileIndex = None
508 508
509 509 blockIndex = None
510 510
511 511 nTotalBlocks = None
512 512
513 513 maxTimeStep = 30
514 514
515 515 lastUTTime = None
516 516
517 517 datablock = None
518 518
519 519 dataOut = None
520 520
521 521 blocksize = None
522 522
523 523 getByBlock = False
524 524
525 525 def __init__(self):
526 526
527 527 raise NotImplementedError
528 528
529 529 def run(self):
530 530
531 531 raise NotImplementedError
532 532
533 533 def getDtypeWidth(self):
534 534
535 535 dtype_index = get_dtype_index(self.dtype)
536 536 dtype_width = get_dtype_width(dtype_index)
537 537
538 538 return dtype_width
539 539
540 540 def getAllowedArgs(self):
541 541 return inspect.getargspec(self.run).args
542 542
543 543 class JRODataReader(JRODataIO):
544
545 firstTime = True
544
546 545 online = 0
547 546
548 547 realtime = 0
549 548
550 549 nReadBlocks = 0
551 550
552 551 delay = 10 #number of seconds waiting a new file
553 552
554 553 nTries = 3 #quantity tries
555 554
556 555 nFiles = 3 #number of files for searching
557 556
558 557 path = None
559 558
560 559 foldercounter = 0
561 560
562 561 flagNoMoreFiles = 0
563 562
564 563 datetimeList = []
565 564
566 565 __isFirstTimeOnline = 1
567 566
568 567 __printInfo = True
569 568
570 569 profileIndex = None
571 570
572 571 nTxs = 1
573 572
574 573 txIndex = None
575 574
576 575 #Added--------------------
577 576
578 577 selBlocksize = None
579 578
580 579 selBlocktime = None
581
582 onlineWithDate = False
580
583 581 def __init__(self):
584 582
585 583 """
586 584 This class is used to find data files
587 585
588 586 Example:
589 587 reader = JRODataReader()
590 588 fileList = reader.findDataFiles()
591 589
592 590 """
593 591 pass
594 592
595 593
596 594 def createObjByDefault(self):
597 595 """
598 596
599 597 """
600 598 raise NotImplementedError
601 599
602 600 def getBlockDimension(self):
603 601
604 602 raise NotImplementedError
605 603
606 def __searchFilesOffLine(self,
607 path,
608 startDate=None,
609 endDate=None,
610 startTime=datetime.time(0,0,0),
611 endTime=datetime.time(23,59,59),
612 set=None,
613 expLabel='',
614 ext='.r',
615 queue=None,
616 cursor=None,
617 skip=None,
618 walk=True):
604 def searchFilesOffLine(self,
605 path,
606 startDate=None,
607 endDate=None,
608 startTime=datetime.time(0,0,0),
609 endTime=datetime.time(23,59,59),
610 set=None,
611 expLabel='',
612 ext='.r',
613 cursor=None,
614 skip=None,
615 walk=True):
616
619 617 self.filenameList = []
620 618 self.datetimeList = []
621 619
622 620 pathList = []
623 621
624 622 dateList, pathList = self.findDatafiles(path, startDate, endDate, expLabel, ext, walk, include_path=True)
625 623
626 624 if dateList == []:
627 # print "[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" %(startDate, endDate, ext, path)
628 return None, None
625 return [], []
629 626
630 627 if len(dateList) > 1:
631 628 print "[Reading] Data found for date range [%s - %s]: total days = %d" %(startDate, endDate, len(dateList))
632 629 else:
633 630 print "[Reading] Data found for date range [%s - %s]: date = %s" %(startDate, endDate, dateList[0])
634 631
635 632 filenameList = []
636 633 datetimeList = []
637 634
638 635 for thisPath in pathList:
639 # thisPath = pathList[pathDict[file]]
640
636
641 637 fileList = glob.glob1(thisPath, "*%s" %ext)
642 638 fileList.sort()
643 639
644 640 skippedFileList = []
645 641
646 642 if cursor is not None and skip is not None:
647 # if cursor*skip > len(fileList):
643
648 644 if skip == 0:
649 if queue is not None:
650 queue.put(len(fileList))
651 645 skippedFileList = []
652 646 else:
653 647 skippedFileList = fileList[cursor*skip: cursor*skip + skip]
654 648
655 649 else:
656 650 skippedFileList = fileList
657 651
658 652 for file in skippedFileList:
659 653
660 654 filename = os.path.join(thisPath,file)
661 655
662 656 if not isFileInDateRange(filename, startDate, endDate):
663 657 continue
664 658
665 659 thisDatetime = isFileInTimeRange(filename, startDate, endDate, startTime, endTime)
666 660
667 661 if not(thisDatetime):
668 662 continue
669 663
670 664 filenameList.append(filename)
671 665 datetimeList.append(thisDatetime)
672 666
673 667 if not(filenameList):
674 668 print "[Reading] Time range selected invalid [%s - %s]: No *%s files in %s)" %(startTime, endTime, ext, path)
675 return None, None
669 return [], []
676 670
677 671 print "[Reading] %d file(s) was(were) found in time range: %s - %s" %(len(filenameList), startTime, endTime)
678 672 print
679 673
680 for i in range(len(filenameList)):
681 print "[Reading] %s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
674 # for i in range(len(filenameList)):
675 # print "[Reading] %s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
682 676
683 677 self.filenameList = filenameList
684 self.datetimeList = datetimeList
678 self.datetimeList = datetimeList
679
685 680 return pathList, filenameList
686 681
687 def __searchFilesOnLine(self, path, expLabel="", ext=None, walk=True, set=None, startDate=None, startTime=None):
688
682 def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True, set=None):
683
689 684 """
690 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
691 devuelve el archivo encontrado ademas de otros datos.
692
693 Input:
694 path : carpeta donde estan contenidos los files que contiene data
695
696 expLabel : Nombre del subexperimento (subfolder)
697
698 ext : extension de los files
699
700 walk : Si es habilitado no realiza busquedas dentro de los subdirectorios (doypath)
701
702 Return:
703 directory : eL directorio donde esta el file encontrado
704 filename : el ultimo file de una determinada carpeta
705 year : el anho
706 doy : el numero de dia del anho
707 set : el set del archivo
708
709
685 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
686 devuelve el archivo encontrado ademas de otros datos.
687
688 Input:
689 path : carpeta donde estan contenidos los files que contiene data
690
691 expLabel : Nombre del subexperimento (subfolder)
692
693 ext : extension de los files
694
695 walk : Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
696
697 Return:
698 directory : eL directorio donde esta el file encontrado
699 filename : el ultimo file de una determinada carpeta
700 year : el anho
701 doy : el numero de dia del anho
702 set : el set del archivo
703
704
710 705 """
711 pathList = None
712 filenameList = None
713 706 if not os.path.isdir(path):
714 707 return None, None, None, None, None, None
715 708
716 709 dirList = []
717 710
718 711 if not walk:
719 712 fullpath = path
720 713 foldercounter = 0
721 714 else:
722 # Filtra solo los directorios
715 #Filtra solo los directorios
723 716 for thisPath in os.listdir(path):
724 717 if not os.path.isdir(os.path.join(path,thisPath)):
725 718 continue
726 719 if not isRadarFolder(thisPath):
727 720 continue
728 721
729 722 dirList.append(thisPath)
730 723
731 724 if not(dirList):
732 725 return None, None, None, None, None, None
733 726
734 727 dirList = sorted( dirList, key=str.lower )
735 728
736 729 doypath = dirList[-1]
737 730 foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0
738 731 fullpath = os.path.join(path, doypath, expLabel)
739 732
740 733
741 734 print "[Reading] %s folder was found: " %(fullpath )
742 735
743 736 if set == None:
744 737 filename = getlastFileFromPath(fullpath, ext)
745 738 else:
746 739 filename = getFileFromSet(fullpath, ext, set)
747 740
748 741 if not(filename):
749 742 return None, None, None, None, None, None
750 743
751 744 print "[Reading] %s file was found" %(filename)
752 745
753 746 if not(self.__verifyFile(os.path.join(fullpath, filename))):
754 747 return None, None, None, None, None, None
755 748
756 749 year = int( filename[1:5] )
757 750 doy = int( filename[5:8] )
758 set = int( filename[8:11] )
751 set = int( filename[8:11] )
759 752
760 753 return fullpath, foldercounter, filename, year, doy, set
761 754
762 755 def __setNextFileOffline(self):
763 756
764 757 idFile = self.fileIndex
765 758
766 759 while (True):
767 760 idFile += 1
768 761 if not(idFile < len(self.filenameList)):
769 762 self.flagNoMoreFiles = 1
770 # print "[Reading] No more Files"
763 # print "[Reading] No more Files"
771 764 return 0
772 765
773 766 filename = self.filenameList[idFile]
774 767
775 768 if not(self.__verifyFile(filename)):
776 769 continue
777 770
778 771 fileSize = os.path.getsize(filename)
779 772 fp = open(filename,'rb')
780 773 break
781 774
782 775 self.flagIsNewFile = 1
783 776 self.fileIndex = idFile
784 777 self.filename = filename
785 778 self.fileSize = fileSize
786 779 self.fp = fp
787 780
788 #print "[Reading] Setting the file: %s"%self.filename
781 # print "[Reading] Setting the file: %s"%self.filename
789 782
790 783 return 1
791 784
792 785 def __setNextFileOnline(self):
793 786 """
794 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
795 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
796 siguientes.
797
798 Affected:
799 self.flagIsNewFile
800 self.filename
801 self.fileSize
802 self.fp
803 self.set
804 self.flagNoMoreFiles
805
806 Return:
807 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
808 1 : si el file fue abierto con exito y esta listo a ser leido
809
810 Excepciones:
811 Si un determinado file no puede ser abierto
812 """
813
787 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
788 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
789 siguientes.
790
791 Affected:
792 self.flagIsNewFile
793 self.filename
794 self.fileSize
795 self.fp
796 self.set
797 self.flagNoMoreFiles
798
799 Return:
800 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
801 1 : si el file fue abierto con exito y esta listo a ser leido
802
803 Excepciones:
804 Si un determinado file no puede ser abierto
805 """
814 806 nFiles = 0
815 807 fileOk_flag = False
816 808 firstTime_flag = True
817 809
818 810 self.set += 1
819 811
820 812 if self.set > 999:
821 813 self.set = 0
822 814 self.foldercounter += 1
823 815
824 816 #busca el 1er file disponible
825 817 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
826 818 if fullfilename:
827 819 if self.__verifyFile(fullfilename, False):
828 820 fileOk_flag = True
829 821
830 822 #si no encuentra un file entonces espera y vuelve a buscar
831 823 if not(fileOk_flag):
832 824 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
833 825
834 826 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
835 827 tries = self.nTries
836 828 else:
837 829 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
838 830
839 831 for nTries in range( tries ):
840 832 if firstTime_flag:
841 833 print "\t[Reading] Waiting %0.2f sec for the next file: \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
842 834 sleep( self.delay )
843 835 else:
844 836 print "\t[Reading] Searching the next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
845 837
846 838 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
847 839 if fullfilename:
848 840 if self.__verifyFile(fullfilename):
849 841 fileOk_flag = True
850 842 break
851 843
852 844 if fileOk_flag:
853 845 break
854 846
855 847 firstTime_flag = False
856 848
857 849 print "\t[Reading] Skipping the file \"%s\" due to this file doesn't exist" % filename
858 850 self.set += 1
859 851
860 852 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
861 853 self.set = 0
862 854 self.doy += 1
863 855 self.foldercounter = 0
864 856
865 857 if fileOk_flag:
866 858 self.fileSize = os.path.getsize( fullfilename )
867 859 self.filename = fullfilename
868 860 self.flagIsNewFile = 1
869 861 if self.fp != None: self.fp.close()
870 862 self.fp = open(fullfilename, 'rb')
871 863 self.flagNoMoreFiles = 0
872 # print '[Reading] Setting the file: %s' % fullfilename
864 # print '[Reading] Setting the file: %s' % fullfilename
873 865 else:
874 866 self.fileSize = 0
875 867 self.filename = None
876 868 self.flagIsNewFile = 0
877 869 self.fp = None
878 870 self.flagNoMoreFiles = 1
879 # print '[Reading] No more files to read'
871 # print '[Reading] No more files to read'
880 872
881 873 return fileOk_flag
882 874
883 875 def setNextFile(self):
884 876 if self.fp != None:
885 877 self.fp.close()
878
886 879 if self.online:
887 880 newFile = self.__setNextFileOnline()
888 881 else:
889 882 newFile = self.__setNextFileOffline()
883
890 884 if not(newFile):
891 if self.onlineWithDate is True:
892 self.onlineWithDate=False
893 self.online = True
894 self.firstTime = False
895 self.setup(
896 path=self.path,
897 startDate=self.startDate,
898 endDate=self.endDate,
899 startTime=self.startTime ,
900 endTime=self.endTime,
901 set=self.set,
902 expLabel=self.expLabel,
903 ext=self.ext,
904 online=self.online,
905 delay=self.delay,
906 walk=self.walk,
907 getblock=self.getblock,
908 nTxs=self.nTxs,
909 realtime=self.realtime,
910 blocksize=self.blocksize,
911 blocktime=self.blocktime
912 )
913 return 1
914 885 print '[Reading] No more files to read'
915 886 return 0
916 887
917 888 if self.verbose:
918 889 print '[Reading] Setting the file: %s' % self.filename
919 890
920 891 self.__readFirstHeader()
921 892 self.nReadBlocks = 0
922 893 return 1
923 894
924 895 def __waitNewBlock(self):
925 896 """
926 897 Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
927 898
928 899 Si el modo de lectura es OffLine siempre retorn 0
929 900 """
930 901 if not self.online:
931 902 return 0
932 903
933 904 if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
934 905 return 0
935 906
936 907 currentPointer = self.fp.tell()
937 908
938 909 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
939 910
940 911 for nTries in range( self.nTries ):
941 912
942 913 self.fp.close()
943 914 self.fp = open( self.filename, 'rb' )
944 915 self.fp.seek( currentPointer )
945 916
946 917 self.fileSize = os.path.getsize( self.filename )
947 918 currentSize = self.fileSize - currentPointer
948 919
949 920 if ( currentSize >= neededSize ):
950 921 self.basicHeaderObj.read(self.fp)
951 922 return 1
952 923
953 924 if self.fileSize == self.fileSizeByHeader:
954 # self.flagEoF = True
925 # self.flagEoF = True
955 926 return 0
956 927
957 928 print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
958 929 sleep( self.delay )
959 930
960 931
961 932 return 0
962 933
963 934 def waitDataBlock(self,pointer_location):
964 935
965 936 currentPointer = pointer_location
966 937
967 938 neededSize = self.processingHeaderObj.blockSize #+ self.basicHeaderSize
968 939
969 940 for nTries in range( self.nTries ):
970 941 self.fp.close()
971 942 self.fp = open( self.filename, 'rb' )
972 943 self.fp.seek( currentPointer )
973 944
974 945 self.fileSize = os.path.getsize( self.filename )
975 946 currentSize = self.fileSize - currentPointer
976 947
977 948 if ( currentSize >= neededSize ):
978 949 return 1
979 950
980 951 print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
981 952 sleep( self.delay )
982 953
983 954 return 0
984 955
985 956 def __jumpToLastBlock(self):
986 957
987 958 if not(self.__isFirstTimeOnline):
988 959 return
989 960
990 961 csize = self.fileSize - self.fp.tell()
991 962 blocksize = self.processingHeaderObj.blockSize
992 963
993 964 #salta el primer bloque de datos
994 965 if csize > self.processingHeaderObj.blockSize:
995 966 self.fp.seek(self.fp.tell() + blocksize)
996 967 else:
997 968 return
998 969
999 970 csize = self.fileSize - self.fp.tell()
1000 971 neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
1001 972 while True:
1002 973
1003 974 if self.fp.tell()<self.fileSize:
1004 975 self.fp.seek(self.fp.tell() + neededsize)
1005 976 else:
1006 977 self.fp.seek(self.fp.tell() - neededsize)
1007 978 break
1008
1009 # csize = self.fileSize - self.fp.tell()
1010 # neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
1011 # factor = int(csize/neededsize)
1012 # if factor > 0:
1013 # self.fp.seek(self.fp.tell() + factor*neededsize)
1014
979
980 # csize = self.fileSize - self.fp.tell()
981 # neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
982 # factor = int(csize/neededsize)
983 # if factor > 0:
984 # self.fp.seek(self.fp.tell() + factor*neededsize)
985
1015 986 self.flagIsNewFile = 0
1016 987 self.__isFirstTimeOnline = 0
1017 988
1018 989 def __setNewBlock(self):
1019 990 #if self.server is None:
1020 991 if self.fp == None:
1021 992 return 0
1022
1023 # if self.online:
1024 # self.__jumpToLastBlock()
1025
993
994 # if self.online:
995 # self.__jumpToLastBlock()
996
1026 997 if self.flagIsNewFile:
1027 998 self.lastUTTime = self.basicHeaderObj.utc
1028 999 return 1
1029 1000
1030 1001 if self.realtime:
1031 1002 self.flagDiscontinuousBlock = 1
1032 1003 if not(self.setNextFile()):
1033 1004 return 0
1034 1005 else:
1035 1006 return 1
1036 1007 #if self.server is None:
1037 1008 currentSize = self.fileSize - self.fp.tell()
1038 1009 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
1039 1010 if (currentSize >= neededSize):
1040 1011 self.basicHeaderObj.read(self.fp)
1041 1012 self.lastUTTime = self.basicHeaderObj.utc
1042 1013 return 1
1043 1014 # else:
1044 1015 # self.basicHeaderObj.read(self.zHeader)
1045 1016 # self.lastUTTime = self.basicHeaderObj.utc
1046 1017 # return 1
1047 1018 if self.__waitNewBlock():
1048 1019 self.lastUTTime = self.basicHeaderObj.utc
1049 1020 return 1
1050 1021 #if self.server is None:
1051 1022 if not(self.setNextFile()):
1052 1023 return 0
1053 1024
1054 1025 deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
1055 1026 self.lastUTTime = self.basicHeaderObj.utc
1056 1027
1057 1028 self.flagDiscontinuousBlock = 0
1058 1029
1059 1030 if deltaTime > self.maxTimeStep:
1060 1031 self.flagDiscontinuousBlock = 1
1061 1032
1062 1033 return 1
1063 1034
1064 1035 def readNextBlock(self):
1065 1036
1066 1037 #Skip block out of startTime and endTime
1067 1038 while True:
1068 if not(self.__setNewBlock()):
1069 print 'returning'
1039 if not(self.__setNewBlock()):
1070 1040 return 0
1041
1071 1042 if not(self.readBlock()):
1072 1043 return 0
1044
1073 1045 self.getBasicHeader()
1046
1074 1047 if not isTimeInRange(self.dataOut.datatime.time(), self.startTime, self.endTime):
1075 1048
1076 1049 print "[Reading] Block No. %d/%d -> %s [Skipping]" %(self.nReadBlocks,
1077 1050 self.processingHeaderObj.dataBlocksPerFile,
1078 1051 self.dataOut.datatime.ctime())
1079 1052 continue
1080 1053
1081 1054 break
1082 1055
1083 1056 if self.verbose:
1084 1057 print "[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
1085 self.processingHeaderObj.dataBlocksPerFile,
1086 self.dataOut.datatime.ctime())
1058 self.processingHeaderObj.dataBlocksPerFile,
1059 self.dataOut.datatime.ctime())
1087 1060 return 1
1088 1061
1089 1062 def __readFirstHeader(self):
1090 1063
1091 1064 self.basicHeaderObj.read(self.fp)
1092 1065 self.systemHeaderObj.read(self.fp)
1093 1066 self.radarControllerHeaderObj.read(self.fp)
1094 1067 self.processingHeaderObj.read(self.fp)
1095 1068
1096 1069 self.firstHeaderSize = self.basicHeaderObj.size
1097 1070
1098 1071 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
1099 1072 if datatype == 0:
1100 1073 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
1101 1074 elif datatype == 1:
1102 1075 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
1103 1076 elif datatype == 2:
1104 1077 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
1105 1078 elif datatype == 3:
1106 1079 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
1107 1080 elif datatype == 4:
1108 1081 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
1109 1082 elif datatype == 5:
1110 1083 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
1111 1084 else:
1112 1085 raise ValueError, 'Data type was not defined'
1113 1086
1114 1087 self.dtype = datatype_str
1115 1088 #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
1116 1089 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
1117 # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
1118 # self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
1090 # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
1091 # self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
1119 1092 self.getBlockDimension()
1120 1093
1121 1094 def __verifyFile(self, filename, msgFlag=True):
1122 1095
1123 1096 msg = None
1124 1097
1125 1098 try:
1126 1099 fp = open(filename, 'rb')
1127 1100 except IOError:
1128 1101
1129 1102 if msgFlag:
1130 1103 print "[Reading] File %s can't be opened" % (filename)
1131 1104
1132 1105 return False
1133 1106
1134 1107 currentPosition = fp.tell()
1135 1108 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
1136 1109
1137 1110 if neededSize == 0:
1138 1111 basicHeaderObj = BasicHeader(LOCALTIME)
1139 1112 systemHeaderObj = SystemHeader()
1140 1113 radarControllerHeaderObj = RadarControllerHeader()
1141 1114 processingHeaderObj = ProcessingHeader()
1142 1115
1143 1116 if not( basicHeaderObj.read(fp) ):
1144 1117 fp.close()
1145 1118 return False
1146 1119
1147 1120 if not( systemHeaderObj.read(fp) ):
1148 1121 fp.close()
1149 1122 return False
1150 1123
1151 1124 if not( radarControllerHeaderObj.read(fp) ):
1152 1125 fp.close()
1153 1126 return False
1154 1127
1155 1128 if not( processingHeaderObj.read(fp) ):
1156 1129 fp.close()
1157 1130 return False
1158 1131
1159 1132 neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
1160 1133 else:
1161 1134 msg = "[Reading] Skipping the file %s due to it hasn't enough data" %filename
1162 1135
1163 1136 fp.close()
1164 1137
1165 1138 fileSize = os.path.getsize(filename)
1166 1139 currentSize = fileSize - currentPosition
1167 1140
1168 1141 if currentSize < neededSize:
1169 1142 if msgFlag and (msg != None):
1170 1143 print msg
1171 1144 return False
1172 1145
1173 1146 return True
1174 1147
1175 1148 def findDatafiles(self, path, startDate=None, endDate=None, expLabel='', ext='.r', walk=True, include_path=False):
1176 1149
1177 1150 path_empty = True
1178 1151
1179 1152 dateList = []
1180 1153 pathList = []
1181 1154
1182 1155 multi_path = path.split(',')
1183 1156
1184 1157 if not walk:
1185 1158
1186 1159 for single_path in multi_path:
1187 1160
1188 1161 if not os.path.isdir(single_path):
1189 1162 continue
1190 1163
1191 1164 fileList = glob.glob1(single_path, "*"+ext)
1192 1165
1193 1166 if not fileList:
1194 1167 continue
1195 1168
1196 1169 path_empty = False
1197 1170
1198 1171 fileList.sort()
1199 1172
1200 1173 for thisFile in fileList:
1201 1174
1202 1175 if not os.path.isfile(os.path.join(single_path, thisFile)):
1203 1176 continue
1204 1177
1205 1178 if not isRadarFile(thisFile):
1206 1179 continue
1207 1180
1208 1181 if not isFileInDateRange(thisFile, startDate, endDate):
1209 1182 continue
1210 1183
1211 1184 thisDate = getDateFromRadarFile(thisFile)
1212 1185
1213 1186 if thisDate in dateList:
1214 1187 continue
1215 1188
1216 1189 dateList.append(thisDate)
1217 1190 pathList.append(single_path)
1218 1191
1219 1192 else:
1220 1193 for single_path in multi_path:
1221 1194
1222 1195 if not os.path.isdir(single_path):
1223 1196 continue
1224 1197
1225 1198 dirList = []
1226 1199
1227 1200 for thisPath in os.listdir(single_path):
1228 1201
1229 1202 if not os.path.isdir(os.path.join(single_path,thisPath)):
1230 1203 continue
1231 1204
1232 1205 if not isRadarFolder(thisPath):
1233 1206 continue
1234 1207
1235 1208 if not isFolderInDateRange(thisPath, startDate, endDate):
1236 1209 continue
1237 1210
1238 1211 dirList.append(thisPath)
1239 1212
1240 1213 if not dirList:
1241 1214 continue
1242 1215
1243 1216 dirList.sort()
1244 1217
1245 1218 for thisDir in dirList:
1246 1219
1247 1220 datapath = os.path.join(single_path, thisDir, expLabel)
1248 1221 fileList = glob.glob1(datapath, "*"+ext)
1249 1222
1250 1223 if not fileList:
1251 1224 continue
1252 1225
1253 1226 path_empty = False
1254 1227
1255 1228 thisDate = getDateFromRadarFolder(thisDir)
1256 1229
1257 1230 pathList.append(datapath)
1258 1231 dateList.append(thisDate)
1259 1232
1260 1233 dateList.sort()
1261 1234
1262 1235 if walk:
1263 1236 pattern_path = os.path.join(multi_path[0], "[dYYYYDDD]", expLabel)
1264 1237 else:
1265 1238 pattern_path = multi_path[0]
1266 1239
1267 1240 if path_empty:
1268 1241 print "[Reading] No *%s files in %s for %s to %s" %(ext, pattern_path, startDate, endDate)
1269 1242 else:
1270 1243 if not dateList:
1271 1244 print "[Reading] Date range selected invalid [%s - %s]: No *%s files in %s)" %(startDate, endDate, ext, path)
1272 1245
1273 1246 if include_path:
1274 1247 return dateList, pathList
1275 1248
1276 1249 return dateList
1277 1250
1278 1251 def setup(self,
1279 1252 path=None,
1280 startDate=None,
1281 endDate=None,
1282 startTime=datetime.time(0,0,0),
1283 endTime=datetime.time(23,59,59),
1284 set=None,
1285 expLabel = "",
1286 ext = None,
1253 startDate=None,
1254 endDate=None,
1255 startTime=datetime.time(0,0,0),
1256 endTime=datetime.time(23,59,59),
1257 set=None,
1258 expLabel = "",
1259 ext = None,
1287 1260 online = False,
1288 1261 delay = 60,
1289 1262 walk = True,
1290 1263 getblock = False,
1291 1264 nTxs = 1,
1292 1265 realtime=False,
1293 1266 blocksize=None,
1294 1267 blocktime=None,
1268 skip=None,
1269 cursor=None,
1270 warnings=True,
1295 1271 verbose=True,
1296 **kwargs):
1272 server=None):
1273 if server is not None:
1274 if 'tcp://' in server:
1275 address = server
1276 else:
1277 address = 'ipc:///tmp/%s' % server
1278 self.server = address
1279 self.context = zmq.Context()
1280 self.receiver = self.context.socket(zmq.PULL)
1281 self.receiver.connect(self.server)
1282 time.sleep(0.5)
1283 print '[Starting] ReceiverData from {}'.format(self.server)
1284 else:
1285 self.server = None
1286 if path == None:
1287 raise ValueError, "[Reading] The path is not valid"
1297 1288
1298 if path == None:
1299 raise ValueError, "[Reading] The path is not valid"
1300
1289 if ext == None:
1290 ext = self.ext
1301 1291
1302 if ext == None:
1303 ext = self.ext
1304
1305 self.verbose=verbose
1306 self.path = path
1307 self.startDate = startDate
1308 self.endDate = endDate
1309 self.startTime = startTime
1310 self.endTime = endTime
1311 self.set = set
1312 self.expLabel = expLabel
1313 self.ext = ext
1314 self.online = online
1315 self.delay = delay
1316 self.walk = walk
1317 self.getblock = getblock
1318 self.nTxs = nTxs
1319 self.realtime = realtime
1320 self.blocksize = blocksize
1321 self.blocktime = blocktime
1322
1323
1324 if self.firstTime is True:
1325 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
1292 if online:
1293 print "[Reading] Searching files in online mode..."
1294
1295 for nTries in range( self.nTries ):
1296 fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk, set=set)
1297
1298 if fullpath:
1299 break
1300
1301 print '[Reading] Waiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
1302 sleep( self.delay )
1303
1304 if not(fullpath):
1305 print "[Reading] There 'isn't any valid file in %s" % path
1306 return
1307
1308 self.year = year
1309 self.doy = doy
1310 self.set = set - 1
1311 self.path = path
1312 self.foldercounter = foldercounter
1313 last_set = None
1314 else:
1315 print "[Reading] Searching files in offline mode ..."
1316 pathList, filenameList = self.searchFilesOffLine(path, startDate=startDate, endDate=endDate,
1326 1317 startTime=startTime, endTime=endTime,
1327 1318 set=set, expLabel=expLabel, ext=ext,
1328 walk=walk)
1329 if filenameList is not None: filenameList = filenameList[:-1]
1319 walk=walk, cursor=cursor,
1320 skip=skip)
1330 1321
1331 if pathList is not None and filenameList is not None and online:
1332 self.onlineWithDate = True
1333 online = False
1322 if not(pathList):
1334 1323 self.fileIndex = -1
1335 self.pathList = pathList
1336 self.filenameList = filenameList
1337 file_name = os.path.basename(filenameList[-1])
1338 basename, ext = os.path.splitext(file_name)
1339 last_set = int(basename[-3:])
1340
1341 if online:
1342 print "[Reading] Searching files in online mode..."
1343
1344 for nTries in range(self.nTries):
1345 fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(path=path,
1346 expLabel=expLabel,
1347 ext=ext,
1348 walk=walk,
1349 startDate=startDate,
1350 startTime=startTime,
1351 set=set)
1352
1353 if fullpath:
1354 break
1355 print '[Reading] Waiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
1356 sleep( self.delay )
1357
1358 if not(fullpath):
1359 print "[Reading] There 'isn't any valid file in %s" % path
1360 return
1361
1362 self.year = year
1363 self.doy = doy
1364 self.set = set - 1
1365 self.path = path
1366 self.foldercounter = foldercounter
1367 last_set = None
1368 else:
1369 print "[Reading] Searching files in offline mode ..."
1370 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
1371 startTime=startTime, endTime=endTime,
1372 set=set, expLabel=expLabel, ext=ext,
1373 walk=walk)
1374
1375 if not(pathList):
1376 # print "[Reading] No *%s files in %s (%s - %s)"%(ext, path,
1377 # datetime.datetime.combine(startDate,startTime).ctime(),
1378 # datetime.datetime.combine(endDate,endTime).ctime())
1379
1380 # sys.exit(-1)
1381
1382 self.fileIndex = -1
1383 self.pathList = []
1384 self.filenameList = []
1385 return
1386
1387 self.fileIndex = -1
1388 self.pathList = pathList
1389 self.filenameList = filenameList
1390 file_name = os.path.basename(filenameList[-1])
1391 basename, ext = os.path.splitext(file_name)
1392 last_set = int(basename[-3:])
1393
1394
1395 self.online = online
1396 self.realtime = realtime
1397 self.delay = delay
1398 ext = ext.lower()
1399 self.ext = ext
1400 self.getByBlock = getblock
1401 self.nTxs = nTxs
1402 self.startTime = startTime
1403 self.endTime = endTime
1404
1405
1406 #Added-----------------
1407 self.selBlocksize = blocksize
1408 self.selBlocktime = blocktime
1409
1410
1411 if not(self.setNextFile()):
1412 if (startDate!=None) and (endDate!=None):
1413 print "[Reading] No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
1414 elif startDate != None:
1415 print "[Reading] No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
1416 else:
1417 print "[Reading] No files"
1418
1324 self.pathList = []
1325 self.filenameList = []
1326 return
1327
1419 1328 self.fileIndex = -1
1420 self.pathList = []
1421 self.filenameList = []
1422 return
1329 self.pathList = pathList
1330 self.filenameList = filenameList
1331 file_name = os.path.basename(filenameList[-1])
1332 basename, ext = os.path.splitext(file_name)
1333 last_set = int(basename[-3:])
1334
1335 self.online = online
1336 self.realtime = realtime
1337 self.delay = delay
1338 ext = ext.lower()
1339 self.ext = ext
1340 self.getByBlock = getblock
1341 self.nTxs = nTxs
1342 self.startTime = startTime
1343 self.endTime = endTime
1344
1345 #Added-----------------
1346 self.selBlocksize = blocksize
1347 self.selBlocktime = blocktime
1348
1349 # Verbose-----------
1350 self.verbose = verbose
1351 self.warnings = warnings
1352
1353 if not(self.setNextFile()):
1354 if (startDate!=None) and (endDate!=None):
1355 print "[Reading] No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
1356 elif startDate != None:
1357 print "[Reading] No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
1358 else:
1359 print "[Reading] No files"
1360
1361 self.fileIndex = -1
1362 self.pathList = []
1363 self.filenameList = []
1364 return
1423 1365
1424 # self.getBasicHeader()
1366 # self.getBasicHeader()
1425 1367
1426 if last_set != None:
1427 self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
1368 if last_set != None:
1369 self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
1428 1370 return
1429 1371
1430 1372 def getBasicHeader(self):
1431 1373
1432 1374 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
1433 1375
1434 1376 self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
1435 1377
1436 1378 self.dataOut.timeZone = self.basicHeaderObj.timeZone
1437 1379
1438 1380 self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
1439 1381
1440 1382 self.dataOut.errorCount = self.basicHeaderObj.errorCount
1441 1383
1442 1384 self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
1443 1385
1444 1386 self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
1445
1446 # self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
1447
1448
1387
1388 # self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
1389
1390
1449 1391 def getFirstHeader(self):
1450 1392
1451 1393 raise NotImplementedError
1452 1394
1453 1395 def getData(self):
1454 1396
1455 1397 raise NotImplementedError
1456 1398
1457 1399 def hasNotDataInBuffer(self):
1458 1400
1459 1401 raise NotImplementedError
1460 1402
1461 1403 def readBlock(self):
1462 1404
1463 1405 raise NotImplementedError
1464 1406
1465 1407 def isEndProcess(self):
1466 1408
1467 1409 return self.flagNoMoreFiles
1468 1410
1469 1411 def printReadBlocks(self):
1470 1412
1471 1413 print "[Reading] Number of read blocks per file %04d" %self.nReadBlocks
1472 1414
1473 1415 def printTotalBlocks(self):
1474 1416
1475 1417 print "[Reading] Number of read blocks %04d" %self.nTotalBlocks
1476 1418
1477 1419 def printNumberOfBlock(self):
1478 1420
1479 1421 if self.flagIsNewBlock:
1480 1422 print "[Reading] Block No. %d/%d -> %s" %(self.nReadBlocks,
1481 1423 self.processingHeaderObj.dataBlocksPerFile,
1482 1424 self.dataOut.datatime.ctime())
1483 1425
1484 1426 def printInfo(self):
1485 1427
1486 1428 if self.__printInfo == False:
1487 1429 return
1488 1430
1489 1431 self.basicHeaderObj.printInfo()
1490 1432 self.systemHeaderObj.printInfo()
1491 1433 self.radarControllerHeaderObj.printInfo()
1492 1434 self.processingHeaderObj.printInfo()
1493 1435
1494 1436 self.__printInfo = False
1495 1437
1496 1438 def run(self,
1497 path=None,
1498 startDate=None,
1499 endDate=None,
1500 startTime=datetime.time(0,0,0),
1501 endTime=datetime.time(23,59,59),
1502 set=None,
1503 expLabel = "",
1504 ext = None,
1505 online = False,
1506 delay = 60,
1507 walk = True,
1508 getblock = False,
1509 nTxs = 1,
1510 realtime=False,
1511 blocksize=None,
1512 blocktime=None,
1513 queue=None,
1514 skip=None,
1515 cursor=None,
1516 warnings=True,
1517 server=None,
1518 verbose=True, **kwargs):
1439 path=None,
1440 startDate=None,
1441 endDate=None,
1442 startTime=datetime.time(0,0,0),
1443 endTime=datetime.time(23,59,59),
1444 set=None,
1445 expLabel = "",
1446 ext = None,
1447 online = False,
1448 delay = 60,
1449 walk = True,
1450 getblock = False,
1451 nTxs = 1,
1452 realtime=False,
1453 blocksize=None,
1454 blocktime=None,
1455 skip=None,
1456 cursor=None,
1457 warnings=True,
1458 server=None,
1459 verbose=True, **kwargs):
1519 1460
1520 1461 if not(self.isConfig):
1521 # self.dataOut = dataOut
1522 self.setup( path=path,
1523 startDate=startDate,
1524 endDate=endDate,
1525 startTime=startTime,
1526 endTime=endTime,
1527 set=set,
1528 expLabel=expLabel,
1529 ext=ext,
1530 online=online,
1531 delay=delay,
1532 walk=walk,
1533 getblock=getblock,
1534 nTxs=nTxs,
1535 realtime=realtime,
1536 blocksize=blocksize,
1537 blocktime=blocktime,
1538 queue=queue,
1539 skip=skip,
1540 cursor=cursor,
1541 warnings=warnings,
1542 server=server,
1543 verbose=verbose, **kwargs)
1462 self.setup(path=path,
1463 startDate=startDate,
1464 endDate=endDate,
1465 startTime=startTime,
1466 endTime=endTime,
1467 set=set,
1468 expLabel=expLabel,
1469 ext=ext,
1470 online=online,
1471 delay=delay,
1472 walk=walk,
1473 getblock=getblock,
1474 nTxs=nTxs,
1475 realtime=realtime,
1476 blocksize=blocksize,
1477 blocktime=blocktime,
1478 skip=skip,
1479 cursor=cursor,
1480 warnings=warnings,
1481 server=server,
1482 verbose=verbose)
1544 1483 self.isConfig = True
1545 1484 if server is None:
1546 1485 self.getData()
1547 1486 else:
1548 1487 self.getFromServer()
1549 1488
1550 1489 class JRODataWriter(JRODataIO):
1551 1490
1552 1491 """
1553 1492 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
1554 1493 de los datos siempre se realiza por bloques.
1555 1494 """
1556 1495
1557 1496 blockIndex = 0
1558 1497
1559 1498 path = None
1560 1499
1561 1500 setFile = None
1562 1501
1563 1502 profilesPerBlock = None
1564 1503
1565 1504 blocksPerFile = None
1566 1505
1567 1506 nWriteBlocks = 0
1568 1507
1569 1508 fileDate = None
1570 1509
1571 1510 def __init__(self, dataOut=None):
1572 1511 raise NotImplementedError
1573 1512
1574 1513
1575 1514 def hasAllDataInBuffer(self):
1576 1515 raise NotImplementedError
1577 1516
1578 1517
1579 1518 def setBlockDimension(self):
1580 1519 raise NotImplementedError
1581 1520
1582 1521
1583 1522 def writeBlock(self):
1584 1523 raise NotImplementedError
1585 1524
1586 1525
1587 1526 def putData(self):
1588 1527 raise NotImplementedError
1589 1528
1590 1529
1591 1530 def getProcessFlags(self):
1592 1531
1593 1532 processFlags = 0
1594 1533
1595 1534 dtype_index = get_dtype_index(self.dtype)
1596 1535 procflag_dtype = get_procflag_dtype(dtype_index)
1597 1536
1598 1537 processFlags += procflag_dtype
1599 1538
1600 1539 if self.dataOut.flagDecodeData:
1601 1540 processFlags += PROCFLAG.DECODE_DATA
1602 1541
1603 1542 if self.dataOut.flagDeflipData:
1604 1543 processFlags += PROCFLAG.DEFLIP_DATA
1605 1544
1606 1545 if self.dataOut.code is not None:
1607 1546 processFlags += PROCFLAG.DEFINE_PROCESS_CODE
1608 1547
1609 1548 if self.dataOut.nCohInt > 1:
1610 1549 processFlags += PROCFLAG.COHERENT_INTEGRATION
1611 1550
1612 1551 if self.dataOut.type == "Spectra":
1613 1552 if self.dataOut.nIncohInt > 1:
1614 1553 processFlags += PROCFLAG.INCOHERENT_INTEGRATION
1615 1554
1616 1555 if self.dataOut.data_dc is not None:
1617 1556 processFlags += PROCFLAG.SAVE_CHANNELS_DC
1618 1557
1619 1558 if self.dataOut.flagShiftFFT:
1620 1559 processFlags += PROCFLAG.SHIFT_FFT_DATA
1621 1560
1622 1561 return processFlags
1623 1562
1624 1563 def setBasicHeader(self):
1625 1564
1626 1565 self.basicHeaderObj.size = self.basicHeaderSize #bytes
1627 1566 self.basicHeaderObj.version = self.versionFile
1628 1567 self.basicHeaderObj.dataBlock = self.nTotalBlocks
1629 1568
1630 1569 utc = numpy.floor(self.dataOut.utctime)
1631 1570 milisecond = (self.dataOut.utctime - utc)* 1000.0
1632 1571
1633 1572 self.basicHeaderObj.utc = utc
1634 1573 self.basicHeaderObj.miliSecond = milisecond
1635 1574 self.basicHeaderObj.timeZone = self.dataOut.timeZone
1636 1575 self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
1637 1576 self.basicHeaderObj.errorCount = self.dataOut.errorCount
1638 1577
1639 1578 def setFirstHeader(self):
1640 1579 """
1641 1580 Obtiene una copia del First Header
1642 1581
1643 1582 Affected:
1644 1583
1645 1584 self.basicHeaderObj
1646 1585 self.systemHeaderObj
1647 1586 self.radarControllerHeaderObj
1648 1587 self.processingHeaderObj self.
1649 1588
1650 1589 Return:
1651 1590 None
1652 1591 """
1653 1592
1654 1593 raise NotImplementedError
1655 1594
1656 1595 def __writeFirstHeader(self):
1657 1596 """
1658 1597 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1659 1598
1660 1599 Affected:
1661 1600 __dataType
1662 1601
1663 1602 Return:
1664 1603 None
1665 1604 """
1666
1667 # CALCULAR PARAMETROS
1668
1605
1606 # CALCULAR PARAMETROS
1607
1669 1608 sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
1670 1609 self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
1671 1610
1672 1611 self.basicHeaderObj.write(self.fp)
1673 1612 self.systemHeaderObj.write(self.fp)
1674 1613 self.radarControllerHeaderObj.write(self.fp)
1675 1614 self.processingHeaderObj.write(self.fp)
1676 1615
1677 1616 def __setNewBlock(self):
1678 1617 """
1679 1618 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1680 1619
1681 1620 Return:
1682 1621 0 : si no pudo escribir nada
1683 1622 1 : Si escribio el Basic el First Header
1684 1623 """
1685 1624 if self.fp == None:
1686 1625 self.setNextFile()
1687 1626
1688 1627 if self.flagIsNewFile:
1689 1628 return 1
1690 1629
1691 1630 if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
1692 1631 self.basicHeaderObj.write(self.fp)
1693 1632 return 1
1694 1633
1695 1634 if not( self.setNextFile() ):
1696 1635 return 0
1697 1636
1698 1637 return 1
1699 1638
1700 1639
1701 1640 def writeNextBlock(self):
1702 1641 """
1703 1642 Selecciona el bloque siguiente de datos y los escribe en un file
1704 1643
1705 1644 Return:
1706 1645 0 : Si no hizo pudo escribir el bloque de datos
1707 1646 1 : Si no pudo escribir el bloque de datos
1708 1647 """
1709 1648 if not( self.__setNewBlock() ):
1710 1649 return 0
1711 1650
1712 1651 self.writeBlock()
1713 1652
1714 1653 print "[Writing] Block No. %d/%d" %(self.blockIndex,
1715 1654 self.processingHeaderObj.dataBlocksPerFile)
1716 1655
1717 1656 return 1
1718 1657
1719 1658 def setNextFile(self):
1720 1659 """
1721 1660 Determina el siguiente file que sera escrito
1722 1661
1723 1662 Affected:
1724 1663 self.filename
1725 1664 self.subfolder
1726 1665 self.fp
1727 1666 self.setFile
1728 1667 self.flagIsNewFile
1729 1668
1730 1669 Return:
1731 1670 0 : Si el archivo no puede ser escrito
1732 1671 1 : Si el archivo esta listo para ser escrito
1733 1672 """
1734 1673 ext = self.ext
1735 1674 path = self.path
1736 1675
1737 1676 if self.fp != None:
1738 1677 self.fp.close()
1739 1678
1740 1679 timeTuple = time.localtime( self.dataOut.utctime)
1741 1680 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1742 1681
1743 1682 fullpath = os.path.join( path, subfolder )
1744 1683 setFile = self.setFile
1745 1684
1746 1685 if not( os.path.exists(fullpath) ):
1747 1686 os.mkdir(fullpath)
1748 1687 setFile = -1 #inicializo mi contador de seteo
1749 1688 else:
1750 1689 filesList = os.listdir( fullpath )
1751 1690 if len( filesList ) > 0:
1752 1691 filesList = sorted( filesList, key=str.lower )
1753 1692 filen = filesList[-1]
1754 1693 # el filename debera tener el siguiente formato
1755 1694 # 0 1234 567 89A BCDE (hex)
1756 1695 # x YYYY DDD SSS .ext
1757 1696 if isNumber( filen[8:11] ):
1758 1697 setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1759 1698 else:
1760 1699 setFile = -1
1761 1700 else:
1762 1701 setFile = -1 #inicializo mi contador de seteo
1763 1702
1764 1703 setFile += 1
1765 1704
1766 1705 #If this is a new day it resets some values
1767 1706 if self.dataOut.datatime.date() > self.fileDate:
1768 1707 setFile = 0
1769 1708 self.nTotalBlocks = 0
1770 1709
1771 1710 filen = '%s%4.4d%3.3d%3.3d%s' % (self.optchar, timeTuple.tm_year, timeTuple.tm_yday, setFile, ext )
1772 1711
1773 1712 filename = os.path.join( path, subfolder, filen )
1774 1713
1775 1714 fp = open( filename,'wb' )
1776 1715
1777 1716 self.blockIndex = 0
1778 1717
1779 1718 #guardando atributos
1780 1719 self.filename = filename
1781 1720 self.subfolder = subfolder
1782 1721 self.fp = fp
1783 1722 self.setFile = setFile
1784 1723 self.flagIsNewFile = 1
1785 1724 self.fileDate = self.dataOut.datatime.date()
1786 1725
1787 1726 self.setFirstHeader()
1788 1727
1789 1728 print '[Writing] Opening file: %s'%self.filename
1790 1729
1791 1730 self.__writeFirstHeader()
1792 1731
1793 1732 return 1
1794 1733
1795 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4, verbose=True):
1734 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4):
1796 1735 """
1797 1736 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1798 1737
1799 1738 Inputs:
1800 1739 path : directory where data will be saved
1801 1740 profilesPerBlock : number of profiles per block
1802 1741 set : initial file set
1803 1742 datatype : An integer number that defines data type:
1804 1743 0 : int8 (1 byte)
1805 1744 1 : int16 (2 bytes)
1806 1745 2 : int32 (4 bytes)
1807 1746 3 : int64 (8 bytes)
1808 1747 4 : float32 (4 bytes)
1809 1748 5 : double64 (8 bytes)
1810 1749
1811 1750 Return:
1812 1751 0 : Si no realizo un buen seteo
1813 1752 1 : Si realizo un buen seteo
1814 1753 """
1815 1754
1816 1755 if ext == None:
1817 1756 ext = self.ext
1818 1757
1819 1758 self.ext = ext.lower()
1820 1759
1821 1760 self.path = path
1822 1761
1823 1762 if set is None:
1824 1763 self.setFile = -1
1825 1764 else:
1826 1765 self.setFile = set - 1
1827 1766
1828 1767 self.blocksPerFile = blocksPerFile
1829 1768
1830 1769 self.profilesPerBlock = profilesPerBlock
1831 1770
1832 1771 self.dataOut = dataOut
1833 1772 self.fileDate = self.dataOut.datatime.date()
1834 1773 #By default
1835 1774 self.dtype = self.dataOut.dtype
1836 1775
1837 1776 if datatype is not None:
1838 1777 self.dtype = get_numpy_dtype(datatype)
1839 1778
1840 1779 if not(self.setNextFile()):
1841 1780 print "[Writing] There isn't a next file"
1842 1781 return 0
1843 1782
1844 1783 self.setBlockDimension()
1845 1784
1846 1785 return 1
1847 1786
1848 1787 def run(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=None, ext=None, datatype=4, **kwargs):
1849 1788
1850 1789 if not(self.isConfig):
1851 1790
1852 1791 self.setup(dataOut, path, blocksPerFile, profilesPerBlock=profilesPerBlock, set=set, ext=ext, datatype=datatype, **kwargs)
1853 1792 self.isConfig = True
1854 1793
1855 1794 self.putData()
Show file before | Show file after | Hide comments
@@ -1,848 +1,848
1 1 '''
2 2 Created on Jul 3, 2014
3 3
4 4 @author: roj-idl71
5 5 '''
6 6
7 7 import os, sys
8 8 import time, datetime
9 9 import numpy
10 10 import fnmatch
11 11 import glob
12 12 from time import sleep
13 13
14 14 try:
15 15 import pyfits
16 16 except ImportError, e:
17 17 print "Fits data cannot be used. Install pyfits module"
18 18
19 19 from xml.etree.ElementTree import ElementTree
20 20
21 21 from jroIO_base import isRadarFolder, isNumber
22 22 from schainpy.model.data.jrodata import Fits
23 23 from schainpy.model.proc.jroproc_base import Operation, ProcessingUnit
24 24
25 25 class PyFits(object):
26 26 name=None
27 27 format=None
28 28 array =None
29 29 data =None
30 30 thdulist=None
31 31 prihdr=None
32 32 hdu=None
33 33
34 34 def __init__(self):
35 35
36 36 pass
37 37
38 38 def setColF(self,name,format,array):
39 39 self.name=name
40 40 self.format=format
41 41 self.array=array
42 42 a1=numpy.array([self.array],dtype=numpy.float32)
43 43 self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
44 44 return self.col1
45 45
46 46 # def setColP(self,name,format,data):
47 47 # self.name=name
48 48 # self.format=format
49 49 # self.data=data
50 50 # a2=numpy.array([self.data],dtype=numpy.float32)
51 51 # self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
52 52 # return self.col2
53 53
54 54
55 55 def writeData(self,name,format,data):
56 56 self.name=name
57 57 self.format=format
58 58 self.data=data
59 59 a2=numpy.array([self.data],dtype=numpy.float32)
60 60 self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
61 61 return self.col2
62 62
63 63 def cFImage(self,idblock,year,month,day,hour,minute,second):
64 64 self.hdu= pyfits.PrimaryHDU(idblock)
65 65 self.hdu.header.set("Year",year)
66 66 self.hdu.header.set("Month",month)
67 67 self.hdu.header.set("Day",day)
68 68 self.hdu.header.set("Hour",hour)
69 69 self.hdu.header.set("Minute",minute)
70 70 self.hdu.header.set("Second",second)
71 71 return self.hdu
72 72
73 73
74 74 def Ctable(self,colList):
75 75 self.cols=pyfits.ColDefs(colList)
76 76 self.tbhdu = pyfits.new_table(self.cols)
77 77 return self.tbhdu
78 78
79 79
80 80 def CFile(self,hdu,tbhdu):
81 81 self.thdulist=pyfits.HDUList([hdu,tbhdu])
82 82
83 83 def wFile(self,filename):
84 84 if os.path.isfile(filename):
85 85 os.remove(filename)
86 86 self.thdulist.writeto(filename)
87 87
88 88
89 89 class ParameterConf:
90 90 ELEMENTNAME = 'Parameter'
91 91 def __init__(self):
92 92 self.name = ''
93 93 self.value = ''
94 94
95 95 def readXml(self, parmElement):
96 96 self.name = parmElement.get('name')
97 97 self.value = parmElement.get('value')
98 98
99 99 def getElementName(self):
100 100 return self.ELEMENTNAME
101 101
102 102 class Metadata(object):
103 103
104 104 def __init__(self, filename):
105 105 self.parmConfObjList = []
106 106 self.readXml(filename)
107 107
108 108 def readXml(self, filename):
109 109 self.projectElement = None
110 110 self.procUnitConfObjDict = {}
111 111 self.projectElement = ElementTree().parse(filename)
112 112 self.project = self.projectElement.tag
113 113
114 114 parmElementList = self.projectElement.getiterator(ParameterConf().getElementName())
115 115
116 116 for parmElement in parmElementList:
117 117 parmConfObj = ParameterConf()
118 118 parmConfObj.readXml(parmElement)
119 119 self.parmConfObjList.append(parmConfObj)
120 120
121 121 class FitsWriter(Operation):
122 122 def __init__(self, **kwargs):
123 123 Operation.__init__(self, **kwargs)
124 124 self.isConfig = False
125 125 self.dataBlocksPerFile = None
126 126 self.blockIndex = 0
127 127 self.flagIsNewFile = 1
128 128 self.fitsObj = None
129 129 self.optchar = 'P'
130 130 self.ext = '.fits'
131 131 self.setFile = 0
132 132
133 133 def setFitsHeader(self, dataOut, metadatafile=None):
134 134
135 135 header_data = pyfits.PrimaryHDU()
136 136
137 137 header_data.header['EXPNAME'] = "RADAR DATA"
138 138 header_data.header['DATATYPE'] = "SPECTRA"
139 139 header_data.header['COMMENT'] = ""
140 140
141 141 if metadatafile:
142 142
143 143 metadata4fits = Metadata(metadatafile)
144 144
145 145 for parameter in metadata4fits.parmConfObjList:
146 146 parm_name = parameter.name
147 147 parm_value = parameter.value
148 148
149 149 header_data.header[parm_name] = parm_value
150 150
151 151 header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())
152 152 header_data.header['CHANNELLIST'] = str(dataOut.channelList)
153 153 header_data.header['NCHANNELS'] = dataOut.nChannels
154 154 #header_data.header['HEIGHTS'] = dataOut.heightList
155 155 header_data.header['NHEIGHTS'] = dataOut.nHeights
156 156
157 157 header_data.header['IPPSECONDS'] = dataOut.ippSeconds
158 158 header_data.header['NCOHINT'] = dataOut.nCohInt
159 159 header_data.header['NINCOHINT'] = dataOut.nIncohInt
160 160 header_data.header['TIMEZONE'] = dataOut.timeZone
161 161 header_data.header['NBLOCK'] = self.blockIndex
162 162
163 163 header_data.writeto(self.filename)
164 164
165 165 self.addExtension(dataOut.heightList,'HEIGHTLIST')
166 166
167 167
168 168 def setup(self, dataOut, path, dataBlocksPerFile=100, metadatafile=None):
169 169
170 170 self.path = path
171 171 self.dataOut = dataOut
172 172 self.metadatafile = metadatafile
173 173 self.dataBlocksPerFile = dataBlocksPerFile
174 174
175 175 def open(self):
176 176 self.fitsObj = pyfits.open(self.filename, mode='update')
177 177
178 178
179 179 def addExtension(self, data, tagname):
180 180 self.open()
181 181 extension = pyfits.ImageHDU(data=data, name=tagname)
182 182 #extension.header['TAG'] = tagname
183 183 self.fitsObj.append(extension)
184 184 self.write()
185 185
186 186 def addData(self, data):
187 187 self.open()
188 188 extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])
189 189 extension.header['UTCTIME'] = self.dataOut.utctime
190 190 self.fitsObj.append(extension)
191 191 self.blockIndex += 1
192 192 self.fitsObj[0].header['NBLOCK'] = self.blockIndex
193 193
194 194 self.write()
195 195
196 196 def write(self):
197 197
198 198 self.fitsObj.flush(verbose=True)
199 199 self.fitsObj.close()
200 200
201 201
202 202 def setNextFile(self):
203 203
204 204 ext = self.ext
205 205 path = self.path
206 206
207 207 timeTuple = time.localtime( self.dataOut.utctime)
208 208 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
209 209
210 210 fullpath = os.path.join( path, subfolder )
211 211 if not( os.path.exists(fullpath) ):
212 212 os.mkdir(fullpath)
213 213 self.setFile = -1 #inicializo mi contador de seteo
214 214 else:
215 215 filesList = os.listdir( fullpath )
216 216 if len( filesList ) > 0:
217 217 filesList = sorted( filesList, key=str.lower )
218 218 filen = filesList[-1]
219 219
220 220 if isNumber( filen[8:11] ):
221 221 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
222 222 else:
223 223 self.setFile = -1
224 224 else:
225 225 self.setFile = -1 #inicializo mi contador de seteo
226 226
227 227 setFile = self.setFile
228 228 setFile += 1
229 229
230 230 thisFile = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
231 231 timeTuple.tm_year,
232 232 timeTuple.tm_yday,
233 233 setFile,
234 234 ext )
235 235
236 236 filename = os.path.join( path, subfolder, thisFile )
237 237
238 238 self.blockIndex = 0
239 239 self.filename = filename
240 240 self.setFile = setFile
241 241 self.flagIsNewFile = 1
242 242
243 243 print 'Writing the file: %s'%self.filename
244 244
245 245 self.setFitsHeader(self.dataOut, self.metadatafile)
246 246
247 247 return 1
248 248
249 249 def writeBlock(self):
250 250 self.addData(self.dataOut.data_spc)
251 251 self.flagIsNewFile = 0
252 252
253 253
254 254 def __setNewBlock(self):
255 255
256 256 if self.flagIsNewFile:
257 257 return 1
258 258
259 259 if self.blockIndex < self.dataBlocksPerFile:
260 260 return 1
261 261
262 262 if not( self.setNextFile() ):
263 263 return 0
264 264
265 265 return 1
266 266
267 267 def writeNextBlock(self):
268 268 if not( self.__setNewBlock() ):
269 269 return 0
270 270 self.writeBlock()
271 271 return 1
272 272
273 273 def putData(self):
274 274 if self.flagIsNewFile:
275 275 self.setNextFile()
276 276 self.writeNextBlock()
277 277
278 278 def run(self, dataOut, path, dataBlocksPerFile=100, metadatafile=None, **kwargs):
279 279 if not(self.isConfig):
280 280 self.setup(dataOut, path, dataBlocksPerFile=dataBlocksPerFile, metadatafile=metadatafile, **kwargs)
281 281 self.isConfig = True
282 282 self.putData()
283 283
284 284
285 285 class FitsReader(ProcessingUnit):
286 286
287 287 # __TIMEZONE = time.timezone
288 288
289 289 expName = None
290 290 datetimestr = None
291 291 utc = None
292 292 nChannels = None
293 293 nSamples = None
294 294 dataBlocksPerFile = None
295 295 comments = None
296 296 lastUTTime = None
297 297 header_dict = None
298 298 data = None
299 299 data_header_dict = None
300 300
301 301 def __init__(self, **kwargs):
302 302 ProcessingUnit.__init__(self, **kwargs)
303 303 self.isConfig = False
304 304 self.ext = '.fits'
305 305 self.setFile = 0
306 306 self.flagNoMoreFiles = 0
307 307 self.flagIsNewFile = 1
308 308 self.flagDiscontinuousBlock = None
309 309 self.fileIndex = None
310 310 self.filename = None
311 311 self.fileSize = None
312 312 self.fitsObj = None
313 313 self.timeZone = None
314 314 self.nReadBlocks = 0
315 315 self.nTotalBlocks = 0
316 316 self.dataOut = self.createObjByDefault()
317 317 self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()
318 318 self.blockIndex = 1
319 319
320 320 def createObjByDefault(self):
321 321
322 322 dataObj = Fits()
323 323
324 324 return dataObj
325 325
326 326 def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):
327 327 try:
328 328 fitsObj = pyfits.open(filename,'readonly')
329 329 except:
330 330 print "File %s can't be opened" %(filename)
331 331 return None
332 332
333 333 header = fitsObj[0].header
334 334 struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")
335 335 utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS
336 336
337 337 ltc = utc
338 338 if useLocalTime:
339 339 ltc -= time.timezone
340 340 thisDatetime = datetime.datetime.utcfromtimestamp(ltc)
341 341 thisTime = thisDatetime.time()
342 342
343 343 if not ((startTime <= thisTime) and (endTime > thisTime)):
344 344 return None
345 345
346 346 return thisDatetime
347 347
348 348 def __setNextFileOnline(self):
349 349 raise NotImplementedError
350 350
351 351 def __setNextFileOffline(self):
352 352 idFile = self.fileIndex
353 353
354 354 while (True):
355 355 idFile += 1
356 356 if not(idFile < len(self.filenameList)):
357 357 self.flagNoMoreFiles = 1
358 358 print "No more Files"
359 359 return 0
360 360
361 361 filename = self.filenameList[idFile]
362 362
363 363 # if not(self.__verifyFile(filename)):
364 364 # continue
365 365
366 366 fileSize = os.path.getsize(filename)
367 367 fitsObj = pyfits.open(filename,'readonly')
368 368 break
369 369
370 370 self.flagIsNewFile = 1
371 371 self.fileIndex = idFile
372 372 self.filename = filename
373 373 self.fileSize = fileSize
374 374 self.fitsObj = fitsObj
375 375 self.blockIndex = 0
376 376 print "Setting the file: %s"%self.filename
377 377
378 378 return 1
379 379
380 380 def __setValuesFromHeader(self):
381 381
382 382 self.dataOut.header = self.header_dict
383 383 self.dataOut.expName = self.expName
384 384
385 385 self.dataOut.timeZone = self.timeZone
386 386 self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
387 387 self.dataOut.comments = self.comments
388 388 # self.dataOut.timeInterval = self.timeInterval
389 389 self.dataOut.channelList = self.channelList
390 390 self.dataOut.heightList = self.heightList
391 391
392 392 self.dataOut.nCohInt = self.nCohInt
393 393 self.dataOut.nIncohInt = self.nIncohInt
394 394
395 395 self.dataOut.ippSeconds = self.ippSeconds
396 396
397 397 def readHeader(self):
398 398 headerObj = self.fitsObj[0]
399 399
400 400 self.header_dict = headerObj.header
401 401 if 'EXPNAME' in headerObj.header.keys():
402 402 self.expName = headerObj.header['EXPNAME']
403 403
404 404 if 'DATATYPE' in headerObj.header.keys():
405 405 self.dataType = headerObj.header['DATATYPE']
406 406
407 407 self.datetimestr = headerObj.header['DATETIME']
408 408 channelList = headerObj.header['CHANNELLIST']
409 409 channelList = channelList.split('[')
410 410 channelList = channelList[1].split(']')
411 411 channelList = channelList[0].split(',')
412 412 channelList = [int(ch) for ch in channelList]
413 413 self.channelList = channelList
414 414 self.nChannels = headerObj.header['NCHANNELS']
415 415 self.nHeights = headerObj.header['NHEIGHTS']
416 416 self.ippSeconds = headerObj.header['IPPSECONDS']
417 417 self.nCohInt = headerObj.header['NCOHINT']
418 418 self.nIncohInt = headerObj.header['NINCOHINT']
419 419 self.dataBlocksPerFile = headerObj.header['NBLOCK']
420 420 self.timeZone = headerObj.header['TIMEZONE']
421 421
422 422 # self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
423 423
424 424 if 'COMMENT' in headerObj.header.keys():
425 425 self.comments = headerObj.header['COMMENT']
426 426
427 427 self.readHeightList()
428 428
429 429 def readHeightList(self):
430 430 self.blockIndex = self.blockIndex + 1
431 431 obj = self.fitsObj[self.blockIndex]
432 432 self.heightList = obj.data
433 433 self.blockIndex = self.blockIndex + 1
434 434
435 435 def readExtension(self):
436 436 obj = self.fitsObj[self.blockIndex]
437 437 self.heightList = obj.data
438 438 self.blockIndex = self.blockIndex + 1
439 439
440 440 def setNextFile(self):
441 441
442 442 if self.online:
443 443 newFile = self.__setNextFileOnline()
444 444 else:
445 445 newFile = self.__setNextFileOffline()
446 446
447 447 if not(newFile):
448 448 return 0
449 449
450 450 self.readHeader()
451 451 self.__setValuesFromHeader()
452 452 self.nReadBlocks = 0
453 453 # self.blockIndex = 1
454 454 return 1
455 455
456 def __searchFilesOffLine(self,
456 def searchFilesOffLine(self,
457 457 path,
458 458 startDate,
459 459 endDate,
460 460 startTime=datetime.time(0,0,0),
461 461 endTime=datetime.time(23,59,59),
462 462 set=None,
463 463 expLabel='',
464 464 ext='.fits',
465 465 walk=True):
466 466
467 467 pathList = []
468 468
469 469 if not walk:
470 470 pathList.append(path)
471 471
472 472 else:
473 473 dirList = []
474 474 for thisPath in os.listdir(path):
475 475 if not os.path.isdir(os.path.join(path,thisPath)):
476 476 continue
477 477 if not isRadarFolder(thisPath):
478 478 continue
479 479
480 480 dirList.append(thisPath)
481 481
482 482 if not(dirList):
483 483 return None, None
484 484
485 485 thisDate = startDate
486 486
487 487 while(thisDate <= endDate):
488 488 year = thisDate.timetuple().tm_year
489 489 doy = thisDate.timetuple().tm_yday
490 490
491 491 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
492 492 if len(matchlist) == 0:
493 493 thisDate += datetime.timedelta(1)
494 494 continue
495 495 for match in matchlist:
496 496 pathList.append(os.path.join(path,match,expLabel))
497 497
498 498 thisDate += datetime.timedelta(1)
499 499
500 500 if pathList == []:
501 501 print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
502 502 return None, None
503 503
504 504 print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
505 505
506 506 filenameList = []
507 507 datetimeList = []
508 508
509 509 for i in range(len(pathList)):
510 510
511 511 thisPath = pathList[i]
512 512
513 513 fileList = glob.glob1(thisPath, "*%s" %ext)
514 514 fileList.sort()
515 515
516 516 for thisFile in fileList:
517 517
518 518 filename = os.path.join(thisPath,thisFile)
519 519 thisDatetime = self.isFileinThisTime(filename, startTime, endTime)
520 520
521 521 if not(thisDatetime):
522 522 continue
523 523
524 524 filenameList.append(filename)
525 525 datetimeList.append(thisDatetime)
526 526
527 527 if not(filenameList):
528 528 print "Any file was found for the time range %s - %s" %(startTime, endTime)
529 529 return None, None
530 530
531 531 print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
532 532 print
533 533
534 534 for i in range(len(filenameList)):
535 535 print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
536 536
537 537 self.filenameList = filenameList
538 538 self.datetimeList = datetimeList
539 539
540 540 return pathList, filenameList
541 541
542 542 def setup(self, path=None,
543 543 startDate=None,
544 544 endDate=None,
545 545 startTime=datetime.time(0,0,0),
546 546 endTime=datetime.time(23,59,59),
547 547 set=0,
548 548 expLabel = "",
549 549 ext = None,
550 550 online = False,
551 551 delay = 60,
552 552 walk = True):
553 553
554 554 if path == None:
555 555 raise ValueError, "The path is not valid"
556 556
557 557 if ext == None:
558 558 ext = self.ext
559 559
560 560 if not(online):
561 561 print "Searching files in offline mode ..."
562 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
562 pathList, filenameList = self.searchFilesOffLine(path, startDate=startDate, endDate=endDate,
563 563 startTime=startTime, endTime=endTime,
564 564 set=set, expLabel=expLabel, ext=ext,
565 565 walk=walk)
566 566
567 567 if not(pathList):
568 568 print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
569 569 datetime.datetime.combine(startDate,startTime).ctime(),
570 570 datetime.datetime.combine(endDate,endTime).ctime())
571 571
572 572 sys.exit(-1)
573 573
574 574 self.fileIndex = -1
575 575 self.pathList = pathList
576 576 self.filenameList = filenameList
577 577
578 578 self.online = online
579 579 self.delay = delay
580 580 ext = ext.lower()
581 581 self.ext = ext
582 582
583 583 if not(self.setNextFile()):
584 584 if (startDate!=None) and (endDate!=None):
585 585 print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
586 586 elif startDate != None:
587 587 print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
588 588 else:
589 589 print "No files"
590 590
591 591 sys.exit(-1)
592 592
593 593
594 594
595 595 def readBlock(self):
596 596 dataObj = self.fitsObj[self.blockIndex]
597 597
598 598 self.data = dataObj.data
599 599 self.data_header_dict = dataObj.header
600 600 self.utc = self.data_header_dict['UTCTIME']
601 601
602 602 self.flagIsNewFile = 0
603 603 self.blockIndex += 1
604 604 self.nTotalBlocks += 1
605 605 self.nReadBlocks += 1
606 606
607 607 return 1
608 608
609 609 def __jumpToLastBlock(self):
610 610 raise NotImplementedError
611 611
612 612 def __waitNewBlock(self):
613 613 """
614 614 Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
615 615
616 616 Si el modo de lectura es OffLine siempre retorn 0
617 617 """
618 618 if not self.online:
619 619 return 0
620 620
621 621 if (self.nReadBlocks >= self.dataBlocksPerFile):
622 622 return 0
623 623
624 624 currentPointer = self.fp.tell()
625 625
626 626 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
627 627
628 628 for nTries in range( self.nTries ):
629 629
630 630 self.fp.close()
631 631 self.fp = open( self.filename, 'rb' )
632 632 self.fp.seek( currentPointer )
633 633
634 634 self.fileSize = os.path.getsize( self.filename )
635 635 currentSize = self.fileSize - currentPointer
636 636
637 637 if ( currentSize >= neededSize ):
638 638 self.__rdBasicHeader()
639 639 return 1
640 640
641 641 print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
642 642 sleep( self.delay )
643 643
644 644
645 645 return 0
646 646
647 647 def __setNewBlock(self):
648 648
649 649 if self.online:
650 650 self.__jumpToLastBlock()
651 651
652 652 if self.flagIsNewFile:
653 653 return 1
654 654
655 655 self.lastUTTime = self.utc
656 656
657 657 if self.online:
658 658 if self.__waitNewBlock():
659 659 return 1
660 660
661 661 if self.nReadBlocks < self.dataBlocksPerFile:
662 662 return 1
663 663
664 664 if not(self.setNextFile()):
665 665 return 0
666 666
667 667 deltaTime = self.utc - self.lastUTTime
668 668
669 669 self.flagDiscontinuousBlock = 0
670 670
671 671 if deltaTime > self.maxTimeStep:
672 672 self.flagDiscontinuousBlock = 1
673 673
674 674 return 1
675 675
676 676
677 677 def readNextBlock(self):
678 678 if not(self.__setNewBlock()):
679 679 return 0
680 680
681 681 if not(self.readBlock()):
682 682 return 0
683 683
684 684 return 1
685 685
686 686 def printInfo(self):
687 687
688 688 pass
689 689
690 690 def getData(self):
691 691
692 692 if self.flagNoMoreFiles:
693 693 self.dataOut.flagNoData = True
694 694 print 'Process finished'
695 695 return 0
696 696
697 697 self.flagDiscontinuousBlock = 0
698 698 self.flagIsNewBlock = 0
699 699
700 700 if not(self.readNextBlock()):
701 701 return 0
702 702
703 703 if self.data is None:
704 704 self.dataOut.flagNoData = True
705 705 return 0
706 706
707 707 self.dataOut.data = self.data
708 708 self.dataOut.data_header = self.data_header_dict
709 709 self.dataOut.utctime = self.utc
710 710
711 711 # self.dataOut.header = self.header_dict
712 712 # self.dataOut.expName = self.expName
713 713 # self.dataOut.nChannels = self.nChannels
714 714 # self.dataOut.timeZone = self.timeZone
715 715 # self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
716 716 # self.dataOut.comments = self.comments
717 717 # # self.dataOut.timeInterval = self.timeInterval
718 718 # self.dataOut.channelList = self.channelList
719 719 # self.dataOut.heightList = self.heightList
720 720 self.dataOut.flagNoData = False
721 721
722 722 return self.dataOut.data
723 723
724 724 def run(self, **kwargs):
725 725
726 726 if not(self.isConfig):
727 727 self.setup(**kwargs)
728 728 self.isConfig = True
729 729
730 730 self.getData()
731 731
732 732 class SpectraHeisWriter(Operation):
733 733 # set = None
734 734 setFile = None
735 735 idblock = None
736 736 doypath = None
737 737 subfolder = None
738 738
739 739 def __init__(self, **kwargs):
740 740 Operation.__init__(self, **kwargs)
741 741 self.wrObj = PyFits()
742 742 # self.dataOut = dataOut
743 743 self.nTotalBlocks=0
744 744 # self.set = None
745 745 self.setFile = None
746 746 self.idblock = 0
747 747 self.wrpath = None
748 748 self.doypath = None
749 749 self.subfolder = None
750 750 self.isConfig = False
751 751
752 752 def isNumber(str):
753 753 """
754 754 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
755 755
756 756 Excepciones:
757 757 Si un determinado string no puede ser convertido a numero
758 758 Input:
759 759 str, string al cual se le analiza para determinar si convertible a un numero o no
760 760
761 761 Return:
762 762 True : si el string es uno numerico
763 763 False : no es un string numerico
764 764 """
765 765 try:
766 766 float( str )
767 767 return True
768 768 except:
769 769 return False
770 770
771 771 def setup(self, dataOut, wrpath):
772 772
773 773 if not(os.path.exists(wrpath)):
774 774 os.mkdir(wrpath)
775 775
776 776 self.wrpath = wrpath
777 777 # self.setFile = 0
778 778 self.dataOut = dataOut
779 779
780 780 def putData(self):
781 781 name= time.localtime( self.dataOut.utctime)
782 782 ext=".fits"
783 783
784 784 if self.doypath == None:
785 785 self.subfolder = 'F%4.4d%3.3d_%d' % (name.tm_year,name.tm_yday,time.mktime(datetime.datetime.now().timetuple()))
786 786 self.doypath = os.path.join( self.wrpath, self.subfolder )
787 787 os.mkdir(self.doypath)
788 788
789 789 if self.setFile == None:
790 790 # self.set = self.dataOut.set
791 791 self.setFile = 0
792 792 # if self.set != self.dataOut.set:
793 793 ## self.set = self.dataOut.set
794 794 # self.setFile = 0
795 795
796 796 #make the filename
797 797 thisFile = 'D%4.4d%3.3d_%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
798 798
799 799 filename = os.path.join(self.wrpath,self.subfolder, thisFile)
800 800
801 801 idblock = numpy.array([self.idblock],dtype="int64")
802 802 header=self.wrObj.cFImage(idblock=idblock,
803 803 year=time.gmtime(self.dataOut.utctime).tm_year,
804 804 month=time.gmtime(self.dataOut.utctime).tm_mon,
805 805 day=time.gmtime(self.dataOut.utctime).tm_mday,
806 806 hour=time.gmtime(self.dataOut.utctime).tm_hour,
807 807 minute=time.gmtime(self.dataOut.utctime).tm_min,
808 808 second=time.gmtime(self.dataOut.utctime).tm_sec)
809 809
810 810 c=3E8
811 811 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
812 812 freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)*(c/(2*deltaHeight*1000))
813 813
814 814 colList = []
815 815
816 816 colFreq=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
817 817
818 818 colList.append(colFreq)
819 819
820 820 nchannel=self.dataOut.nChannels
821 821
822 822 for i in range(nchannel):
823 823 col = self.wrObj.writeData(name="PCh"+str(i+1),
824 824 format=str(self.dataOut.nFFTPoints)+'E',
825 825 data=10*numpy.log10(self.dataOut.data_spc[i,:]))
826 826
827 827 colList.append(col)
828 828
829 829 data=self.wrObj.Ctable(colList=colList)
830 830
831 831 self.wrObj.CFile(header,data)
832 832
833 833 self.wrObj.wFile(filename)
834 834
835 835 #update the setFile
836 836 self.setFile += 1
837 837 self.idblock += 1
838 838
839 839 return 1
840 840
841 841 def run(self, dataOut, **kwargs):
842 842
843 843 if not(self.isConfig):
844 844
845 845 self.setup(dataOut, **kwargs)
846 846 self.isConfig = True
847 847
848 848 self.putData()
Show file before | Show file after | Hide comments
@@ -1,863 +1,863
1 1 '''
2 2 Created on Jul 3, 2014
3 3
4 4 @author: roj-com0419
5 5 '''
6 6
7 7 import os,sys
8 8 import time,datetime
9 9 import h5py
10 10 import numpy
11 11 import fnmatch
12 12 import re
13 13
14 14 from schainpy.model.data.jroheaderIO import RadarControllerHeader, SystemHeader
15 15 from schainpy.model.data.jrodata import Voltage
16 16 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
17 17
18 18
19 19 def isNumber(str):
20 20 """
21 21 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
22 22
23 23 Excepciones:
24 24 Si un determinado string no puede ser convertido a numero
25 25 Input:
26 26 str, string al cual se le analiza para determinar si convertible a un numero o no
27 27
28 28 Return:
29 29 True : si el string es uno numerico
30 30 False : no es un string numerico
31 31 """
32 32 try:
33 33 float( str )
34 34 return True
35 35 except:
36 36 return False
37 37
38 38 def getFileFromSet(path, ext, set=None):
39 39 validFilelist = []
40 40 fileList = os.listdir(path)
41 41
42 42
43 43 if len(fileList) < 1:
44 44 return None
45 45
46 46 # 0 1234 567 89A BCDE
47 47 # H YYYY DDD SSS .ext
48 48
49 49 for thisFile in fileList:
50 50 try:
51 51 number= int(thisFile[6:16])
52 52
53 53 # year = int(thisFile[1:5])
54 54 # doy = int(thisFile[5:8])
55 55 except:
56 56 continue
57 57
58 58 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
59 59 continue
60 60
61 61 validFilelist.append(thisFile)
62 62
63 63 if len(validFilelist) < 1:
64 64 return None
65 65
66 66 validFilelist = sorted( validFilelist, key=str.lower )
67 67
68 68 if set == None:
69 69 return validFilelist[-1]
70 70
71 71 print "set =" ,set
72 72 for thisFile in validFilelist:
73 73 if set <= int(thisFile[6:16]):
74 74 print thisFile,int(thisFile[6:16])
75 75 return thisFile
76 76
77 77 return validFilelist[-1]
78 78
79 79 myfile = fnmatch.filter(validFilelist,'*%10d*'%(set))
80 80 #myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
81 81
82 82 if len(myfile)!= 0:
83 83 return myfile[0]
84 84 else:
85 85 filename = '*%10.10d%s'%(set,ext.lower())
86 86 print 'the filename %s does not exist'%filename
87 87 print '...going to the last file: '
88 88
89 89 if validFilelist:
90 90 validFilelist = sorted( validFilelist, key=str.lower )
91 91 return validFilelist[-1]
92 92
93 93 return None
94 94
95 95 def getlastFileFromPath(path, ext):
96 96 """
97 97 Depura el fileList dejando solo los que cumplan el formato de "res-xxxxxx.ext"
98 98 al final de la depuracion devuelve el ultimo file de la lista que quedo.
99 99
100 100 Input:
101 101 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
102 102 ext : extension de los files contenidos en una carpeta
103 103
104 104 Return:
105 105 El ultimo file de una determinada carpeta, no se considera el path.
106 106 """
107 107 validFilelist = []
108 108 fileList = os.listdir(path)
109 109
110 110 # 0 1234 567 89A BCDE
111 111 # H YYYY DDD SSS .ext
112 112
113 113 for thisFile in fileList:
114 114
115 115 try:
116 116 number= int(thisFile[6:16])
117 117 except:
118 118 print "There is a file or folder with different format"
119 119 if not isNumber(number):
120 120 continue
121 121
122 122 # year = thisFile[1:5]
123 123 # if not isNumber(year):
124 124 # continue
125 125
126 126 # doy = thisFile[5:8]
127 127 # if not isNumber(doy):
128 128 # continue
129 129
130 130 number= int(number)
131 131 # year = int(year)
132 132 # doy = int(doy)
133 133
134 134 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
135 135 continue
136 136
137 137
138 138 validFilelist.append(thisFile)
139 139
140 140
141 141 if validFilelist:
142 142 validFilelist = sorted( validFilelist, key=str.lower )
143 143 return validFilelist[-1]
144 144
145 145 return None
146 146
147 147
148 148
149 149 class HFReader(ProcessingUnit):
150 150 '''
151 151 classdocs
152 152 '''
153 153 path = None
154 154 startDate= None
155 155 endDate = None
156 156 startTime= None
157 157 endTime = None
158 158 walk = None
159 159 isConfig = False
160 160 dataOut=None
161 161 nTries = 3
162 162 ext = ".hdf5"
163 163
164 164 def __init__(self, **kwargs):
165 165 '''
166 166 Constructor
167 167 '''
168 168 ProcessingUnit.__init__(self, **kwargs)
169 169
170 170 self.isConfig =False
171 171
172 172 self.datablock = None
173 173
174 174 self.filename_current=None
175 175
176 176 self.utc = 0
177 177
178 178 self.ext='.hdf5'
179 179
180 180 self.flagIsNewFile = 1
181 181
182 182 #-------------------------------------------------
183 183 self.fileIndex=None
184 184
185 185 self.profileIndex_offset=None
186 186
187 187 self.filenameList=[]
188 188
189 189 self.hfFilePointer= None
190 190
191 191 self.filename_online = None
192 192
193 193 self.status=True
194 194
195 195 self.flagNoMoreFiles= False
196 196
197 197 self.__waitForNewFile = 20
198 198
199 199
200 200 #--------------------------------------------------
201 201
202 202 self.dataOut = self.createObjByDefault()
203 203
204 204
205 205 def createObjByDefault(self):
206 206
207 207 dataObj = Voltage()
208 208
209 209 return dataObj
210 210
211 211 def setObjProperties(self):
212 212
213 213 pass
214 214
215 215 def getBlockDimension(self):
216 216 """
217 217 Obtiene la cantidad de puntos a leer por cada bloque de datos
218 218
219 219 Affected:
220 220 self.blocksize
221 221
222 222 Return:
223 223 None
224 224 """
225 225 pts2read =self.nChannels*self.nHeights*self.nProfiles
226 226 self.blocksize = pts2read
227 227
228 228 def __readHeader(self):
229 229
230 230 self.nProfiles = 100
231 231 self.nHeights = 1000
232 232 self.nChannels = 2
233 233 self.__firstHeigth=0
234 234 self.__nSamples=1000
235 235 self.__deltaHeigth=1.5
236 236 self.__sample_rate=1e5
237 237 #self.__frequency=2.72e6
238 238 #self.__frequency=3.64e6
239 239 self.__frequency=None
240 240 self.__online = False
241 241 self.filename_next_set=None
242 242
243 243 #print "Frequency of Operation:", self.__frequency
244 244
245 245
246 246 def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''):
247 247 self.path = path
248 248 self.startDate = startDate
249 249 self.endDate = endDate
250 250 self.startTime = startTime
251 251 self.endTime = endTime
252 252 self.walk = walk
253 253
254 254 def __checkPath(self):
255 255 if os.path.exists(self.path):
256 256 self.status=1
257 257 else:
258 258 self.status=0
259 259 print 'Path %s does not exits'%self.path
260 260 return
261 261 return
262 262
263 263 def __selDates(self, hf_dirname_format):
264 264 try:
265 265 dir_hf_filename= self.path+"/"+hf_dirname_format
266 266 fp= h5py.File(dir_hf_filename,'r')
267 267 hipoc=fp['t'].value
268 268 fp.close()
269 269 date_time=datetime.datetime.utcfromtimestamp(hipoc)
270 270 year =int(date_time[0:4])
271 271 month=int(date_time[5:7])
272 272 dom =int(date_time[8:10])
273 273 thisDate= datetime.date(year,month,dom)
274 274 if (thisDate>=self.startDate and thisDate <= self.endDate):
275 275 return hf_dirname_format
276 276 except:
277 277 return None
278 278
279 279 def __findDataForDates(self,online=False):
280 280 if not(self.status):
281 281 return None
282 282
283 283 pat = '\d+.\d+'
284 284 dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
285 285 dirnameList = filter(lambda x:x!=None,dirnameList)
286 286 dirnameList = [x.string for x in dirnameList]
287 287 if not(online):
288 288
289 289 dirnameList = [self.__selDates(x) for x in dirnameList]
290 290 dirnameList = filter(lambda x:x!=None,dirnameList)
291 291
292 292 if len(dirnameList)>0:
293 293 self.status = 1
294 294 self.dirnameList = dirnameList
295 295 self.dirnameList.sort()
296 296
297 297 else:
298 298 self.status = 0
299 299 return None
300 300
301 301 def __getTimeFromData(self):
302 302 startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
303 303 endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
304 304 print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader)
305 305 print '........................................'
306 306 filter_filenameList=[]
307 307 self.filenameList.sort()
308 308 for i in range(len(self.filenameList)-1):
309 309 filename=self.filenameList[i]
310 310 dir_hf_filename= filename
311 311 fp= h5py.File(dir_hf_filename,'r')
312 312 hipoc=fp['t'].value
313 313 hipoc=hipoc+self.timezone
314 314 date_time=datetime.datetime.utcfromtimestamp(hipoc)
315 315 fp.close()
316 316 year =int(date_time[0:4])
317 317 month=int(date_time[5:7])
318 318 dom =int(date_time[8:10])
319 319 hour =int(date_time[11:13])
320 320 min =int(date_time[14:16])
321 321 sec =int(date_time[17:19])
322 322 this_time=datetime.datetime(year,month,dom,hour,min,sec)
323 323 if (this_time>=startDateTime_Reader and this_time <= endDateTime_Reader):
324 324 filter_filenameList.append(filename)
325 325 filter_filenameList.sort()
326 326 self.filenameList = filter_filenameList
327 327 return 1
328 328
329 329 def __getFilenameList(self):
330 330 #print "hola"
331 331 #print self.dirnameList
332 332 dirList = [os.path.join(self.path,x) for x in self.dirnameList]
333 333 self.filenameList= dirList
334 334 #print self.filenameList
335 335 #print "pase",len(self.filenameList)
336 336
337 337 def __selectDataForTimes(self, online=False):
338 338
339 339 if not(self.status):
340 340 return None
341 341 #----------------
342 342 self.__getFilenameList()
343 343 #----------------
344 344 if not(online):
345 345 if not(self.all):
346 346 self.__getTimeFromData()
347 347 if len(self.filenameList)>0:
348 348 self.status=1
349 349 self.filenameList.sort()
350 350 else:
351 351 self.status=0
352 352 return None
353 353 else:
354 354 if self.set != None:
355 355
356 356 filename=getFileFromSet(self.path,self.ext,self.set)
357 357
358 358 if self.flag_nextfile==True:
359 359 self.dirnameList=[filename]
360 360 fullfilename=self.path+"/"+filename
361 361 self.filenameList=[fullfilename]
362 362 self.filename_next_set=int(filename[6:16])+10
363 363
364 364 self.flag_nextfile=False
365 365 else:
366 366 print filename
367 367 print "PRIMERA CONDICION"
368 368 #if self.filename_next_set== int(filename[6:16]):
369 369 print "TODO BIEN"
370 370
371 371 if filename == None:
372 372 raise ValueError, "corregir"
373 373
374 374 self.dirnameList=[filename]
375 375 fullfilename=self.path+"/"+filename
376 376 self.filenameList=[fullfilename]
377 377 self.filename_next_set=int(filename[6:16])+10
378 378 print "Setting next file",self.filename_next_set
379 379 self.set=int(filename[6:16])
380 380 if True:
381 381 pass
382 382 else:
383 383 print "ESTOY AQUI PORQUE NO EXISTE EL SIGUIENTE ARCHIVO"
384 384
385 385 else:
386 386 filename =getlastFileFromPath(self.path,self.ext)
387 387
388 388 if self.flag_nextfile==True:
389 389 self.dirnameList=[filename]
390 390 fullfilename=self.path+"/"+filename
391 391 self.filenameList=[self.filenameList[-1]]
392 392 self.filename_next_set=int(filename[6:16])+10
393 393
394 394 self.flag_nextfile=False
395 395 else:
396 396 filename=getFileFromSet(self.path,self.ext,self.set)
397 397 print filename
398 398 print "PRIMERA CONDICION"
399 399 #if self.filename_next_set== int(filename[6:16]):
400 400 print "TODO BIEN"
401 401
402 402 if filename == None:
403 403 raise ValueError, "corregir"
404 404
405 405 self.dirnameList=[filename]
406 406 fullfilename=self.path+"/"+filename
407 407 self.filenameList=[fullfilename]
408 408 self.filename_next_set=int(filename[6:16])+10
409 409 print "Setting next file",self.filename_next_set
410 410 self.set=int(filename[6:16])
411 411 if True:
412 412 pass
413 413 else:
414 414 print "ESTOY AQUI PORQUE NO EXISTE EL SIGUIENTE ARCHIVO"
415 415
416 416
417 417
418 def __searchFilesOffline(self,
418 def searchFilesOffLine(self,
419 419 path,
420 420 startDate,
421 421 endDate,
422 422 ext,
423 423 startTime=datetime.time(0,0,0),
424 424 endTime=datetime.time(23,59,59),
425 425 walk=True):
426 426
427 427 self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
428 428
429 429 self.__checkPath()
430 430
431 431 self.__findDataForDates()
432 432 #print self.dirnameList
433 433
434 434 self.__selectDataForTimes()
435 435
436 436 for i in range(len(self.filenameList)):
437 437 print "%s"% (self.filenameList[i])
438 438
439 439 return
440 440
441 def __searchFilesOnline(self,
441 def searchFilesOnLine(self,
442 442 path,
443 443 expLabel= "",
444 444 ext=None,
445 445 startDate=None,
446 446 endDate=None,
447 447 walk=True,
448 448 set=None):
449 449
450 450
451 451 startDate = datetime.datetime.utcnow().date()
452 452 endDate = datetime.datetime.utcnow().date()
453 453
454 454 self.__setParameters(path=path,startDate=startDate,endDate=endDate,walk=walk)
455 455
456 456 self.__checkPath()
457 457
458 458 fullpath=path
459 459 print "%s folder was found: " %(fullpath )
460 460
461 461 if set == None:
462 462 self.set=None
463 463 filename =getlastFileFromPath(fullpath,ext)
464 464 startDate= datetime.datetime.utcnow().date
465 465 endDate= datetime.datetime.utcnow().date()
466 466 #
467 467 else:
468 468 filename= getFileFromSet(fullpath,ext,set)
469 469 startDate=None
470 470 endDate=None
471 471 #
472 472 if not (filename):
473 473 return None,None,None,None,None
474 474 #print "%s file was found" %(filename)
475 475
476 476 #
477 477 # dir_hf_filename= self.path+"/"+filename
478 478 # fp= h5py.File(dir_hf_filename,'r')
479 479 # hipoc=fp['t'].value
480 480 # fp.close()
481 481 # date_time=datetime.datetime.utcfromtimestamp(hipoc)
482 482 #
483 483 # year =int(date_time[0:4])
484 484 # month=int(date_time[5:7])
485 485 # dom =int(date_time[8:10])
486 486 # set= int(filename[4:10])
487 487 # self.set=set-1
488 488 #self.dirnameList=[filename]
489 489 filenameList= fullpath+"/"+filename
490 490 self.dirnameList=[filename]
491 491 self.filenameList=[filenameList]
492 492 self.flag_nextfile=True
493 493
494 494 #self.__findDataForDates(online=True)
495 495 #self.dirnameList=[self.dirnameList[-1]]
496 496 #print self.dirnameList
497 497 #self.__selectDataForTimes(online=True)
498 498 #return fullpath,filename,year,month,dom,set
499 499 return
500 500
501 501 def __setNextFile(self,online=False):
502 502 """
503 503 """
504 504 if not(online):
505 505 newFile = self.__setNextFileOffline()
506 506 else:
507 507 newFile = self.__setNextFileOnline()
508 508
509 509 if not(newFile):
510 510 return 0
511 511 return 1
512 512
513 513 def __setNextFileOffline(self):
514 514 """
515 515 """
516 516 idFile= self.fileIndex
517 517 while(True):
518 518 idFile += 1
519 519 if not (idFile < len(self.filenameList)):
520 520 self.flagNoMoreFiles = 1
521 521 print "No more Files"
522 522 return 0
523 523 filename = self.filenameList[idFile]
524 524 hfFilePointer =h5py.File(filename,'r')
525 525
526 526 epoc=hfFilePointer['t'].value
527 527 #this_time=datetime.datetime(year,month,dom,hour,min,sec)
528 528 break
529 529
530 530 self.flagIsNewFile = 1
531 531 self.fileIndex = idFile
532 532 self.filename = filename
533 533
534 534 self.hfFilePointer = hfFilePointer
535 535 hfFilePointer.close()
536 536 self.__t0=epoc
537 537 print "Setting the file: %s"%self.filename
538 538
539 539 return 1
540 540
541 541 def __setNextFileOnline(self):
542 542 """
543 543 """
544 544 print "SOY NONE",self.set
545 545 if self.set==None:
546 546 pass
547 547 else:
548 548 self.set +=10
549 549
550 550 filename = self.filenameList[0]#fullfilename
551 551 if self.filename_online != None:
552 552 self.__selectDataForTimes(online=True)
553 553 filename = self.filenameList[0]
554 554 while self.filename_online == filename:
555 555 print 'waiting %d seconds to get a new file...'%(self.__waitForNewFile)
556 556 time.sleep(self.__waitForNewFile)
557 557 #self.__findDataForDates(online=True)
558 558 self.set=self.filename_next_set
559 559 self.__selectDataForTimes(online=True)
560 560 filename = self.filenameList[0]
561 561 sizeoffile=os.path.getsize(filename)
562 562
563 563 #print filename
564 564 sizeoffile=os.path.getsize(filename)
565 565 if sizeoffile<1670240:
566 566 print "%s is not the rigth size"%filename
567 567 delay=50
568 568 print 'waiting %d seconds for delay...'%(delay)
569 569 time.sleep(delay)
570 570 sizeoffile=os.path.getsize(filename)
571 571 if sizeoffile<1670240:
572 572 delay=50
573 573 print 'waiting %d more seconds for delay...'%(delay)
574 574 time.sleep(delay)
575 575
576 576 sizeoffile=os.path.getsize(filename)
577 577 if sizeoffile<1670240:
578 578 delay=50
579 579 print 'waiting %d more seconds for delay...'%(delay)
580 580 time.sleep(delay)
581 581
582 582 try:
583 583 hfFilePointer=h5py.File(filename,'r')
584 584
585 585 except:
586 586 print "Error reading file %s"%filename
587 587
588 588 self.filename_online=filename
589 589 epoc=hfFilePointer['t'].value
590 590
591 591 self.hfFilePointer=hfFilePointer
592 592 hfFilePointer.close()
593 593 self.__t0=epoc
594 594
595 595
596 596 self.flagIsNewFile = 1
597 597 self.filename = filename
598 598
599 599 print "Setting the file: %s"%self.filename
600 600 return 1
601 601
602 602 def __getExpParameters(self):
603 603 if not(self.status):
604 604 return None
605 605
606 606 def setup(self,
607 607 path = None,
608 608 startDate = None,
609 609 endDate = None,
610 610 startTime = datetime.time(0,0,0),
611 611 endTime = datetime.time(23,59,59),
612 612 set = None,
613 613 expLabel = "",
614 614 ext = None,
615 615 all=0,
616 616 timezone=0,
617 617 online = False,
618 618 delay = 60,
619 619 walk = True):
620 620 '''
621 621 In this method we should set all initial parameters.
622 622
623 623 '''
624 624 if path==None:
625 625 raise ValueError,"The path is not valid"
626 626
627 627 if ext==None:
628 628 ext = self.ext
629 629
630 630 self.timezone= timezone
631 631 self.online= online
632 632 self.all=all
633 633 #if set==None:
634 634
635 635 #print set
636 636 if not(online):
637 637 print "Searching files in offline mode..."
638 638
639 self.__searchFilesOffline(path, startDate, endDate, ext, startTime, endTime, walk)
639 self.searchFilesOffLine(path, startDate, endDate, ext, startTime, endTime, walk)
640 640 else:
641 641 print "Searching files in online mode..."
642 self.__searchFilesOnline(path, walk,ext,set=set)
642 self.searchFilesOnLine(path, walk,ext,set=set)
643 643 if set==None:
644 644 pass
645 645 else:
646 646 self.set=set-10
647 647
648 648 # for nTries in range(self.nTries):
649 649 #
650 # fullpath,file,year,month,day,set = self.__searchFilesOnline(path=path,expLabel=expLabel,ext=ext, walk=walk,set=set)
650 # fullpath,file,year,month,day,set = self.searchFilesOnLine(path=path,expLabel=expLabel,ext=ext, walk=walk,set=set)
651 651 #
652 652 # if fullpath:
653 653 # break
654 654 # print '\tWaiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
655 655 # time.sleep(self.delay)
656 656 # if not(fullpath):
657 657 # print "There ins't valid files in %s" % path
658 658 # return None
659 659
660 660
661 661 if not(self.filenameList):
662 662 print "There is no files into the folder: %s"%(path)
663 663 sys.exit(-1)
664 664
665 665 self.__getExpParameters()
666 666
667 667
668 668 self.fileIndex = -1
669 669
670 670 self.__setNextFile(online)
671 671
672 672 self.__readMetadata()
673 673
674 674 self.__setLocalVariables()
675 675
676 676 self.__setHeaderDO()
677 677 #self.profileIndex_offset= 0
678 678
679 679 #self.profileIndex = self.profileIndex_offset
680 680
681 681 self.isConfig = True
682 682
683 683 def __readMetadata(self):
684 684 self.__readHeader()
685 685
686 686
687 687 def __setLocalVariables(self):
688 688
689 689 self.datablock = numpy.zeros((self.nChannels, self.nHeights,self.nProfiles), dtype = numpy.complex)
690 690 #
691 691
692 692
693 693
694 694 self.profileIndex = 9999
695 695
696 696
697 697 def __setHeaderDO(self):
698 698
699 699
700 700 self.dataOut.radarControllerHeaderObj = RadarControllerHeader()
701 701
702 702 self.dataOut.systemHeaderObj = SystemHeader()
703 703
704 704
705 705 #---------------------------------------------------------
706 706 self.dataOut.systemHeaderObj.nProfiles=100
707 707 self.dataOut.systemHeaderObj.nSamples=1000
708 708
709 709
710 710 SAMPLING_STRUCTURE=[('h0', '<f4'), ('dh', '<f4'), ('nsa', '<u4')]
711 711 self.dataOut.radarControllerHeaderObj.samplingWindow=numpy.zeros((1,),SAMPLING_STRUCTURE)
712 712 self.dataOut.radarControllerHeaderObj.samplingWindow['h0']=0
713 713 self.dataOut.radarControllerHeaderObj.samplingWindow['dh']=1.5
714 714 self.dataOut.radarControllerHeaderObj.samplingWindow['nsa']=1000
715 715 self.dataOut.radarControllerHeaderObj.nHeights=int(self.dataOut.radarControllerHeaderObj.samplingWindow['nsa'])
716 716 self.dataOut.radarControllerHeaderObj.firstHeight = self.dataOut.radarControllerHeaderObj.samplingWindow['h0']
717 717 self.dataOut.radarControllerHeaderObj.deltaHeight = self.dataOut.radarControllerHeaderObj.samplingWindow['dh']
718 718 self.dataOut.radarControllerHeaderObj.samplesWin = self.dataOut.radarControllerHeaderObj.samplingWindow['nsa']
719 719
720 720 self.dataOut.radarControllerHeaderObj.nWindows=1
721 721 self.dataOut.radarControllerHeaderObj.codetype=0
722 722 self.dataOut.radarControllerHeaderObj.numTaus=0
723 723 #self.dataOut.radarControllerHeaderObj.Taus = numpy.zeros((1,),'<f4')
724 724
725 725
726 726 #self.dataOut.radarControllerHeaderObj.nCode=numpy.zeros((1,), '<u4')
727 727 #self.dataOut.radarControllerHeaderObj.nBaud=numpy.zeros((1,), '<u4')
728 728 #self.dataOut.radarControllerHeaderObj.code=numpy.zeros(0)
729 729
730 730 self.dataOut.radarControllerHeaderObj.code_size=0
731 731 self.dataOut.nBaud=0
732 732 self.dataOut.nCode=0
733 733 self.dataOut.nPairs=0
734 734
735 735
736 736 #---------------------------------------------------------
737 737
738 738 self.dataOut.type = "Voltage"
739 739
740 740 self.dataOut.data = None
741 741
742 742 self.dataOut.dtype = numpy.dtype([('real','<f4'),('imag','<f4')])
743 743
744 744 self.dataOut.nProfiles = 1
745 745
746 746 self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
747 747
748 748 self.dataOut.channelList = range(self.nChannels)
749 749
750 750 #self.dataOut.channelIndexList = None
751 751
752 752 self.dataOut.flagNoData = True
753 753
754 754 #Set to TRUE if the data is discontinuous
755 755 self.dataOut.flagDiscontinuousBlock = False
756 756
757 757 self.dataOut.utctime = None
758 758
759 759 self.dataOut.timeZone = self.timezone
760 760
761 761 self.dataOut.dstFlag = 0
762 762
763 763 self.dataOut.errorCount = 0
764 764
765 765 self.dataOut.nCohInt = 1
766 766
767 767 self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights()
768 768
769 769 self.dataOut.flagDecodeData = False #asumo que la data esta decodificada
770 770
771 771 self.dataOut.flagDeflipData = False #asumo que la data esta sin flip
772 772
773 773 self.dataOut.flagShiftFFT = False
774 774
775 775 self.dataOut.ippSeconds = 1.0*self.__nSamples/self.__sample_rate
776 776
777 777 #Time interval between profiles
778 778 #self.dataOut.timeInterval =self.dataOut.ippSeconds * self.dataOut.nCohInt
779 779
780 780
781 781 self.dataOut.frequency = self.__frequency
782 782
783 783 self.dataOut.realtime = self.__online
784 784
785 785 def __hasNotDataInBuffer(self):
786 786
787 787 if self.profileIndex >= self.nProfiles:
788 788 return 1
789 789
790 790 return 0
791 791
792 792 def readNextBlock(self):
793 793 if not(self.__setNewBlock()):
794 794 return 0
795 795
796 796 if not(self.readBlock()):
797 797 return 0
798 798
799 799 return 1
800 800
801 801 def __setNewBlock(self):
802 802
803 803 if self.hfFilePointer==None:
804 804 return 0
805 805
806 806 if self.flagIsNewFile:
807 807 return 1
808 808
809 809 if self.profileIndex < self.nProfiles:
810 810 return 1
811 811
812 812 self.__setNextFile(self.online)
813 813
814 814 return 1
815 815
816 816
817 817
818 818 def readBlock(self):
819 819 fp=h5py.File(self.filename,'r')
820 820 #Puntero que apunta al archivo hdf5
821 821 ch0=(fp['ch0']).value #Primer canal (100,1000)--(perfiles,alturas)
822 822 ch1=(fp['ch1']).value #Segundo canal (100,1000)--(perfiles,alturas)
823 823 fp.close()
824 824 ch0= ch0.swapaxes(0,1) #Primer canal (100,1000)--(alturas,perfiles)
825 825 ch1= ch1.swapaxes(0,1) #Segundo canal (100,1000)--(alturas,perfiles)
826 826 self.datablock = numpy.array([ch0,ch1])
827 827 self.flagIsNewFile=0
828 828
829 829 self.profileIndex=0
830 830
831 831 return 1
832 832
833 833 def getData(self):
834 834 if self.flagNoMoreFiles:
835 835 self.dataOut.flagNoData = True
836 836 print 'Process finished'
837 837 return 0
838 838
839 839 if self.__hasNotDataInBuffer():
840 840 if not(self.readNextBlock()):
841 841 self.dataOut.flagNodata=True
842 842 return 0
843 843
844 844 ##############################
845 845 ##############################
846 846 self.dataOut.data = self.datablock[:,:,self.profileIndex]
847 847 self.dataOut.utctime = self.__t0 + self.dataOut.ippSeconds*self.profileIndex
848 848 self.dataOut.profileIndex= self.profileIndex
849 849 self.dataOut.flagNoData=False
850 850 self.profileIndex +=1
851 851
852 852 return self.dataOut.data
853 853
854 854
855 855 def run(self, **kwargs):
856 856 '''
857 857 This method will be called many times so here you should put all your code
858 858 '''
859 859
860 860 if not self.isConfig:
861 861 self.setup(**kwargs)
862 862 self.isConfig = True
863 863 self.getData()
Show file before | Show file after | Hide comments
@@ -1,675 +1,675
1 1 '''
2 2 Created on Set 9, 2015
3 3
4 4 @author: roj-idl71 Karim Kuyeng
5 5 '''
6 6
7 7 import os
8 8 import sys
9 9 import glob
10 10 import fnmatch
11 11 import datetime
12 12 import time
13 13 import re
14 14 import h5py
15 15 import numpy
16 16
17 17 try:
18 18 from gevent import sleep
19 19 except:
20 20 from time import sleep
21 21
22 22 from schainpy.model.data.jroheaderIO import RadarControllerHeader, SystemHeader
23 23 from schainpy.model.data.jrodata import Voltage
24 24 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
25 25 from numpy import imag
26 26
27 27 class AMISRReader(ProcessingUnit):
28 28 '''
29 29 classdocs
30 30 '''
31 31
32 32 def __init__(self):
33 33 '''
34 34 Constructor
35 35 '''
36 36
37 37 ProcessingUnit.__init__(self)
38 38
39 39 self.set = None
40 40 self.subset = None
41 41 self.extension_file = '.h5'
42 42 self.dtc_str = 'dtc'
43 43 self.dtc_id = 0
44 44 self.status = True
45 45 self.isConfig = False
46 46 self.dirnameList = []
47 47 self.filenameList = []
48 48 self.fileIndex = None
49 49 self.flagNoMoreFiles = False
50 50 self.flagIsNewFile = 0
51 51 self.filename = ''
52 52 self.amisrFilePointer = None
53 53
54 54
55 55 self.dataset = None
56 56
57 57
58 58
59 59
60 60 self.profileIndex = 0
61 61
62 62
63 63 self.beamCodeByFrame = None
64 64 self.radacTimeByFrame = None
65 65
66 66 self.dataset = None
67 67
68 68
69 69
70 70
71 71 self.__firstFile = True
72 72
73 73 self.buffer = None
74 74
75 75
76 76 self.timezone = 'ut'
77 77
78 78 self.__waitForNewFile = 20
79 79 self.__filename_online = None
80 80 #Is really necessary create the output object in the initializer
81 81 self.dataOut = Voltage()
82 82
83 83 def setup(self,path=None,
84 84 startDate=None,
85 85 endDate=None,
86 86 startTime=None,
87 87 endTime=None,
88 88 walk=True,
89 89 timezone='ut',
90 90 all=0,
91 91 code = None,
92 92 nCode = 0,
93 93 nBaud = 0,
94 94 online=False):
95 95
96 96 self.timezone = timezone
97 97 self.all = all
98 98 self.online = online
99 99
100 100 self.code = code
101 101 self.nCode = int(nCode)
102 102 self.nBaud = int(nBaud)
103 103
104 104
105 105
106 106 #self.findFiles()
107 107 if not(online):
108 108 #Busqueda de archivos offline
109 self.__searchFilesOffline(path, startDate, endDate, startTime, endTime, walk)
109 self.searchFilesOffLine(path, startDate, endDate, startTime, endTime, walk)
110 110 else:
111 self.__searchFilesOnline(path, startDate, endDate, startTime,endTime,walk)
111 self.searchFilesOnLine(path, startDate, endDate, startTime,endTime,walk)
112 112
113 113 if not(self.filenameList):
114 114 print "There is no files into the folder: %s"%(path)
115 115
116 116 sys.exit(-1)
117 117
118 118 self.fileIndex = -1
119 119
120 120 self.readNextFile(online)
121 121
122 122 '''
123 123 Add code
124 124 '''
125 125 self.isConfig = True
126 126
127 127 pass
128 128
129 129
130 130 def readAMISRHeader(self,fp):
131 131 header = 'Raw11/Data/RadacHeader'
132 132 self.beamCodeByPulse = fp.get(header+'/BeamCode') # LIST OF BEAMS PER PROFILE, TO BE USED ON REARRANGE
133 133 self.beamCode = fp.get('Raw11/Data/Beamcodes') # NUMBER OF CHANNELS AND IDENTIFY POSITION TO CREATE A FILE WITH THAT INFO
134 134 #self.code = fp.get(header+'/Code') # NOT USE FOR THIS
135 135 self.frameCount = fp.get(header+'/FrameCount')# NOT USE FOR THIS
136 136 self.modeGroup = fp.get(header+'/ModeGroup')# NOT USE FOR THIS
137 137 self.nsamplesPulse = fp.get(header+'/NSamplesPulse')# TO GET NSA OR USING DATA FOR THAT
138 138 self.pulseCount = fp.get(header+'/PulseCount')# NOT USE FOR THIS
139 139 self.radacTime = fp.get(header+'/RadacTime')# 1st TIME ON FILE ANDE CALCULATE THE REST WITH IPP*nindexprofile
140 140 self.timeCount = fp.get(header+'/TimeCount')# NOT USE FOR THIS
141 141 self.timeStatus = fp.get(header+'/TimeStatus')# NOT USE FOR THIS
142 142 self.rangeFromFile = fp.get('Raw11/Data/Samples/Range')
143 143 self.frequency = fp.get('Rx/Frequency')
144 144 txAus = fp.get('Raw11/Data/Pulsewidth')
145 145
146 146
147 147 self.nblocks = self.pulseCount.shape[0] #nblocks
148 148
149 149 self.nprofiles = self.pulseCount.shape[1] #nprofile
150 150 self.nsa = self.nsamplesPulse[0,0] #ngates
151 151 self.nchannels = self.beamCode.shape[1]
152 152 self.ippSeconds = (self.radacTime[0][1] -self.radacTime[0][0]) #Ipp in seconds
153 153 #self.__waitForNewFile = self.nblocks # wait depending on the number of blocks since each block is 1 sec
154 154 self.__waitForNewFile = self.nblocks * self.nprofiles * self.ippSeconds # wait until new file is created
155 155
156 156 #filling radar controller header parameters
157 157 self.__ippKm = self.ippSeconds *.15*1e6 # in km
158 158 self.__txA = (txAus.value)*.15 #(ipp[us]*.15km/1us) in km
159 159 self.__txB = 0
160 160 nWindows=1
161 161 self.__nSamples = self.nsa
162 162 self.__firstHeight = self.rangeFromFile[0][0]/1000 #in km
163 163 self.__deltaHeight = (self.rangeFromFile[0][1] - self.rangeFromFile[0][0])/1000
164 164
165 165 #for now until understand why the code saved is different (code included even though code not in tuf file)
166 166 #self.__codeType = 0
167 167 # self.__nCode = None
168 168 # self.__nBaud = None
169 169 self.__code = self.code
170 170 self.__codeType = 0
171 171 if self.code != None:
172 172 self.__codeType = 1
173 173 self.__nCode = self.nCode
174 174 self.__nBaud = self.nBaud
175 175 #self.__code = 0
176 176
177 177 #filling system header parameters
178 178 self.__nSamples = self.nsa
179 179 self.newProfiles = self.nprofiles/self.nchannels
180 180 self.__channelList = range(self.nchannels)
181 181
182 182 self.__frequency = self.frequency[0][0]
183 183
184 184
185 185
186 186 def createBuffers(self):
187 187
188 188 pass
189 189
190 190 def __setParameters(self,path='', startDate='',endDate='',startTime='', endTime='', walk=''):
191 191 self.path = path
192 192 self.startDate = startDate
193 193 self.endDate = endDate
194 194 self.startTime = startTime
195 195 self.endTime = endTime
196 196 self.walk = walk
197 197
198 198 def __checkPath(self):
199 199 if os.path.exists(self.path):
200 200 self.status = 1
201 201 else:
202 202 self.status = 0
203 203 print 'Path:%s does not exists'%self.path
204 204
205 205 return
206 206
207 207
208 208 def __selDates(self, amisr_dirname_format):
209 209 try:
210 210 year = int(amisr_dirname_format[0:4])
211 211 month = int(amisr_dirname_format[4:6])
212 212 dom = int(amisr_dirname_format[6:8])
213 213 thisDate = datetime.date(year,month,dom)
214 214
215 215 if (thisDate>=self.startDate and thisDate <= self.endDate):
216 216 return amisr_dirname_format
217 217 except:
218 218 return None
219 219
220 220
221 221 def __findDataForDates(self,online=False):
222 222
223 223 if not(self.status):
224 224 return None
225 225
226 226 pat = '\d+.\d+'
227 227 dirnameList = [re.search(pat,x) for x in os.listdir(self.path)]
228 228 dirnameList = filter(lambda x:x!=None,dirnameList)
229 229 dirnameList = [x.string for x in dirnameList]
230 230 if not(online):
231 231 dirnameList = [self.__selDates(x) for x in dirnameList]
232 232 dirnameList = filter(lambda x:x!=None,dirnameList)
233 233 if len(dirnameList)>0:
234 234 self.status = 1
235 235 self.dirnameList = dirnameList
236 236 self.dirnameList.sort()
237 237 else:
238 238 self.status = 0
239 239 return None
240 240
241 241 def __getTimeFromData(self):
242 242 startDateTime_Reader = datetime.datetime.combine(self.startDate,self.startTime)
243 243 endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
244 244
245 245 print 'Filtering Files from %s to %s'%(startDateTime_Reader, endDateTime_Reader)
246 246 print '........................................'
247 247 filter_filenameList = []
248 248 self.filenameList.sort()
249 249 #for i in range(len(self.filenameList)-1):
250 250 for i in range(len(self.filenameList)):
251 251 filename = self.filenameList[i]
252 252 fp = h5py.File(filename,'r')
253 253 time_str = fp.get('Time/RadacTimeString')
254 254
255 255 startDateTimeStr_File = time_str[0][0].split('.')[0]
256 256 junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
257 257 startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
258 258
259 259 endDateTimeStr_File = time_str[-1][-1].split('.')[0]
260 260 junk = time.strptime(endDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
261 261 endDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
262 262
263 263 fp.close()
264 264
265 265 if self.timezone == 'lt':
266 266 startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300)
267 267 endDateTime_File = endDateTime_File - datetime.timedelta(minutes = 300)
268 268
269 269 if (endDateTime_File>=startDateTime_Reader and endDateTime_File<endDateTime_Reader):
270 270 #self.filenameList.remove(filename)
271 271 filter_filenameList.append(filename)
272 272
273 273 if (endDateTime_File>=endDateTime_Reader):
274 274 break
275 275
276 276
277 277 filter_filenameList.sort()
278 278 self.filenameList = filter_filenameList
279 279 return 1
280 280
281 281 def __filterByGlob1(self, dirName):
282 282 filter_files = glob.glob1(dirName, '*.*%s'%self.extension_file)
283 283 filter_files.sort()
284 284 filterDict = {}
285 285 filterDict.setdefault(dirName)
286 286 filterDict[dirName] = filter_files
287 287 return filterDict
288 288
289 289 def __getFilenameList(self, fileListInKeys, dirList):
290 290 for value in fileListInKeys:
291 291 dirName = value.keys()[0]
292 292 for file in value[dirName]:
293 293 filename = os.path.join(dirName, file)
294 294 self.filenameList.append(filename)
295 295
296 296
297 297 def __selectDataForTimes(self, online=False):
298 298 #aun no esta implementado el filtro for tiempo
299 299 if not(self.status):
300 300 return None
301 301
302 302 dirList = [os.path.join(self.path,x) for x in self.dirnameList]
303 303
304 304 fileListInKeys = [self.__filterByGlob1(x) for x in dirList]
305 305
306 306 self.__getFilenameList(fileListInKeys, dirList)
307 307 if not(online):
308 308 #filtro por tiempo
309 309 if not(self.all):
310 310 self.__getTimeFromData()
311 311
312 312 if len(self.filenameList)>0:
313 313 self.status = 1
314 314 self.filenameList.sort()
315 315 else:
316 316 self.status = 0
317 317 return None
318 318
319 319 else:
320 320 #get the last file - 1
321 321 self.filenameList = [self.filenameList[-2]]
322 322
323 323 new_dirnameList = []
324 324 for dirname in self.dirnameList:
325 325 junk = numpy.array([dirname in x for x in self.filenameList])
326 326 junk_sum = junk.sum()
327 327 if junk_sum > 0:
328 328 new_dirnameList.append(dirname)
329 329 self.dirnameList = new_dirnameList
330 330 return 1
331 331
332 def __searchFilesOnline(self, path, startDate, endDate, startTime=datetime.time(0,0,0),
332 def searchFilesOnLine(self, path, startDate, endDate, startTime=datetime.time(0,0,0),
333 333 endTime=datetime.time(23,59,59),walk=True):
334 334
335 335 if endDate ==None:
336 336 startDate = datetime.datetime.utcnow().date()
337 337 endDate = datetime.datetime.utcnow().date()
338 338
339 339 self.__setParameters(path=path, startDate=startDate, endDate=endDate,startTime = startTime,endTime=endTime, walk=walk)
340 340
341 341 self.__checkPath()
342 342
343 343 self.__findDataForDates(online=True)
344 344
345 345 self.dirnameList = [self.dirnameList[-1]]
346 346
347 347 self.__selectDataForTimes(online=True)
348 348
349 349 return
350 350
351 351
352 def __searchFilesOffline(self,
352 def searchFilesOffLine(self,
353 353 path,
354 354 startDate,
355 355 endDate,
356 356 startTime=datetime.time(0,0,0),
357 357 endTime=datetime.time(23,59,59),
358 358 walk=True):
359 359
360 360 self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
361 361
362 362 self.__checkPath()
363 363
364 364 self.__findDataForDates()
365 365
366 366 self.__selectDataForTimes()
367 367
368 368 for i in range(len(self.filenameList)):
369 369 print "%s" %(self.filenameList[i])
370 370
371 371 return
372 372
373 373 def __setNextFileOffline(self):
374 374 idFile = self.fileIndex
375 375
376 376 while (True):
377 377 idFile += 1
378 378 if not(idFile < len(self.filenameList)):
379 379 self.flagNoMoreFiles = 1
380 380 print "No more Files"
381 381 return 0
382 382
383 383 filename = self.filenameList[idFile]
384 384
385 385 amisrFilePointer = h5py.File(filename,'r')
386 386
387 387 break
388 388
389 389 self.flagIsNewFile = 1
390 390 self.fileIndex = idFile
391 391 self.filename = filename
392 392
393 393 self.amisrFilePointer = amisrFilePointer
394 394
395 395 print "Setting the file: %s"%self.filename
396 396
397 397 return 1
398 398
399 399
400 400 def __setNextFileOnline(self):
401 401 filename = self.filenameList[0]
402 402 if self.__filename_online != None:
403 403 self.__selectDataForTimes(online=True)
404 404 filename = self.filenameList[0]
405 405 wait = 0
406 406 while self.__filename_online == filename:
407 407 print 'waiting %d seconds to get a new file...'%(self.__waitForNewFile)
408 408 if wait == 5:
409 409 return 0
410 410 sleep(self.__waitForNewFile)
411 411 self.__selectDataForTimes(online=True)
412 412 filename = self.filenameList[0]
413 413 wait += 1
414 414
415 415 self.__filename_online = filename
416 416
417 417 self.amisrFilePointer = h5py.File(filename,'r')
418 418 self.flagIsNewFile = 1
419 419 self.filename = filename
420 420 print "Setting the file: %s"%self.filename
421 421 return 1
422 422
423 423
424 424 def readData(self):
425 425 buffer = self.amisrFilePointer.get('Raw11/Data/Samples/Data')
426 426 re = buffer[:,:,:,0]
427 427 im = buffer[:,:,:,1]
428 428 dataset = re + im*1j
429 429 self.radacTime = self.amisrFilePointer.get('Raw11/Data/RadacHeader/RadacTime')
430 430 timeset = self.radacTime[:,0]
431 431 return dataset,timeset
432 432
433 433 def reshapeData(self):
434 434 #self.beamCodeByPulse, self.beamCode, self.nblocks, self.nprofiles, self.nsa,
435 435 channels = self.beamCodeByPulse[0,:]
436 436 nchan = self.nchannels
437 437 #self.newProfiles = self.nprofiles/nchan #must be defined on filljroheader
438 438 nblocks = self.nblocks
439 439 nsamples = self.nsa
440 440
441 441 #Dimensions : nChannels, nProfiles, nSamples
442 442 new_block = numpy.empty((nblocks, nchan, self.newProfiles, nsamples), dtype="complex64")
443 443 ############################################
444 444
445 445 for thisChannel in range(nchan):
446 446 new_block[:,thisChannel,:,:] = self.dataset[:,numpy.where(channels==self.beamCode[0][thisChannel])[0],:]
447 447
448 448
449 449 new_block = numpy.transpose(new_block, (1,0,2,3))
450 450 new_block = numpy.reshape(new_block, (nchan,-1, nsamples))
451 451
452 452 return new_block
453 453
454 454 def updateIndexes(self):
455 455
456 456 pass
457 457
458 458 def fillJROHeader(self):
459 459
460 460 #fill radar controller header
461 461 self.dataOut.radarControllerHeaderObj = RadarControllerHeader(ippKm=self.__ippKm,
462 462 txA=self.__txA,
463 463 txB=0,
464 464 nWindows=1,
465 465 nHeights=self.__nSamples,
466 466 firstHeight=self.__firstHeight,
467 467 deltaHeight=self.__deltaHeight,
468 468 codeType=self.__codeType,
469 469 nCode=self.__nCode, nBaud=self.__nBaud,
470 470 code = self.__code,
471 471 fClock=1)
472 472
473 473
474 474
475 475 #fill system header
476 476 self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
477 477 nProfiles=self.newProfiles,
478 478 nChannels=len(self.__channelList),
479 479 adcResolution=14,
480 480 pciDioBusWith=32)
481 481
482 482 self.dataOut.type = "Voltage"
483 483
484 484 self.dataOut.data = None
485 485
486 486 self.dataOut.dtype = numpy.dtype([('real','<i8'),('imag','<i8')])
487 487
488 488 # self.dataOut.nChannels = 0
489 489
490 490 # self.dataOut.nHeights = 0
491 491
492 492 self.dataOut.nProfiles = self.newProfiles*self.nblocks
493 493
494 494 #self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
495 495 ranges = numpy.reshape(self.rangeFromFile.value,(-1))
496 496 self.dataOut.heightList = ranges/1000.0 #km
497 497
498 498
499 499 self.dataOut.channelList = self.__channelList
500 500
501 501 self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights()
502 502
503 503 # self.dataOut.channelIndexList = None
504 504
505 505 self.dataOut.flagNoData = True
506 506
507 507 #Set to TRUE if the data is discontinuous
508 508 self.dataOut.flagDiscontinuousBlock = False
509 509
510 510 self.dataOut.utctime = None
511 511
512 512 #self.dataOut.timeZone = -5 #self.__timezone/60 #timezone like jroheader, difference in minutes between UTC and localtime
513 513 if self.timezone == 'lt':
514 514 self.dataOut.timeZone = time.timezone / 60. #get the timezone in minutes
515 515 else:
516 516 self.dataOut.timeZone = 0 #by default time is UTC
517 517
518 518 self.dataOut.dstFlag = 0
519 519
520 520 self.dataOut.errorCount = 0
521 521
522 522 self.dataOut.nCohInt = 1
523 523
524 524 self.dataOut.flagDecodeData = False #asumo que la data esta decodificada
525 525
526 526 self.dataOut.flagDeflipData = False #asumo que la data esta sin flip
527 527
528 528 self.dataOut.flagShiftFFT = False
529 529
530 530 self.dataOut.ippSeconds = self.ippSeconds
531 531
532 532 #Time interval between profiles
533 533 #self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
534 534
535 535 self.dataOut.frequency = self.__frequency
536 536
537 537 self.dataOut.realtime = self.online
538 538 pass
539 539
540 540 def readNextFile(self,online=False):
541 541
542 542 if not(online):
543 543 newFile = self.__setNextFileOffline()
544 544 else:
545 545 newFile = self.__setNextFileOnline()
546 546
547 547 if not(newFile):
548 548 return 0
549 549
550 550 #if self.__firstFile:
551 551 self.readAMISRHeader(self.amisrFilePointer)
552 552 self.createBuffers()
553 553 self.fillJROHeader()
554 554 #self.__firstFile = False
555 555
556 556
557 557
558 558 self.dataset,self.timeset = self.readData()
559 559
560 560 if self.endDate!=None:
561 561 endDateTime_Reader = datetime.datetime.combine(self.endDate,self.endTime)
562 562 time_str = self.amisrFilePointer.get('Time/RadacTimeString')
563 563 startDateTimeStr_File = time_str[0][0].split('.')[0]
564 564 junk = time.strptime(startDateTimeStr_File, '%Y-%m-%d %H:%M:%S')
565 565 startDateTime_File = datetime.datetime(junk.tm_year,junk.tm_mon,junk.tm_mday,junk.tm_hour, junk.tm_min, junk.tm_sec)
566 566 if self.timezone == 'lt':
567 567 startDateTime_File = startDateTime_File - datetime.timedelta(minutes = 300)
568 568 if (startDateTime_File>endDateTime_Reader):
569 569 return 0
570 570
571 571 self.jrodataset = self.reshapeData()
572 572 #----self.updateIndexes()
573 573 self.profileIndex = 0
574 574
575 575 return 1
576 576
577 577
578 578 def __hasNotDataInBuffer(self):
579 579 if self.profileIndex >= (self.newProfiles*self.nblocks):
580 580 return 1
581 581 return 0
582 582
583 583
584 584 def getData(self):
585 585
586 586 if self.flagNoMoreFiles:
587 587 self.dataOut.flagNoData = True
588 588 print 'Process finished'
589 589 return 0
590 590
591 591 if self.__hasNotDataInBuffer():
592 592 if not (self.readNextFile(self.online)):
593 593 return 0
594 594
595 595
596 596 if self.dataset is None: # setear esta condicion cuando no hayan datos por leers
597 597 self.dataOut.flagNoData = True
598 598 return 0
599 599
600 600 #self.dataOut.data = numpy.reshape(self.jrodataset[self.profileIndex,:],(1,-1))
601 601
602 602 self.dataOut.data = self.jrodataset[:,self.profileIndex,:]
603 603
604 604 #self.dataOut.utctime = self.jrotimeset[self.profileIndex]
605 605 #verificar basic header de jro data y ver si es compatible con este valor
606 606 #self.dataOut.utctime = self.timeset + (self.profileIndex * self.ippSeconds * self.nchannels)
607 607 indexprof = numpy.mod(self.profileIndex, self.newProfiles)
608 608 indexblock = self.profileIndex/self.newProfiles
609 609 #print indexblock, indexprof
610 610 self.dataOut.utctime = self.timeset[indexblock] + (indexprof * self.ippSeconds * self.nchannels)
611 611 self.dataOut.profileIndex = self.profileIndex
612 612 self.dataOut.flagNoData = False
613 613 # if indexprof == 0:
614 614 # print self.dataOut.utctime
615 615
616 616 self.profileIndex += 1
617 617
618 618 return self.dataOut.data
619 619
620 620
621 621 def run(self, **kwargs):
622 622 '''
623 623 This method will be called many times so here you should put all your code
624 624 '''
625 625
626 626 if not self.isConfig:
627 627 self.setup(**kwargs)
628 628 self.isConfig = True
629 629
630 630 self.getData()
631 631
632 632 class Writer(Operation):
633 633 '''
634 634 classdocs
635 635 '''
636 636
637 637 def __init__(self):
638 638 '''
639 639 Constructor
640 640 '''
641 641 self.dataOut = None
642 642
643 643 self.isConfig = False
644 644
645 645 def setup(self, dataIn, path, blocksPerFile, set=0, ext=None):
646 646 '''
647 647 In this method we should set all initial parameters.
648 648
649 649 Input:
650 650 dataIn : Input data will also be outputa data
651 651
652 652 '''
653 653 self.dataOut = dataIn
654 654
655 655
656 656
657 657
658 658
659 659 self.isConfig = True
660 660
661 661 return
662 662
663 663 def run(self, dataIn, **kwargs):
664 664 '''
665 665 This method will be called many times so here you should put all your code
666 666
667 667 Inputs:
668 668
669 669 dataIn : object with the data
670 670
671 671 '''
672 672
673 673 if not self.isConfig:
674 674 self.setup(dataIn, **kwargs)
675 675 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,1095 +1,1095
1 1 import numpy
2 2 import time
3 3 import os
4 4 import h5py
5 5 import re
6 6 import datetime
7 7
8 8 from schainpy.model.data.jrodata import *
9 9 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
10 10 # from jroIO_base import *
11 11 from schainpy.model.io.jroIO_base import *
12 12 import schainpy
13 13
14 14
15 15 class ParamReader(ProcessingUnit):
16 16 '''
17 17 Reads HDF5 format files
18 18
19 19 path
20 20
21 21 startDate
22 22
23 23 endDate
24 24
25 25 startTime
26 26
27 27 endTime
28 28 '''
29 29
30 30 ext = ".hdf5"
31 31
32 32 optchar = "D"
33 33
34 34 timezone = None
35 35
36 36 startTime = None
37 37
38 38 endTime = None
39 39
40 40 fileIndex = None
41 41
42 42 utcList = None #To select data in the utctime list
43 43
44 44 blockList = None #List to blocks to be read from the file
45 45
46 46 blocksPerFile = None #Number of blocks to be read
47 47
48 48 blockIndex = None
49 49
50 50 path = None
51 51
52 52 #List of Files
53 53
54 54 filenameList = None
55 55
56 56 datetimeList = None
57 57
58 58 #Hdf5 File
59 59
60 60 listMetaname = None
61 61
62 62 listMeta = None
63 63
64 64 listDataname = None
65 65
66 66 listData = None
67 67
68 68 listShapes = None
69 69
70 70 fp = None
71 71
72 72 #dataOut reconstruction
73 73
74 74 dataOut = None
75 75
76 76
77 77 def __init__(self, **kwargs):
78 78 ProcessingUnit.__init__(self, **kwargs)
79 79 self.dataOut = Parameters()
80 80 return
81 81
82 82 def setup(self, **kwargs):
83 83
84 84 path = kwargs['path']
85 85 startDate = kwargs['startDate']
86 86 endDate = kwargs['endDate']
87 87 startTime = kwargs['startTime']
88 88 endTime = kwargs['endTime']
89 89 walk = kwargs['walk']
90 90 if kwargs.has_key('ext'):
91 91 ext = kwargs['ext']
92 92 else:
93 93 ext = '.hdf5'
94 94 if kwargs.has_key('timezone'):
95 95 self.timezone = kwargs['timezone']
96 96 else:
97 97 self.timezone = 'lt'
98 98
99 99 print "[Reading] Searching files in offline mode ..."
100 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
100 pathList, filenameList = self.searchFilesOffLine(path, startDate=startDate, endDate=endDate,
101 101 startTime=startTime, endTime=endTime,
102 102 ext=ext, walk=walk)
103 103
104 104 if not(filenameList):
105 105 print "There is no files into the folder: %s"%(path)
106 106 sys.exit(-1)
107 107
108 108 self.fileIndex = -1
109 109 self.startTime = startTime
110 110 self.endTime = endTime
111 111
112 112 self.__readMetadata()
113 113
114 114 self.__setNextFileOffline()
115 115
116 116 return
117 117
118 def __searchFilesOffLine(self,
118 def searchFilesOffLine(self,
119 119 path,
120 120 startDate=None,
121 121 endDate=None,
122 122 startTime=datetime.time(0,0,0),
123 123 endTime=datetime.time(23,59,59),
124 124 ext='.hdf5',
125 125 walk=True):
126 126
127 127 expLabel = ''
128 128 self.filenameList = []
129 129 self.datetimeList = []
130 130
131 131 pathList = []
132 132
133 133 JRODataObj = JRODataReader()
134 134 dateList, pathList = JRODataObj.findDatafiles(path, startDate, endDate, expLabel, ext, walk, include_path=True)
135 135
136 136 if dateList == []:
137 137 print "[Reading] No *%s files in %s from %s to %s)"%(ext, path,
138 138 datetime.datetime.combine(startDate,startTime).ctime(),
139 139 datetime.datetime.combine(endDate,endTime).ctime())
140 140
141 141 return None, None
142 142
143 143 if len(dateList) > 1:
144 144 print "[Reading] %d days were found in date range: %s - %s" %(len(dateList), startDate, endDate)
145 145 else:
146 146 print "[Reading] data was found for the date %s" %(dateList[0])
147 147
148 148 filenameList = []
149 149 datetimeList = []
150 150
151 151 #----------------------------------------------------------------------------------
152 152
153 153 for thisPath in pathList:
154 154 # thisPath = pathList[pathDict[file]]
155 155
156 156 fileList = glob.glob1(thisPath, "*%s" %ext)
157 157 fileList.sort()
158 158
159 159 for file in fileList:
160 160
161 161 filename = os.path.join(thisPath,file)
162 162
163 163 if not isFileInDateRange(filename, startDate, endDate):
164 164 continue
165 165
166 166 thisDatetime = self.__isFileInTimeRange(filename, startDate, endDate, startTime, endTime)
167 167
168 168 if not(thisDatetime):
169 169 continue
170 170
171 171 filenameList.append(filename)
172 172 datetimeList.append(thisDatetime)
173 173
174 174 if not(filenameList):
175 175 print "[Reading] Any file was found int time range %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
176 176 return None, None
177 177
178 178 print "[Reading] %d file(s) was(were) found in time range: %s - %s" %(len(filenameList), startTime, endTime)
179 179 print
180 180
181 181 for i in range(len(filenameList)):
182 182 print "[Reading] %s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
183 183
184 184 self.filenameList = filenameList
185 185 self.datetimeList = datetimeList
186 186
187 187 return pathList, filenameList
188 188
189 189 def __isFileInTimeRange(self,filename, startDate, endDate, startTime, endTime):
190 190
191 191 """
192 192 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
193 193
194 194 Inputs:
195 195 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
196 196
197 197 startDate : fecha inicial del rango seleccionado en formato datetime.date
198 198
199 199 endDate : fecha final del rango seleccionado en formato datetime.date
200 200
201 201 startTime : tiempo inicial del rango seleccionado en formato datetime.time
202 202
203 203 endTime : tiempo final del rango seleccionado en formato datetime.time
204 204
205 205 Return:
206 206 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
207 207 fecha especificado, de lo contrario retorna False.
208 208
209 209 Excepciones:
210 210 Si el archivo no existe o no puede ser abierto
211 211 Si la cabecera no puede ser leida.
212 212
213 213 """
214 214
215 215 try:
216 216 fp = h5py.File(filename,'r')
217 217 grp1 = fp['Data']
218 218
219 219 except IOError:
220 220 traceback.print_exc()
221 221 raise IOError, "The file %s can't be opened" %(filename)
222 222 #chino rata
223 223 #In case has utctime attribute
224 224 grp2 = grp1['utctime']
225 225 # thisUtcTime = grp2.value[0] - 5*3600 #To convert to local time
226 226 thisUtcTime = grp2.value[0]
227 227
228 228 fp.close()
229 229
230 230 if self.timezone == 'lt':
231 231 thisUtcTime -= 5*3600
232 232
233 233 thisDatetime = datetime.datetime.fromtimestamp(thisUtcTime[0] + 5*3600)
234 234 # thisDatetime = datetime.datetime.fromtimestamp(thisUtcTime[0])
235 235 thisDate = thisDatetime.date()
236 236 thisTime = thisDatetime.time()
237 237
238 238 startUtcTime = (datetime.datetime.combine(thisDate,startTime)- datetime.datetime(1970, 1, 1)).total_seconds()
239 239 endUtcTime = (datetime.datetime.combine(thisDate,endTime)- datetime.datetime(1970, 1, 1)).total_seconds()
240 240
241 241 #General case
242 242 # o>>>>>>>>>>>>>><<<<<<<<<<<<<<o
243 243 #-----------o----------------------------o-----------
244 244 # startTime endTime
245 245
246 246 if endTime >= startTime:
247 247 thisUtcLog = numpy.logical_and(thisUtcTime > startUtcTime, thisUtcTime < endUtcTime)
248 248 if numpy.any(thisUtcLog): #If there is one block between the hours mentioned
249 249 return thisDatetime
250 250 return None
251 251
252 252 #If endTime < startTime then endTime belongs to the next day
253 253 #<<<<<<<<<<<o o>>>>>>>>>>>
254 254 #-----------o----------------------------o-----------
255 255 # endTime startTime
256 256
257 257 if (thisDate == startDate) and numpy.all(thisUtcTime < startUtcTime):
258 258 return None
259 259
260 260 if (thisDate == endDate) and numpy.all(thisUtcTime > endUtcTime):
261 261 return None
262 262
263 263 if numpy.all(thisUtcTime < startUtcTime) and numpy.all(thisUtcTime > endUtcTime):
264 264 return None
265 265
266 266 return thisDatetime
267 267
268 268 def __setNextFileOffline(self):
269 269
270 270 self.fileIndex += 1
271 271 idFile = self.fileIndex
272 272
273 273 if not(idFile < len(self.filenameList)):
274 274 print "No more Files"
275 275 return 0
276 276
277 277 filename = self.filenameList[idFile]
278 278
279 279 filePointer = h5py.File(filename,'r')
280 280
281 281 self.filename = filename
282 282
283 283 self.fp = filePointer
284 284
285 285 print "Setting the file: %s"%self.filename
286 286
287 287 # self.__readMetadata()
288 288 self.__setBlockList()
289 289 self.__readData()
290 290 # self.nRecords = self.fp['Data'].attrs['blocksPerFile']
291 291 # self.nRecords = self.fp['Data'].attrs['nRecords']
292 292 self.blockIndex = 0
293 293 return 1
294 294
295 295 def __setBlockList(self):
296 296 '''
297 297 Selects the data within the times defined
298 298
299 299 self.fp
300 300 self.startTime
301 301 self.endTime
302 302
303 303 self.blockList
304 304 self.blocksPerFile
305 305
306 306 '''
307 307 fp = self.fp
308 308 startTime = self.startTime
309 309 endTime = self.endTime
310 310
311 311 grp = fp['Data']
312 312 thisUtcTime = grp['utctime'].value.astype(numpy.float)[0]
313 313
314 314 #ERROOOOR
315 315 if self.timezone == 'lt':
316 316 thisUtcTime -= 5*3600
317 317
318 318 thisDatetime = datetime.datetime.fromtimestamp(thisUtcTime[0] + 5*3600)
319 319
320 320 thisDate = thisDatetime.date()
321 321 thisTime = thisDatetime.time()
322 322
323 323 startUtcTime = (datetime.datetime.combine(thisDate,startTime) - datetime.datetime(1970, 1, 1)).total_seconds()
324 324 endUtcTime = (datetime.datetime.combine(thisDate,endTime) - datetime.datetime(1970, 1, 1)).total_seconds()
325 325
326 326 ind = numpy.where(numpy.logical_and(thisUtcTime >= startUtcTime, thisUtcTime < endUtcTime))[0]
327 327
328 328 self.blockList = ind
329 329 self.blocksPerFile = len(ind)
330 330
331 331 return
332 332
333 333 def __readMetadata(self):
334 334 '''
335 335 Reads Metadata
336 336
337 337 self.pathMeta
338 338
339 339 self.listShapes
340 340 self.listMetaname
341 341 self.listMeta
342 342
343 343 '''
344 344
345 345 # grp = self.fp['Data']
346 346 # pathMeta = os.path.join(self.path, grp.attrs['metadata'])
347 347 #
348 348 # if pathMeta == self.pathMeta:
349 349 # return
350 350 # else:
351 351 # self.pathMeta = pathMeta
352 352 #
353 353 # filePointer = h5py.File(self.pathMeta,'r')
354 354 # groupPointer = filePointer['Metadata']
355 355
356 356 filename = self.filenameList[0]
357 357
358 358 fp = h5py.File(filename,'r')
359 359
360 360 gp = fp['Metadata']
361 361
362 362 listMetaname = []
363 363 listMetadata = []
364 364 for item in gp.items():
365 365 name = item[0]
366 366
367 367 if name=='array dimensions':
368 368 table = gp[name][:]
369 369 listShapes = {}
370 370 for shapes in table:
371 371 listShapes[shapes[0]] = numpy.array([shapes[1],shapes[2],shapes[3],shapes[4],shapes[5]])
372 372 else:
373 373 data = gp[name].value
374 374 listMetaname.append(name)
375 375 listMetadata.append(data)
376 376
377 377 # if name=='type':
378 378 # self.__initDataOut(data)
379 379
380 380 self.listShapes = listShapes
381 381 self.listMetaname = listMetaname
382 382 self.listMeta = listMetadata
383 383
384 384 fp.close()
385 385 return
386 386
387 387 def __readData(self):
388 388 grp = self.fp['Data']
389 389 listdataname = []
390 390 listdata = []
391 391
392 392 for item in grp.items():
393 393 name = item[0]
394 394 listdataname.append(name)
395 395
396 396 array = self.__setDataArray(grp[name],self.listShapes[name])
397 397 listdata.append(array)
398 398
399 399 self.listDataname = listdataname
400 400 self.listData = listdata
401 401 return
402 402
403 403 def __setDataArray(self, dataset, shapes):
404 404
405 405 nDims = shapes[0]
406 406
407 407 nDim2 = shapes[1] #Dimension 0
408 408
409 409 nDim1 = shapes[2] #Dimension 1, number of Points or Parameters
410 410
411 411 nDim0 = shapes[3] #Dimension 2, number of samples or ranges
412 412
413 413 mode = shapes[4] #Mode of storing
414 414
415 415 blockList = self.blockList
416 416
417 417 blocksPerFile = self.blocksPerFile
418 418
419 419 #Depending on what mode the data was stored
420 420 if mode == 0: #Divided in channels
421 421 arrayData = dataset.value.astype(numpy.float)[0][blockList]
422 422 if mode == 1: #Divided in parameter
423 423 strds = 'table'
424 424 nDatas = nDim1
425 425 newShapes = (blocksPerFile,nDim2,nDim0)
426 426 elif mode==2: #Concatenated in a table
427 427 strds = 'table0'
428 428 arrayData = dataset[strds].value
429 429 #Selecting part of the dataset
430 430 utctime = arrayData[:,0]
431 431 u, indices = numpy.unique(utctime, return_index=True)
432 432
433 433 if blockList.size != indices.size:
434 434 indMin = indices[blockList[0]]
435 435 if blockList[1] + 1 >= indices.size:
436 436 arrayData = arrayData[indMin:,:]
437 437 else:
438 438 indMax = indices[blockList[1] + 1]
439 439 arrayData = arrayData[indMin:indMax,:]
440 440 return arrayData
441 441
442 442 # One dimension
443 443 if nDims == 0:
444 444 arrayData = dataset.value.astype(numpy.float)[0][blockList]
445 445
446 446 # Two dimensions
447 447 elif nDims == 2:
448 448 arrayData = numpy.zeros((blocksPerFile,nDim1,nDim0))
449 449 newShapes = (blocksPerFile,nDim0)
450 450 nDatas = nDim1
451 451
452 452 for i in range(nDatas):
453 453 data = dataset[strds + str(i)].value
454 454 arrayData[:,i,:] = data[blockList,:]
455 455
456 456 # Three dimensions
457 457 else:
458 458 arrayData = numpy.zeros((blocksPerFile,nDim2,nDim1,nDim0))
459 459 for i in range(nDatas):
460 460
461 461 data = dataset[strds + str(i)].value
462 462
463 463 for b in range(blockList.size):
464 464 arrayData[b,:,i,:] = data[:,:,blockList[b]]
465 465
466 466 return arrayData
467 467
468 468 def __setDataOut(self):
469 469 listMeta = self.listMeta
470 470 listMetaname = self.listMetaname
471 471 listDataname = self.listDataname
472 472 listData = self.listData
473 473 listShapes = self.listShapes
474 474
475 475 blockIndex = self.blockIndex
476 476 # blockList = self.blockList
477 477
478 478 for i in range(len(listMeta)):
479 479 setattr(self.dataOut,listMetaname[i],listMeta[i])
480 480
481 481 for j in range(len(listData)):
482 482 nShapes = listShapes[listDataname[j]][0]
483 483 mode = listShapes[listDataname[j]][4]
484 484 if nShapes == 1:
485 485 setattr(self.dataOut,listDataname[j],listData[j][blockIndex])
486 486 elif nShapes > 1:
487 487 setattr(self.dataOut,listDataname[j],listData[j][blockIndex,:])
488 488 elif mode==0:
489 489 setattr(self.dataOut,listDataname[j],listData[j][blockIndex])
490 490 #Mode Meteors
491 491 elif mode ==2:
492 492 selectedData = self.__selectDataMode2(listData[j], blockIndex)
493 493 setattr(self.dataOut, listDataname[j], selectedData)
494 494 return
495 495
496 496 def __selectDataMode2(self, data, blockIndex):
497 497 utctime = data[:,0]
498 498 aux, indices = numpy.unique(utctime, return_inverse=True)
499 499 selInd = numpy.where(indices == blockIndex)[0]
500 500 selData = data[selInd,:]
501 501
502 502 return selData
503 503
504 504 def getData(self):
505 505
506 506 # if self.flagNoMoreFiles:
507 507 # self.dataOut.flagNoData = True
508 508 # print 'Process finished'
509 509 # return 0
510 510 #
511 511 if self.blockIndex==self.blocksPerFile:
512 512 if not( self.__setNextFileOffline() ):
513 513 self.dataOut.flagNoData = True
514 514 return 0
515 515
516 516 # if self.datablock == None: # setear esta condicion cuando no hayan datos por leers
517 517 # self.dataOut.flagNoData = True
518 518 # return 0
519 519 # self.__readData()
520 520 self.__setDataOut()
521 521 self.dataOut.flagNoData = False
522 522
523 523 self.blockIndex += 1
524 524
525 525 return
526 526
527 527 def run(self, **kwargs):
528 528
529 529 if not(self.isConfig):
530 530 self.setup(**kwargs)
531 531 # self.setObjProperties()
532 532 self.isConfig = True
533 533
534 534 self.getData()
535 535
536 536 return
537 537
538 538 class ParamWriter(Operation):
539 539 '''
540 540 HDF5 Writer, stores parameters data in HDF5 format files
541 541
542 542 path: path where the files will be stored
543 543
544 544 blocksPerFile: number of blocks that will be saved in per HDF5 format file
545 545
546 546 mode: selects the data stacking mode: '0' channels, '1' parameters, '3' table (for meteors)
547 547
548 548 metadataList: list of attributes that will be stored as metadata
549 549
550 550 dataList: list of attributes that will be stores as data
551 551
552 552 '''
553 553
554 554
555 555 ext = ".hdf5"
556 556
557 557 optchar = "D"
558 558
559 559 metaoptchar = "M"
560 560
561 561 metaFile = None
562 562
563 563 filename = None
564 564
565 565 path = None
566 566
567 567 setFile = None
568 568
569 569 fp = None
570 570
571 571 grp = None
572 572
573 573 ds = None
574 574
575 575 firsttime = True
576 576
577 577 #Configurations
578 578
579 579 blocksPerFile = None
580 580
581 581 blockIndex = None
582 582
583 583 dataOut = None
584 584
585 585 #Data Arrays
586 586
587 587 dataList = None
588 588
589 589 metadataList = None
590 590
591 591 # arrayDim = None
592 592
593 593 dsList = None #List of dictionaries with dataset properties
594 594
595 595 tableDim = None
596 596
597 597 # dtype = [('arrayName', 'S20'),('nChannels', 'i'), ('nPoints', 'i'), ('nSamples', 'i'),('mode', 'b')]
598 598
599 599 dtype = [('arrayName', 'S20'),('nDimensions', 'i'), ('dim2', 'i'), ('dim1', 'i'),('dim0', 'i'),('mode', 'b')]
600 600
601 601 currentDay = None
602 602
603 603 lastTime = None
604 604
605 605 def __init__(self, **kwargs):
606 606 Operation.__init__(self, **kwargs)
607 607 self.isConfig = False
608 608 return
609 609
610 610 def setup(self, dataOut, path=None, blocksPerFile=10, metadataList=None, dataList=None, mode=None, **kwargs):
611 611 self.path = path
612 612 self.blocksPerFile = blocksPerFile
613 613 self.metadataList = metadataList
614 614 self.dataList = dataList
615 615 self.dataOut = dataOut
616 616 self.mode = mode
617 617
618 618 if self.mode is not None:
619 619 self.mode = numpy.zeros(len(self.dataList)) + mode
620 620 else:
621 621 self.mode = numpy.ones(len(self.dataList))
622 622
623 623 arrayDim = numpy.zeros((len(self.dataList),5))
624 624
625 625 #Table dimensions
626 626 dtype0 = self.dtype
627 627 tableList = []
628 628
629 629 #Dictionary and list of tables
630 630 dsList = []
631 631
632 632 for i in range(len(self.dataList)):
633 633 dsDict = {}
634 634 dataAux = getattr(self.dataOut, self.dataList[i])
635 635 dsDict['variable'] = self.dataList[i]
636 636 #--------------------- Conditionals ------------------------
637 637 #There is no data
638 638 if dataAux is None:
639 639 return 0
640 640
641 641 #Not array, just a number
642 642 #Mode 0
643 643 if type(dataAux)==float or type(dataAux)==int:
644 644 dsDict['mode'] = 0
645 645 dsDict['nDim'] = 0
646 646 arrayDim[i,0] = 0
647 647 dsList.append(dsDict)
648 648
649 649 #Mode 2: meteors
650 650 elif mode[i] == 2:
651 651 # dsDict['nDim'] = 0
652 652 dsDict['dsName'] = 'table0'
653 653 dsDict['mode'] = 2 # Mode meteors
654 654 dsDict['shape'] = dataAux.shape[-1]
655 655 dsDict['nDim'] = 0
656 656 dsDict['dsNumber'] = 1
657 657
658 658 arrayDim[i,3] = dataAux.shape[-1]
659 659 arrayDim[i,4] = mode[i] #Mode the data was stored
660 660
661 661 dsList.append(dsDict)
662 662
663 663 #Mode 1
664 664 else:
665 665 arrayDim0 = dataAux.shape #Data dimensions
666 666 arrayDim[i,0] = len(arrayDim0) #Number of array dimensions
667 667 arrayDim[i,4] = mode[i] #Mode the data was stored
668 668
669 669 strtable = 'table'
670 670 dsDict['mode'] = 1 # Mode parameters
671 671
672 672 # Three-dimension arrays
673 673 if len(arrayDim0) == 3:
674 674 arrayDim[i,1:-1] = numpy.array(arrayDim0)
675 675 nTables = int(arrayDim[i,2])
676 676 dsDict['dsNumber'] = nTables
677 677 dsDict['shape'] = arrayDim[i,2:4]
678 678 dsDict['nDim'] = 3
679 679
680 680 for j in range(nTables):
681 681 dsDict = dsDict.copy()
682 682 dsDict['dsName'] = strtable + str(j)
683 683 dsList.append(dsDict)
684 684
685 685 # Two-dimension arrays
686 686 elif len(arrayDim0) == 2:
687 687 arrayDim[i,2:-1] = numpy.array(arrayDim0)
688 688 nTables = int(arrayDim[i,2])
689 689 dsDict['dsNumber'] = nTables
690 690 dsDict['shape'] = arrayDim[i,3]
691 691 dsDict['nDim'] = 2
692 692
693 693 for j in range(nTables):
694 694 dsDict = dsDict.copy()
695 695 dsDict['dsName'] = strtable + str(j)
696 696 dsList.append(dsDict)
697 697
698 698 # One-dimension arrays
699 699 elif len(arrayDim0) == 1:
700 700 arrayDim[i,3] = arrayDim0[0]
701 701 dsDict['shape'] = arrayDim0[0]
702 702 dsDict['dsNumber'] = 1
703 703 dsDict['dsName'] = strtable + str(0)
704 704 dsDict['nDim'] = 1
705 705 dsList.append(dsDict)
706 706
707 707 table = numpy.array((self.dataList[i],) + tuple(arrayDim[i,:]),dtype = dtype0)
708 708 tableList.append(table)
709 709
710 710 # self.arrayDim = arrayDim
711 711 self.dsList = dsList
712 712 self.tableDim = numpy.array(tableList, dtype = dtype0)
713 713 self.blockIndex = 0
714 714
715 715 timeTuple = time.localtime(dataOut.utctime)
716 716 self.currentDay = timeTuple.tm_yday
717 717 return 1
718 718
719 719 def putMetadata(self):
720 720
721 721 fp = self.createMetadataFile()
722 722 self.writeMetadata(fp)
723 723 fp.close()
724 724 return
725 725
726 726 def createMetadataFile(self):
727 727 ext = self.ext
728 728 path = self.path
729 729 setFile = self.setFile
730 730
731 731 timeTuple = time.localtime(self.dataOut.utctime)
732 732
733 733 subfolder = ''
734 734 fullpath = os.path.join( path, subfolder )
735 735
736 736 if not( os.path.exists(fullpath) ):
737 737 os.mkdir(fullpath)
738 738 setFile = -1 #inicializo mi contador de seteo
739 739
740 740 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
741 741 fullpath = os.path.join( path, subfolder )
742 742
743 743 if not( os.path.exists(fullpath) ):
744 744 os.mkdir(fullpath)
745 745 setFile = -1 #inicializo mi contador de seteo
746 746
747 747 else:
748 748 filesList = os.listdir( fullpath )
749 749 filesList = sorted( filesList, key=str.lower )
750 750 if len( filesList ) > 0:
751 751 filesList = [k for k in filesList if 'M' in k]
752 752 filen = filesList[-1]
753 753 # el filename debera tener el siguiente formato
754 754 # 0 1234 567 89A BCDE (hex)
755 755 # x YYYY DDD SSS .ext
756 756 if isNumber( filen[8:11] ):
757 757 setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
758 758 else:
759 759 setFile = -1
760 760 else:
761 761 setFile = -1 #inicializo mi contador de seteo
762 762
763 763 if self.setType is None:
764 764 setFile += 1
765 765 file = '%s%4.4d%3.3d%03d%s' % (self.metaoptchar,
766 766 timeTuple.tm_year,
767 767 timeTuple.tm_yday,
768 768 setFile,
769 769 ext )
770 770 else:
771 771 setFile = timeTuple.tm_hour*60+timeTuple.tm_min
772 772 file = '%s%4.4d%3.3d%04d%s' % (self.metaoptchar,
773 773 timeTuple.tm_year,
774 774 timeTuple.tm_yday,
775 775 setFile,
776 776 ext )
777 777
778 778 filename = os.path.join( path, subfolder, file )
779 779 self.metaFile = file
780 780 #Setting HDF5 File
781 781 fp = h5py.File(filename,'w')
782 782
783 783 return fp
784 784
785 785 def writeMetadata(self, fp):
786 786
787 787 grp = fp.create_group("Metadata")
788 788 grp.create_dataset('array dimensions', data = self.tableDim, dtype = self.dtype)
789 789
790 790 for i in range(len(self.metadataList)):
791 791 grp.create_dataset(self.metadataList[i], data=getattr(self.dataOut, self.metadataList[i]))
792 792 return
793 793
794 794 def timeFlag(self):
795 795 currentTime = self.dataOut.utctime
796 796
797 797 if self.lastTime is None:
798 798 self.lastTime = currentTime
799 799
800 800 #Day
801 801 timeTuple = time.localtime(currentTime)
802 802 dataDay = timeTuple.tm_yday
803 803
804 804 #Time
805 805 timeDiff = currentTime - self.lastTime
806 806
807 807 #Si el dia es diferente o si la diferencia entre un dato y otro supera la hora
808 808 if dataDay != self.currentDay:
809 809 self.currentDay = dataDay
810 810 return True
811 811 elif timeDiff > 3*60*60:
812 812 self.lastTime = currentTime
813 813 return True
814 814 else:
815 815 self.lastTime = currentTime
816 816 return False
817 817
818 818 def setNextFile(self):
819 819
820 820 ext = self.ext
821 821 path = self.path
822 822 setFile = self.setFile
823 823 mode = self.mode
824 824
825 825 timeTuple = time.localtime(self.dataOut.utctime)
826 826 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
827 827
828 828 fullpath = os.path.join( path, subfolder )
829 829
830 830 if os.path.exists(fullpath):
831 831 filesList = os.listdir( fullpath )
832 832 filesList = [k for k in filesList if 'D' in k]
833 833 if len( filesList ) > 0:
834 834 filesList = sorted( filesList, key=str.lower )
835 835 filen = filesList[-1]
836 836 # el filename debera tener el siguiente formato
837 837 # 0 1234 567 89A BCDE (hex)
838 838 # x YYYY DDD SSS .ext
839 839 if isNumber( filen[8:11] ):
840 840 setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
841 841 else:
842 842 setFile = -1
843 843 else:
844 844 setFile = -1 #inicializo mi contador de seteo
845 845 else:
846 846 os.makedirs(fullpath)
847 847 setFile = -1 #inicializo mi contador de seteo
848 848
849 849 if self.setType is None:
850 850 setFile += 1
851 851 file = '%s%4.4d%3.3d%03d%s' % (self.metaoptchar,
852 852 timeTuple.tm_year,
853 853 timeTuple.tm_yday,
854 854 setFile,
855 855 ext )
856 856 else:
857 857 setFile = timeTuple.tm_hour*60+timeTuple.tm_min
858 858 file = '%s%4.4d%3.3d%04d%s' % (self.metaoptchar,
859 859 timeTuple.tm_year,
860 860 timeTuple.tm_yday,
861 861 setFile,
862 862 ext )
863 863
864 864 filename = os.path.join( path, subfolder, file )
865 865
866 866 #Setting HDF5 File
867 867 fp = h5py.File(filename,'w')
868 868 #write metadata
869 869 self.writeMetadata(fp)
870 870 #Write data
871 871 grp = fp.create_group("Data")
872 872 # grp.attrs['metadata'] = self.metaFile
873 873
874 874 # grp.attrs['blocksPerFile'] = 0
875 875 ds = []
876 876 data = []
877 877 dsList = self.dsList
878 878 i = 0
879 879 while i < len(dsList):
880 880 dsInfo = dsList[i]
881 881 #One-dimension data
882 882 if dsInfo['mode'] == 0:
883 883 # ds0 = grp.create_dataset(self.dataList[i], (1,1), maxshape=(1,self.blocksPerFile) , chunks = True, dtype='S20')
884 884 ds0 = grp.create_dataset(dsInfo['variable'], (1,1), maxshape=(1,self.blocksPerFile) , chunks = True, dtype=numpy.float64)
885 885 ds.append(ds0)
886 886 data.append([])
887 887 i += 1
888 888 continue
889 889 # nDimsForDs.append(nDims[i])
890 890
891 891 elif dsInfo['mode'] == 2:
892 892 grp0 = grp.create_group(dsInfo['variable'])
893 893 ds0 = grp0.create_dataset(dsInfo['dsName'], (1,dsInfo['shape']), data = numpy.zeros((1,dsInfo['shape'])) , maxshape=(None,dsInfo['shape']), chunks=True)
894 894 ds.append(ds0)
895 895 data.append([])
896 896 i += 1
897 897 continue
898 898
899 899 elif dsInfo['mode'] == 1:
900 900 grp0 = grp.create_group(dsInfo['variable'])
901 901
902 902 for j in range(dsInfo['dsNumber']):
903 903 dsInfo = dsList[i]
904 904 tableName = dsInfo['dsName']
905 905 shape = int(dsInfo['shape'])
906 906
907 907 if dsInfo['nDim'] == 3:
908 908 ds0 = grp0.create_dataset(tableName, (shape[0],shape[1],1) , data = numpy.zeros((shape[0],shape[1],1)), maxshape = (None,shape[1],None), chunks=True)
909 909 else:
910 910 ds0 = grp0.create_dataset(tableName, (1,shape), data = numpy.zeros((1,shape)) , maxshape=(None,shape), chunks=True)
911 911
912 912 ds.append(ds0)
913 913 data.append([])
914 914 i += 1
915 915 # nDimsForDs.append(nDims[i])
916 916
917 917 fp.flush()
918 918 fp.close()
919 919
920 920 # self.nDatas = nDatas
921 921 # self.nDims = nDims
922 922 # self.nDimsForDs = nDimsForDs
923 923 #Saving variables
924 924 print 'Writing the file: %s'%filename
925 925 self.filename = filename
926 926 # self.fp = fp
927 927 # self.grp = grp
928 928 # self.grp.attrs.modify('nRecords', 1)
929 929 self.ds = ds
930 930 self.data = data
931 931 # self.setFile = setFile
932 932 self.firsttime = True
933 933 self.blockIndex = 0
934 934 return
935 935
936 936 def putData(self):
937 937
938 938 if self.blockIndex == self.blocksPerFile or self.timeFlag():
939 939 self.setNextFile()
940 940
941 941 # if not self.firsttime:
942 942 self.readBlock()
943 943 self.setBlock() #Prepare data to be written
944 944 self.writeBlock() #Write data
945 945
946 946 return
947 947
948 948 def readBlock(self):
949 949
950 950 '''
951 951 data Array configured
952 952
953 953
954 954 self.data
955 955 '''
956 956 dsList = self.dsList
957 957 ds = self.ds
958 958 #Setting HDF5 File
959 959 fp = h5py.File(self.filename,'r+')
960 960 grp = fp["Data"]
961 961 ind = 0
962 962
963 963 # grp.attrs['blocksPerFile'] = 0
964 964 while ind < len(dsList):
965 965 dsInfo = dsList[ind]
966 966
967 967 if dsInfo['mode'] == 0:
968 968 ds0 = grp[dsInfo['variable']]
969 969 ds[ind] = ds0
970 970 ind += 1
971 971 else:
972 972
973 973 grp0 = grp[dsInfo['variable']]
974 974
975 975 for j in range(dsInfo['dsNumber']):
976 976 dsInfo = dsList[ind]
977 977 ds0 = grp0[dsInfo['dsName']]
978 978 ds[ind] = ds0
979 979 ind += 1
980 980
981 981 self.fp = fp
982 982 self.grp = grp
983 983 self.ds = ds
984 984
985 985 return
986 986
987 987 def setBlock(self):
988 988 '''
989 989 data Array configured
990 990
991 991
992 992 self.data
993 993 '''
994 994 #Creating Arrays
995 995 dsList = self.dsList
996 996 data = self.data
997 997 ind = 0
998 998
999 999 while ind < len(dsList):
1000 1000 dsInfo = dsList[ind]
1001 1001 dataAux = getattr(self.dataOut, dsInfo['variable'])
1002 1002
1003 1003 mode = dsInfo['mode']
1004 1004 nDim = dsInfo['nDim']
1005 1005
1006 1006 if mode == 0 or mode == 2 or nDim == 1:
1007 1007 data[ind] = dataAux
1008 1008 ind += 1
1009 1009 # elif nDim == 1:
1010 1010 # data[ind] = numpy.reshape(dataAux,(numpy.size(dataAux),1))
1011 1011 # ind += 1
1012 1012 elif nDim == 2:
1013 1013 for j in range(dsInfo['dsNumber']):
1014 1014 data[ind] = dataAux[j,:]
1015 1015 ind += 1
1016 1016 elif nDim == 3:
1017 1017 for j in range(dsInfo['dsNumber']):
1018 1018 data[ind] = dataAux[:,j,:]
1019 1019 ind += 1
1020 1020
1021 1021 self.data = data
1022 1022 return
1023 1023
1024 1024 def writeBlock(self):
1025 1025 '''
1026 1026 Saves the block in the HDF5 file
1027 1027 '''
1028 1028 dsList = self.dsList
1029 1029
1030 1030 for i in range(len(self.ds)):
1031 1031 dsInfo = dsList[i]
1032 1032 nDim = dsInfo['nDim']
1033 1033 mode = dsInfo['mode']
1034 1034
1035 1035 # First time
1036 1036 if self.firsttime:
1037 1037 # self.ds[i].resize(self.data[i].shape)
1038 1038 # self.ds[i][self.blockIndex,:] = self.data[i]
1039 1039 if type(self.data[i]) == numpy.ndarray:
1040 1040
1041 1041 if nDim == 3:
1042 1042 self.data[i] = self.data[i].reshape((self.data[i].shape[0],self.data[i].shape[1],1))
1043 1043 self.ds[i].resize(self.data[i].shape)
1044 1044 if mode == 2:
1045 1045 self.ds[i].resize(self.data[i].shape)
1046 1046 self.ds[i][:] = self.data[i]
1047 1047 else:
1048 1048
1049 1049 # From second time
1050 1050 # Meteors!
1051 1051 if mode == 2:
1052 1052 dataShape = self.data[i].shape
1053 1053 dsShape = self.ds[i].shape
1054 1054 self.ds[i].resize((self.ds[i].shape[0] + dataShape[0],self.ds[i].shape[1]))
1055 1055 self.ds[i][dsShape[0]:,:] = self.data[i]
1056 1056 # No dimension
1057 1057 elif mode == 0:
1058 1058 self.ds[i].resize((self.ds[i].shape[0], self.ds[i].shape[1] + 1))
1059 1059 self.ds[i][0,-1] = self.data[i]
1060 1060 # One dimension
1061 1061 elif nDim == 1:
1062 1062 self.ds[i].resize((self.ds[i].shape[0] + 1, self.ds[i].shape[1]))
1063 1063 self.ds[i][-1,:] = self.data[i]
1064 1064 # Two dimension
1065 1065 elif nDim == 2:
1066 1066 self.ds[i].resize((self.ds[i].shape[0] + 1,self.ds[i].shape[1]))
1067 1067 self.ds[i][self.blockIndex,:] = self.data[i]
1068 1068 # Three dimensions
1069 1069 elif nDim == 3:
1070 1070 self.ds[i].resize((self.ds[i].shape[0],self.ds[i].shape[1],self.ds[i].shape[2]+1))
1071 1071 self.ds[i][:,:,-1] = self.data[i]
1072 1072
1073 1073 self.firsttime = False
1074 1074 self.blockIndex += 1
1075 1075
1076 1076 #Close to save changes
1077 1077 self.fp.flush()
1078 1078 self.fp.close()
1079 1079 return
1080 1080
1081 1081 def run(self, dataOut, path=None, blocksPerFile=10, metadataList=None, dataList=None, mode=None, **kwargs):
1082 1082
1083 1083 if not(self.isConfig):
1084 1084 flagdata = self.setup(dataOut, path=path, blocksPerFile=blocksPerFile,
1085 1085 metadataList=metadataList, dataList=dataList, mode=mode, **kwargs)
1086 1086
1087 1087 if not(flagdata):
1088 1088 return
1089 1089
1090 1090 self.isConfig = True
1091 1091 # self.putMetadata()
1092 1092 self.setNextFile()
1093 1093
1094 1094 self.putData()
1095 1095 return
Show file before | Show file after | Hide comments
@@ -1,6 +0,0
1 [Desktop Entry]
2 Encoding=UTF-8
3 Name=Link to
4 Type=Link
5 URL=file:///home/nanosat/schain/schainpy/utils/parameters.txt
6 Icon=text-plain
General Comments 0
You need to be logged in to leave comments. Login now