##// END OF EJS Templates
schain
RSS
-USRP Reader was added to Signal Chain GUI...
Miguel Valdez -
r589:341989823444
parent child
Show More
Show file before | Show file after | Hide comments
@@ -0,0 +1,87
1 """
2 Classes to save parameters from Windows.
3
4 -Project window
5 -Voltage window
6 -Spectra window
7 -SpectraHeis window
8 -Correlation window
9
10 """
11
12 class ProjectParms():
13
14 parmsOk = False
15 project_name = None
16 datatype = None
17 ext = None
18 dpath = None
19 startDate = None
20 endDate = None
21 startTime = None
22 endTime = None
23 online = None
24 delay = None
25 walk = None
26 expLabel = None
27 set = None
28 ippKm = None
29
30 def __init__(self):
31
32 self.parmsOk = True
33 self.expLabel = ''
34 self.set = None
35 self.ippKm = None
36 self.walk = None
37 self.delay = None
38
39 def getDatatypeIndex(self):
40
41 indexDatatype = None
42
43 if self.datatype.lower() == 'voltage':
44 indexDatatype = 0
45 if self.datatype.lower() == 'spectra':
46 indexDatatype = 1
47 if self.datatype.lower() == 'fits':
48 indexDatatype = 2
49 if self.datatype.lower() == 'usrp':
50 indexDatatype = 3
51
52 return indexDatatype
53
54 def getExt(self):
55
56 ext = None
57
58 if self.datatype.lower() == 'voltage':
59 ext = '.r'
60 if self.datatype.lower() == 'spectra':
61 ext = '.pdata'
62 if self.datatype.lower() == 'fits':
63 ext = '.fits'
64 if self.datatype.lower() == 'usrp':
65 ext = '.hdf5'
66
67 return ext
68
69 def set(self, project_name, datatype, ext, dpath, online,
70 startDate=None, endDate=None, startTime=None, endTime=None,
71 delay=None, walk=None, set=None, ippKm=None, parmsOk=True):
72
73 project_name = project_name
74 datatype = datatype
75 ext = ext
76 dpath = dpath
77 startDate = startDate
78 endDate = endDate
79 startTime = startTime
80 endTime = endTime
81 online = online
82 delay = delay
83 walk = walk
84 set = set
85 ippKm = ippKm
86
87 self.parmsOk = parmsOk No newline at end of file
Show file before | Show file after | Hide comments
@@ -0,0 +1,211
1 # -*- coding: utf-8 -*-
2 """
3 This module contains every model class to create, modify and show a property tree on a GUI.
4 """
5
6 from PyQt4 import QtCore
7 import itertools
8
9 HORIZONTAL_HEADERS = ("Property","Value " )
10
11 HORIZONTAL = ("RAMA :",)
12
13 class PropertyBuffer():
14
15 def __init__(self):
16
17 self.clear()
18
19 def clear(self):
20
21 self.headerList = []
22 self.parmList = []
23 self.valueList = []
24
25 def append(self, header, parm, value):
26
27 self.headerList.append(header)
28 self.parmList.append(parm)
29 self.valueList.append(value)
30
31 return
32
33 def get(self):
34
35 return self.headerList, self.parmList, self.valueList
36
37 def getPropertyModel(self):
38
39 propertiesModel = TreeModel()
40 propertiesModel.showProperties(self.headerList, self.parmList, self.valueList)
41
42 return propertiesModel
43
44
45 class TreeModel(QtCore.QAbstractItemModel):
46 '''
47 a model to display a few names, ordered by encabezado
48
49 '''
50 def __init__(self ,parent=None):
51 super(TreeModel, self).__init__(parent)
52 self.people = []
53
54 def initProjectView(self):
55 """
56 Reemplazo del mΓ©todo showtree
57 """
58 HORIZONTAL_HEADERS = ("Property","Value " )
59 HORIZONTAL = ("RAMA :",)
60 self.rootItem = TreeItem(None, "ALL", None)
61 self.parents = {0 : self.rootItem}
62 self.__setupModelData()
63
64 def initPUVoltageView(self):
65 HORIZONTAL_HEADERS = ("Operation"," Parameter Value " )
66 HORIZONTAL = ("RAMA :",)
67 self.rootItem = TreeItem(None, "ALL", None)
68 self.parents = {0 : self.rootItem}
69 self.__setupModelData()
70
71 def showProperties(self,headerList, parmList, valueList):
72 """
73 set2Obje
74 """
75 for header, parameter, value in itertools.izip(headerList, parmList, valueList):
76 person = person_class(header, parameter, value)
77 self.people.append(person)
78
79 self.rootItem = TreeItem(None, "ALL", None)
80 self.parents = {0 : self.rootItem}
81 self.__setupModelData()
82
83 def columnCount(self, parent=None):
84 if parent and parent.isValid():
85 return parent.internalPointer().columnCount()
86 else:
87 return len(HORIZONTAL_HEADERS)
88
89 def data(self, index, role):
90 if not index.isValid():
91 return QtCore.QVariant()
92
93 item = index.internalPointer()
94 if role == QtCore.Qt.DisplayRole:
95 return item.data(index.column())
96 if role == QtCore.Qt.UserRole:
97 if item:
98 return item.person
99
100 return QtCore.QVariant()
101
102 def index(self, row, column, parent):
103 if not self.hasIndex(row, column, parent):
104 return QtCore.QModelIndex()
105
106 if not parent.isValid():
107 parentItem = self.rootItem
108 else:
109 parentItem = parent.internalPointer()
110
111 childItem = parentItem.child(row)
112 if childItem:
113 return self.createIndex(row, column, childItem)
114 else:
115 return QtCore.QModelIndex()
116
117 def parent(self, index):
118 if not index.isValid():
119 return QtCore.QModelIndex()
120
121 childItem = index.internalPointer()
122 if not childItem:
123 return QtCore.QModelIndex()
124
125 parentItem = childItem.parent()
126
127 if parentItem == self.rootItem:
128 return QtCore.QModelIndex()
129
130 return self.createIndex(parentItem.row(), 0, parentItem)
131
132 def rowCount(self, parent=QtCore.QModelIndex()):
133 if parent.column() > 0:
134 return 0
135 if not parent.isValid():
136 p_Item = self.rootItem
137 else:
138 p_Item = parent.internalPointer()
139 return p_Item.childCount()
140
141 def __setupModelData(self):
142 for person in self.people:
143 if person.value:
144 encabezado = person.header
145
146 if not self.parents.has_key(encabezado):
147 newparent = TreeItem(None, encabezado, self.rootItem)
148 self.rootItem.appendChild(newparent)
149
150 self.parents[encabezado] = newparent
151
152 parentItem = self.parents[encabezado]
153 newItem = TreeItem(person, "", parentItem)
154 parentItem.appendChild(newItem)
155
156 class person_class(object):
157 '''
158 a trivial custom data object
159 '''
160 def __init__(self, header, parameter, value):
161 self.header = header
162 self.parameter = parameter
163 self.value = value
164
165 def __repr__(self):
166 return "PERSON - %s %s"% (self.parameter, self.header)
167
168 class TreeItem(object):
169 '''
170 a python object used to return row/column data, and keep note of
171 it's parents and/or children
172 '''
173 def __init__(self, person, header, parentItem):
174 self.person = person
175 self.parentItem = parentItem
176 self.header = header
177 self.childItems = []
178
179 def appendChild(self, item):
180 self.childItems.append(item)
181
182 def child(self, row):
183 return self.childItems[row]
184
185 def childCount(self):
186 return len(self.childItems)
187
188 def columnCount(self):
189 return 2
190
191 def data(self, column):
192 if self.person == None:
193 if column == 0:
194 return QtCore.QVariant(self.header)
195 if column == 1:
196 return QtCore.QVariant("")
197 else:
198 if column == 0:
199 return QtCore.QVariant(self.person.parameter)
200 if column == 1:
201 return QtCore.QVariant(self.person.value)
202 return QtCore.QVariant()
203
204 def parent(self):
205 return self.parentItem
206
207 def row(self):
208 if self.parentItem:
209 return self.parentItem.childItems.index(self)
210 return 0
211 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,1061 +1,1088
1 1 '''
2 2 Created on September , 2012
3 3 @author:
4 4 '''
5 5 from xml.etree.ElementTree import Element, SubElement
6 6 from xml.etree import ElementTree as ET
7 7 from xml.dom import minidom
8 8
9 9 #import datetime
10 10 from model import *
11 11
12 12 try:
13 13 from gevent import sleep
14 14 except:
15 15 from time import sleep
16 16
17 17 import ast
18 18
19 19 def prettify(elem):
20 20 """Return a pretty-printed XML string for the Element.
21 21 """
22 22 rough_string = ET.tostring(elem, 'utf-8')
23 23 reparsed = minidom.parseString(rough_string)
24 24 return reparsed.toprettyxml(indent=" ")
25 25
26 26 class ParameterConf():
27 27
28 28 id = None
29 29 name = None
30 30 value = None
31 31 format = None
32 32
33 33 __formated_value = None
34 34
35 35 ELEMENTNAME = 'Parameter'
36 36
37 37 def __init__(self):
38 38
39 39 self.format = 'str'
40 40
41 41 def getElementName(self):
42 42
43 43 return self.ELEMENTNAME
44 44
45 45 def getValue(self):
46 46
47 47 if self.__formated_value != None:
48 48
49 49 return self.__formated_value
50 50
51 51 value = self.value
52 52
53 53 if self.format == 'bool':
54 54 value = int(value)
55 55
56 56 if self.format == 'list':
57 57 strList = value.split(',')
58 58
59 59 self.__formated_value = strList
60 60
61 61 return self.__formated_value
62 62
63 63 if self.format == 'intlist':
64 64 """
65 65 Example:
66 66 value = (0,1,2)
67 67 """
68 68 value = value.replace('(', '')
69 69 value = value.replace(')', '')
70 70
71 71 value = value.replace('[', '')
72 72 value = value.replace(']', '')
73 73
74 74 strList = value.split(',')
75 75 intList = [int(x) for x in strList]
76 76
77 77 self.__formated_value = intList
78 78
79 79 return self.__formated_value
80 80
81 81 if self.format == 'floatlist':
82 82 """
83 83 Example:
84 84 value = (0.5, 1.4, 2.7)
85 85 """
86 86
87 87 value = value.replace('(', '')
88 88 value = value.replace(')', '')
89 89
90 90 value = value.replace('[', '')
91 91 value = value.replace(']', '')
92 92
93 93 strList = value.split(',')
94 94 floatList = [float(x) for x in strList]
95 95
96 96 self.__formated_value = floatList
97 97
98 98 return self.__formated_value
99 99
100 100 if self.format == 'date':
101 101 strList = value.split('/')
102 102 intList = [int(x) for x in strList]
103 103 date = datetime.date(intList[0], intList[1], intList[2])
104 104
105 105 self.__formated_value = date
106 106
107 107 return self.__formated_value
108 108
109 109 if self.format == 'time':
110 110 strList = value.split(':')
111 111 intList = [int(x) for x in strList]
112 112 time = datetime.time(intList[0], intList[1], intList[2])
113 113
114 114 self.__formated_value = time
115 115
116 116 return self.__formated_value
117 117
118 118 if self.format == 'pairslist':
119 119 """
120 120 Example:
121 121 value = (0,1),(1,2)
122 122 """
123 123
124 124 value = value.replace('(', '')
125 125 value = value.replace(')', '')
126 126
127 127 value = value.replace('[', '')
128 128 value = value.replace(']', '')
129 129
130 130 strList = value.split(',')
131 131 intList = [int(item) for item in strList]
132 132 pairList = []
133 133 for i in range(len(intList)/2):
134 134 pairList.append((intList[i*2], intList[i*2 + 1]))
135 135
136 136 self.__formated_value = pairList
137 137
138 138 return self.__formated_value
139 139
140 140 if self.format == 'multilist':
141 141 """
142 142 Example:
143 143 value = (0,1,2),(3,4,5)
144 144 """
145 145 multiList = ast.literal_eval(value)
146 146
147 147 self.__formated_value = multiList
148 148
149 149 return self.__formated_value
150 150
151 151 format_func = eval(self.format)
152 152
153 153 self.__formated_value = format_func(value)
154 154
155 155 return self.__formated_value
156 156
157 157 def setup(self, id, name, value, format='str'):
158 158
159 159 self.id = id
160 160 self.name = name
161 161 self.value = str(value)
162 162 self.format = str.lower(format)
163 163
164 164 def update(self, name, value, format='str'):
165 165
166 166 self.name = name
167 167 self.value = str(value)
168 168 self.format = format
169 169
170 170 def makeXml(self, opElement):
171 171
172 172 parmElement = SubElement(opElement, self.ELEMENTNAME)
173 173 parmElement.set('id', str(self.id))
174 174 parmElement.set('name', self.name)
175 175 parmElement.set('value', self.value)
176 176 parmElement.set('format', self.format)
177 177
178 178 def readXml(self, parmElement):
179 179
180 180 self.id = parmElement.get('id')
181 181 self.name = parmElement.get('name')
182 182 self.value = parmElement.get('value')
183 183 self.format = str.lower(parmElement.get('format'))
184 184
185 185 #Compatible with old signal chain version
186 186 if self.format == 'int' and self.name == 'idfigure':
187 187 self.name = 'id'
188 188
189 189 def printattr(self):
190 190
191 191 print "Parameter[%s]: name = %s, value = %s, format = %s" %(self.id, self.name, self.value, self.format)
192 192
193 193 class OperationConf():
194 194
195 195 id = None
196 196 name = None
197 197 priority = None
198 198 type = None
199 199
200 200 parmConfObjList = []
201 201
202 202 ELEMENTNAME = 'Operation'
203 203
204 204 def __init__(self):
205 205
206 self.id = 0
206 self.id = '0'
207 207 self.name = None
208 208 self.priority = None
209 209 self.type = 'self'
210 210
211 211
212 212 def __getNewId(self):
213 213
214 214 return int(self.id)*10 + len(self.parmConfObjList) + 1
215 215
216 216 def getElementName(self):
217 217
218 218 return self.ELEMENTNAME
219 219
220 220 def getParameterObjList(self):
221 221
222 222 return self.parmConfObjList
223 223
224 224 def getParameterObj(self, parameterName):
225 225
226 226 for parmConfObj in self.parmConfObjList:
227 227
228 228 if parmConfObj.name != parameterName:
229 229 continue
230 230
231 231 return parmConfObj
232 232
233 233 return None
234 234
235 235 def getParameterObjfromValue(self,parameterValue):
236 236 for parmConfObj in self.parmConfObjList:
237 237
238 238 if parmConfObj.getValue() != parameterValue:
239 239 continue
240 240
241 241 return parmConfObj.getValue()
242 242
243 243 return None
244 244
245 245 def getParameterValue(self, parameterName):
246 246
247 247 parameterObj = self.getParameterObj(parameterName)
248 248 value = parameterObj.getValue()
249 249
250 250 return value
251 251
252 252 def setup(self, id, name, priority, type):
253 253
254 254 self.id = id
255 255 self.name = name
256 256 self.type = type
257 257 self.priority = priority
258 258
259 259 self.parmConfObjList = []
260 260
261 261 def removeParameters(self):
262 262
263 263 for obj in self.parmConfObjList:
264 264 del obj
265 265
266 266 self.parmConfObjList = []
267 267
268 268 def addParameter(self, name, value, format='str'):
269 269
270 270 id = self.__getNewId()
271 271
272 272 parmConfObj = ParameterConf()
273 273 parmConfObj.setup(id, name, value, format)
274 274
275 275 self.parmConfObjList.append(parmConfObj)
276 276
277 277 return parmConfObj
278 278
279 279 def changeParameter(self, name, value, format='str'):
280 280
281 281 parmConfObj = self.getParameterObj(name)
282 282 parmConfObj.update(name, value, format)
283 283
284 284 return parmConfObj
285 285
286 286 def makeXml(self, upElement):
287 287
288 288 opElement = SubElement(upElement, self.ELEMENTNAME)
289 289 opElement.set('id', str(self.id))
290 290 opElement.set('name', self.name)
291 291 opElement.set('type', self.type)
292 292 opElement.set('priority', str(self.priority))
293 293
294 294 for parmConfObj in self.parmConfObjList:
295 295 parmConfObj.makeXml(opElement)
296 296
297 297 def readXml(self, opElement):
298 298
299 299 self.id = opElement.get('id')
300 300 self.name = opElement.get('name')
301 301 self.type = opElement.get('type')
302 302 self.priority = opElement.get('priority')
303 303
304 304 #Compatible with old signal chain version
305 305 #Use of 'run' method instead 'init'
306 306 if self.type == 'self' and self.name == 'init':
307 307 self.name = 'run'
308 308
309 309 self.parmConfObjList = []
310 310
311 311 parmElementList = opElement.getiterator(ParameterConf().getElementName())
312 312
313 313 for parmElement in parmElementList:
314 314 parmConfObj = ParameterConf()
315 315 parmConfObj.readXml(parmElement)
316 316
317 317 #Compatible with old signal chain version
318 318 #If an 'plot' OPERATION is found, changes name operation by the value of its type PARAMETER
319 319 if self.type != 'self' and self.name == 'Plot':
320 320 if parmConfObj.format == 'str' and parmConfObj.name == 'type':
321 321 self.name = parmConfObj.value
322 322 continue
323 323
324 324 self.parmConfObjList.append(parmConfObj)
325 325
326 326 def printattr(self):
327 327
328 328 print "%s[%s]: name = %s, type = %s, priority = %s" %(self.ELEMENTNAME,
329 329 self.id,
330 330 self.name,
331 331 self.type,
332 332 self.priority)
333 333
334 334 for parmConfObj in self.parmConfObjList:
335 335 parmConfObj.printattr()
336 336
337 337 def createObject(self):
338 338
339 339 if self.type == 'self':
340 340 raise ValueError, "This operation type cannot be created"
341 341
342 342 if self.type == 'external' or self.type == 'other':
343 343 className = eval(self.name)
344 344 opObj = className()
345 345
346 346 return opObj
347 347
348 348 class ProcUnitConf():
349 349
350 350 id = None
351 351 name = None
352 352 datatype = None
353 353 inputId = None
354 354 parentId = None
355 355
356 356 opConfObjList = []
357 357
358 358 procUnitObj = None
359 359 opObjList = []
360 360
361 361 ELEMENTNAME = 'ProcUnit'
362 362
363 363 def __init__(self):
364 364
365 365 self.id = None
366 366 self.datatype = None
367 367 self.name = None
368 368 self.inputId = None
369 369
370 370 self.opConfObjList = []
371 371
372 372 self.procUnitObj = None
373 373 self.opObjDict = {}
374 374
375 375 def __getPriority(self):
376 376
377 377 return len(self.opConfObjList)+1
378 378
379 379 def __getNewId(self):
380 380
381 381 return int(self.id)*10 + len(self.opConfObjList) + 1
382 382
383 383 def getElementName(self):
384 384
385 385 return self.ELEMENTNAME
386 386
387 387 def getId(self):
388 388
389 return str(self.id)
389 return self.id
390 390
391 391 def getInputId(self):
392 392
393 return str(self.inputId)
393 return self.inputId
394 394
395 395 def getOperationObjList(self):
396 396
397 397 return self.opConfObjList
398 398
399 399 def getOperationObj(self, name=None):
400 400
401 401 for opConfObj in self.opConfObjList:
402 402
403 403 if opConfObj.name != name:
404 404 continue
405 405
406 406 return opConfObj
407 407
408 408 return None
409 409
410 410 def getOpObjfromParamValue(self,value=None):
411 411
412 412 for opConfObj in self.opConfObjList:
413 413 if opConfObj.getParameterObjfromValue(parameterValue=value) != value:
414 414 continue
415 415 return opConfObj
416 416 return None
417 417
418 418 def getProcUnitObj(self):
419 419
420 420 return self.procUnitObj
421 421
422 422 def setup(self, id, name, datatype, inputId, parentId=None):
423 423
424 424 self.id = id
425 425 self.name = name
426 426 self.datatype = datatype
427 427 self.inputId = inputId
428 428 self.parentId = parentId
429 429
430 430 self.opConfObjList = []
431 431
432 432 self.addOperation(name='run', optype='self')
433 433
434 434 def removeOperations(self):
435 435
436 436 for obj in self.opConfObjList:
437 437 del obj
438 438
439 439 self.opConfObjList = []
440 440 self.addOperation(name='run')
441 441
442 442 def addParameter(self, **kwargs):
443 443 '''
444 444 Add parameters to "run" operation
445 445 '''
446 446 opObj = self.opConfObjList[0]
447 447
448 448 opObj.addParameter(**kwargs)
449 449
450 450 return opObj
451 451
452 452 def addOperation(self, name, optype='self'):
453 453
454 454 id = self.__getNewId()
455 455 priority = self.__getPriority()
456 456
457 457 opConfObj = OperationConf()
458 458 opConfObj.setup(id, name=name, priority=priority, type=optype)
459 459
460 460 self.opConfObjList.append(opConfObj)
461 461
462 462 return opConfObj
463 463
464 464 def makeXml(self, procUnitElement):
465 465
466 466 upElement = SubElement(procUnitElement, self.ELEMENTNAME)
467 467 upElement.set('id', str(self.id))
468 468 upElement.set('name', self.name)
469 469 upElement.set('datatype', self.datatype)
470 470 upElement.set('inputId', str(self.inputId))
471 471
472 472 for opConfObj in self.opConfObjList:
473 473 opConfObj.makeXml(upElement)
474 474
475 475 def readXml(self, upElement):
476 476
477 477 self.id = upElement.get('id')
478 478 self.name = upElement.get('name')
479 479 self.datatype = upElement.get('datatype')
480 480 self.inputId = upElement.get('inputId')
481
481
482 if self.inputId == 'None':
483 self.inputId = '0'
484
482 485 self.opConfObjList = []
483 486
484 487 opElementList = upElement.getiterator(OperationConf().getElementName())
485 488
486 489 for opElement in opElementList:
487 490 opConfObj = OperationConf()
488 491 opConfObj.readXml(opElement)
489 492 self.opConfObjList.append(opConfObj)
490 493
491 494 def printattr(self):
492 495
493 496 print "%s[%s]: name = %s, datatype = %s, inputId = %s" %(self.ELEMENTNAME,
494 497 self.id,
495 498 self.name,
496 499 self.datatype,
497 500 self.inputId)
498 501
499 502 for opConfObj in self.opConfObjList:
500 503 opConfObj.printattr()
501 504
502 505 def createObjects(self):
503 506
504 507 className = eval(self.name)
505 508 procUnitObj = className()
506 509
507 510 for opConfObj in self.opConfObjList:
508 511
509 512 if opConfObj.type == 'self':
510 513 continue
511 514
512 515 opObj = opConfObj.createObject()
513 516
514 517 self.opObjDict[opConfObj.id] = opObj
515 518 procUnitObj.addOperation(opObj, opConfObj.id)
516 519
517 520 self.procUnitObj = procUnitObj
518 521
519 522 return procUnitObj
520 523
521 524 def run(self):
522 525
523 526 finalSts = False
524 527
525 528 for opConfObj in self.opConfObjList:
526 529
527 530 kwargs = {}
528 531 for parmConfObj in opConfObj.getParameterObjList():
529 532 if opConfObj.name == 'run' and parmConfObj.name == 'datatype':
530 533 continue
531 534
532 535 kwargs[parmConfObj.name] = parmConfObj.getValue()
533 536
534 537 #print "\tRunning the '%s' operation with %s" %(opConfObj.name, opConfObj.id)
535 538 sts = self.procUnitObj.call(opType = opConfObj.type,
536 539 opName = opConfObj.name,
537 540 opId = opConfObj.id,
538 541 **kwargs)
539 542 finalSts = finalSts or sts
540 543
541 544 return finalSts
542 545
543 546 def close(self):
544 547
545 548 for opConfObj in self.opConfObjList:
546 549 if opConfObj.type == 'self':
547 550 continue
548 551
549 552 opObj = self.procUnitObj.getOperationObj(opConfObj.id)
550 553 opObj.close()
551 554
552 555 self.procUnitObj.close()
553 556
554 557 return
555 558
556 559 class ReadUnitConf(ProcUnitConf):
557 560
558 561 path = None
559 562 startDate = None
560 563 endDate = None
561 564 startTime = None
562 565 endTime = None
563 566
564 567 ELEMENTNAME = 'ReadUnit'
565 568
566 569 def __init__(self):
567 570
568 571 self.id = None
569 572 self.datatype = None
570 573 self.name = None
571 self.inputId = 0
574 self.inputId = None
575
576 self.parentId = None
572 577
573 578 self.opConfObjList = []
574 579 self.opObjList = []
575 580
576 581 def getElementName(self):
577 582
578 583 return self.ELEMENTNAME
579 584
580 585 def setup(self, id, name, datatype, path, startDate="", endDate="", startTime="", endTime="", parentId=None, **kwargs):
581 586
582 587 self.id = id
583 588 self.name = name
584 589 self.datatype = datatype
585 590
586 591 self.path = path
587 592 self.startDate = startDate
588 593 self.endDate = endDate
589 594 self.startTime = startTime
590 595 self.endTime = endTime
591 596
597 self.inputId = '0'
598 self.parentId = parentId
599
592 600 self.addRunOperation(**kwargs)
593 601
594 def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, **kwargs):
602 def update(self, datatype, path, startDate, endDate, startTime, endTime, parentId=None, name=None, **kwargs):
603
604 if name==None:
605 if 'Reader' in datatype:
606 name = datatype
607 else:
608 name = '%sReader' %(datatype)
595 609
610 if datatype==None:
611 datatype = name.replace('Reader','')
612
596 613 self.datatype = datatype
614 self.name = name
597 615 self.path = path
598 616 self.startDate = startDate
599 617 self.endDate = endDate
600 618 self.startTime = startTime
601 619 self.endTime = endTime
602 620
621 self.inputId = None
622 self.parentId = parentId
623
603 624 self.updateRunOperation(**kwargs)
604 625
605 626 def addRunOperation(self, **kwargs):
606 627
607 628 opObj = self.addOperation(name = 'run', optype = 'self')
608 629
609 630 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
610 631 opObj.addParameter(name='path' , value=self.path, format='str')
611 632 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
612 633 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
613 634 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
614 635 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
615 636
616 637 for key, value in kwargs.items():
617 638 opObj.addParameter(name=key, value=value, format=type(value).__name__)
618 639
619 640 return opObj
620 641
621 642 def updateRunOperation(self, **kwargs):
622 643
623 644 opObj = self.getOperationObj(name = 'run')
624 645 opObj.removeParameters()
625 646
626 647 opObj.addParameter(name='datatype' , value=self.datatype, format='str')
627 648 opObj.addParameter(name='path' , value=self.path, format='str')
628 649 opObj.addParameter(name='startDate' , value=self.startDate, format='date')
629 650 opObj.addParameter(name='endDate' , value=self.endDate, format='date')
630 651 opObj.addParameter(name='startTime' , value=self.startTime, format='time')
631 652 opObj.addParameter(name='endTime' , value=self.endTime, format='time')
632 653
633 654 for key, value in kwargs.items():
634 655 opObj.addParameter(name=key, value=value, format=type(value).__name__)
635 656
636 657 return opObj
637 658
638 659 class Project():
639 660
640 661 id = None
641 662 name = None
642 663 description = None
643 664 # readUnitConfObjList = None
644 665 procUnitConfObjDict = None
645 666
646 667 ELEMENTNAME = 'Project'
647 668
648 669 def __init__(self, control=None, dataq=None):
649 670
650 671 self.id = None
651 672 self.name = None
652 673 self.description = None
653 674
654 675 self.procUnitConfObjDict = {}
655 676
656 677 #global data_q
657 678 #data_q = dataq
658 679
659 680 if control==None:
660 681 control = {}
661 682 control['stop'] = False
662 683 control['pause'] = False
663 684
664 685 self.control = control
665 686
666 687 def __getNewId(self):
667 688
668 689 id = int(self.id)*10 + len(self.procUnitConfObjDict) + 1
669 690
670 691 return str(id)
671 692
672 693 def getElementName(self):
673 694
674 695 return self.ELEMENTNAME
675 696
676 697 def getId(self):
677 698
678 699 return self.id
679 700
680 701 def setup(self, id, name, description):
681 702
682 703 self.id = id
683 704 self.name = name
684 705 self.description = description
685 706
686 707 def update(self, name, description):
687 708
688 709 self.name = name
689 710 self.description = description
690 711
691 712 def addReadUnit(self, datatype=None, name=None, **kwargs):
692 713
693 714 #Compatible with old signal chain version
694 715 if datatype==None and name==None:
695 716 raise ValueError, "datatype or name should be defined"
696 717
697 718 if name==None:
698 719 if 'Reader' in datatype:
699 720 name = datatype
700 721 else:
701 722 name = '%sReader' %(datatype)
702 723
703 724 if datatype==None:
704 725 datatype = name.replace('Reader','')
705 726
706 id = self.__getNewId()
727 idReadUnit = self.__getNewId()
707 728
708 729 readUnitConfObj = ReadUnitConf()
709 readUnitConfObj.setup(id, name, datatype, parentId=self.id, **kwargs)
730 readUnitConfObj.setup(idReadUnit, name, datatype, parentId=self.id, **kwargs)
710 731
711 732 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
712 733
713 734 return readUnitConfObj
714 735
715 def addProcUnit(self, inputId=0, datatype=None, name=None):
736 def addProcUnit(self, inputId='0', datatype=None, name=None):
716 737
717 738 #Compatible with old signal chain version
718 739 if datatype==None and name==None:
719 740 raise ValueError, "datatype or name should be defined"
720 741
721 742 if name==None:
722 743 if 'Proc' in datatype:
723 744 name = datatype
724 745 else:
725 746 name = '%sProc' %(datatype)
726 747
727 748 if datatype==None:
728 749 datatype = name.replace('Proc','')
729 750
730 id = self.__getNewId()
751 idProcUnit = self.__getNewId()
731 752
732 753 procUnitConfObj = ProcUnitConf()
733 procUnitConfObj.setup(id, name, datatype, inputId, parentId=self.id)
754 procUnitConfObj.setup(idProcUnit, name, datatype, inputId, parentId=self.id)
734 755
735 756 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
736 757
737 758 return procUnitConfObj
738 759
739 760 def removeProcUnit(self, id):
740 761
741 762 if id in self.procUnitConfObjDict.keys():
742 763 self.procUnitConfObjDict.pop(id)
743 764
744 765 def getReadUnitId(self):
745 766
746 767 readUnitConfObj = self.getReadUnitObj()
747 768
748 769 return readUnitConfObj.id
749 770
750 771 def getReadUnitObj(self):
751 772
752 773 for obj in self.procUnitConfObjDict.values():
753 774 if obj.getElementName() == "ReadUnit":
754 775 return obj
755 776
756 777 return None
757 778
758 779 def getProcUnitObj(self, id):
759 780
760 781 return self.procUnitConfObjDict[id]
761 782
762 783 def getProcUnitObjByName(self, name):
763 784
764 785 for obj in self.procUnitConfObjDict.values():
765 786 if obj.name == name:
766 787 return obj
767 788
768 789 return None
769 790
770 791 def makeXml(self):
771 792
772 793 projectElement = Element('Project')
773 794 projectElement.set('id', str(self.id))
774 795 projectElement.set('name', self.name)
775 796 projectElement.set('description', self.description)
776 797
777 798 # for readUnitConfObj in self.readUnitConfObjList:
778 799 # readUnitConfObj.makeXml(projectElement)
779 800
780 801 for procUnitConfObj in self.procUnitConfObjDict.values():
781 802 procUnitConfObj.makeXml(projectElement)
782 803
783 804 self.projectElement = projectElement
784 805
785 806 def writeXml(self, filename):
786 807
787 808 self.makeXml()
788 809
789 810 #print prettify(self.projectElement)
790 811
791 812 ElementTree(self.projectElement).write(filename, method='xml')
792 813
793 814 def readXml(self, filename):
794 815
795 816 #tree = ET.parse(filename)
796 817 self.projectElement = None
797 818 # self.readUnitConfObjList = []
798 819 self.procUnitConfObjDict = {}
799 820
800 821 self.projectElement = ElementTree().parse(filename)
801 822
802 823 self.project = self.projectElement.tag
803 824
804 825 self.id = self.projectElement.get('id')
805 826 self.name = self.projectElement.get('name')
806 827 self.description = self.projectElement.get('description')
807 828
808 829 readUnitElementList = self.projectElement.getiterator(ReadUnitConf().getElementName())
809 830
810 831 for readUnitElement in readUnitElementList:
811 832 readUnitConfObj = ReadUnitConf()
812 833 readUnitConfObj.readXml(readUnitElement)
813 834
835 if readUnitConfObj.parentId == None:
836 readUnitConfObj.parentId = self.id
837
814 838 self.procUnitConfObjDict[readUnitConfObj.getId()] = readUnitConfObj
815 839
816 840 procUnitElementList = self.projectElement.getiterator(ProcUnitConf().getElementName())
817 841
818 842 for procUnitElement in procUnitElementList:
819 843 procUnitConfObj = ProcUnitConf()
820 844 procUnitConfObj.readXml(procUnitElement)
821 845
846 if procUnitConfObj.parentId == None:
847 procUnitConfObj.parentId = self.id
848
822 849 self.procUnitConfObjDict[procUnitConfObj.getId()] = procUnitConfObj
823 850
824 851 def printattr(self):
825 852
826 853 print "Project[%s]: name = %s, description = %s" %(self.id,
827 854 self.name,
828 855 self.description)
829 856
830 857 # for readUnitConfObj in self.readUnitConfObjList:
831 858 # readUnitConfObj.printattr()
832 859
833 860 for procUnitConfObj in self.procUnitConfObjDict.values():
834 861 procUnitConfObj.printattr()
835 862
836 863 def createObjects(self):
837 864
838 865 # for readUnitConfObj in self.readUnitConfObjList:
839 866 # readUnitConfObj.createObjects()
840 867
841 868 for procUnitConfObj in self.procUnitConfObjDict.values():
842 869 procUnitConfObj.createObjects()
843 870
844 871 def __connect(self, objIN, thisObj):
845 872
846 873 thisObj.setInput(objIN.getOutputObj())
847 874
848 875 def connectObjects(self):
849 876
850 877 for thisPUConfObj in self.procUnitConfObjDict.values():
851 878
852 879 inputId = thisPUConfObj.getInputId()
853 880
854 881 if int(inputId) == 0:
855 882 continue
856 883
857 884 #Get input object
858 885 puConfINObj = self.procUnitConfObjDict[inputId]
859 886 puObjIN = puConfINObj.getProcUnitObj()
860 887
861 888 #Get current object
862 889 thisPUObj = thisPUConfObj.getProcUnitObj()
863 890
864 891 self.__connect(puObjIN, thisPUObj)
865 892
866 893 def run(self):
867 894
868 895 # for readUnitConfObj in self.readUnitConfObjList:
869 896 # readUnitConfObj.run()
870 897 print
871 898 print "*"*40
872 899 print " Starting SIGNAL CHAIN PROCESSING "
873 900 print "*"*40
874 901 print
875 902
876 903 keyList = self.procUnitConfObjDict.keys()
877 904 keyList.sort()
878 905
879 906 while(True):
880 907
881 908 finalSts = False
882 909
883 910 for procKey in keyList:
884 911 # print "Running the '%s' process with %s" %(procUnitConfObj.name, procUnitConfObj.id)
885 912
886 913 procUnitConfObj = self.procUnitConfObjDict[procKey]
887 914 sts = procUnitConfObj.run()
888 915 finalSts = finalSts or sts
889 916
890 917 #If every process unit finished so end process
891 918 if not(finalSts):
892 919 print "Every process unit have finished"
893 920 break
894 921
895 922 if self.control['pause']:
896 923 print "Process suspended"
897 924
898 925 while True:
899 926 sleep(0.1)
900 927
901 928 if not self.control['pause']:
902 929 break
903 930
904 931 if self.control['stop']:
905 932 break
906 933 print "Process reinitialized"
907 934
908 935 if self.control['stop']:
909 936 print "Process stopped"
910 937 break
911 938
912 939 #Closing every process
913 940 for procKey in keyList:
914 941 procUnitConfObj = self.procUnitConfObjDict[procKey]
915 942 procUnitConfObj.close()
916 943
917 944 print "Process finished"
918 945
919 946 def start(self, filename):
920 947
921 948 self.writeXml(filename)
922 949 self.readXml(filename)
923 950
924 951 self.createObjects()
925 952 self.connectObjects()
926 953 self.run()
927 954
928 955 if __name__ == '__main__':
929 956
930 957 desc = "Segundo Test"
931 958 filename = "schain.xml"
932 959
933 960 controllerObj = Project()
934 961
935 962 controllerObj.setup(id = '191', name='test01', description=desc)
936 963
937 964 readUnitConfObj = controllerObj.addReadUnit(datatype='Voltage',
938 965 path='data/rawdata/',
939 966 startDate='2011/01/01',
940 967 endDate='2012/12/31',
941 968 startTime='00:00:00',
942 969 endTime='23:59:59',
943 970 online=1,
944 971 walk=1)
945 972
946 973 # opObj00 = readUnitConfObj.addOperation(name='printInfo')
947 974
948 975 procUnitConfObj0 = controllerObj.addProcUnit(datatype='Voltage', inputId=readUnitConfObj.getId())
949 976
950 977 opObj10 = procUnitConfObj0.addOperation(name='selectChannels')
951 978 opObj10.addParameter(name='channelList', value='3,4,5', format='intlist')
952 979
953 980 opObj10 = procUnitConfObj0.addOperation(name='selectHeights')
954 981 opObj10.addParameter(name='minHei', value='90', format='float')
955 982 opObj10.addParameter(name='maxHei', value='180', format='float')
956 983
957 984 opObj12 = procUnitConfObj0.addOperation(name='CohInt', optype='external')
958 985 opObj12.addParameter(name='n', value='10', format='int')
959 986
960 987 procUnitConfObj1 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj0.getId())
961 988 procUnitConfObj1.addParameter(name='nFFTPoints', value='32', format='int')
962 989 # procUnitConfObj1.addParameter(name='pairList', value='(0,1),(0,2),(1,2)', format='')
963 990
964 991
965 992 opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
966 993 opObj11.addParameter(name='idfigure', value='1', format='int')
967 994 opObj11.addParameter(name='wintitle', value='SpectraPlot0', format='str')
968 995 opObj11.addParameter(name='zmin', value='40', format='int')
969 996 opObj11.addParameter(name='zmax', value='90', format='int')
970 997 opObj11.addParameter(name='showprofile', value='1', format='int')
971 998
972 999 # opObj11 = procUnitConfObj1.addOperation(name='CrossSpectraPlot', optype='external')
973 1000 # opObj11.addParameter(name='idfigure', value='2', format='int')
974 1001 # opObj11.addParameter(name='wintitle', value='CrossSpectraPlot', format='str')
975 1002 # opObj11.addParameter(name='zmin', value='40', format='int')
976 1003 # opObj11.addParameter(name='zmax', value='90', format='int')
977 1004
978 1005
979 1006 # procUnitConfObj2 = controllerObj.addProcUnit(datatype='Voltage', inputId=procUnitConfObj0.getId())
980 1007 #
981 1008 # opObj12 = procUnitConfObj2.addOperation(name='CohInt', optype='external')
982 1009 # opObj12.addParameter(name='n', value='2', format='int')
983 1010 # opObj12.addParameter(name='overlapping', value='1', format='int')
984 1011 #
985 1012 # procUnitConfObj3 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj2.getId())
986 1013 # procUnitConfObj3.addParameter(name='nFFTPoints', value='32', format='int')
987 1014 #
988 1015 # opObj11 = procUnitConfObj3.addOperation(name='SpectraPlot', optype='external')
989 1016 # opObj11.addParameter(name='idfigure', value='2', format='int')
990 1017 # opObj11.addParameter(name='wintitle', value='SpectraPlot1', format='str')
991 1018 # opObj11.addParameter(name='zmin', value='40', format='int')
992 1019 # opObj11.addParameter(name='zmax', value='90', format='int')
993 1020 # opObj11.addParameter(name='showprofile', value='1', format='int')
994 1021
995 1022 # opObj11 = procUnitConfObj1.addOperation(name='RTIPlot', optype='external')
996 1023 # opObj11.addParameter(name='idfigure', value='10', format='int')
997 1024 # opObj11.addParameter(name='wintitle', value='RTI', format='str')
998 1025 ## opObj11.addParameter(name='xmin', value='21', format='float')
999 1026 ## opObj11.addParameter(name='xmax', value='22', format='float')
1000 1027 # opObj11.addParameter(name='zmin', value='40', format='int')
1001 1028 # opObj11.addParameter(name='zmax', value='90', format='int')
1002 1029 # opObj11.addParameter(name='showprofile', value='1', format='int')
1003 1030 # opObj11.addParameter(name='timerange', value=str(60), format='int')
1004 1031
1005 1032 # opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
1006 1033 # opObj10.addParameter(name='channelList', value='0,2,4,6', format='intlist')
1007 1034 #
1008 1035 # opObj12 = procUnitConfObj1.addOperation(name='IncohInt', optype='external')
1009 1036 # opObj12.addParameter(name='n', value='2', format='int')
1010 1037 #
1011 1038 # opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
1012 1039 # opObj11.addParameter(name='idfigure', value='2', format='int')
1013 1040 # opObj11.addParameter(name='wintitle', value='SpectraPlot10', format='str')
1014 1041 # opObj11.addParameter(name='zmin', value='70', format='int')
1015 1042 # opObj11.addParameter(name='zmax', value='90', format='int')
1016 1043 #
1017 1044 # opObj10 = procUnitConfObj1.addOperation(name='selectChannels')
1018 1045 # opObj10.addParameter(name='channelList', value='2,6', format='intlist')
1019 1046 #
1020 1047 # opObj12 = procUnitConfObj1.addOperation(name='IncohInt', optype='external')
1021 1048 # opObj12.addParameter(name='n', value='2', format='int')
1022 1049 #
1023 1050 # opObj11 = procUnitConfObj1.addOperation(name='SpectraPlot', optype='external')
1024 1051 # opObj11.addParameter(name='idfigure', value='3', format='int')
1025 1052 # opObj11.addParameter(name='wintitle', value='SpectraPlot10', format='str')
1026 1053 # opObj11.addParameter(name='zmin', value='70', format='int')
1027 1054 # opObj11.addParameter(name='zmax', value='90', format='int')
1028 1055
1029 1056
1030 1057 # opObj12 = procUnitConfObj1.addOperation(name='decoder')
1031 1058 # opObj12.addParameter(name='ncode', value='2', format='int')
1032 1059 # opObj12.addParameter(name='nbauds', value='8', format='int')
1033 1060 # opObj12.addParameter(name='code0', value='001110011', format='int')
1034 1061 # opObj12.addParameter(name='code1', value='001110011', format='int')
1035 1062
1036 1063
1037 1064
1038 1065 # procUnitConfObj2 = controllerObj.addProcUnit(datatype='Spectra', inputId=procUnitConfObj1.getId())
1039 1066 #
1040 1067 # opObj21 = procUnitConfObj2.addOperation(name='IncohInt', optype='external')
1041 1068 # opObj21.addParameter(name='n', value='2', format='int')
1042 1069 #
1043 1070 # opObj11 = procUnitConfObj2.addOperation(name='SpectraPlot', optype='external')
1044 1071 # opObj11.addParameter(name='idfigure', value='4', format='int')
1045 1072 # opObj11.addParameter(name='wintitle', value='SpectraPlot OBJ 2', format='str')
1046 1073 # opObj11.addParameter(name='zmin', value='70', format='int')
1047 1074 # opObj11.addParameter(name='zmax', value='90', format='int')
1048 1075
1049 1076 print "Escribiendo el archivo XML"
1050 1077
1051 1078 controllerObj.writeXml(filename)
1052 1079
1053 1080 print "Leyendo el archivo XML"
1054 1081 controllerObj.readXml(filename)
1055 1082 #controllerObj.printattr()
1056 1083
1057 1084 controllerObj.createObjects()
1058 1085 controllerObj.connectObjects()
1059 1086 controllerObj.run()
1060 1087
1061 1088 No newline at end of file
Show file before | Show file after | Hide comments
This diff has been collapsed as it changes many lines, (1094 lines changed) Show them Hide them
@@ -1,6665 +1,7053
1 1 # -*- coding: utf-8 -*-
2 2 """
3 3 Module implementing MainWindow.
4 4 #+++++++++++++GUI V1++++++++++++++#
5 5 @author: AlexanderValdezPortocarrero Γ±_Γ±
6 6 """
7 7 import os, sys, time
8 8 import datetime
9 import numpy
9 10 import Queue
11
12 from collections import OrderedDict
13 from os.path import expanduser
14 from time import sleep
15
10 16 from PyQt4.QtGui import QMainWindow
11 17 from PyQt4.QtCore import pyqtSignature
12 18 from PyQt4.QtCore import pyqtSignal
13 19 from PyQt4 import QtCore
14 20 from PyQt4 import QtGui
15 21
16 22 from schainpy.gui.viewer.ui_unitprocess import Ui_UnitProcess
17 23 from schainpy.gui.viewer.ui_ftp import Ui_Ftp
18 24 from schainpy.gui.viewer.ui_mainwindow import Ui_BasicWindow
19 25 from schainpy.controller import Project
20 26
21 from modelProperties import treeModel
22 from collections import OrderedDict
23 from os.path import expanduser
24 #from CodeWarrior.Standard_Suite import file
25 from comm import *
27 from propertiesViewModel import TreeModel, PropertyBuffer
28 from parametersModel import ProjectParms
26 29
27 try:
28 from gevent import sleep
29 except:
30 from time import sleep
31
32 30 from schainpy.gui.figures import tools
33 import numpy
31 from schainpy.gui.viewcontroller.comm import ControllerThread
34 32
35 33 FIGURES_PATH = tools.get_path()
36 34
37 35 def isRadarFile(file):
38 36 try:
39 37 year = int(file[1:5])
40 38 doy = int(file[5:8])
41 39 set = int(file[8:11])
42 40 except:
43 41 return 0
44 42
45 43 return 1
46 44
47 45 def isRadarPath(path):
48 46 try:
49 47 year = int(path[1:5])
50 48 doy = int(path[5:8])
51 49 except:
52 50 return 0
53 51
54 52 return 1
55
53
56 54 class BasicWindow(QMainWindow, Ui_BasicWindow):
57 55 """
58 56 """
59 57 def __init__(self, parent=None):
60 58 """
61 59
62 60 """
63 61 QMainWindow.__init__(self, parent)
64 62 self.setupUi(self)
65 63 self.__puObjDict = {}
66 64 self.__itemTreeDict = {}
67 65 self.readUnitConfObjList = []
68 66 self.operObjList = []
69 67 self.projecObjView = None
70 68 self.idProject = 0
71 69 # self.idImag = 0
72 70
73 71 self.idImagscope = 0
74 72 self.idImagspectra = 0
75 73 self.idImagcross = 0
76 74 self.idImagrti = 0
77 75 self.idImagcoherence = 0
78 76 self.idImagpower = 0
79 77 self.idImagrtinoise = 0
80 78 self.idImagspectraHeis = 0
81 79 self.idImagrtiHeis = 0
82 80
83 81 self.online = 0
84 82 self.walk = 0
85 83 self.create = False
86 84 self.selectedItemTree = None
87 self.commCtrlPThread = None
85 self.controllerObj = None
86 # self.commCtrlPThread = None
88 87 # self.create_figure()
89 88 self.temporalFTP = ftpBuffer()
90 89 self.projectProperCaracteristica = []
91 90 self.projectProperPrincipal = []
92 91 self.projectProperDescripcion = []
93 92 self.volProperCaracteristica = []
94 93 self.volProperPrincipal = []
95 94 self.volProperDescripcion = []
96 95 self.specProperCaracteristica = []
97 96 self.specProperPrincipal = []
98 97 self.specProperDescripcion = []
99 98
100 99 self.specHeisProperCaracteristica = []
101 100 self.specHeisProperPrincipal = []
102 101 self.specHeisProperDescripcion = []
103 102
104 103 # self.pathWorkSpace = './'
105 104
106 105 self.__projectObjDict = {}
107 106 self.__operationObjDict = {}
108 107
109 108 self.__ftpProcUnitAdded = False
110 109 self.__ftpProcUnitId = None
111 110 self.__initialized = False
112 111
113 self.create_comm()
112 # self.create_comm()
114 113 self.create_updating_timer()
115 114 self.setParameter()
116 115
117 116 @pyqtSignature("")
118 117 def on_actionOpen_triggered(self):
119 118 """
120 119 Slot documentation goes here.
121 120 """
122 121 self.openProject()
123 122
124 123 @pyqtSignature("")
125 124 def on_actionCreate_triggered(self):
126 125 """
127 126 Slot documentation goes here.
128 127 """
129 128 self.setInputsProject_View()
130 129 self.create = True
131 130
132 131 @pyqtSignature("")
133 132 def on_actionSave_triggered(self):
134 133 """
135 134 Slot documentation goes here.
136 135 """
137 136 self.saveProject()
138 137
139 138 @pyqtSignature("")
140 139 def on_actionClose_triggered(self):
141 140 """
142 141 Slot documentation goes here.
143 142 """
144 143 self.close()
145 144
146 145 @pyqtSignature("")
147 146 def on_actionStart_triggered(self):
148 147 """
149 148 """
150 149 self.playProject()
151 150
152 151 @pyqtSignature("")
153 152 def on_actionPause_triggered(self):
154 153 """
155 154 """
156 155 self.pauseProject()
157 156
158 157 @pyqtSignature("")
159 158 def on_actionStop_triggered(self):
160 159 """
161 160 """
162 161 self.stopProject()
163 162
164 163 @pyqtSignature("")
165 164 def on_actionFTP_triggered(self):
166 165 """
167 166 """
168 167 self.configFTPWindowObj = Ftp(self)
169 168 # if self.temporalFTP.create:
170 169 if self.temporalFTP.createforView:
171 170 server, folder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.temporalFTP.recover()
172 171 self.configFTPWindowObj.setParmsfromTemporal(server, folder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos)
173 172 self.configFTPWindowObj.show()
174 173 self.configFTPWindowObj.closed.connect(self.createFTPConfig)
175 174
176 175 def createFTPConfig(self):
177 176 self.console.clear()
178 177 if not self.configFTPWindowObj.create:
179 178 self.console.append("There is no FTP configuration")
180 179 return
181 180 self.console.append("Push Ok in Spectra view to Add FTP Configuration")
182 181 server, folder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.configFTPWindowObj.getParmsFromFtpWindow()
183 182 self.temporalFTP.save(server, folder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos)
184 183
185 184 @pyqtSignature("")
186 185 def on_actionOpenToolbar_triggered(self):
187 186 """
188 187 Slot documentation goes here.
189 188 """
190 189 self.openProject()
191 190
192 191 @pyqtSignature("")
193 192 def on_actionCreateToolbar_triggered(self):
194 193 """
195 194 Slot documentation goes here.
196 195 """
197 196 self.setInputsProject_View()
198 197 self.create = True
199 198
200 199 @pyqtSignature("")
201 200 def on_actionAddPU_triggered(self):
202 201 if len(self.__projectObjDict) == 0:
203 202 outputstr = "First Create a Project then add Processing Unit"
204 203 self.console.clear()
205 204 self.console.append(outputstr)
206 205 return 0
207 206 else:
208 207 self.addPUWindow()
209 208 self.console.clear()
210 209 self.console.append("Please, Choose the type of Processing Unit")
211 210 self.console.append("If your Datatype is rawdata, you will start with processing unit Type Voltage")
212 211 self.console.append("If your Datatype is pdata, you will choose between processing unit Type Spectra or Correlation")
213 212 self.console.append("If your Datatype is fits, you will start with processing unit Type SpectraHeis")
214 213
215 214
216 215 @pyqtSignature("")
217 216 def on_actionSaveToolbar_triggered(self):
218 217 """
219 218 Slot documentation goes here.
220 219 """
221 220 self.saveProject()
222 221
223 222 @pyqtSignature("")
224 223 def on_actionStarToolbar_triggered(self):
225 224 """
226 225 Slot documentation goes here.
227 226 """
228 227 self.playProject()
229 228
230 229 @pyqtSignature("")
231 230 def on_actionPauseToolbar_triggered(self):
232 231
233 232 self.pauseProject()
234 233
235 234 @pyqtSignature("")
236 235 def on_actionStopToolbar_triggered(self):
237 236 """
238 237 Slot documentation goes here.
239 238 """
240 239 self.stopProject()
241 240
242 241 @pyqtSignature("int")
243 242 def on_proComReadMode_activated(self, index):
244 243 """
245 244 SELECCION DEL MODO DE LECTURA ON=1, OFF=0
246 245 """
247 246 if index == 0:
248 247 self.online = 0
249 248 self.proDelay.setText("0")
250 249 self.proSet.setText("0")
251 250 self.proSet.setEnabled(False)
252 251 self.proDelay.setEnabled(False)
253 252 elif index == 1:
254 253 self.online = 1
255 254 self.proSet.setText(" ")
256 255 self.proDelay.setText("5")
257 256 self.proSet.setEnabled(True)
258 257 self.proDelay.setEnabled(True)
259 258
260 259 @pyqtSignature("int")
261 260 def on_proComDataType_activated(self, index):
262 261 """
263 262 Voltage or Spectra
264 263 """
265 264 if index == 0:
266 self.datatype = '.r'
265 extension = '.r'
267 266 elif index == 1:
268 self.datatype = '.pdata'
267 extension = '.pdata'
269 268 elif index == 2:
270 self.datatype = '.fits'
271
272 self.proDataType.setText(self.datatype)
269 extension = '.fits'
270 elif index == 3:
271 extension = '.hdf5'
272
273 self.proDataType.setText(extension)
273 274 self.console.clear()
274 275
275 276 @pyqtSignature("int")
276 277 def on_proComWalk_activated(self, index):
277 278 """
278 279
279 280 """
280 281 if index == 0:
281 282 self.walk = 0
282 283 elif index == 1:
283 284 self.walk = 1
284 285
285 286 @pyqtSignature("")
286 287 def on_proToolPath_clicked(self):
287 288 """
288 289 Choose your path
289 290 """
290 291 self.dataPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
291 292 self.proDataPath.setText(self.dataPath)
292 293
293 294 self.proComStartDate.clear()
294 295 self.proComEndDate.clear()
295 296
296 297 if not os.path.exists(self.dataPath):
297 298 self.proOk.setEnabled(False)
298 299 self.console.clear()
299 300 self.console.append("Write a correct a path")
300 301 return
301 302 self.console.clear()
302 303 self.console.append("Select the read mode")
303 304
304 305
305 306 @pyqtSignature("")
306 307 def on_proLoadButton_clicked(self):
308
307 309 self.console.clear()
308 parms_ok, project_name, datatype, ext, data_path, read_mode, delay, walk , set = self.checkInputsProject()
309 if read_mode == "Offline":
310 if parms_ok:
311 self.proComStartDate.clear()
312 self.proComEndDate.clear()
313 self.loadDays(data_path, ext, walk)
314 self.proComStartDate.setEnabled(True)
315 self.proComEndDate.setEnabled(True)
316 self.proStartTime.setEnabled(True)
317 self.proEndTime.setEnabled(True)
318 self.frame_2.setEnabled(True)
310
311 parameter_list = self.checkInputsProject()
312
313 if not parameter_list[0]:
319 314 return
315
316 parms_ok, project_name, datatype, ext, data_path, read_mode, delay, walk, set = parameter_list
317
318 if read_mode == "Offline":
319 self.proComStartDate.clear()
320 self.proComEndDate.clear()
321 self.proComStartDate.setEnabled(True)
322 self.proComEndDate.setEnabled(True)
323 self.proStartTime.setEnabled(True)
324 self.proEndTime.setEnabled(True)
325 self.frame_2.setEnabled(True)
326
320 327 if read_mode == "Online":
321 if parms_ok:
322 self.proComStartDate.addItem("2010/01/30")
323 self.proComEndDate.addItem("2013/12/30")
324 self.loadDays(data_path, ext, walk)
325 self.proComStartDate.setEnabled(False)
326 self.proComEndDate.setEnabled(False)
327 self.proStartTime.setEnabled(False)
328 self.proEndTime.setEnabled(False)
329 self.frame_2.setEnabled(True)
330
328 self.proComStartDate.addItem("2000/01/30")
329 self.proComEndDate.addItem("2016/12/31")
330 self.proComStartDate.setEnabled(False)
331 self.proComEndDate.setEnabled(False)
332 self.proStartTime.setEnabled(False)
333 self.proEndTime.setEnabled(False)
334 self.frame_2.setEnabled(True)
335
336 self.loadDays(data_path, ext, walk)
337
331 338 @pyqtSignature("int")
332 339 def on_proComStartDate_activated(self, index):
333 340 """
334 341 SELECCION DEL RANGO DE FECHAS -START DATE
335 342 """
336 343 stopIndex = self.proComEndDate.count() - self.proComEndDate.currentIndex()
337 344 self.proComEndDate.clear()
338 345 for i in self.dateList[index:]:
339 346 self.proComEndDate.addItem(i)
340 347 self.proComEndDate.setCurrentIndex(self.proComEndDate.count() - stopIndex)
341 348
342 349 @pyqtSignature("int")
343 350 def on_proComEndDate_activated(self, index):
344 351 """
345 352 SELECCION DEL RANGO DE FECHAS-END DATE
346 353 """
347 354 startIndex = self.proComStartDate.currentIndex()
348 355 stopIndex = self.proComEndDate.count() - index
349 356 self.proComStartDate.clear()
350 357 for i in self.dateList[:len(self.dateList) - stopIndex + 1]:
351 358 self.proComStartDate.addItem(i)
352 359 self.proComStartDate.setCurrentIndex(startIndex)
353 360
354 361 @pyqtSignature("")
355 362 def on_proOk_clicked(self):
356 363 """
357 364 AΓ±ade al Obj XML de Projecto, name,datatype,date,time,readmode,wait,etc, crea el readUnitProcess del archivo xml.
358 365 Prepara la configuraciΓ³n del diΓ‘grama del Arbol del treeView numero 2
359 366 """
360 367 if self.create:
361 368 self.idProject += 1
362 369 projectId = self.idProject
363 370 projectObjView = self.createProjectView(projectId)
364 371 readUnitObj = self.createReadUnitView(projectObjView)
365 372 self.addProject2ProjectExplorer(id=projectId, name=projectObjView.name)
366 373 else:
367 374 projectObjView = self.updateProjectView()
368 375 projectId = projectObjView.getId()
369 376 idReadUnit = projectObjView.getReadUnitId()
370 377 readUnitObj = self.updateReadUnitView(projectObjView, idReadUnit)
371 378
372 379 self.__itemTreeDict[projectId].setText(projectObjView.name)
373 380 # Project Properties
374 self.showProjectProperties(projectObjView)
381 self.refreshProjectProperties(projectObjView)
375 382 # Disable tabProject after finish the creation
376 383 self.tabProject.setEnabled(True)
377 384
378 385 @pyqtSignature("")
379 386 def on_proClear_clicked(self):
380 387 self.setInputsProject_View()
381 388 projectObj = self.getSelectedProjectObj()
382 389
383 390 @pyqtSignature("int")
384 391 def on_volOpCebChannels_stateChanged(self, p0):
385 392 """
386 393 Check Box habilita operaciones de SelecciοΏ½n de Canales
387 394 """
388 395 if p0 == 2:
389 396 self.volOpComChannels.setEnabled(True)
390 397 self.volOpChannel.setEnabled(True)
391 398
392 399 if p0 == 0:
393 400 self.volOpComChannels.setEnabled(False)
394 401 self.volOpChannel.setEnabled(False)
395 402 self.volOpChannel.clear()
396 403
397 404 @pyqtSignature("int")
398 405 def on_volOpCebHeights_stateChanged(self, p0):
399 406 """
400 407 Check Box habilita operaciones de SelecciοΏ½n de Alturas
401 408 """
402 409 if p0 == 2:
403 410 self.volOpHeights.setEnabled(True)
404 411 self.volOpComHeights.setEnabled(True)
405 412
406 413 if p0 == 0:
407 414 self.volOpHeights.setEnabled(False)
408 415 self.volOpHeights.clear()
409 416 self.volOpComHeights.setEnabled(False)
410 417
411 418 @pyqtSignature("int")
412 419 def on_volOpCebFilter_stateChanged(self, p0):
413 420 """
414 421 Name='Decoder', optype='other'
415 422 """
416 423 if p0 == 2:
417 424 self.volOpFilter.setEnabled(True)
418 425
419 426 if p0 == 0:
420 427 self.volOpFilter.setEnabled(False)
421 428 self.volOpFilter.clear()
422 429
423 430 @pyqtSignature("int")
424 431 def on_volOpCebProfile_stateChanged(self, p0):
425 432 """
426 433 Check Box habilita ingreso del rango de Perfiles
427 434 """
428 435 if p0 == 2:
429 436 self.volOpComProfile.setEnabled(True)
430 437 self.volOpProfile.setEnabled(True)
431 438
432 439 if p0 == 0:
433 440 self.volOpComProfile.setEnabled(False)
434 441 self.volOpProfile.setEnabled(False)
435 442 self.volOpProfile.clear()
436 443
437 444 @pyqtSignature("int")
438 445 def on_volOpCebDecodification_stateChanged(self, p0):
439 446 """
440 447 Check Box habilita
441 448 """
442 449 if p0 == 2:
443 450 self.volOpComCode.setEnabled(True)
444 451 self.volOpComMode.setEnabled(True)
445 452 if p0 == 0:
446 453 self.volOpComCode.setEnabled(False)
447 454 self.volOpComMode.setEnabled(False)
448 455
449 456 @pyqtSignature("int")
450 457 def on_volOpCebFlip_stateChanged(self, p0):
451 458 """
452 459 Check Box habilita ingresode del numero de Integraciones a realizar
453 460 """
454 461 if p0 == 2:
455 462 self.volOpFlip.setEnabled(True)
456 463 if p0 == 0:
457 464 self.volOpFlip.setEnabled(False)
458 465 self.volOpFlip.clear()
459 466
460 467 @pyqtSignature("int")
461 468 def on_volOpCebCohInt_stateChanged(self, p0):
462 469 """
463 470 Check Box habilita ingresode del numero de Integraciones a realizar
464 471 """
465 472 if p0 == 2:
466 473 self.volOpCohInt.setEnabled(True)
467 474 if p0 == 0:
468 475 self.volOpCohInt.setEnabled(False)
469 476 self.volOpCohInt.clear()
470 477
471 478 @pyqtSignature("int")
472 479 def on_volOpCebRadarfrequency_stateChanged(self, p0):
473 480 """
474 481 Check Box habilita ingresode del numero de Integraciones a realizar
475 482 """
476 483 if p0 == 2:
477 484 self.volOpRadarfrequency.setEnabled(True)
478 485 if p0 == 0:
479 486 self.volOpRadarfrequency.clear()
480 487 self.volOpRadarfrequency.setEnabled(False)
481 488
482 489 @pyqtSignature("")
483 490 def on_volOutputToolPath_clicked(self):
484 491 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
485 492 self.volOutputPath.setText(dirOutPath)
486 493
487 494 @pyqtSignature("")
488 495 def on_specOutputToolPath_clicked(self):
489 496 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
490 497 self.specOutputPath.setText(dirOutPath)
491 498
492 499 @pyqtSignature("")
493 500 def on_specHeisOutputToolPath_clicked(self):
494 501 dirOutPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
495 502 self.specHeisOutputPath.setText(dirOutPath)
496 503
497 504 @pyqtSignature("")
498 505 def on_specHeisOutputMetadaToolPath_clicked(self):
499 home = expanduser("~")
500 self.dir = os.path.join(home, 'schain_workspace')
501 filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open text file", self.dir, self.tr("Text Files (*.xml)")))
506
507 filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open text file", self.pathWorkSpace, self.tr("Text Files (*.xml)")))
502 508 self.specHeisOutputMetada.setText(filename)
503 509
504 510 @pyqtSignature("")
505 511 def on_volOpOk_clicked(self):
506 512 """
507 513 BUSCA EN LA LISTA DE OPERACIONES DEL TIPO VOLTAJE Y LES AοΏ½ADE EL PARAMETRO ADECUADO ESPERANDO LA ACEPTACION DEL USUARIO
508 514 PARA AGREGARLO AL ARCHIVO DE CONFIGURACION XML
509 515 """
510 516
511 517 checkPath = False
512 518
513 519 self.actionSaveToolbar.setEnabled(False)
514 520 self.actionStarToolbar.setEnabled(False)
515 521
516 puObj = self.getSelectedPUObj()
522 puObj = self.getSelectedItemObj()
517 523 puObj.removeOperations()
518 524
519 525 if self.volOpCebRadarfrequency.isChecked():
520 value = self.volOpRadarfrequency.text()
526 value = str(self.volOpRadarfrequency.text())
521 527 format = 'float'
522 528 name_operation = 'setRadarFrequency'
523 529 name_parameter = 'frequency'
524 530 if not value == "":
525 531 try:
526 532 radarfreq = float(self.volOpRadarfrequency.text())
527 533 except:
528 534 self.console.clear()
529 535 self.console.append("Write the parameter Radar Frequency type float")
530 536 return 0
531 537 opObj = puObj.addOperation(name=name_operation)
532 538 opObj.addParameter(name=name_parameter, value=radarfreq, format=format)
533
534
535 539
536 540 if self.volOpCebChannels.isChecked():
537 541 value = str(self.volOpChannel.text())
538 542
539 543 if value == "":
540 544 print "Please fill channel list"
541 545 return 0
542 546
543 547 format = 'intlist'
544 548 if self.volOpComChannels.currentIndex() == 0:
545 549 name_operation = "selectChannels"
546 550 name_parameter = 'channelList'
547 551 else:
548 552 name_operation = "selectChannelsByIndex"
549 553 name_parameter = 'channelIndexList'
550 554
551 555 opObj = puObj.addOperation(name=name_operation)
552 556 opObj.addParameter(name=name_parameter, value=value, format=format)
553 557
554 558 if self.volOpCebHeights.isChecked():
555 559 value = str(self.volOpHeights.text())
556 560
557 561 if value == "":
558 562 print "Please fill height range"
559 563 return 0
560 564
561 565 valueList = value.split(',')
562 566 format = 'float'
563 567 if self.volOpComHeights.currentIndex() == 0:
564 568 name_operation = 'selectHeights'
565 569 name_parameter1 = 'minHei'
566 570 name_parameter2 = 'maxHei'
567 571 else:
568 572 name_operation = 'selectHeightsByIndex'
569 573 name_parameter1 = 'minIndex'
570 574 name_parameter2 = 'maxIndex'
571 575
572 576 opObj = puObj.addOperation(name=name_operation)
573 577 opObj.addParameter(name=name_parameter1, value=valueList[0], format=format)
574 578 opObj.addParameter(name=name_parameter2, value=valueList[1], format=format)
575 579
576 580 if self.volOpCebFilter.isChecked():
577 581 value = str(self.volOpFilter.text())
578 582 if value == "":
579 583 print "Please fill filter value"
580 584 return 0
581 585
582 586 format = 'int'
583 587 name_operation = 'filterByHeights'
584 588 name_parameter = 'window'
585 589 opObj = puObj.addOperation(name=name_operation)
586 590 opObj.addParameter(name=name_parameter, value=value, format=format)
587 591
588 592 if self.volOpCebProfile.isChecked():
589 593 value = str(self.volOpProfile.text())
590 594
591 595 if value == "":
592 596 print "Please fill profile value"
593 597 return 0
594 598
595 599 format = 'intlist'
596 600 optype = 'other'
597 601 name_operation = 'ProfileSelector'
598 602 if self.volOpComProfile.currentIndex() == 0:
599 603 name_parameter = 'profileList'
600 604 else:
601 605 name_parameter = 'profileRangeList'
602 606 opObj = puObj.addOperation(name='ProfileSelector', optype='other')
603 607 opObj.addParameter(name=name_parameter, value=value, format=format)
604 608
605 609 if self.volOpCebDecodification.isChecked():
606 610 name_operation = 'Decoder'
607 611 optype = 'other'
608 612 format1 = 'floatlist'
609 613 format2 = 'int'
610 614 format3 = 'int'
611 615 format4 = 'int'
612 616 name_parameter1 = 'code'
613 617 name_parameter2 = 'nCode'
614 618 name_parameter3 = 'nBaud'
615 619 name_parameter4 = 'mode'
616 620
617 621 if self.volOpComCode.currentIndex() == 0:
618 622 value1 = '1,1,-1'
619 623 value2 = '1'
620 624 value3 = '3'
621 625 if self.volOpComCode.currentIndex() == 1:
622 626 value1 = '1,1,-1,1'
623 627 value2 = '1'
624 628 value3 = '4'
625 629 if self.volOpComCode.currentIndex() == 2:
626 630 value1 = '1,1,1,-1,1'
627 631 value2 = '1'
628 632 value3 = '5'
629 633 if self.volOpComCode.currentIndex() == 3:
630 634 value1 = '1,1,1,-1,-1,1,-1'
631 635 value2 = '1'
632 636 value3 = '7'
633 637 if self.volOpComCode.currentIndex() == 4:
634 638 value1 = '1,1,1,-1,-1,-1,1,-1,-1,1,-1'
635 639 value2 = '1'
636 640 value3 = '11'
637 641 if self.volOpComCode.currentIndex() == 5:
638 642 value1 = '1,1,1,1,1,-1,-1,1,1,-1,1,-1,1'
639 643 value2 = '1'
640 644 value3 = '13'
641 645 if self.volOpComCode.currentIndex() == 6:
642 646 value1 = '1,1,-1,-1,-1,1'
643 647 value2 = '2'
644 648 value3 = '3'
645 649 if self.volOpComCode.currentIndex() == 7:
646 650 value1 = '1,1,-1,1,-1,-1,1,-1'
647 651 value2 = '2'
648 652 value3 = '4'
649 653 if self.volOpComCode.currentIndex() == 8:
650 654 value1 = '1,1,1,-1,1,-1,-1,-1,1,-1'
651 655 value2 = '2'
652 656 value3 = '5'
653 657 if self.volOpComCode.currentIndex() == 9:
654 658 value1 = '1,1,1,-1,-1,1,-1,-1,-1,-1,1,1,-1,1'
655 659 value2 = '2'
656 660 value3 = '7'
657 661 if self.volOpComCode.currentIndex() == 10:
658 662 value1 = '1,1,1,-1,-1,-1,1,-1,-1,1,-1,-1 ,-1 ,-1 ,1 ,1,1,-1 ,1 ,1 ,-1 ,1'
659 663 value2 = '2'
660 664 value3 = '11'
661 665 if self.volOpComCode.currentIndex() == 11:
662 666 value1 = '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'
663 667 value2 = '2'
664 668 value3 = '13'
665 669 if self.volOpComMode.currentIndex() == 0:
666 670 value4 = '0'
667 671 if self.volOpComMode.currentIndex() == 1:
668 672 value4 = '1'
669 673 if self.volOpComMode.currentIndex() == 2:
670 674 value4 = '2'
671 675 opObj = puObj.addOperation(name=name_operation, optype='other')
672 676 if self.volOpComCode.currentIndex() == 12:
673 677 pass
674 678 else:
675 679 opObj.addParameter(name=name_parameter1, value=value1, format=format1)
676 680 opObj.addParameter(name=name_parameter2, value=value2, format=format2)
677 681 opObj.addParameter(name=name_parameter3, value=value3, format=format3)
678 682 opObj.addParameter(name=name_parameter4, value=value4, format=format4)
679 683
680 684 if self.volOpCebFlip.isChecked():
681 685 name_operation = 'deFlip'
682 686 optype = 'self'
683 value = self.volOpFlip.text()
687 value = str(self.volOpFlip.text())
684 688 name_parameter = 'channelList'
685 689 format = 'intlist'
686 690
687 691 opObj = puObj.addOperation(name=name_operation, optype=optype)
688 opObj.addParameter(name=name_parameter, value=value, format=format)
692 if value:
693 opObj.addParameter(name=name_parameter, value=value, format=format)
689 694
690 695 if self.volOpCebCohInt.isChecked():
691 696 name_operation = 'CohInt'
692 697 optype = 'other'
693 value = self.volOpCohInt.text()
698 value = str(self.volOpCohInt.text())
694 699 name_parameter = 'n'
695 700 format = 'float'
696 701
697 702 opObj = puObj.addOperation(name=name_operation, optype=optype)
698 703 opObj.addParameter(name=name_parameter, value=value, format=format)
699 704
700 705 if self.volGraphCebshow.isChecked():
701 706 name_operation = 'Scope'
702 707 optype = 'other'
703 708 name_parameter = 'type'
704 709 value = 'Scope'
705 710 if self.idImagscope == 0:
706 711 self.idImagscope = 100
707 712 else:
708 713 self.idImagscope = self.idImagscope + 1
709 714
710 715 name_parameter1 = 'id'
711 716 value1 = int(self.idImagscope)
712 717 format1 = 'int'
713 718 format = 'str'
714 719
715 720 opObj = puObj.addOperation(name=name_operation, optype=optype)
716 721 # opObj.addParameter(name=name_parameter, value=value, format=format)
717 722 opObj.addParameter(name=name_parameter1, value=value1, format=format1)
718 723
719 channelList = self.volGraphChannelList.text()
720 xvalue = self.volGraphfreqrange.text()
721 yvalue = self.volGraphHeightrange.text()
724 channelList = str(self.volGraphChannelList.text())
725 xvalue = str(self.volGraphfreqrange.text())
726 yvalue = str(self.volGraphHeightrange.text())
722 727
723 728 if self.volGraphChannelList.isModified():
724 729 try:
725 730 value = str(channelList)
726 731 except:
727 732 return 0
728 733 opObj.addParameter(name='channelList', value=value, format='intlist')
729 734
730 735 if not xvalue == "":
731 736 xvalueList = xvalue.split(',')
732 737 try:
733 738 value0 = int(xvalueList[0])
734 739 value1 = int(xvalueList[1])
735 740 except:
736 741 return 0
737 742 opObj.addParameter(name='xmin', value=value0, format='int')
738 743 opObj.addParameter(name='xmax', value=value1, format='int')
739 744
740 745
741 746 if not yvalue == "":
742 747 yvalueList = yvalue.split(",")
743 748 try:
744 749 value = yvalueList[0]
745 750 value = yvalueList[1]
746 751 except:
747 752 return 0
748 753 opObj.addParameter(name='ymin', value=yvalueList[0], format='int')
749 754 opObj.addParameter(name='ymax', value=yvalueList[1], format='int')
750 755
751 756 if self.volGraphCebSave.isChecked():
752 757 checkPath = True
753 758 opObj.addParameter(name='save', value='1', format='int')
754 759 opObj.addParameter(name='figpath', value=self.volGraphPath.text(), format='str')
755 value = self.volGraphPrefix.text()
760 value = str(self.volGraphPrefix.text())
756 761 if not value == "":
757 762 try:
758 763 value = str(self.volGraphPrefix.text())
759 764 except:
760 765 self.console.clear()
761 766 self.console.append("Please Write prefix")
762 767 return 0
763 768 opObj.addParameter(name='figfile', value=self.volGraphPrefix.text(), format='str')
764 769
765 770 localfolder = None
766 771 if checkPath:
767 772 localfolder = str(self.specGraphPath.text())
768 773 if localfolder == '':
769 774 self.console.clear()
770 775 self.console.append("Graphic path should be defined")
771 776 return 0
772 777
773 778 # if something happend
774 779 parms_ok, output_path, blocksperfile, profilesperblock = self.checkInputsPUSave(datatype='Voltage')
775 780 if parms_ok:
776 781 name_operation = 'VoltageWriter'
777 782 optype = 'other'
778 783 name_parameter1 = 'path'
779 784 name_parameter2 = 'blocksPerFile'
780 785 name_parameter3 = 'profilesPerBlock'
781 786 value1 = output_path
782 787 value2 = blocksperfile
783 788 value3 = profilesperblock
784 789 format = "int"
785 790 opObj = puObj.addOperation(name=name_operation, optype=optype)
786 791 opObj.addParameter(name=name_parameter1, value=value1)
787 792 opObj.addParameter(name=name_parameter2, value=value2, format=format)
788 793 opObj.addParameter(name=name_parameter3, value=value3, format=format)
789 794
790 795 #---------NEW VOLTAGE PROPERTIES
791 self.showPUVoltageProperties(puObj)
796 self.refreshPUProperties(puObj)
792 797
793 798 self.console.clear()
794 799 self.console.append("If you want to save your project")
795 800 self.console.append("click on your project name in the Tree Project Explorer")
796 801
797 802 self.actionSaveToolbar.setEnabled(True)
798 803 self.actionStarToolbar.setEnabled(True)
799 804
800 805 return 1
801 806
802 807 """
803 808 Voltage Graph
804 809 """
805 810 @pyqtSignature("int")
806 811 def on_volGraphCebSave_stateChanged(self, p0):
807 812 """
808 813 Check Box habilita ingresode del numero de Integraciones a realizar
809 814 """
810 815 if p0 == 2:
811 816 self.volGraphPath.setEnabled(True)
812 817 self.volGraphPrefix.setEnabled(True)
813 818 self.volGraphToolPath.setEnabled(True)
814 819
815 820 if p0 == 0:
816 821 self.volGraphPath.setEnabled(False)
817 822 self.volGraphPrefix.setEnabled(False)
818 823 self.volGraphToolPath.setEnabled(False)
819 824
820 825 @pyqtSignature("")
821 826 def on_volGraphToolPath_clicked(self):
822 827 """
823 828 Donde se guardan los DATOS
824 829 """
825 830 self.dataPath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
826 831 self.volGraphPath.setText(self.dataPath)
827 832
828 833 # if not os.path.exists(self.dataPath):
829 834 # self.volGraphOk.setEnabled(False)
830 835 # return
831 836
832 837 @pyqtSignature("int")
833 838 def on_volGraphCebshow_stateChanged(self, p0):
834 839 """
835 840 Check Box habilita ingresode del numero de Integraciones a realizar
836 841 """
837 842 if p0 == 0:
838 843
839 844 self.volGraphChannelList.setEnabled(False)
840 845 self.volGraphfreqrange.setEnabled(False)
841 846 self.volGraphHeightrange.setEnabled(False)
842 847 if p0 == 2:
843 848
844 849 self.volGraphChannelList.setEnabled(True)
845 850 self.volGraphfreqrange.setEnabled(True)
846 851 self.volGraphHeightrange.setEnabled(True)
847 852
848 853 """
849 854 Spectra operation
850 855 """
851 856 @pyqtSignature("int")
852 857 def on_specOpCebRadarfrequency_stateChanged(self, p0):
853 858 """
854 859 Check Box habilita ingresode del numero de Integraciones a realizar
855 860 """
856 861 if p0 == 2:
857 862 self.specOpRadarfrequency.setEnabled(True)
858 863 if p0 == 0:
859 864 self.specOpRadarfrequency.clear()
860 865 self.specOpRadarfrequency.setEnabled(False)
861 866
862 867
863 868 @pyqtSignature("int")
864 869 def on_specOpCebCrossSpectra_stateChanged(self, p0):
865 870 """
866 871 Habilita la opcion de aοΏ½adir el parοΏ½metro CrossSpectra a la Unidad de Procesamiento .
867 872 """
868 873 if p0 == 2:
869 874 # self.specOpnFFTpoints.setEnabled(True)
870 875 self.specOppairsList.setEnabled(True)
871 876 if p0 == 0:
872 877 # self.specOpnFFTpoints.setEnabled(False)
873 878 self.specOppairsList.setEnabled(False)
874 879
875 880 @pyqtSignature("int")
876 881 def on_specOpCebChannel_stateChanged(self, p0):
877 882 """
878 883 Habilita la opcion de aοΏ½adir el parοΏ½metro numero de Canales a la Unidad de Procesamiento .
879 884 """
880 885 if p0 == 2:
881 886 self.specOpChannel.setEnabled(True)
882 887 self.specOpComChannel.setEnabled(True)
883 888 if p0 == 0:
884 889 self.specOpChannel.setEnabled(False)
885 890 self.specOpComChannel.setEnabled(False)
886 891
887 892 @pyqtSignature("int")
888 893 def on_specOpCebHeights_stateChanged(self, p0):
889 894 """
890 895 Habilita la opcion de aοΏ½adir el parοΏ½metro de alturas a la Unidad de Procesamiento .
891 896 """
892 897 if p0 == 2:
893 898 self.specOpComHeights.setEnabled(True)
894 899 self.specOpHeights.setEnabled(True)
895 900 if p0 == 0:
896 901 self.specOpComHeights.setEnabled(False)
897 902 self.specOpHeights.setEnabled(False)
898 903
899 904
900 905 @pyqtSignature("int")
901 906 def on_specOpCebIncoherent_stateChanged(self, p0):
902 907 """
903 908 Habilita la opcion de aοΏ½adir el parοΏ½metro integraciones incoherentes a la Unidad de Procesamiento .
904 909 """
905 910 if p0 == 2:
906 911 self.specOpIncoherent.setEnabled(True)
907 912 if p0 == 0:
908 913 self.specOpIncoherent.setEnabled(False)
909 914
910 915 @pyqtSignature("int")
911 916 def on_specOpCebRemoveDC_stateChanged(self, p0):
912 917 """
913 918 Habilita la opcion de aοΏ½adir el parοΏ½metro remover DC a la Unidad de Procesamiento .
914 919 """
915 920 if p0 == 2:
916 921 self.specOpComRemoveDC.setEnabled(True)
917 922 if p0 == 0:
918 923 self.specOpComRemoveDC.setEnabled(False)
919 924
920 925 @pyqtSignature("int")
921 926 def on_specOpCebgetNoise_stateChanged(self, p0):
922 927 """
923 928 Habilita la opcion de aοΏ½adir la estimacion de ruido a la Unidad de Procesamiento .
924 929 """
925 930 if p0 == 2:
926 931 self.specOpgetNoise.setEnabled(True)
927 932
928 933 if p0 == 0:
929 934 self.specOpgetNoise.setEnabled(False)
930 935
931 936 def refreshID(self, puObj):
932 937 opObj = puObj.getOperationObj(name='Scope')
933 938 # opObj = puObj.getOpObjfromParamValue(value="Scope")
934 939 if opObj == None:
935 940 pass
936 941 else:
937 942 name_parameter1 = 'id'
938 943 format1 = 'int'
939 944 if self.idImagscope == 0:
940 945 self.idImagscope = 100
941 946 else:
942 947 self.idImagscope = self.idImagscope + 1
943 948 value1 = int(self.idImagscope)
944 949 opObj.changeParameter(name=name_parameter1, value=value1, format=format1)
945 950
946 951 opObj = puObj.getOperationObj(name='SpectraPlot')
947 952 # opObj = puObj.getOpObjfromParamValue(value="SpectraPlot")
948 953 if opObj == None:
949 954 pass
950 955 else:
951 956 name_parameter1 = 'id'
952 957 format1 = 'int'
953 958 if self.idImagspectra == 0:
954 959 self.idImagspectra = 200
955 960 else:
956 961 self.idImagspectra = self.idImagspectra + 1
957 962 value1 = int(self.idImagspectra)
958 963 opObj.changeParameter(name=name_parameter1, value=value1, format=format1)
959 964
960 965 opObj = puObj.getOperationObj(name='CrossSpectraPlot')
961 966 # opObj = puObj.getOpObjfromParamValue(value="CrossSpectraPlot")
962 967 if opObj == None:
963 968 pass
964 969 else:
965 970 name_parameter1 = 'id'
966 971 format1 = 'int'
967 972 if self.idImagcross == 0:
968 973 self.idImagcross = 300
969 974 else:
970 975 self.idImagcross = self.idImagcross + 1
971 976 value1 = int(self.idImagcross)
972 977 opObj.changeParameter(name=name_parameter1, value=value1, format=format1)
973 978
974 979 opObj = puObj.getOperationObj(name='RTIPlot')
975 980 # opObj = puObj.getOpObjfromParamValue(value="RTIPlot")
976 981 if opObj == None:
977 982 pass
978 983 else:
979 984 name_parameter1 = 'id'
980 985 format1 = 'int'
981 986 if self.idImagrti == 0:
982 987 self.idImagrti = 400
983 988 else:
984 989 self.idImagrti = self.idImagrti + 1
985 990 value1 = int(self.idImagrti)
986 991 opObj.changeParameter(name=name_parameter1, value=value1, format=format1)
987 992
988 993 opObj = puObj.getOperationObj(name='CoherenceMap')
989 994 # opObj = puObj.getOpObjfromParamValue(value="CoherenceMap")
990 995 if opObj == None:
991 996 pass
992 997 else:
993 998 name_parameter1 = 'id'
994 999 format1 = 'int'
995 1000 if self.idImagcoherence == 0:
996 1001 self.idImagcoherence = 500
997 1002 else:
998 1003 self.idImagcoherence = self.idImagcoherence + 1
999 1004 value1 = int(self.idImagcoherence)
1000 1005 opObj.changeParameter(name=name_parameter1, value=value1, format=format1)
1001 1006
1002 1007 opObj = puObj.getOperationObj(name='PowerProfilePlot')
1003 1008 # opObj = puObj.getOpObjfromParamValue(value="PowerProfilePlot")
1004 1009 if opObj == None:
1005 1010 pass
1006 1011 else:
1007 1012 name_parameter1 = 'id'
1008 1013 format1 = 'int'
1009 1014 if self.idImagpower == 0:
1010 1015 self.idImagpower = 600
1011 1016 else:
1012 1017 self.idImagpower = self.idImagpower + 1
1013 1018 value1 = int(self.idImagpower)
1014 1019 opObj.changeParameter(name=name_parameter1, value=value1, format=format1)
1015 1020
1016 1021 opObj = puObj.getOperationObj(name='Noise')
1017 1022 # opObj = puObj.getOpObjfromParamValue(value="Noise")
1018 1023 if opObj == None:
1019 1024 pass
1020 1025 else:
1021 1026 name_parameter1 = 'id'
1022 1027 format1 = 'int'
1023 1028 if self.idImagrtinoise == 0:
1024 1029 self.idImagrtinoise = 700
1025 1030 else:
1026 1031 self.idImagrtinoise = self.idImagrtinoise + 1
1027 1032 value1 = int(self.idImagrtinoise)
1028 1033 opObj.changeParameter(name=name_parameter1, value=value1, format=format1)
1029 1034
1030 1035 opObj = puObj.getOperationObj(name='SpectraHeisScope')
1031 1036 # opObj = puObj.getOpObjfromParamValue(value="SpectraHeisScope")
1032 1037 if opObj == None:
1033 1038 pass
1034 1039 else:
1035 1040 name_parameter1 = 'id'
1036 1041 format1 = 'int'
1037 1042 if self.idImagspectraHeis == 0:
1038 1043 self.idImagspectraHeis = 800
1039 1044 else:
1040 1045 self.idImagspectraHeis = self.idImagspectraHeis + 1
1041 1046 value1 = int(self.idImagspectraHeis)
1042 1047 opObj.changeParameter(name=name_parameter1, value=value1, format=format1)
1043 1048
1044 1049 opObj = puObj.getOperationObj(name='RTIfromSpectraHeis')
1045 1050 # opObj = puObj.getOpObjfromParamValue(value="RTIfromSpectraHeis")
1046 1051 if opObj == None:
1047 1052 pass
1048 1053 else:
1049 1054 name_parameter1 = 'id'
1050 1055 format1 = 'int'
1051 1056 if self.idImagrtiHeis == 0:
1052 1057 self.idImagrtiHeis = 900
1053 1058 else:
1054 1059 self.idImagrtiHeis = self.idImagrtiHeis + 1
1055 1060 value1 = int(self.idImagrtiHeis)
1056 1061 opObj.changeParameter(name=name_parameter1, value=value1, format=format1)
1057 1062
1058 1063 @pyqtSignature("")
1059 1064 def on_specOpOk_clicked(self):
1060 1065 """
1061 1066 AΓ‘ADE OPERACION SPECTRA
1062 1067 """
1063 1068
1064 1069 addFTP = False
1065 1070 checkPath = False
1066 1071
1067 1072 self.actionSaveToolbar.setEnabled(False)
1068 1073 self.actionStarToolbar.setEnabled(False)
1069 1074
1070 puObj = self.getSelectedPUObj()
1075 projectObj = self.getSelectedProjectObj()
1076 puObj = self.getSelectedItemObj()
1077
1071 1078 puObj.removeOperations()
1072 1079
1073 1080 if self.specOpCebRadarfrequency.isChecked():
1074 1081 value = self.specOpRadarfrequency.text()
1075 1082 format = 'float'
1076 1083 name_operation = 'setRadarFrequency'
1077 1084 name_parameter = 'frequency'
1078 1085 if not value == "":
1079 1086 try:
1080 1087 radarfreq = float(self.specOpRadarfrequency.text())
1081 1088 except:
1082 1089 self.console.clear()
1083 1090 self.console.append("Write the parameter Radar Frequency type float")
1084 1091 return 0
1085 1092 opObj = puObj.addOperation(name=name_operation)
1086 1093 opObj.addParameter(name=name_parameter, value=radarfreq, format=format)
1087 1094
1088
1089 if self.proComDataType.currentText() == 'Voltage':
1090 name_parameter = 'nFFTPoints'
1091 value = self.specOpnFFTpoints.text()
1092 name_parameter1 = 'nProfiles'
1093 value1 = self.specOpProfiles.text()
1094 name_parameter2 = 'ippFactor'
1095 value2 = self.specOpippFactor.text()
1096 format = 'int'
1095 inputId = puObj.getInputId()
1096 inputPuObj = projectObj.getProcUnitObj(inputId)
1097
1098 if inputPuObj.datatype == 'Voltage' or inputPuObj.datatype == 'USRP':
1099
1097 1100 try:
1098 1101 value = int(self.specOpnFFTpoints.text())
1102 puObj.addParameter(name='nFFTPoints', value=value, format='int')
1099 1103 except:
1100 1104 self.console.clear()
1101 self.console.append("Please Write the number of FFT")
1105 self.console.append("Please write the number of FFT")
1102 1106 return 0
1103 puObj.addParameter(name=name_parameter, value=value, format=format)
1104 if not value1 == "":
1105 try:
1106 value1 = int(self.specOpProfiles.text())
1107 except:
1108 self.console.clear()
1109 self.console.append("Please Write the number of Profiles")
1110 return 0
1111 puObj.addParameter(name=name_parameter1, value=value1, format=format)
1112 if not value2 == "":
1113 try:
1114 value2 = int(self.specOpippFactor.text())
1115 except:
1116 self.console.clear()
1117 self.console.append("Please Write the Number of IppFactor")
1118 puObj.addParameter(name=name_parameter2 , value=value2 , format=format)
1107
1108 try:
1109 value1 = int(self.specOpProfiles.text())
1110 puObj.addParameter(name='nProfiles', value=value1, format='int')
1111 except:
1112 self.console.append("Please Write the number of Profiles")
1113
1114 try:
1115 value2 = int(self.specOpippFactor.text())
1116 puObj.addParameter(name='ippFactor' , value=value2 , format='int')
1117 except:
1118 self.console.append("Please Write the Number of IppFactor")
1119
1119 1120
1120 1121 if self.specOpCebCrossSpectra.isChecked():
1121 1122 name_parameter = 'pairsList'
1122 1123 format = 'pairslist'
1123 1124 value2 = self.specOppairsList.text()
1124 1125 puObj.addParameter(name=name_parameter, value=value2, format=format)
1125 1126
1126 1127 if self.specOpCebHeights.isChecked():
1127 1128 value = str(self.specOpHeights.text())
1128 1129
1129 1130 if value == "":
1130 1131 print "Please fill height range"
1131 1132 return 0
1132 1133
1133 1134 valueList = value.split(',')
1134 1135 format = 'float'
1135 1136 value0 = valueList[0]
1136 1137 value1 = valueList[1]
1137 1138
1138 1139 if self.specOpComHeights.currentIndex() == 0:
1139 1140 name_operation = 'selectHeights'
1140 1141 name_parameter1 = 'minHei'
1141 1142 name_parameter2 = 'maxHei'
1142 1143 else:
1143 1144 name_operation = 'selectHeightsByIndex'
1144 1145 name_parameter1 = 'minIndex'
1145 1146 name_parameter2 = 'maxIndex'
1146 1147 opObj = puObj.addOperation(name=name_operation)
1147 1148 opObj.addParameter(name=name_parameter1, value=value0, format=format)
1148 1149 opObj.addParameter(name=name_parameter2, value=value1, format=format)
1149 1150
1150 1151 if self.specOpCebChannel.isChecked():
1151 1152 value = str(self.specOpChannel.text())
1152 1153
1153 1154 if value == "":
1154 1155 print "Please fill channel list"
1155 1156 return 0
1156 1157
1157 1158 format = 'intlist'
1158 1159 if self.specOpComChannel.currentIndex() == 0:
1159 1160 name_operation = "selectChannels"
1160 1161 name_parameter = 'channelList'
1161 1162 else:
1162 1163 name_operation = "selectChannelsByIndex"
1163 1164 name_parameter = 'channelIndexList'
1164 1165 opObj = puObj.addOperation(name=name_operation)
1165 1166 opObj.addParameter(name=name_parameter, value=value, format=format)
1166 1167
1167 1168 if self.specOpCebIncoherent.isChecked():
1168 1169 value = str(self.specOpIncoherent.text())
1169 1170
1170 1171 if value == "":
1171 1172 print "Please fill Incoherent integration value"
1172 1173 return 0
1173 1174
1174 1175 name_operation = 'IncohInt'
1175 1176 optype = 'other'
1176 1177 if self.specOpCobIncInt.currentIndex() == 0:
1177 1178 name_parameter = 'timeInterval'
1178 1179 format = 'float'
1179 1180 else:
1180 1181 name_parameter = 'n'
1181 1182 format = 'float'
1182 1183
1183 1184 opObj = puObj.addOperation(name=name_operation, optype=optype)
1184 1185 opObj.addParameter(name=name_parameter, value=value, format=format)
1185 1186
1186 1187 if self.specOpCebRemoveDC.isChecked():
1187 1188 name_operation = 'removeDC'
1188 1189 name_parameter = 'mode'
1189 1190 format = 'int'
1190 1191 if self.specOpComRemoveDC.currentIndex() == 0:
1191 1192 value = 1
1192 1193 else:
1193 1194 value = 2
1194 1195 opObj = puObj.addOperation(name=name_operation)
1195 1196 opObj.addParameter(name=name_parameter, value=value, format=format)
1196 1197
1197 1198 if self.specOpCebRemoveInt.isChecked():
1198 1199 name_operation = 'removeInterference'
1199 1200 opObj = puObj.addOperation(name=name_operation)
1200 1201
1201 1202
1202 1203 if self.specOpCebgetNoise.isChecked():
1203 1204 value = self.specOpgetNoise.text()
1204 1205 valueList = value.split(',')
1205 1206 format = 'float'
1206 1207 name_operation = "getNoise"
1207 1208 opObj = puObj.addOperation(name=name_operation)
1208 1209
1209 1210 if not value == '':
1210 1211 valueList = value.split(',')
1211 1212 length = len(valueList)
1212 1213 if length == 1:
1213 1214 try:
1214 1215 value1 = float(valueList[0])
1215 1216 except:
1216 1217 self.console.clear()
1217 1218 self.console.append("Please Write correct parameter Get Noise")
1218 1219 return 0
1219 1220 name1 = 'minHei'
1220 1221 opObj.addParameter(name=name1, value=value1, format=format)
1221 1222 elif length == 2:
1222 1223 try:
1223 1224 value1 = float(valueList[0])
1224 1225 value2 = float(valueList[1])
1225 1226 except:
1226 1227 self.console.clear()
1227 1228 self.console.append("Please Write corrects parameter Get Noise")
1228 1229 return 0
1229 1230 name1 = 'minHei'
1230 1231 name2 = 'maxHei'
1231 1232 opObj.addParameter(name=name1, value=value1, format=format)
1232 1233 opObj.addParameter(name=name2, value=value2, format=format)
1233 1234
1234 1235 elif length == 3:
1235 1236 try:
1236 1237 value1 = float(valueList[0])
1237 1238 value2 = float(valueList[1])
1238 1239 value3 = float(valueList[2])
1239 1240 except:
1240 1241 self.console.clear()
1241 1242 self.console.append("Please Write corrects parameter Get Noise")
1242 1243 return 0
1243 1244 name1 = 'minHei'
1244 1245 name2 = 'maxHei'
1245 1246 name3 = 'minVel'
1246 1247 opObj.addParameter(name=name1, value=value1, format=format)
1247 1248 opObj.addParameter(name=name2, value=value2, format=format)
1248 1249 opObj.addParameter(name=name3, value=value3, format=format)
1249 1250
1250 1251 elif length == 4:
1251 1252 try:
1252 1253 value1 = float(valueList[0])
1253 1254 value2 = float(valueList[1])
1254 1255 value3 = float(valueList[2])
1255 1256 value4 = float(valueList[3])
1256 1257 except:
1257 1258 self.console.clear()
1258 1259 self.console.append("Please Write corrects parameter Get Noise")
1259 1260 return 0
1260 1261 name1 = 'minHei'
1261 1262 name2 = 'maxHei'
1262 1263 name3 = 'minVel'
1263 1264 name4 = 'maxVel'
1264 1265 opObj.addParameter(name=name1, value=value1, format=format)
1265 1266 opObj.addParameter(name=name2, value=value2, format=format)
1266 1267 opObj.addParameter(name=name3, value=value3, format=format)
1267 1268 opObj.addParameter(name=name4, value=value4, format=format)
1268 1269
1269 1270 elif length > 4:
1270 1271 self.console.clear()
1271 1272 self.console.append("Get Noise Operation only accepts 4 parameters")
1272 1273 return 0
1273 1274
1274 1275 #-----Spectra Plot-----
1275 1276 if self.specGraphCebSpectraplot.isChecked():
1276 1277 name_operation = 'SpectraPlot'
1277 1278 optype = 'other'
1278 1279 name_parameter = 'type'
1279 1280 value = 'SpectraPlot'
1280 1281 format = 'str'
1281 1282 if self.idImagspectra == 0:
1282 1283 self.idImagspectra = 200
1283 1284 else:
1284 1285 self.idImagspectra = self.idImagspectra + 1
1285 1286 name_parameter1 = 'id'
1286 1287 value1 = int(self.idImagspectra)
1287 1288 format1 = 'int'
1288 1289
1289 1290 format = 'str'
1290 1291
1291 1292 channelList = self.specGgraphChannelList.text()
1292 1293 xvalue = self.specGgraphFreq.text()
1293 1294 yvalue = self.specGgraphHeight.text()
1294 1295 zvalue = self.specGgraphDbsrange.text()
1295 1296 opObj = puObj.addOperation(name=name_operation, optype=optype)
1296 1297 # opObj.addParameter(name=name_parameter, value=value, format=format)
1297 1298 opObj.addParameter(name=name_parameter1, value=value1, format=format1)
1298 1299
1299 1300 if not channelList == '':
1300 1301 name_parameter = 'channelList'
1301 1302 format = 'intlist'
1302 1303 opObj.addParameter(name=name_parameter, value=channelList, format=format)
1303 1304
1304 1305 if not xvalue == '':
1305 1306 xvalueList = xvalue.split(',')
1306 1307 try:
1307 1308 value1 = float(xvalueList[0])
1308 1309 value2 = float(xvalueList[1])
1309 1310 except:
1310 1311 self.console.clear()
1311 1312 self.console.append("Please Write corrects parameter freq")
1312 1313 return 0
1313 1314 name1 = 'xmin'
1314 1315 name2 = 'xmax'
1315 1316 format = 'float'
1316 1317 opObj.addParameter(name=name1, value=value1, format=format)
1317 1318 opObj.addParameter(name=name2, value=value2, format=format)
1318 1319 #------specGgraphHeight---
1319 1320 if not yvalue == '':
1320 1321 yvalueList = yvalue.split(",")
1321 1322 try:
1322 1323 value1 = float(yvalueList[0])
1323 1324 value2 = float(yvalueList[1])
1324 1325 except:
1325 1326 self.console.clear()
1326 1327 self.console.append("Please Write corrects parameter Height")
1327 1328 return 0
1328 1329 name1 = 'ymin'
1329 1330 name2 = 'ymax'
1330 1331 format = 'float'
1331 1332 opObj.addParameter(name=name1, value=value1, format=format)
1332 1333 opObj.addParameter(name=name2, value=value2, format=format)
1333 1334
1334 1335 if not zvalue == '':
1335 1336 zvalueList = zvalue.split(",")
1336 1337 try:
1337 1338 value = float(zvalueList[0])
1338 1339 value = float(zvalueList[1])
1339 1340 except:
1340 1341 self.console.clear()
1341 1342 self.console.append("Please Write corrects parameter Dbsrange")
1342 1343 return 0
1343 1344 format = 'float'
1344 1345 opObj.addParameter(name='zmin', value=zvalueList[0], format=format)
1345 1346 opObj.addParameter(name='zmax', value=zvalueList[1], format=format)
1346 1347
1347 1348 if self.specGraphSaveSpectra.isChecked():
1348 1349 checkPath = True
1349 1350 name_parameter1 = 'save'
1350 1351 name_parameter2 = 'figpath'
1351 1352 name_parameter3 = 'figfile'
1352 1353 value1 = '1'
1353 1354 value2 = self.specGraphPath.text()
1354 1355 value3 = self.specGraphPrefix.text()
1355 1356 format1 = 'bool'
1356 1357 format2 = 'str'
1357 1358 opObj.addParameter(name=name_parameter1, value=value1 , format=format1)
1358 1359 opObj.addParameter(name=name_parameter2, value=value2, format=format2)
1359 1360 opObj.addParameter(name=name_parameter3, value=value3, format=format2)
1360 1361
1361 1362 # opObj.addParameter(name='wr_period', value='5',format='int')
1362 1363
1363 1364 if self.specGraphftpSpectra.isChecked():
1364 1365 opObj.addParameter(name='ftp', value='1', format='int')
1365 1366 self.addFTPConf2Operation(puObj, opObj)
1366 1367 addFTP = True
1367 1368
1368 1369 if self.specGraphCebCrossSpectraplot.isChecked():
1369 1370 name_operation = 'CrossSpectraPlot'
1370 1371 optype = 'other'
1371 1372 opObj = puObj.addOperation(name=name_operation, optype=optype)
1372 1373 # opObj.addParameter(name='type', value="CrossSpectraPlot", format='str')
1373 1374 opObj.addParameter(name='power_cmap', value='jet', format='str')
1374 1375 opObj.addParameter(name='coherence_cmap', value='jet', format='str')
1375 1376 opObj.addParameter(name='phase_cmap', value='RdBu_r', format='str')
1376 1377
1377 1378 if self.idImagcross == 0:
1378 1379 self.idImagcross = 300
1379 1380 else:
1380 1381 self.idImagcross = self.idImagcross + 1
1381 1382 value1 = int(self.idImagcross)
1382 1383 channelList = self.specGgraphChannelList.text()
1383 1384 xvalue = self.specGgraphFreq.text()
1384 1385 yvalue = self.specGgraphHeight.text()
1385 1386 zvalue = self.specGgraphDbsrange.text()
1386 1387
1387 1388 opObj.addParameter(name='id', value=value1, format='int')
1388 1389
1389 1390 if self.specGgraphChannelList.isModified():
1390 1391 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1391 1392
1392 1393 if not xvalue == '':
1393 1394 xvalueList = xvalue.split(',')
1394 1395 try:
1395 1396 value = float(xvalueList[0])
1396 1397 value = float(xvalueList[1])
1397 1398 except:
1398 1399 return 0
1399 1400 format = 'float'
1400 1401 opObj.addParameter(name='xmin', value=xvalueList[0], format=format)
1401 1402 opObj.addParameter(name='xmax', value=xvalueList[1], format=format)
1402 1403
1403 1404 if not yvalue == '':
1404 1405 yvalueList = yvalue.split(",")
1405 1406 try:
1406 1407 value = float(yvalueList[0])
1407 1408 value = float(yvalueList[1])
1408 1409 except:
1409 1410 return 0
1410 1411 format = 'float'
1411 1412 opObj.addParameter(name='ymin', value=yvalueList[0], format=format)
1412 1413 opObj.addParameter(name='ymax', value=yvalueList[1], format=format)
1413 1414
1414 1415
1415 1416 if not zvalue == '':
1416 1417 zvalueList = zvalue.split(",")
1417 1418 try:
1418 1419 value = float(zvalueList[0])
1419 1420 value = float(zvalueList[1])
1420 1421 except:
1421 1422 return 0
1422 1423 opObj.addParameter(name='zmin', value=zvalueList[0], format='float')
1423 1424 opObj.addParameter(name='zmax', value=zvalueList[1], format='float')
1424 1425
1425 1426 if self.specGraphSaveCross.isChecked():
1426 1427 checkPath = True
1427 1428 opObj.addParameter(name='save', value='1', format='bool')
1428 1429 opObj.addParameter(name='figpath', value=self.specGraphPath.text(), format='str')
1429 1430 value = self.specGraphPrefix.text()
1430 1431 if not value == "":
1431 1432 try:
1432 1433 value = str(self.specGraphPrefix.text())
1433 1434 except:
1434 1435 self.console.clear()
1435 1436 self.console.append("Please Write prefix")
1436 1437 return 0
1437 1438 opObj.addParameter(name='figfile', value=value, format='str')
1438 1439 # opObj.addParameter(name='figfile', value=self.specGraphPrefix.text(), format='str')
1439 1440 if self.specGraphftpCross.isChecked():
1440 1441 opObj.addParameter(name='ftp', value='1', format='int')
1441 1442 self.addFTPConf2Operation(puObj, opObj)
1442 1443 addFTP = True
1443 1444
1444 1445 if self.specGraphCebRTIplot.isChecked():
1445 1446 name_operation = 'RTIPlot'
1446 1447 optype = 'other'
1447 1448 name_parameter = 'type'
1448 1449 value = 'RTIPlot'
1449 1450 format = 'str'
1450 1451
1451 1452 if self.idImagrti == 0:
1452 1453 self.idImagrti = 400
1453 1454 else:
1454 1455 self.idImagrti = self.idImagrti + 1
1455 1456
1456 1457 name_parameter1 = 'id'
1457 1458 value1 = int(self.idImagrti)
1458 1459 format1 = 'int'
1459 1460
1460 1461 format = 'str'
1461 1462
1462 1463 opObj = puObj.addOperation(name=name_operation, optype=optype)
1463 1464 # opObj.addParameter(name=name_parameter, value=value, format=format)
1464 1465 opObj.addParameter(name=name_parameter1, value=value1, format=format1)
1465 1466
1466 1467 channelList = self.specGgraphChannelList.text()
1467 1468 xvalue = self.specGgraphTminTmax.text()
1468 1469 yvalue = self.specGgraphHeight.text()
1469 1470 zvalue = self.specGgraphDbsrange.text()
1470 1471 timerange = self.specGgraphTimeRange.text()
1471 1472
1472 1473 if not channelList == '':
1473 1474 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1474 1475
1475 1476 if not xvalue == '':
1476 1477 xvalueList = xvalue.split(',')
1477 1478 try:
1478 1479 value = float(xvalueList[0])
1479 1480 value = float(xvalueList[1])
1480 1481 except:
1481 1482 return 0
1482 1483 format = 'float'
1483 1484 opObj.addParameter(name='xmin', value=xvalueList[0], format=format)
1484 1485 opObj.addParameter(name='xmax', value=xvalueList[1], format=format)
1485 1486
1486 1487 if not timerange == '':
1487 1488 format = 'int'
1488 1489 try:
1489 1490 timerange = int(timerange)
1490 1491 except:
1491 1492 return 0
1492 1493 opObj.addParameter(name='timerange', value=timerange, format=format)
1493 1494
1494 1495
1495 1496 if not yvalue == '':
1496 1497 yvalueList = yvalue.split(",")
1497 1498 try:
1498 1499 value = float(yvalueList[0])
1499 1500 value = float(yvalueList[1])
1500 1501 except:
1501 1502 return 0
1502 1503 format = 'float'
1503 1504 opObj.addParameter(name='ymin', value=yvalueList[0], format=format)
1504 1505 opObj.addParameter(name='ymax', value=yvalueList[1], format=format)
1505 1506
1506 1507 if not zvalue == '':
1507 1508 zvalueList = zvalue.split(",")
1508 1509 try:
1509 1510 value = float(zvalueList[0])
1510 1511 value = float(zvalueList[1])
1511 1512 except:
1512 1513 return 0
1513 1514 format = 'float'
1514 1515 opObj.addParameter(name='zmin', value=zvalueList[0], format=format)
1515 1516 opObj.addParameter(name='zmax', value=zvalueList[1], format=format)
1516 1517
1517 1518 if self.specGraphSaveRTIplot.isChecked():
1518 1519 checkPath = True
1519 1520 opObj.addParameter(name='save', value='1', format='bool')
1520 1521 opObj.addParameter(name='figpath', value=self.specGraphPath.text(), format='str')
1521 1522 value = self.specGraphPrefix.text()
1522 1523 if not value == "":
1523 1524 try:
1524 1525 value = str(self.specGraphPrefix.text())
1525 1526 except:
1526 1527 self.console.clear()
1527 1528 self.console.append("Please Write prefix")
1528 1529 return 0
1529 1530 opObj.addParameter(name='figfile', value=value, format='str')
1530 1531
1531 1532 # test_ftp
1532 1533 if self.specGraphftpRTIplot.isChecked():
1533 1534 opObj.addParameter(name='ftp', value='1', format='int')
1534 1535 self.addFTPConf2Operation(puObj, opObj)
1535 1536 addFTP = True
1536 1537
1537 1538 if self.specGraphCebCoherencmap.isChecked():
1538 1539 name_operation = 'CoherenceMap'
1539 1540 optype = 'other'
1540 1541 name_parameter = 'type'
1541 1542 value = 'CoherenceMap'
1542 1543 format = 'str'
1543 1544 if self.idImagcoherence == 0:
1544 1545 self.idImagcoherence = 500
1545 1546 else:
1546 1547 self.idImagcoherence = self.idImagcoherence + 1
1547 1548
1548 1549 name_parameter1 = 'id'
1549 1550 value1 = int(self.idImagcoherence)
1550 1551 format1 = 'int'
1551 1552
1552 1553 opObj = puObj.addOperation(name=name_operation, optype=optype)
1553 1554 # opObj.addParameter(name=name_parameter, value=value, format=format)
1554 1555 # opObj.addParameter(name='coherence_cmap', value='jet', format='str')
1555 1556 # opObj.addParameter(name='phase_cmap', value='RdBu_r', format='str')
1556 1557 opObj.addParameter(name=name_parameter1, value=value1, format=format1)
1557 1558
1558 1559 channelList = self.specGgraphChannelList.text()
1559 1560 if not channelList == '':
1560 1561 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1561 1562
1562 1563 timerange = self.specGgraphTimeRange.text()
1563 1564 if not timerange == '':
1564 1565 try:
1565 1566 timerange = int(timerange)
1566 1567 except:
1567 1568 return 0
1568 1569 format = 'int'
1569 1570 opObj.addParameter(name='timerange', value=timerange, format=format)
1570 1571
1571 1572 xvalue = self.specGgraphTminTmax.text()
1572 1573 if not xvalue == '':
1573 1574 xvalueList = xvalue.split(',')
1574 1575 try:
1575 1576 value = float(xvalueList[0])
1576 1577 value = float(xvalueList[1])
1577 1578 except:
1578 1579 return 0
1579 1580 format = 'float'
1580 1581 opObj.addParameter(name='xmin', value=xvalueList[0], format=format)
1581 1582 opObj.addParameter(name='xmax', value=xvalueList[1], format=format)
1582 1583
1583 1584 yvalue = self.specGgraphHeight.text()
1584 1585 if not yvalue == '':
1585 1586 yvalueList = yvalue.split(",")
1586 1587 try:
1587 1588 value = float(yvalueList[0])
1588 1589 value = float(yvalueList[1])
1589 1590 except:
1590 1591 return 0
1591 1592 format = 'float'
1592 1593 opObj.addParameter(name='ymin', value=yvalueList[0], format=format)
1593 1594 opObj.addParameter(name='ymax', value=yvalueList[1], format=format)
1594 1595
1595 1596 zvalue = self.specGgraphmagnitud.text()
1596 1597 if not zvalue == '':
1597 1598 zvalueList = zvalue.split(",")
1598 1599 try:
1599 1600 value = float(zvalueList[0])
1600 1601 value = float(zvalueList[1])
1601 1602 except:
1602 1603 return 0
1603 1604 opObj.addParameter(name='zmin', value=zvalueList[0], format='float')
1604 1605 opObj.addParameter(name='zmax', value=zvalueList[1], format='float')
1605 1606
1606 1607 if self.specGraphSaveCoherencemap.isChecked():
1607 1608 checkPath = True
1608 1609 opObj.addParameter(name='save', value='1', format='bool')
1609 1610 opObj.addParameter(name='figpath', value=self.specGraphPath.text(), format='str')
1610 1611 value = self.specGraphPrefix.text()
1611 1612 if not value == "":
1612 1613 try:
1613 1614 value = str(self.specGraphPrefix.text())
1614 1615 except:
1615 1616 self.console.clear()
1616 1617 self.console.append("Please Write prefix")
1617 1618 return 0
1618 1619 opObj.addParameter(name='figfile', value=value, format='str')
1619 1620
1620 1621 # test_ftp
1621 1622 if self.specGraphftpCoherencemap.isChecked():
1622 1623 opObj.addParameter(name='ftp', value='1', format='int')
1623 1624 self.addFTPConf2Operation(puObj, opObj)
1624 1625 addFTP = True
1625 1626
1626 1627 if self.specGraphPowerprofile.isChecked():
1627 1628 name_operation = 'PowerProfilePlot'
1628 1629 optype = 'other'
1629 1630 name_parameter = 'type'
1630 1631 value = 'PowerProfilePlot'
1631 1632 format = 'str'
1632 1633
1633 1634 if self.idImagpower == 0:
1634 1635 self.idImagpower = 600
1635 1636 else:
1636 1637 self.idImagpower = self.idImagpower + 1
1637 1638 value1 = int(self.idImagpower)
1638 1639 opObj = puObj.addOperation(name=name_operation, optype=optype)
1639 1640 # opObj.addParameter(name=name_parameter, value=value, format='str')
1640 1641 opObj.addParameter(name='id', value=value1, format='int')
1641 1642
1642 1643 channelList = self.specGgraphChannelList.text()
1643 1644 if not channelList == '':
1644 1645 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1645 1646
1646 1647 xvalue = self.specGgraphDbsrange.text()
1647 1648 if not xvalue == '':
1648 1649 xvalueList = xvalue.split(',')
1649 1650 try:
1650 1651 value = float(xvalueList[0])
1651 1652 value = float(xvalueList[1])
1652 1653 except:
1653 1654 return 0
1654 1655 format = 'float'
1655 1656 opObj.addParameter(name='xmin', value=xvalueList[0], format=format)
1656 1657 opObj.addParameter(name='xmax', value=xvalueList[1], format=format)
1657 1658
1658 1659 yvalue = self.specGgraphHeight.text()
1659 1660 if not yvalue == '':
1660 1661 yvalueList = yvalue.split(",")
1661 1662 try:
1662 1663 value = float(yvalueList[0])
1663 1664 value = float(yvalueList[1])
1664 1665 except:
1665 1666 return 0
1666 1667 format = 'float'
1667 1668 opObj.addParameter(name='ymin', value=yvalueList[0], format=format)
1668 1669 opObj.addParameter(name='ymax', value=yvalueList[1], format=format)
1669 1670
1670 1671
1671 1672 if self.specGraphSavePowerprofile.isChecked():
1672 1673 checkPath = True
1673 1674 opObj.addParameter(name='save', value='1', format='bool')
1674 1675 opObj.addParameter(name='figpath', value=self.specGraphPath.text(), format='str')
1675 1676 value = self.specGraphPrefix.text()
1676 1677 if not value == "":
1677 1678 try:
1678 1679 value = str(self.specGraphPrefix.text())
1679 1680 except:
1680 1681 self.console.clear()
1681 1682 self.console.append("Please Write prefix")
1682 1683 return 0
1683 1684 opObj.addParameter(name='figfile', value=value, format='str')
1684 1685
1685 1686
1686 1687 if self.specGraphftpPowerprofile.isChecked():
1687 1688 opObj.addParameter(name='ftp', value='1', format='int')
1688 1689 self.addFTPConf2Operation(puObj, opObj)
1689 1690 addFTP = True
1690 1691 # rti noise
1691 1692
1692 1693 if self.specGraphCebRTInoise.isChecked():
1693 1694 name_operation = 'Noise'
1694 1695 optype = 'other'
1695 1696 name_parameter = 'type'
1696 1697 value = 'Noise'
1697 1698 format = 'str'
1698 1699
1699 1700 if self.idImagrtinoise == 0:
1700 1701 self.idImagrtinoise = 700
1701 1702 else:
1702 1703 self.idImagrtinoise = self.idImagrtinoise + 1
1703 1704
1704 1705 name_parameter1 = 'id'
1705 1706 value1 = int(self.idImagrtinoise)
1706 1707 format1 = 'int'
1707 1708 format = 'str'
1708 1709
1709 1710 opObj = puObj.addOperation(name=name_operation, optype=optype)
1710 1711 # opObj.addParameter(name=name_parameter, value=value, format=format)
1711 1712 opObj.addParameter(name=name_parameter1, value=value1, format=format1)
1712 1713
1713 1714 channelList = self.specGgraphChannelList.text()
1714 1715 xvalue = self.specGgraphTminTmax.text()
1715 1716 yvalue = self.specGgraphDbsrange.text()
1716 1717 timerange = self.specGgraphTimeRange.text()
1717 1718
1718 1719
1719 1720 if not channelList == '':
1720 1721 opObj.addParameter(name='channelList', value=channelList, format='intlist')
1721 1722
1722 1723 if not timerange == '':
1723 1724 format = 'int'
1724 1725 try:
1725 1726 timerange = int(timerange)
1726 1727 except:
1727 1728 return 0
1728 1729 opObj.addParameter(name='timerange', value=timerange, format=format)
1729 1730
1730 1731 if not xvalue == '':
1731 1732 xvalueList = xvalue.split(',')
1732 1733 try:
1733 1734 value = float(xvalueList[0])
1734 1735 value = float(xvalueList[1])
1735 1736 except:
1736 1737 return 0
1737 1738 format = 'float'
1738 1739 opObj.addParameter(name='xmin', value=xvalueList[0], format=format)
1739 1740 opObj.addParameter(name='xmax', value=xvalueList[1], format=format)
1740 1741
1741 1742 if not yvalue == '':
1742 1743 yvalueList = yvalue.split(",")
1743 1744 try:
1744 1745 value = float(yvalueList[0])
1745 1746 value = float(yvalueList[1])
1746 1747 except:
1747 1748 return 0
1748 1749 format = 'float'
1749 1750 opObj.addParameter(name='ymin', value=yvalueList[0], format=format)
1750 1751 opObj.addParameter(name='ymax', value=yvalueList[1], format=format)
1751 1752
1752 1753 if self.specGraphSaveRTInoise.isChecked():
1753 1754 checkPath = True
1754 1755 opObj.addParameter(name='save', value='1', format='bool')
1755 1756 opObj.addParameter(name='figpath', value=self.specGraphPath.text(), format='str')
1756 1757 value = self.specGraphPrefix.text()
1757 1758 if not value == "":
1758 1759 try:
1759 1760 value = str(self.specGraphPrefix.text())
1760 1761 except:
1761 1762 self.console.clear()
1762 1763 self.console.append("Please Write prefix")
1763 1764 return 0
1764 1765 opObj.addParameter(name='figfile', value=value, format='str')
1765 1766
1766 1767 # test_ftp
1767 1768 if self.specGraphftpRTInoise.isChecked():
1768 1769 opObj.addParameter(name='ftp', value='1', format='int')
1769 1770 self.addFTPConf2Operation(puObj, opObj)
1770 1771 addFTP = True
1771 1772
1772 1773 localfolder = None
1773 1774 if checkPath:
1774 1775 localfolder = str(self.specGraphPath.text())
1775 1776 if localfolder == '':
1776 1777 self.console.clear()
1777 1778 self.console.append("Graphic path should be defined")
1778 1779 return 0
1779 1780
1780 1781 if addFTP:
1781 1782 if not localfolder:
1782 1783 self.console.clear()
1783 1784 self.console.append("You have to save the plots before sending them to FTP Server")
1784 1785 return 0
1785 1786
1786 1787 if not self.temporalFTP.create:
1787 1788 self.temporalFTP.setwithoutconfiguration()
1788 1789
1789 1790 server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.temporalFTP.recover()
1790 1791 self.createFTPProcUnitView(server, username, password, remotefolder,
1791 1792 ftp_wei, exp_code, sub_exp_code, plot_pos,
1792 1793 localfolder=localfolder)
1793 1794 else:
1794 1795 self.removeFTPProcUnitView()
1795 1796
1796 1797 # if something happend
1797 1798 parms_ok, output_path, blocksperfile, profilesperblock = self.checkInputsPUSave(datatype='Spectra')
1798 1799 if parms_ok:
1799 1800 name_operation = 'SpectraWriter'
1800 1801 optype = 'other'
1801 1802 name_parameter1 = 'path'
1802 1803 name_parameter2 = 'blocksPerFile'
1803 1804 name_parameter3 = 'profilesPerBlock'
1804 1805 value1 = output_path
1805 1806 value2 = blocksperfile
1806 1807 value3 = profilesperblock
1807 1808 format = "int"
1808 1809
1809 1810 opObj = puObj.addOperation(name=name_operation, optype=optype)
1810 1811 opObj.addParameter(name=name_parameter1, value=value1)
1811 1812 opObj.addParameter(name=name_parameter2, value=value2, format=format)
1812 1813 opObj.addParameter(name=name_parameter3, value=value3, format=format)
1813 1814
1814 self.showPUSpectraProperties(puObj)
1815 self.refreshPUProperties(puObj)
1815 1816
1816 1817 self.console.clear()
1817 1818 self.console.append("If you want to save your project")
1818 1819 self.console.append("click on your project name in the Tree Project Explorer")
1819 1820
1820 1821 self.actionSaveToolbar.setEnabled(True)
1821 1822 self.actionStarToolbar.setEnabled(True)
1822 1823
1823 1824 return 1
1824 1825
1825 1826 """
1826 1827 Spectra Graph
1827 1828 """
1828 1829 @pyqtSignature("int")
1829 1830 def on_specGraphCebSpectraplot_stateChanged(self, p0):
1830 1831
1831 1832 if p0 == 2:
1832 1833 self.specGgraphChannelList.setEnabled(True)
1833 1834 self.specGgraphFreq.setEnabled(True)
1834 1835 self.specGgraphHeight.setEnabled(True)
1835 1836 self.specGgraphDbsrange.setEnabled(True)
1836 1837 if p0 == 0:
1837 1838 self.specGgraphFreq.setEnabled(False)
1838 1839 self.specGgraphHeight.setEnabled(False)
1839 1840 self.specGgraphDbsrange.setEnabled(False)
1840 1841
1841 1842
1842 1843 @pyqtSignature("int")
1843 1844 def on_specGraphCebCrossSpectraplot_stateChanged(self, p0):
1844 1845
1845 1846 if p0 == 2:
1846 1847 self.specGgraphFreq.setEnabled(True)
1847 1848 self.specGgraphHeight.setEnabled(True)
1848 1849 self.specGgraphDbsrange.setEnabled(True)
1849 1850 if p0 == 0:
1850 1851 self.specGgraphFreq.setEnabled(False)
1851 1852 self.specGgraphHeight.setEnabled(False)
1852 1853 self.specGgraphDbsrange.setEnabled(False)
1853 1854
1854 1855 @pyqtSignature("int")
1855 1856 def on_specGraphCebRTIplot_stateChanged(self, p0):
1856 1857
1857 1858 if p0 == 2:
1858 1859 self.specGgraphChannelList.setEnabled(True)
1859 1860 self.specGgraphTminTmax.setEnabled(True)
1860 1861 self.specGgraphHeight.setEnabled(True)
1861 1862 self.specGgraphDbsrange.setEnabled(True)
1862 1863 self.specGgraphTimeRange.setEnabled(True)
1863 1864
1864 1865 if p0 == 0:
1865 1866 self.specGgraphTminTmax.setEnabled(False)
1866 1867 self.specGgraphHeight.setEnabled(False)
1867 1868 self.specGgraphDbsrange.setEnabled(False)
1868 1869 self.specGgraphTimeRange.setEnabled(False)
1869 1870
1870 1871
1871 1872 @pyqtSignature("int")
1872 1873 def on_specGraphCebRTInoise_stateChanged(self, p0):
1873 1874 if p0 == 2:
1874 1875 self.specGgraphChannelList.setEnabled(True)
1875 1876 self.specGgraphTminTmax.setEnabled(True)
1876 1877 self.specGgraphDbsrange.setEnabled(True)
1877 1878 self.specGgraphTimeRange.setEnabled(True)
1878 1879
1879 1880 if p0 == 0:
1880 1881 self.specGgraphTminTmax.setEnabled(False)
1881 1882 self.specGgraphDbsrange.setEnabled(False)
1882 1883 self.specGgraphTimeRange.setEnabled(False)
1883 1884
1884 1885
1885 1886
1886 1887
1887 1888 @pyqtSignature("int")
1888 1889 def on_specGraphCebCoherencmap_stateChanged(self, p0):
1889 1890
1890 1891 if p0 == 2:
1891 1892 self.specGgraphTminTmax.setEnabled(True)
1892 1893 self.specGgraphHeight.setEnabled(True)
1893 1894 self.specGgraphmagnitud.setEnabled(True)
1894 1895 self.specGgraphTimeRange.setEnabled(True)
1895 1896
1896 1897 if p0 == 0:
1897 1898 self.specGgraphTminTmax.setEnabled(False)
1898 1899 self.specGgraphHeight.setEnabled(False)
1899 1900 self.specGgraphmagnitud.setEnabled(False)
1900 1901 self.specGgraphTimeRange.setEnabled(False)
1901 1902
1902 1903
1903 1904
1904 1905
1905 1906 @pyqtSignature("int")
1906 1907 def on_specGraphPowerprofile_stateChanged(self, p0):
1907 1908
1908 1909 if p0 == 2:
1909 1910
1910 1911 self.specGgraphHeight.setEnabled(True)
1911 1912 self.specGgraphDbsrange.setEnabled(True)
1912 1913 if p0 == 0:
1913 1914 self.specGgraphHeight.setEnabled(False)
1914 1915 self.specGgraphDbsrange.setEnabled(False)
1915 1916
1916 1917 @pyqtSignature("int")
1917 1918 def on_specGraphPhase_stateChanged(self, p0):
1918 1919
1919 1920 if p0 == 2:
1920 1921 self.specGgraphTminTmax.setEnabled(True)
1921 1922 self.specGgraphPhaserange.setEnabled(True)
1922 1923
1923 1924 if p0 == 0:
1924 1925 self.specGgraphTminTmax.setEnabled(False)
1925 1926 self.specGgraphPhaserange.setEnabled(False)
1926 1927
1927 1928 @pyqtSignature("int")
1928 1929 def on_specGraphSaveSpectra_stateChanged(self, p0):
1929 1930 """
1930 1931 """
1931 1932 if p0 == 2:
1932 1933 self.specGraphPath.setEnabled(True)
1933 1934 self.specGraphPrefix.setEnabled(True)
1934 1935 self.specGraphToolPath.setEnabled(True)
1935 1936 if p0 == 0:
1936 1937 self.specGraphPath.setEnabled(False)
1937 1938 self.specGraphPrefix.setEnabled(False)
1938 1939 self.specGraphToolPath.setEnabled(False)
1939 1940
1940 1941
1941 1942 @pyqtSignature("int")
1942 1943 def on_specGraphSaveCross_stateChanged(self, p0):
1943 1944 if p0 == 2:
1944 1945 self.specGraphPath.setEnabled(True)
1945 1946 self.specGraphPrefix.setEnabled(True)
1946 1947 self.specGraphToolPath.setEnabled(True)
1947 1948
1948 1949 @pyqtSignature("int")
1949 1950 def on_specGraphSaveRTIplot_stateChanged(self, p0):
1950 1951 if p0 == 2:
1951 1952 self.specGraphPath.setEnabled(True)
1952 1953 self.specGraphPrefix.setEnabled(True)
1953 1954 self.specGraphToolPath.setEnabled(True)
1954 1955
1955 1956 @pyqtSignature("int")
1956 1957 def on_specGraphSaveRTInoise_stateChanged(self, p0):
1957 1958 if p0 == 2:
1958 1959 self.specGraphPath.setEnabled(True)
1959 1960 self.specGraphPrefix.setEnabled(True)
1960 1961 self.specGraphToolPath.setEnabled(True)
1961 1962
1962 1963 @pyqtSignature("int")
1963 1964 def on_specGraphSaveCoherencemap_stateChanged(self, p0):
1964 1965 if p0 == 2:
1965 1966 self.specGraphPath.setEnabled(True)
1966 1967 self.specGraphPrefix.setEnabled(True)
1967 1968 self.specGraphToolPath.setEnabled(True)
1968 1969
1969 1970
1970 1971 @pyqtSignature("int")
1971 1972 def on_specGraphSavePowerprofile_stateChanged(self, p0):
1972 1973 if p0 == 2:
1973 1974 self.specGraphPath.setEnabled(True)
1974 1975 self.specGraphPrefix.setEnabled(True)
1975 1976 self.specGraphToolPath.setEnabled(True)
1976 1977
1977 1978
1978 1979 #-------ftp-----#
1979 1980 @pyqtSignature("int")
1980 1981 def on_specGraphftpSpectra_stateChanged(self, p0):
1981 1982 """
1982 1983 """
1983 1984 if p0 == 2:
1984 1985 self.specGgraphftpratio.setEnabled(True)
1985 1986
1986 1987 if p0 == 0:
1987 1988 self.specGgraphftpratio.setEnabled(False)
1988 1989
1989 1990
1990 1991 @pyqtSignature("int")
1991 1992 def on_specGraphftpCross_stateChanged(self, p0):
1992 1993 if p0 == 2:
1993 1994 self.specGgraphftpratio.setEnabled(True)
1994 1995
1995 1996 @pyqtSignature("int")
1996 1997 def on_specGraphftpRTIplot_stateChanged(self, p0):
1997 1998 if p0 == 2:
1998 1999 self.specGgraphftpratio.setEnabled(True)
1999 2000
2000 2001 @pyqtSignature("int")
2001 2002 def on_specGraphftpRTInoise_stateChanged(self, p0):
2002 2003 if p0 == 2:
2003 2004 self.specGgraphftpratio.setEnabled(True)
2004 2005
2005 2006 @pyqtSignature("int")
2006 2007 def on_specGraphftpCoherencemap_stateChanged(self, p0):
2007 2008 if p0 == 2:
2008 2009 self.specGgraphftpratio.setEnabled(True)
2009 2010
2010 2011 @pyqtSignature("int")
2011 2012 def on_specGraphftpPowerprofile_stateChanged(self, p0):
2012 2013 if p0 == 2:
2013 2014 self.specGgraphftpratio.setEnabled(True)
2014 2015
2015 2016 #-------------------#
2016 2017
2017 2018
2018 2019
2019 2020 @pyqtSignature("")
2020 2021 def on_specGraphToolPath_clicked(self):
2021 2022 """
2022 2023 """
2023 2024 self.savePath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
2024 2025 self.specGraphPath.setText(self.savePath)
2025 2026 if not os.path.exists(self.savePath):
2026 2027 self.console.clear()
2027 2028 self.console.append("Write a correct a path")
2028 2029 return
2029 2030
2030 2031 @pyqtSignature("")
2031 2032 def on_specHeisGraphToolPath_clicked(self):
2032 2033 """
2033 2034 """
2034 2035 self.savePath = str(QtGui.QFileDialog.getExistingDirectory(self, 'Open Directory', './', QtGui.QFileDialog.ShowDirsOnly))
2035 2036 self.specHeisGraphPath.setText(self.savePath)
2036 2037 if not os.path.exists(self.savePath):
2037 2038 self.console.clear()
2038 2039 self.console.append("Write a correct a path")
2039 2040 return
2040 2041
2041 2042 @pyqtSignature("")
2042 2043 def on_specGraphClear_clicked(self):
2043 2044 self.clearspecGraph()
2044 2045
2045 2046 @pyqtSignature("int")
2046 2047 def on_specHeisOpCebIncoherent_stateChanged(self, p0):
2047 2048 """
2048 2049 Habilita la opcion de aοΏ½adir el parοΏ½metro integraciones incoherentes a la Unidad de Procesamiento .
2049 2050 """
2050 2051 if p0 == 2:
2051 2052 self.specHeisOpIncoherent.setEnabled(True)
2052 2053 self.specHeisOpCobIncInt.setEnabled(True)
2053 2054 if p0 == 0:
2054 2055 self.specHeisOpIncoherent.setEnabled(False)
2055 2056 self.specHeisOpCobIncInt.setEnabled(False)
2056 2057
2057 2058 @pyqtSignature("")
2058 2059 def on_specHeisOpOk_clicked(self):
2059 2060 """
2060 2061 AΓ‘ADE OPERACION SPECTRAHEIS
2061 2062 """
2062 2063 addFTP = False
2063 2064 checkPath = False
2064 2065
2065 2066 self.actionSaveToolbar.setEnabled(False)
2066 2067 self.actionStarToolbar.setEnabled(False)
2067 2068
2068 puObj = self.getSelectedPUObj()
2069 puObj = self.getSelectedItemObj()
2069 2070 puObj.removeOperations()
2070 2071
2071 2072 if self.specHeisOpCebIncoherent.isChecked():
2072 2073 value = self.specHeisOpIncoherent.text()
2073 2074 name_operation = 'IncohInt4SpectraHeis'
2074 2075 optype = 'other'
2075 2076 if self.specOpCobIncInt.currentIndex() == 0:
2076 2077 name_parameter = 'timeInterval'
2077 2078 format = 'float'
2078 2079 opObj = puObj.addOperation(name=name_operation, optype=optype)
2079 2080 opObj.addParameter(name=name_parameter, value=value, format=format)
2080 2081
2081 2082 # ---- Spectra Plot-----
2082 2083 if self.specHeisGraphCebSpectraplot.isChecked():
2083 2084 name_operation = 'SpectraHeisScope'
2084 2085 optype = 'other'
2085 2086 name_parameter = 'type'
2086 2087 value = 'SpectraHeisScope'
2087 2088 format = 'str'
2088 2089 if self.idImagspectraHeis == 0:
2089 2090 self.idImagspectraHeis = 800
2090 2091 else:
2091 2092 self.idImagspectraHeis = self.idImagspectraHeis + 1
2092 2093 name_parameter1 = 'id'
2093 2094 value1 = int(self.idImagspectraHeis)
2094 2095 format1 = 'int'
2095 2096
2096 2097 format = 'str'
2097 2098
2098 2099 channelList = self.specHeisGgraphChannelList.text()
2099 2100 xvalue = self.specHeisGgraphXminXmax.text()
2100 2101 yvalue = self.specHeisGgraphYminYmax.text()
2101 2102 opObj = puObj.addOperation(name=name_operation, optype=optype)
2102 2103 # opObj.addParameter(name=name_parameter, value=value, format=format)
2103 2104 opObj.addParameter(name=name_parameter1, value=value1, format=format1)
2104 2105
2105 2106 if not channelList == '':
2106 2107 name_parameter = 'channelList'
2107 2108 format = 'intlist'
2108 2109 opObj.addParameter(name=name_parameter, value=channelList, format=format)
2109 2110
2110 2111 if not xvalue == '':
2111 2112 xvalueList = xvalue.split(',')
2112 2113 try:
2113 2114 value1 = float(xvalueList[0])
2114 2115 value2 = float(xvalueList[1])
2115 2116 except:
2116 2117 self.console.clear()
2117 2118 self.console.append("Please Write corrects parameter xmin-xmax")
2118 2119 return 0
2119 2120 name1 = 'xmin'
2120 2121 name2 = 'xmax'
2121 2122 format = 'float'
2122 2123 opObj.addParameter(name=name1, value=value1, format=format)
2123 2124 opObj.addParameter(name=name2, value=value2, format=format)
2124 2125 #------specHeisGgraphYmin-Ymax---
2125 2126 if not yvalue == '':
2126 2127 yvalueList = yvalue.split(",")
2127 2128 try:
2128 2129 value1 = float(yvalueList[0])
2129 2130 value2 = float(yvalueList[1])
2130 2131 except:
2131 2132 self.console.clear()
2132 2133 self.console.append("Please Write corrects parameter Ymix-Ymax")
2133 2134 return 0
2134 2135 name1 = 'ymin'
2135 2136 name2 = 'ymax'
2136 2137 format = 'float'
2137 2138 opObj.addParameter(name=name1, value=value1, format=format)
2138 2139 opObj.addParameter(name=name2, value=value2, format=format)
2139 2140
2140 2141 if self.specHeisGraphSaveSpectra.isChecked():
2141 2142 checkPath = True
2142 2143 name_parameter1 = 'save'
2143 2144 name_parameter2 = 'figpath'
2144 2145 name_parameter3 = 'figfile'
2145 2146 value1 = '1'
2146 2147 value2 = self.specHeisGraphPath.text()
2147 2148 value3 = self.specHeisGraphPrefix.text()
2148 2149 format1 = 'bool'
2149 2150 format2 = 'str'
2150 2151 opObj.addParameter(name=name_parameter1, value=value1 , format=format1)
2151 2152 opObj.addParameter(name=name_parameter2, value=value2, format=format2)
2152 2153 if not value3 == "":
2153 2154 try:
2154 2155 value3 = str(self.specHeisGraphPrefix.text())
2155 2156 except:
2156 2157 self.console.clear()
2157 2158 self.console.append("Please Write prefix")
2158 2159 return 0
2159 2160 opObj.addParameter(name='figfile', value=self.specHeisGraphPrefix.text(), format='str')
2160 2161
2161 2162 # opObj.addParameter(name=name_parameter3, value=value3, format=format2)
2162 2163 # opObj.addParameter(name='wr_period', value='5',format='int')
2163 2164
2164 2165 if self.specHeisGraphftpSpectra.isChecked():
2165 2166 opObj.addParameter(name='ftp', value='1', format='int')
2166 2167 self.addFTPConf2Operation(puObj, opObj)
2167 2168 addFTP = True
2168 2169
2169 2170 if self.specHeisGraphCebRTIplot.isChecked():
2170 2171 name_operation = 'RTIfromSpectraHeis'
2171 2172 optype = 'other'
2172 2173 name_parameter = 'type'
2173 2174 value = 'RTIfromSpectraHeis'
2174 2175 format = 'str'
2175 2176
2176 2177 if self.idImagrtiHeis == 0:
2177 2178 self.idImagrtiHeis = 900
2178 2179 else:
2179 2180 self.idImagrtiHeis = self.idImagrtiHeis + 1
2180 2181
2181 2182 name_parameter1 = 'id'
2182 2183 value1 = int(self.idImagrtiHeis)
2183 2184 format1 = 'int'
2184 2185
2185 2186 format = 'str'
2186 2187
2187 2188 opObj = puObj.addOperation(name=name_operation, optype=optype)
2188 2189 # opObj.addParameter(name=name_parameter, value=value, format=format)
2189 2190 opObj.addParameter(name=name_parameter1, value=value1, format=format1)
2190 2191
2191 2192 channelList = self.specHeisGgraphChannelList.text()
2192 2193 xvalue = self.specHeisGgraphTminTmax.text()
2193 2194 yvalue = self.specHeisGgraphYminYmax.text()
2194 2195 timerange = self.specHeisGgraphTimeRange.text()
2195 2196
2196 2197 if not channelList == '':
2197 2198 opObj.addParameter(name='channelList', value=channelList, format='intlist')
2198 2199
2199 2200 if not xvalue == '':
2200 2201 xvalueList = xvalue.split(',')
2201 2202 try:
2202 2203 value = float(xvalueList[0])
2203 2204 value = float(xvalueList[1])
2204 2205 except:
2205 2206 return 0
2206 2207 format = 'float'
2207 2208 opObj.addParameter(name='xmin', value=xvalueList[0], format=format)
2208 2209 opObj.addParameter(name='xmax', value=xvalueList[1], format=format)
2209 2210
2210 2211 if not timerange == '':
2211 2212 format = 'int'
2212 2213 try:
2213 2214 timerange = int(timerange)
2214 2215 except:
2215 2216 return 0
2216 2217 opObj.addParameter(name='timerange', value=timerange, format=format)
2217 2218
2218 2219
2219 2220 if not yvalue == '':
2220 2221 yvalueList = yvalue.split(",")
2221 2222 try:
2222 2223 value = float(yvalueList[0])
2223 2224 value = float(yvalueList[1])
2224 2225 except:
2225 2226 return 0
2226 2227 format = 'float'
2227 2228 opObj.addParameter(name='ymin', value=yvalueList[0], format=format)
2228 2229 opObj.addParameter(name='ymax', value=yvalueList[1], format=format)
2229 2230
2230 2231 if self.specHeisGraphSaveRTIplot.isChecked():
2231 2232 checkPath = True
2232 2233 opObj.addParameter(name='save', value='1', format='bool')
2233 2234 opObj.addParameter(name='figpath', value=self.specHeisGraphPath.text(), format='str')
2234 2235 value = self.specHeisGraphPrefix.text()
2235 2236 if not value == "":
2236 2237 try:
2237 2238 value = str(self.specHeisGraphPrefix.text())
2238 2239 except:
2239 2240 self.console.clear()
2240 2241 self.console.append("Please Write prefix")
2241 2242 return 0
2242 2243 opObj.addParameter(name='figfile', value=value, format='str')
2243 2244
2244 2245 # test_ftp
2245 2246 if self.specHeisGraphftpRTIplot.isChecked():
2246 2247 opObj.addParameter(name='ftp', value='1', format='int')
2247 2248 self.addFTPConf2Operation(puObj, opObj)
2248 2249 addFTP = True
2249 2250
2250 2251 localfolder = None
2251 2252 if checkPath:
2252 2253 localfolder = str(self.specGraphPath.text())
2253 2254 if localfolder == '':
2254 2255 self.console.clear()
2255 2256 self.console.append("Graphic path should be defined")
2256 2257 return 0
2257 2258
2258 2259 if addFTP:
2259 2260 if not localfolder:
2260 2261 self.console.clear()
2261 2262 self.console.append("You have to save the plots before sending them to FTP Server")
2262 2263 return 0
2263 2264
2264 2265 if not self.temporalFTP.create:
2265 2266 self.temporalFTP.setwithoutconfiguration()
2266 2267
2267 2268 server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.temporalFTP.recover()
2268 2269 self.createFTPProcUnitView(server, username, password, remotefolder,
2269 2270 ftp_wei, exp_code, sub_exp_code, plot_pos,
2270 2271 localfolder=localfolder)
2271 2272 else:
2272 2273 self.removeFTPProcUnitView()
2273 2274
2274 2275 # if something happened
2275 2276 parms_ok, output_path, blocksperfile, metada = self.checkInputsPUSave(datatype='SpectraHeis')
2276 2277 if parms_ok:
2277 2278 name_operation = 'FitsWriter'
2278 2279 optype = 'other'
2279 2280 name_parameter1 = 'path'
2280 2281 name_parameter2 = 'dataBlocksPerFile'
2281 2282 name_parameter3 = 'metadatafile'
2282 2283 value1 = output_path
2283 2284 value2 = blocksperfile
2284 2285 value3 = metada
2285 2286 format2 = "int"
2286 2287 format3 = "str"
2287 2288 opObj = puObj.addOperation(name=name_operation, optype=optype)
2288 2289 opObj.addParameter(name=name_parameter1, value=value1)
2289 2290 opObj.addParameter(name=name_parameter2, value=value2, format=format2)
2290 2291 opObj.addParameter(name=name_parameter3, value=value3, format=format3)
2291 2292
2292 self.showPUSpectraHeisProperties(puObj)
2293 self.refreshPUProperties(puObj)
2293 2294
2294 2295 self.console.clear()
2295 2296 self.console.append("Click on save icon ff you want to save your project")
2296 2297
2297 2298 self.actionSaveToolbar.setEnabled(True)
2298 2299 self.actionStarToolbar.setEnabled(True)
2299 2300
2300 2301 return 1
2301 2302 @pyqtSignature("int")
2302 2303 def on_specHeisGraphCebSpectraplot_stateChanged(self, p0):
2303 2304
2304 2305 if p0 == 2:
2305 2306 self.specHeisGgraphChannelList.setEnabled(True)
2306 2307 self.specHeisGgraphXminXmax.setEnabled(True)
2307 2308 self.specHeisGgraphYminYmax.setEnabled(True)
2308 2309 if p0 == 0:
2309 2310 self.specHeisGgraphXminXmax.setEnabled(False)
2310 2311 self.specHeisGgraphYminYmax.setEnabled(False)
2311 2312
2312 2313 @pyqtSignature("int")
2313 2314 def on_specHeisGraphCebRTIplot_stateChanged(self, p0):
2314 2315
2315 2316 if p0 == 2:
2316 2317 self.specHeisGgraphChannelList.setEnabled(True)
2317 2318 self.specHeisGgraphTminTmax.setEnabled(True)
2318 2319 self.specHeisGgraphYminYmax.setEnabled(True)
2319 2320 self.specHeisGgraphTimeRange.setEnabled(True)
2320 2321
2321 2322 if p0 == 0:
2322 2323 self.specHeisGgraphTminTmax.setEnabled(False)
2323 2324 self.specHeisGgraphYminYmax.setEnabled(False)
2324 2325 self.specHeisGgraphTimeRange.setEnabled(False)
2325 2326
2326 2327 @pyqtSignature("int")
2327 2328 def on_specHeisGraphSaveSpectra_stateChanged(self, p0):
2328 2329 """
2329 2330 """
2330 2331 if p0 == 2:
2331 2332 self.specHeisGraphPath.setEnabled(True)
2332 2333 self.specHeisGraphPrefix.setEnabled(True)
2333 2334 self.specHeisGraphToolPath.setEnabled(True)
2334 2335 if p0 == 0:
2335 2336 self.specHeisGraphPath.setEnabled(False)
2336 2337 self.specHeisGraphPrefix.setEnabled(False)
2337 2338 self.specHeisGraphToolPath.setEnabled(False)
2338 2339
2339 2340 @pyqtSignature("int")
2340 2341 def on_specHeisGraphSaveRTIplot_stateChanged(self, p0):
2341 2342 if p0 == 2:
2342 2343 self.specHeisGraphPath.setEnabled(True)
2343 2344 self.specHeisGraphPrefix.setEnabled(True)
2344 2345 self.specHeisGraphToolPath.setEnabled(True)
2345 2346
2346 2347 @pyqtSignature("int")
2347 2348 def on_specHeisGraphftpSpectra_stateChanged(self, p0):
2348 2349 """
2349 2350 """
2350 2351 if p0 == 2:
2351 2352 self.specHeisGgraphftpratio.setEnabled(True)
2352 2353
2353 2354 if p0 == 0:
2354 2355 self.specHeisGgraphftpratio.setEnabled(False)
2355 2356
2356 2357 @pyqtSignature("int")
2357 2358 def on_specHeisGraphftpRTIplot_stateChanged(self, p0):
2358 2359 if p0 == 2:
2359 2360 self.specHeisGgraphftpratio.setEnabled(True)
2360 2361
2361 2362 @pyqtSignature("")
2362 2363 def on_specHeisGraphClear_clicked(self):
2363 2364 pass
2365
2366 def __getParmsFromProjectWindow(self):
2367 """
2368 Check Inputs Project:
2369 - project_name
2370 - datatype
2371 - ext
2372 - data_path
2373 - readmode
2374 - delay
2375 - set
2376 - walk
2377 """
2378 parms_ok = True
2379
2380 project_name = str(self.proName.text())
2381
2382 if project_name == '' or project_name == None:
2383 outputstr = "Enter a project Name"
2384 self.console.append(outputstr)
2385 parms_ok = False
2386 project_name = None
2387
2388 datatype = str(self.proComDataType.currentText())
2389 ext = str(self.proDataType.text())
2390
2391 dpath = str(self.proDataPath.text())
2392
2393 if dpath == '':
2394 outputstr = 'Datapath is empty'
2395 self.console.append(outputstr)
2396 parms_ok = False
2397 dpath = None
2398
2399 if dpath != None:
2400 if not os.path.isdir(dpath):
2401 outputstr = 'Datapath (%s) does not exist' % dpath
2402 self.console.append(outputstr)
2403 parms_ok = False
2404 dpath = None
2405
2406 online = str(self.proComReadMode.currentIndex())
2407
2408 delay = None
2409 if online==1:
2410 try:
2411 delay = int(str(self.proDelay.text()))
2412 except:
2413 outputstr = 'Delay value (%s) must be a integer number' %str(self.proName.text())
2414 self.console.append(outputstr)
2415 parms_ok = False
2416
2417
2418 set = None
2419 ippKm = None
2420
2421 value = str(self.proSet.text())
2422
2423 if datatype.lower() == "usrp":
2424 try:
2425 ippKm = float(value)
2426 except:
2427 outputstr = 'IPP value (%s) must be a float number' % str(self.proName.text())
2428 self.console.append(outputstr)
2429 parms_ok = False
2430 else:
2431 try:
2432 set = int(value)
2433 except:
2434 pass
2435
2436 walk = self.proComWalk.currentIndex()
2437
2438 starDate = str(self.proComStartDate.currentText())
2439 endDate = str(self.proComEndDate.currentText())
2440
2441 # startDateList = starDate.split("/")
2442 # endDateList = endDate.split("/")
2443 #
2444 # starDate = datetime.date(int(startDateList[0]), int(startDateList[1]), int(startDateList[2]))
2445 # endDate = datetime.date(int(endDateList[0]), int(endDateList[1]), int(endDateList[2]))
2446
2447 startTime = self.proStartTime.time()
2448 endTime = self.proEndTime.time()
2449
2450 startTime = startTime.strftime("%H:%M:%S")
2451 endTime = endTime.strftime("%H:%M:%S")
2452
2453 projectParms = ProjectParms()
2454
2455 projectParms.project_name = project_name
2456 projectParms.datatype = datatype
2457 projectParms.ext = ext
2458 projectParms.dpath = dpath
2459 projectParms.online = online
2460 projectParms.startDate = startDate
2461 projectParms.endDate = endDate
2462 projectParms.startTime = startTime
2463 projectParms.endTime = endTime
2464 projectParms.delay=delay
2465 projectParms.walk=walk
2466 projectParms.set=set
2467 projectParms.ippKm=ippKm
2468 projectParms.parmsOk=parms_ok
2469
2470 return projectParms
2471
2472
2473 def __getParmsFromProjectObj(self, projectObjView):
2474
2475 parms_ok = True
2476
2477 project_name, description = projectObjView.name, projectObjView.description
2478
2479 readUnitObj = projectObjView.getReadUnitObj()
2480 datatype = readUnitObj.datatype
2481
2482 operationObj = readUnitObj.getOperationObj(name='run')
2483
2484 dpath = operationObj.getParameterValue(parameterName='path')
2485 startDate = operationObj.getParameterValue(parameterName='startDate')
2486 endDate = operationObj.getParameterValue(parameterName='endDate')
2487
2488 startDate = startDate.strftime("%Y/%m/%d")
2489 endDate = endDate.strftime("%Y/%m/%d")
2490
2491 startTime = operationObj.getParameterValue(parameterName='startTime')
2492 endTime = operationObj.getParameterValue(parameterName='endTime')
2493
2494 startTime = startTime.strftime("%H:%M:%S")
2495 endTime = endTime.strftime("%H:%M:%S")
2496
2497 online = 0
2498 try:
2499 online = operationObj.getParameterValue(parameterName='online')
2500 except:
2501 pass
2502
2503 delay = ''
2504 try:
2505 delay = operationObj.getParameterValue(parameterName='delay')
2506 except:
2507 pass
2508
2509 walk = 0
2510 try:
2511 walk = operationObj.getParameterValue(parameterName='walk')
2512 except:
2513 pass
2514
2515 set = ''
2516 try:
2517 set = operationObj.getParameterValue(parameterName='set')
2518 except:
2519 pass
2520
2521 ippKm = ''
2522 if datatype.lower() == 'usrp':
2523 try:
2524 ippKm = operationObj.getParameterValue(parameterName='ippKm')
2525 except:
2526 pass
2527
2528 projectParms = ProjectParms()
2529
2530 projectParms.project_name = project_name
2531 projectParms.datatype = datatype
2532 projectParms.ext = None
2533 projectParms.dpath = dpath
2534 projectParms.online = online
2535 projectParms.startDate = startDate
2536 projectParms.endDate = endDate
2537 projectParms.startTime = startTime
2538 projectParms.endTime = endTime
2539 projectParms.delay=delay
2540 projectParms.walk=walk
2541 projectParms.set=set
2542 projectParms.ippKm=ippKm
2543 projectParms.parmsOk=parms_ok
2544
2545 return projectParms
2546
2547 def refreshProjectWindow2(self, projectObjView):
2548
2549 projectParms = self.__getParmsFromProjectObj(projectObjView)
2550
2551 index = projectParms.getDatatypeIndex()
2552
2553 self.proName.setText(projectObjView.name)
2554 self.proDescription.clear()
2555 self.proDescription.append(projectObjView.description)
2556
2557 self.on_proComDataType_activated(index=index)
2558 self.proDataType.setText(projectParms.getExt())
2559 self.proDataPath.setText(projectParms.dpath)
2560 self.proComDataType.setCurrentIndex(index)
2561 self.proComReadMode.setCurrentIndex(projectParms.online)
2562 self.proDelay.setText(str(projectParms.delay))
2563 self.proSet.setText(str(projectParms.set))
2564
2565 dateList = self.loadDays(data_path = projectParms.dpath,
2566 ext = projectParms.getExt(),
2567 walk = projectParms.walk,
2568 expLabel = projectParms.expLabel)
2569
2570 try:
2571 startDateIndex = dateList.index(projectParms.startDate)
2572 except:
2573 startDateIndex = 0
2574
2575 try:
2576 endDateIndex = dateList.index(projectParms.endDate)
2577 except:
2578 endDateIndex = -1
2579
2580 self.proComStartDate.setCurrentIndex(startDateIndex)
2581 self.proComEndDate.setCurrentIndex(endDateIndex)
2582
2583 startlist = projectParms.startTime.split(":")
2584 endlist = projectParms.endTime.split(":")
2585
2586 self.time.setHMS(int(startlist[0]), int(startlist[1]), int(startlist[2]))
2587 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
2588
2589 self.proStartTime.setTime(self.time)
2590 self.proEndTime.setTime(self.time)
2591
2592 def refreshProjectProperties(self, projectObjView):
2593
2594 propertyBuffObj = PropertyBuffer()
2595 name = projectObjView.name
2596
2597 propertyBuffObj.append("Properties", "Name", projectObjView.name),
2598 propertyBuffObj.append("Properties", "Description", projectObjView.description)
2599 propertyBuffObj.append("Properties", "Workspace", self.pathWorkSpace)
2600
2601 readUnitObj = projectObjView.getReadUnitObj()
2602 runOperationObj = readUnitObj.getOperationObj(name='run')
2603
2604 for thisParmObj in runOperationObj.getParameterObjList():
2605 propertyBuffObj.append("Reading parms", thisParmObj.name, str(thisParmObj.getValue()))
2606
2607 propertiesModel = propertyBuffObj.getPropertyModel()
2608
2609 self.treeProjectProperties.setModel(propertiesModel)
2610 self.treeProjectProperties.expandAll()
2611 self.treeProjectProperties.resizeColumnToContents(0)
2612 self.treeProjectProperties.resizeColumnToContents(1)
2613
2614 def refreshPUProperties(self, puObjView):
2615
2616 propertyBuffObj = PropertyBuffer()
2617
2618 for thisOp in puObjView.getOperationObjList():
2619
2620 operationName = thisOp.name
2621 if operationName == 'run':
2622 operationName = 'Properties'
2623 else:
2624 if not thisOp.getParameterObjList():
2625 propertyBuffObj.append(operationName, '--', '--')
2364 2626
2627 for thisParmObj in thisOp.getParameterObjList():
2628
2629 propertyBuffObj.append(operationName, thisParmObj.name, str(thisParmObj.getValue()))
2630
2631 propertiesModel = propertyBuffObj.getPropertyModel()
2632
2633 self.treeProjectProperties.setModel(propertiesModel)
2634 self.treeProjectProperties.expandAll()
2635 self.treeProjectProperties.resizeColumnToContents(0)
2636 self.treeProjectProperties.resizeColumnToContents(1)
2637
2365 2638 def on_click(self, index):
2366 2639
2367 2640 self.selectedItemTree = self.projectExplorerModel.itemFromIndex(index)
2368 if self.getSelectedProjectObj():
2369 projectObjView = self.getSelectedProjectObj()
2370 project_name, description = projectObjView.name, projectObjView.description
2371 id = int(projectObjView.id)
2372 idReadUnit = projectObjView.getReadUnitId()
2373 readUnitObj = projectObjView.getProcUnitObj(idReadUnit)
2374 datatype, data_path, startDate, endDate, startTime, endTime , online , delay, walk , set = self.showProjectProperties(projectObjView)
2375 # show ProjectView
2376 self.refreshProjectWindow(project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, set)
2377 if datatype == 'Voltage':
2378 ext = '.r'
2379 elif datatype == 'Spectra':
2380 ext = '.pdata'
2381 elif datatype == 'Fits':
2382 ext = '.fits'
2383 if online == 0:
2384 self.proComStartDate.clear()
2385 self.proComEndDate.clear()
2386 self.loadDays(data_path, ext, walk)
2641
2642 projectObjView = self.getSelectedProjectObj()
2643
2644 if not projectObjView:
2645 return
2646
2647 #A project has been selected
2648 if projectObjView == self.getSelectedItemObj():
2649
2650 self.refreshProjectWindow2(projectObjView)
2651 self.refreshProjectProperties(projectObjView)
2652
2387 2653 self.tabProject.setEnabled(True)
2388 2654 self.tabVoltage.setEnabled(False)
2389 2655 self.tabSpectra.setEnabled(False)
2390 2656 self.tabCorrelation.setEnabled(False)
2391 2657 self.tabSpectraHeis.setEnabled(False)
2392 self.tabWidgetProject.setCurrentWidget(self.tabProject)
2393
2658 self.tabWidgetProject.setCurrentWidget(self.tabProject)
2659
2660 return
2661
2662 #A processing unit has been selected
2663 voltEnable = False
2664 specEnable = False
2665 corrEnable = False
2666 specHeisEnable = False
2667 tabSelected = self.tabProject
2668
2669 puObj = self.getSelectedItemObj()
2670 inputId = puObj.getInputId()
2671 inputPUObj = projectObjView.getProcUnitObj(inputId)
2672
2394 2673 if self.selectedItemTree.text() == 'Voltage':
2395 2674 datatype = 'Voltage'
2396 puObj = self.getSelectedPUObj()
2397 self.showtabPUCreated(datatype=datatype)
2675
2398 2676 if len(puObj.getOperationObjList()) == 1:
2399 self.setInputsPU_View(datatype)
2677 self.clearPUWindow(datatype)
2400 2678 else:
2401 2679 self.refreshPUWindow(datatype=datatype, puObj=puObj)
2402 self.showPUVoltageProperties(puObj)
2680 self.refreshPUProperties(puObj)
2681
2682 voltEnable = True
2683 tabSelected = self.tabVoltage
2403 2684
2404 2685 if self.selectedItemTree.text() == 'Spectra':
2405 2686
2406 2687 datatype = 'Spectra'
2407 puObj = self.getSelectedPUObj()
2408 self.showtabPUCreated(datatype=datatype)
2409 if readUnitObj.datatype == 'Spectra':
2688
2689 if inputPUObj.datatype == 'Spectra':
2410 2690 self.specOpnFFTpoints.setEnabled(False)
2411 2691 self.specOpProfiles.setEnabled(False)
2412 2692 self.specOpippFactor.setEnabled(False)
2413
2414 2693 else:
2415 2694 self.specOpnFFTpoints.setEnabled(True)
2416 2695 self.specOpProfiles.setEnabled(True)
2417 2696 self.specOpippFactor.setEnabled(True)
2418 2697
2419 2698 if len(puObj.getOperationObjList()) == 1:
2420 self.setInputsPU_View(datatype)
2699 self.clearPUWindow(datatype)
2421 2700
2422 2701 opObj = puObj.getOperationObj(name="run")
2423 2702 if opObj == None:
2424 2703 self.specOpnFFTpoints.clear()
2425 2704 self.specOpProfiles.clear()
2426 2705 self.specOpippFactor.clear()
2427 2706 else:
2428 2707 parmObj = opObj.getParameterObj(parameterName='nFFTPoints')
2429 2708 if parmObj == None:
2430 2709 self.specOpnFFTpoints.clear()
2431 2710 else:
2432 2711 value = opObj.getParameterValue(parameterName='nFFTPoints')
2433 2712 self.specOpnFFTpoints.setText(str(value))
2434 2713
2435 2714 parmObj = opObj.getParameterObj(parameterName='nProfiles')
2436 2715 if parmObj == None:
2437 2716 self.specOpProfiles.clear()
2438 2717 else:
2439 2718 value = opObj.getParameterValue(parameterName='nProfiles')
2440 2719 self.specOpProfiles.setText(str(value))
2441 2720
2442 2721 parmObj = opObj.getParameterObj(parameterName="ippFactor")
2443 2722 if parmObj == None:
2444 2723 self.specOpippFactor.clear()
2445 2724 else:
2446 2725 value = opObj.getParameterValue(parameterName='ippFactor')
2447 2726 self.specOpippFactor.setText(str(value))
2448 2727
2449 2728 opObj = puObj.getOperationObj(name="run")
2450 2729 if opObj == None:
2451 2730 self.specOppairsList.clear()
2452 2731 self.specOpCebCrossSpectra.setCheckState(0)
2453 2732 else:
2454 2733 parmObj = opObj.getParameterObj(parameterName='pairsList')
2455 2734 if parmObj == None:
2456 2735 self.specOppairsList.clear()
2457 2736 self.specOpCebCrossSpectra.setCheckState(0)
2458 2737 else:
2459 2738 value = opObj.getParameterValue(parameterName='pairsList')
2460 2739 value = str(value)[1:-1]
2461 2740 self.specOppairsList.setText(str(value))
2462 2741 self.specOppairsList.setEnabled(True)
2463 2742 self.specOpCebCrossSpectra.setCheckState(QtCore.Qt.Checked)
2464 2743
2465 2744 else:
2466 2745 self.refreshPUWindow(datatype=datatype, puObj=puObj)
2467 self.showPUSpectraProperties(puObj)
2746 self.refreshPUProperties(puObj)
2747
2748 specEnable = True
2749 tabSelected = self.tabSpectra
2468 2750
2469 2751 if self.selectedItemTree.text() == 'Correlation':
2470 self.tabCorrelation.setEnabled(True)
2471 self.tabVoltage.setEnabled(False)
2472 self.tabSpectra.setEnabled(False)
2473 self.tabWidgetProject.setCurrentWidget(self.tabCorrelation)
2752
2753 corrEnable = True
2754 tabSelected = self.tabCorrelation
2474 2755
2475 2756 if self.selectedItemTree.text() == 'SpectraHeis':
2476 2757 datatype = 'SpectraHeis'
2477 puObj = self.getSelectedPUObj()
2478 self.showtabPUCreated(datatype=datatype)
2758
2479 2759 if len(puObj.getOperationObjList()) == 1:
2480 self.setInputsPU_View(datatype)
2760 self.clearPUWindow(datatype)
2481 2761 else:
2482 2762 self.refreshPUWindow(datatype=datatype, puObj=puObj)
2483 self.showPUSpectraHeisProperties(puObj)
2763 self.refreshPUProperties(puObj)
2484 2764
2765 specHeisEnable = False
2766 tabSelected = self.tabSpectraHeis
2767
2768 self.tabProject.setEnabled(False)
2769 self.tabVoltage.setEnabled(voltEnable)
2770 self.tabSpectra.setEnabled(specEnable)
2771 self.tabCorrelation.setEnabled(corrEnable)
2772 self.tabSpectraHeis.setEnabled(specHeisEnable)
2773 self.tabWidgetProject.setCurrentWidget(tabSelected)
2485 2774
2486 2775 def on_right_click(self, pos):
2487 2776
2488 2777 self.menu = QtGui.QMenu()
2489 quitAction0 = self.menu.addAction("Create a new project")
2490 quitAction1 = self.menu.addAction("Create a new processing unit")
2491 quitAction2 = self.menu.addAction("Delete selected unit")
2778 quitAction0 = self.menu.addAction("Create a New Project")
2779 quitAction1 = self.menu.addAction("Create a New Processing Unit")
2780 quitAction2 = self.menu.addAction("Delete Item")
2492 2781 quitAction3 = self.menu.addAction("Quit")
2493 2782
2494 2783 if len(self.__itemTreeDict) == 0:
2495 2784 quitAction2.setEnabled(False)
2496 2785 else:
2497 2786 quitAction2.setEnabled(True)
2498 2787
2499 2788 action = self.menu.exec_(self.mapToGlobal(pos))
2500 2789
2501 2790 if action == quitAction0:
2502 2791 self. setInputsProject_View()
2503 2792 self.create = True
2504 2793
2505 2794 if action == quitAction1:
2506 2795 if len(self.__projectObjDict) == 0:
2507 outputstr = "First Create a Project then add Processing Unit"
2796 outputstr = "You need to create a Project before adding a Processing Unit"
2508 2797 self.console.clear()
2509 2798 self.console.append(outputstr)
2510 2799 return 0
2511 2800 else:
2512 2801 self.addPUWindow()
2513 2802 self.console.clear()
2514 2803 self.console.append("Please, Choose the type of Processing Unit")
2515 self.console.append("If your Datatype is rawdata, you will start with processing unit Type Voltage")
2516 self.console.append("If your Datatype is pdata, you will choose between processing unit Type Spectra or Correlation")
2517 self.console.append("If your Datatype is fits, you will start with processing unit Type SpectraHeis")
2804 # self.console.append("If your Datatype is rawdata, you will start with processing unit Type Voltage")
2805 # self.console.append("If your Datatype is pdata, you will choose between processing unit Type Spectra or Correlation")
2806 # self.console.append("If your Datatype is fits, you will start with processing unit Type SpectraHeis")
2518 2807
2519 2808 if action == quitAction2:
2520 2809 index = self.selectedItemTree
2521 2810 try:
2522 2811 index.parent()
2523 2812 except:
2524 self.console.append('First left click on Project or Processing Unit')
2813 self.console.append('Please first select a Project or Processing Unit')
2525 2814 return 0
2526 2815 # print index.parent(),index
2527 2816 if index.parent() == None:
2528 2817 self.projectExplorerModel.removeRow(index.row())
2529 2818 else:
2530 2819 index.parent().removeRow(index.row())
2531 self.deleteProjectorPU()
2820 self.removeItemTreeFromProject()
2532 2821 self.console.clear()
2533 2822 # for i in self.projectExplorerTree.selectionModel().selection().indexes():
2534 2823 # print i.row()
2535 2824
2536 2825 if action == quitAction3:
2537 2826 self.close()
2538 2827 return 0
2539 2828
2540 2829 def refreshProjectWindow(self, project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, set):
2541 2830
2542 2831 self.proName.setText(str(project_name))
2543 2832
2544 2833 if datatype == 'Voltage':
2545 2834 ext = '.r'
2546 2835 value = 0
2547 2836 elif datatype == 'Spectra':
2548 2837 ext = '.pdata'
2549 2838 value = 1
2550 2839 elif datatype == 'Fits':
2551 ext = 'fits'
2840 ext = '.fits'
2552 2841 value = 2
2842 elif datatype == 'USRP':
2843 ext = '.hdf5'
2844 value = 3
2845
2553 2846 self.proDataType.setText(ext)
2554 2847 self.proDataPath.setText(str(data_path))
2555 2848 self.proComDataType.setCurrentIndex(value)
2556 2849 self.proComReadMode.setCurrentIndex(int(online))
2557 2850 self.proDelay.setText(str(delay))
2558 2851 self.proSet.setText(str(set))
2559 2852 self.proComStartDate.clear()
2560 2853 self.proComEndDate.clear()
2561 2854 self.proComStartDate.addItem(str(startDate))
2562 2855 self.proComEndDate.addItem(str(endDate))
2563 2856 starTime = str(startTime)
2564 2857 starlist = starTime.split(":")
2565 2858 endTime = str(endTime)
2566 2859 endlist = endTime.split(":")
2567 2860 self.time.setHMS(int(starlist[0]), int(starlist[1]), int(starlist[2]))
2568 2861 self.proStartTime.setTime(self.time)
2569 2862 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
2570 2863 self.proEndTime.setTime(self.time)
2571 2864 self.proDescription.clear()
2572 2865 self.proDescription.append(description)
2573 2866
2574 2867 def refreshPUWindow(self, datatype, puObj):
2575 2868
2576 2869 if datatype == 'Voltage':
2577 2870 opObj = puObj.getOperationObj(name='setRadarFrequency')
2578 2871 if opObj == None:
2579 2872 self.volOpRadarfrequency.clear()
2580 2873 self.volOpCebRadarfrequency.setCheckState(0)
2581 2874 else:
2582 2875 value = opObj.getParameterValue(parameterName='frequency')
2583 2876 value = str(value)
2584 2877 self.volOpRadarfrequency.setText(value)
2585 2878 self.volOpRadarfrequency.setEnabled(True)
2586 2879 self.volOpCebRadarfrequency.setCheckState(QtCore.Qt.Checked)
2587 2880
2588 2881
2589 2882 opObj = puObj.getOperationObj(name="selectChannels")
2590 2883
2591 2884 if opObj == None:
2592 2885 opObj = puObj.getOperationObj(name="selectChannelsByIndex")
2593 2886
2594 2887 if opObj == None:
2595 2888 self.volOpChannel.clear()
2596 2889 self.volOpCebChannels.setCheckState(0)
2597 2890 else:
2598 2891 channelEnabled = False
2599 2892 try:
2600 2893 value = opObj.getParameterValue(parameterName='channelList')
2601 2894 value = str(value)[1:-1]
2602 2895 channelEnabled = True
2603 2896 channelMode = 0
2604 2897 except:
2605 2898 pass
2606 2899 try:
2607 2900 value = opObj.getParameterValue(parameterName='channelIndexList')
2608 2901 value = str(value)[1:-1]
2609 2902 channelEnabled = True
2610 2903 channelMode = 1
2611 2904 except:
2612 2905 pass
2613 2906
2614 2907 if channelEnabled:
2615 2908 self.volOpChannel.setText(value)
2616 2909 self.volOpChannel.setEnabled(True)
2617 2910 self.volOpCebChannels.setCheckState(QtCore.Qt.Checked)
2618 self.VOLOpComChannel.setCurrentIndex(channelMode)
2911 self.volOpComChannels.setCurrentIndex(channelMode)
2619 2912
2620 2913 opObj = puObj.getOperationObj(name="selectHeights")
2621 2914 if opObj == None:
2622 2915 self.volOpHeights.clear()
2623 2916 self.volOpCebHeights.setCheckState(0)
2624 2917 else:
2625 2918 value1 = int(opObj.getParameterValue(parameterName='minHei'))
2626 2919 value1 = str(value1)
2627 2920 value2 = int(opObj.getParameterValue(parameterName='maxHei'))
2628 2921 value2 = str(value2)
2629 2922 value = value1 + "," + value2
2630 2923 self.volOpHeights.setText(value)
2631 2924 self.volOpHeights.setEnabled(True)
2632 2925 self.volOpCebHeights.setCheckState(QtCore.Qt.Checked)
2633 2926
2634 2927 opObj = puObj.getOperationObj(name="filterByHeights")
2635 2928 if opObj == None:
2636 2929 self.volOpFilter.clear()
2637 2930 self.volOpCebFilter.setCheckState(0)
2638 2931 else:
2639 2932 value = opObj.getParameterValue(parameterName='window')
2640 2933 value = str(value)
2641 2934 self.volOpFilter.setText(value)
2642 2935 self.volOpFilter.setEnabled(True)
2643 2936 self.volOpCebFilter.setCheckState(QtCore.Qt.Checked)
2644 2937
2645 2938 opObj = puObj.getOperationObj(name="ProfileSelector")
2646 2939 if opObj == None:
2647 2940 self.volOpProfile.clear()
2648 2941 self.volOpCebProfile.setCheckState(0)
2649 2942 else:
2650 2943 for parmObj in opObj.getParameterObjList():
2651 2944 if parmObj.name == "profileRangeList":
2652 2945 value = opObj.getParameterValue(parameterName='profileRangeList')
2653 2946 value = str(value)[1:-1]
2654 2947 self.volOpProfile.setText(value)
2655 2948 self.volOpProfile.setEnabled(True)
2656 2949 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
2657 2950 self.volOpComProfile.setCurrentIndex(1)
2658 2951 if parmObj.name == "profileList":
2659 2952 value = opObj.getParameterValue(parameterName='profileList')
2660 2953 value = str(value)[1:-1]
2661 2954 self.volOpProfile.setText(value)
2662 2955 self.volOpProfile.setEnabled(True)
2663 2956 self.volOpCebProfile.setCheckState(QtCore.Qt.Checked)
2664 2957 self.volOpComProfile.setCurrentIndex(0)
2665 2958
2666 2959
2667 2960 opObj = puObj.getOperationObj(name="Decoder")
2668 2961 if opObj == None:
2669 2962 self.volOpCebDecodification.setCheckState(0)
2670 2963 else:
2671 2964 try:
2672 2965 valueCode = opObj.getParameterValue(parameterName='nCode')
2673 2966 status = "on"
2674 2967 except:
2675 2968 status = "off"
2676 2969 if not status == "off":
2677 2970 if int(valueCode) == 1:
2678 2971 valueBaud = opObj.getParameterValue(parameterName='nBaud')
2679 2972 if int(valueBaud) == 3:
2680 2973 self.volOpComCode.setCurrentIndex(0)
2681 2974 if int(valueBaud) == 4:
2682 2975 self.volOpComCode.setCurrentIndex(1)
2683 2976 if int(valueBaud) == 5:
2684 2977 self.volOpComCode.setCurrentIndex(2)
2685 2978 if int(valueBaud) == 7:
2686 2979 self.volOpComCode.setCurrentIndex(3)
2687 2980 if int(valueBaud) == 11:
2688 2981 self.volOpComCode.setCurrentIndex(4)
2689 2982 if int(valueBaud) == 13:
2690 2983 self.volOpComCode.setCurrentIndex(5)
2691 2984 else:
2692 2985 valueBaud = opObj.getParameterValue(parameterName='nBaud')
2693 2986 if int(valueBaud) == 3:
2694 2987 self.volOpComCode.setCurrentIndex(6)
2695 2988 if int(valueBaud) == 4:
2696 2989 self.volOpComCode.setCurrentIndex(7)
2697 2990 if int(valueBaud) == 5:
2698 2991 self.volOpComCode.setCurrentIndex(8)
2699 2992 if int(valueBaud) == 7:
2700 2993 self.volOpComCode.setCurrentIndex(9)
2701 2994 if int(valueBaud) == 11:
2702 2995 self.volOpComCode.setCurrentIndex(10)
2703 2996 if int(valueBaud) == 13:
2704 2997 self.volOpComCode.setCurrentIndex(11)
2705 2998
2706 2999 for parmObj in opObj.getParameterObjList():
2707 3000 if parmObj.name == "nBaud":
2708 3001 value = opObj.getParameterValue(parameterName='nBaud')
2709 3002 if parmObj.name == "mode":
2710 3003 value = opObj.getParameterValue(parameterName='mode')
2711 3004 self.volOpComMode.setCurrentIndex(value)
2712 3005 else:
2713 3006 self.volOpComCode.setCurrentIndex(12)
2714 3007 self.volOpCebDecodification.setCheckState(QtCore.Qt.Checked)
2715 3008
2716 3009 opObj = puObj.getOperationObj(name="deFlip")
2717 3010 if opObj == None:
2718 3011 self.volOpFlip.clear()
2719 3012 self.volOpFlip.setEnabled(False)
2720 3013 self.volOpCebFlip.setCheckState(0)
2721 3014 else:
2722 3015 try:
2723 3016 value = opObj.getParameterValue(parameterName='channelList')
2724 3017 value = str(value)[1:-1]
2725 3018 except:
2726 3019 value = ""
2727 3020
2728 3021 self.volOpFlip.setText(value)
2729 3022 self.volOpFlip.setEnabled(True)
2730 3023 self.volOpCebFlip.setCheckState(QtCore.Qt.Checked)
2731 3024
2732 3025 opObj = puObj.getOperationObj(name="CohInt")
2733 3026 if opObj == None:
2734 3027 self.volOpCohInt.clear()
2735 3028 self.volOpCebCohInt.setCheckState(0)
2736 3029 else:
2737 3030 value = opObj.getParameterValue(parameterName='n')
2738 3031 self.volOpCohInt.setText(str(value))
2739 3032 self.volOpCohInt.setEnabled(True)
2740 3033 self.volOpCebCohInt.setCheckState(QtCore.Qt.Checked)
2741 3034
2742 3035 opObj = puObj.getOperationObj(name='Scope')
2743 3036 if opObj == None:
2744 3037 self.volGraphCebshow.setCheckState(0)
2745 3038 else:
2746 3039 self.volGraphCebshow.setCheckState(QtCore.Qt.Checked)
2747 3040 value = opObj.getParameterObj(parameterName='channelList')
2748 3041 if value == None:
2749 3042 self.volGraphChannelList.clear()
2750 3043 else:
2751 3044 value = opObj.getParameterValue(parameterName='channelList')
2752 3045 value = str(value)[1:-1]
2753 3046 self.volGraphChannelList.setText(value)
2754 3047 self.volOpProfile.setEnabled(True)
2755 3048
2756 3049 for parmObj in opObj.getParameterObjList():
2757 3050 if parmObj.name == "xmin":
2758 3051 value1 = opObj.getParameterValue(parameterName='xmin')
2759 3052 value1 = str(value1)
2760 3053 value2 = opObj.getParameterValue(parameterName='xmax')
2761 3054 value2 = str(value2)
2762 3055 value = value1 + "," + value2
2763 3056 self.volGraphfreqrange.setText(value)
2764 3057 else:
2765 3058 self.volGraphfreqrange.clear()
2766 3059 for parmObj in opObj.getParameterObjList():
2767 3060 if parmObj.name == "ymin":
2768 3061 value1 = opObj.getParameterValue(parameterName='ymin')
2769 3062 value1 = str(value1)
2770 3063 value2 = opObj.getParameterValue(parameterName='ymax')
2771 3064 value2 = str(value2)
2772 3065 value = value1 + "," + value2
2773 3066 value2 = str(value2)
2774 3067 self.volGraphHeightrange.setText(value)
2775 3068 else:
2776 3069 self.volGraphHeightrange.clear()
2777 3070
2778 3071
2779 3072 for parmObj in opObj.getParameterObjList():
2780 3073 if parmObj.name == "save":
2781 3074 self.volGraphCebSave.setCheckState(QtCore.Qt.Checked)
2782 3075 else:
2783 3076 self.volGraphCebSave.setCheckState(QtCore.Qt.Unchecked)
2784 3077
2785 3078 # outputVoltageWrite
2786 3079 opObj = puObj.getOperationObj(name='VoltageWriter')
2787 3080 if opObj == None:
2788 3081 self.volOutputPath.clear()
2789 3082 self.volOutputblocksperfile.clear()
2790 3083 self.volOutputprofilesperblock.clear()
2791 3084 else:
2792 3085 value = opObj.getParameterObj(parameterName='path')
2793 3086 if value == None:
2794 3087 self.volOutputPath.clear()
2795 3088 else:
2796 3089 value = opObj.getParameterValue(parameterName='path')
2797 3090 path = str(value)
2798 3091 self.volOutputPath.setText(path)
2799 3092 value = opObj.getParameterObj(parameterName='blocksPerFile')
2800 3093 if value == None:
2801 3094 self.volOutputblocksperfile.clear()
2802 3095 else:
2803 3096 value = opObj.getParameterValue(parameterName='blocksPerFile')
2804 3097 blocksperfile = str(value)
2805 3098 self.volOutputblocksperfile.setText(blocksperfile)
2806 3099 value = opObj.getParameterObj(parameterName='profilesPerBlock')
2807 3100 if value == None:
2808 3101 self.volOutputprofilesperblock.clear()
2809 3102 else:
2810 3103 value = opObj.getParameterValue(parameterName='profilesPerBlock')
2811 3104 profilesPerBlock = str(value)
2812 3105 self.volOutputprofilesperblock.setText(profilesPerBlock)
2813 3106
2814 3107 if datatype == 'Spectra':
2815 3108
2816 3109 opObj = puObj.getOperationObj(name='setRadarFrequency')
2817 3110 if opObj == None:
2818 3111 self.specOpRadarfrequency.clear()
2819 3112 self.specOpCebRadarfrequency.setCheckState(0)
2820 3113 else:
2821 3114 value = opObj.getParameterValue(parameterName='frequency')
2822 3115 value = str(value)
2823 3116 self.specOpRadarfrequency.setText(value)
2824 3117 self.specOpRadarfrequency.setEnabled(True)
2825 3118 self.specOpCebRadarfrequency.setCheckState(QtCore.Qt.Checked)
2826 3119
2827 3120 opObj = puObj.getOperationObj(name="run")
2828 3121 if opObj == None:
2829 3122 self.specOpnFFTpoints.clear()
2830 3123 self.specOpProfiles.clear()
2831 3124 self.specOpippFactor.clear()
2832 3125 else:
2833 3126 parmObj = opObj.getParameterObj(parameterName='nFFTPoints')
2834 3127 if parmObj == None:
2835 3128 self.specOpnFFTpoints.clear()
2836 3129 else:
2837 3130 self.specOpnFFTpoints.setEnabled(True)
2838 3131 value = opObj.getParameterValue(parameterName='nFFTPoints')
2839 3132 self.specOpnFFTpoints.setText(str(value))
2840 3133
2841 3134 parmObj = opObj.getParameterObj(parameterName='nProfiles')
2842 3135 if parmObj == None:
2843 3136 self.specOpProfiles.clear()
2844 3137 else:
2845 3138 self.specOpProfiles.setEnabled(True)
2846 3139 value = opObj.getParameterValue(parameterName='nProfiles')
2847 3140 self.specOpProfiles.setText(str(value))
2848 3141
2849 3142 parmObj = opObj.getParameterObj(parameterName='ippFactor')
2850 3143 if parmObj == None:
2851 3144 self.specOpippFactor.clear()
2852 3145 else:
2853 3146 self.specOpippFactor.setEnabled(True)
2854 3147 value = opObj.getParameterValue(parameterName='ippFactor')
2855 3148 self.specOpippFactor.setText(str(value))
2856 3149
2857 3150 opObj = puObj.getOperationObj(name="run")
2858 3151 if opObj == None:
2859 3152 self.specOppairsList.clear()
2860 3153 self.specOpCebCrossSpectra.setCheckState(0)
2861 3154 else:
2862 3155 parmObj = opObj.getParameterObj(parameterName='pairsList')
2863 3156 if parmObj == None:
2864 3157 self.specOppairsList.clear()
2865 3158 self.specOpCebCrossSpectra.setCheckState(0)
2866 3159 else:
2867 3160 value = opObj.getParameterValue(parameterName='pairsList')
2868 3161 value = str(value)[1:-1]
2869 3162 self.specOppairsList.setText(str(value))
2870 3163 self.specOppairsList.setEnabled(True)
2871 3164 self.specOpCebCrossSpectra.setCheckState(QtCore.Qt.Checked)
2872 3165
2873 3166 opObj = puObj.getOperationObj(name="selectChannels")
2874 3167
2875 3168 if opObj == None:
2876 3169 opObj = puObj.getOperationObj(name="selectChannelsByIndex")
2877 3170
2878 3171 if opObj == None:
2879 3172 self.specOpChannel.clear()
2880 3173 self.specOpCebChannel.setCheckState(0)
2881 3174 else:
2882 3175 channelEnabled = False
2883 3176 try:
2884 3177 value = opObj.getParameterValue(parameterName='channelList')
2885 3178 value = str(value)[1:-1]
2886 3179 channelEnabled = True
2887 3180 channelMode = 0
2888 3181 except:
2889 3182 pass
2890 3183 try:
2891 3184 value = opObj.getParameterValue(parameterName='channelIndexList')
2892 3185 value = str(value)[1:-1]
2893 3186 channelEnabled = True
2894 3187 channelMode = 1
2895 3188 except:
2896 3189 pass
2897 3190
2898 3191 if channelEnabled:
2899 3192 self.specOpChannel.setText(value)
2900 3193 self.specOpChannel.setEnabled(True)
2901 3194 self.specOpCebChannel.setCheckState(QtCore.Qt.Checked)
2902 3195 self.specOpComChannel.setCurrentIndex(channelMode)
2903 3196
2904 3197 opObj = puObj.getOperationObj(name="selectHeights")
2905 3198 if opObj == None:
2906 3199 self.specOpHeights.clear()
2907 3200 self.specOpCebHeights.setCheckState(0)
2908 3201 else:
2909 3202 value1 = int(opObj.getParameterValue(parameterName='minHei'))
2910 3203 value1 = str(value1)
2911 3204 value2 = int(opObj.getParameterValue(parameterName='maxHei'))
2912 3205 value2 = str(value2)
2913 3206 value = value1 + "," + value2
2914 3207 self.specOpHeights.setText(value)
2915 3208 self.specOpHeights.setEnabled(True)
2916 3209 self.specOpCebHeights.setCheckState(QtCore.Qt.Checked)
2917 3210
2918 3211 opObj = puObj.getOperationObj(name="IncohInt")
2919 3212 if opObj == None:
2920 3213 self.specOpIncoherent.clear()
2921 3214 self.specOpCebIncoherent.setCheckState(0)
2922 3215 else:
2923 3216 for parmObj in opObj.getParameterObjList():
2924 3217 if parmObj.name == 'timeInterval':
2925 3218 value = opObj.getParameterValue(parameterName='timeInterval')
2926 3219 value = float(value)
2927 3220 self.specOpIncoherent.setText(str(value))
2928 3221 self.specOpIncoherent.setEnabled(True)
2929 3222 self.specOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
2930 3223 self.specOpCobIncInt.setCurrentIndex(0)
2931 3224
2932 3225 if parmObj.name == 'n':
2933 3226 value = opObj.getParameterValue(parameterName='n')
2934 3227 value = float(value)
2935 3228 self.specOpIncoherent.setText(str(value))
2936 3229 self.specOpIncoherent.setEnabled(True)
2937 3230 self.specOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
2938 3231 self.specOpCobIncInt.setCurrentIndex(1)
2939 3232
2940 3233 opObj = puObj.getOperationObj(name="removeDC")
2941 3234 if opObj == None:
2942 3235 self.specOpCebRemoveDC.setCheckState(0)
2943 3236 else:
2944 3237 self.specOpCebRemoveDC.setCheckState(QtCore.Qt.Checked)
2945 3238 value = opObj.getParameterValue(parameterName='mode')
2946 3239 if value == 1:
2947 3240 self.specOpComRemoveDC.setCurrentIndex(0)
2948 3241 elif value == 2:
2949 3242 self.specOpComRemoveDC.setCurrentIndex(1)
2950 3243
2951 3244 opObj = puObj.getOperationObj(name="removeInterference")
2952 3245 if opObj == None:
2953 3246 self.specOpCebRemoveInt.setCheckState(0)
2954 3247 else:
2955 3248 self.specOpCebRemoveInt.setCheckState(QtCore.Qt.Checked)
2956 3249
2957 3250 opObj = puObj.getOperationObj(name='getNoise')
2958 3251 if opObj == None:
2959 3252 self.specOpCebgetNoise.setCheckState(0)
2960 3253 self.specOpgetNoise.clear()
2961 3254 else:
2962 3255 self.specOpCebgetNoise.setCheckState(QtCore.Qt.Checked)
2963 3256 parmObj = opObj.getParameterObj(parameterName='minHei')
2964 3257 if parmObj == None:
2965 3258 self.specOpgetNoise.clear()
2966 3259 value1 = None
2967 3260 else:
2968 3261 value1 = opObj.getParameterValue(parameterName='minHei')
2969 3262 value1 = str(value1)
2970 3263 parmObj = opObj.getParameterObj(parameterName='maxHei')
2971 3264 if parmObj == None:
2972 3265 value2 = None
2973 3266 value = value1
2974 3267 self.specOpgetNoise.setText(value)
2975 3268 self.specOpgetNoise.setEnabled(True)
2976 3269 else:
2977 3270 value2 = opObj.getParameterValue(parameterName='maxHei')
2978 3271 value2 = str(value2)
2979 3272 parmObj = opObj.getParameterObj(parameterName='minVel')
2980 3273 if parmObj == None:
2981 3274 value3 = None
2982 3275 value = value1 + "," + value2
2983 3276 self.specOpgetNoise.setText(value)
2984 3277 self.specOpgetNoise.setEnabled(True)
2985 3278 else:
2986 3279 value3 = opObj.getParameterValue(parameterName='minVel')
2987 3280 value3 = str(value3)
2988 3281 parmObj = opObj.getParameterObj(parameterName='maxVel')
2989 3282 if parmObj == None:
2990 3283 value4 = None
2991 3284 value = value1 + "," + value2 + "," + value3
2992 3285 self.specOpgetNoise.setText(value)
2993 3286 self.specOpgetNoise.setEnabled(True)
2994 3287 else:
2995 3288 value4 = opObj.getParameterValue(parameterName='maxVel')
2996 3289 value4 = str(value4)
2997 3290 value = value1 + "," + value2 + "," + value3 + ',' + value4
2998 3291 self.specOpgetNoise.setText(value)
2999 3292 self.specOpgetNoise.setEnabled(True)
3000 3293
3001 3294 opObj = puObj.getOperationObj(name='SpectraPlot')
3002 3295 # opObj = puObj.getOpObjfromParamValue(value="SpectraPlot")
3003 3296 if opObj == None:
3004 3297 self.specGraphCebSpectraplot.setCheckState(0)
3005 3298 self.specGraphSaveSpectra.setCheckState(0)
3006 3299 self.specGraphftpSpectra.setCheckState(0)
3007 3300
3008 3301 else:
3009 3302 operationSpectraPlot = "Enable"
3010 3303 self.specGraphCebSpectraplot.setCheckState(QtCore.Qt.Checked)
3011 3304 parmObj = opObj.getParameterObj(parameterName='channelList')
3012 3305 if parmObj == None:
3013 3306 self.specGgraphChannelList.clear()
3014 3307 else:
3015 3308 value = opObj.getParameterValue(parameterName='channelList')
3016 3309 channelListSpectraPlot = str(value)[1:-1]
3017 3310 self.specGgraphChannelList.setText(channelListSpectraPlot)
3018 3311 self.specGgraphChannelList.setEnabled(True)
3019 3312
3020 3313 parmObj = opObj.getParameterObj(parameterName='xmin')
3021 3314 if parmObj == None:
3022 3315 self.specGgraphFreq.clear()
3023 3316 else:
3024 3317 value1 = opObj.getParameterValue(parameterName='xmin')
3025 3318 value1 = str(value1)
3026 3319 value2 = opObj.getParameterValue(parameterName='xmax')
3027 3320 value2 = str(value2)
3028 3321 value = value1 + "," + value2
3029 3322 self.specGgraphFreq.setText(value)
3030 3323 self.specGgraphFreq.setEnabled(True)
3031 3324
3032 3325 parmObj = opObj.getParameterObj(parameterName='ymin')
3033 3326 if parmObj == None:
3034 3327 self.specGgraphHeight.clear()
3035 3328 else:
3036 3329 value1 = opObj.getParameterValue(parameterName='ymin')
3037 3330 value1 = str(value1)
3038 3331 value2 = opObj.getParameterValue(parameterName='ymax')
3039 3332 value2 = str(value2)
3040 3333 value = value1 + "," + value2
3041 3334 self.specGgraphHeight.setText(value)
3042 3335 self.specGgraphHeight.setEnabled(True)
3043 3336
3044 3337 parmObj = opObj.getParameterObj(parameterName='zmin')
3045 3338 if parmObj == None:
3046 3339 self.specGgraphDbsrange.clear()
3047 3340 else:
3048 3341 value1 = opObj.getParameterValue(parameterName='zmin')
3049 3342 value1 = str(value1)
3050 3343 value2 = opObj.getParameterValue(parameterName='zmax')
3051 3344 value2 = str(value2)
3052 3345 value = value1 + "," + value2
3053 3346 self.specGgraphDbsrange.setText(value)
3054 3347 self.specGgraphDbsrange.setEnabled(True)
3055 3348
3056 3349
3057 3350 parmObj = opObj.getParameterObj(parameterName="figpath")
3058 3351 if parmObj == None:
3059 3352 self.specGraphSaveSpectra.setCheckState(0)
3060 3353 else:
3061 3354 self.specGraphSaveSpectra.setCheckState(QtCore.Qt.Checked)
3062 3355 value = opObj.getParameterValue(parameterName='figpath')
3063 3356 self.specGraphPath.setText(value)
3064 3357
3065 3358 parmObj = opObj.getParameterObj(parameterName="ftp")
3066 3359 if parmObj == None:
3067 3360 self.specGraphftpSpectra.setCheckState(0)
3068 3361 else:
3069 3362 self.specGraphftpSpectra.setCheckState(QtCore.Qt.Checked)
3070 3363 try:
3071 3364 value = opObj.getParameterValue(parameterName='wr_period')
3072 3365 except:
3073 3366 value = " "
3074 3367 self.specGgraphftpratio.setText(str(value))
3075 3368
3076 3369 opObj = puObj.getOperationObj(name='CrossSpectraPlot')
3077 3370 # opObj = puObj.getOpObjfromParamValue(value="CrossSpectraPlot")
3078 3371 if opObj == None:
3079 3372 self.specGraphCebCrossSpectraplot.setCheckState(0)
3080 3373 self.specGraphSaveCross.setCheckState(0)
3081 3374
3082 3375 else:
3083 3376 operationCrossSpectraPlot = "Enable"
3084 3377 self.specGraphCebCrossSpectraplot.setCheckState(QtCore.Qt.Checked)
3085 3378 parmObj = opObj.getParameterObj(parameterName='xmin')
3086 3379 if parmObj == None:
3087 3380 self.specGgraphFreq.clear()
3088 3381 else:
3089 3382 value1 = opObj.getParameterValue(parameterName='xmin')
3090 3383 value1 = str(value1)
3091 3384 value2 = opObj.getParameterValue(parameterName='xmax')
3092 3385 value2 = str(value2)
3093 3386 value = value1 + "," + value2
3094 3387 self.specGgraphFreq.setText(value)
3095 3388 self.specGgraphFreq.setEnabled(True)
3096 3389
3097 3390 parmObj = opObj.getParameterObj(parameterName='ymin')
3098 3391 if parmObj == None:
3099 3392 self.specGgraphHeight.clear()
3100 3393 else:
3101 3394 value1 = opObj.getParameterValue(parameterName='ymin')
3102 3395 value1 = str(value1)
3103 3396 value2 = opObj.getParameterValue(parameterName='ymax')
3104 3397 value2 = str(value2)
3105 3398 value = value1 + "," + value2
3106 3399 self.specGgraphHeight.setText(value)
3107 3400 self.specGgraphHeight.setEnabled(True)
3108 3401
3109 3402 parmObj = opObj.getParameterObj(parameterName='zmin')
3110 3403 if parmObj == None:
3111 3404 self.specGgraphDbsrange.clear()
3112 3405 else:
3113 3406 value1 = opObj.getParameterValue(parameterName='zmin')
3114 3407 value1 = str(value1)
3115 3408 value2 = opObj.getParameterValue(parameterName='zmax')
3116 3409 value2 = str(value2)
3117 3410 value = value1 + "," + value2
3118 3411 self.specGgraphDbsrange.setText(value)
3119 3412 self.specGgraphDbsrange.setEnabled(True)
3120 3413
3121 3414 parmObj = opObj.getParameterObj(parameterName="figpath")
3122 3415 if parmObj == None:
3123 3416 self.specGraphSaveCross.setCheckState(0)
3124 3417
3125 3418 else:
3126 3419 self.specGraphSaveCross.setCheckState(QtCore.Qt.Checked)
3127 3420 value = opObj.getParameterValue(parameterName='figpath')
3128 3421 self.specGraphPath.setText(value)
3129 3422
3130 3423 parmObj = opObj.getParameterObj(parameterName="ftp")
3131 3424 if parmObj == None:
3132 3425 self.specGraphftpCross.setCheckState(0)
3133 3426 else:
3134 3427 self.specGraphftpCross.setCheckState(QtCore.Qt.Checked)
3135 3428 try:
3136 3429 value = opObj.getParameterValue(parameterName='wr_period')
3137 3430 except:
3138 3431 value = " "
3139 3432 self.specGgraphftpratio.setText(str(value))
3140 3433
3141 3434 opObj = puObj.getOperationObj(name='RTIPlot')
3142 3435 # opObj = puObj.getOpObjfromParamValue(value="RTIPlot")
3143 3436 if opObj == None:
3144 3437 self.specGraphCebRTIplot.setCheckState(0)
3145 3438 self.specGraphSaveRTIplot.setCheckState(0)
3146 3439 self.specGraphftpRTIplot.setCheckState(0)
3147 3440 else:
3148 3441 self.specGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
3149 3442 parmObj = opObj.getParameterObj(parameterName='channelList')
3150 3443 if parmObj == None:
3151 3444 self.specGgraphChannelList.clear()
3152 3445 else:
3153 3446 value = opObj.getParameterValue(parameterName='channelList')
3154 3447 channelListRTIPlot = str(value)[1:-1]
3155 3448 self.specGgraphChannelList.setText(channelListRTIPlot)
3156 3449 self.specGgraphChannelList.setEnabled(True)
3157 3450
3158 3451 parmObj = opObj.getParameterObj(parameterName='xmin')
3159 3452 if parmObj == None:
3160 3453 self.specGgraphTminTmax.clear()
3161 3454 else:
3162 3455 value1 = opObj.getParameterValue(parameterName='xmin')
3163 3456 value1 = str(value1)
3164 3457 value2 = opObj.getParameterValue(parameterName='xmax')
3165 3458 value2 = str(value2)
3166 3459 value = value1 + "," + value2
3167 3460 self.specGgraphTminTmax.setText(value)
3168 3461 self.specGgraphTminTmax.setEnabled(True)
3169 3462
3170 3463 parmObj = opObj.getParameterObj(parameterName='timerange')
3171 3464 if parmObj == None:
3172 3465 self.specGgraphTimeRange.clear()
3173 3466 else:
3174 3467 value1 = opObj.getParameterValue(parameterName='timerange')
3175 3468 value1 = str(value1)
3176 3469 self.specGgraphTimeRange.setText(value1)
3177 3470 self.specGgraphTimeRange.setEnabled(True)
3178 3471
3179 3472 parmObj = opObj.getParameterObj(parameterName='ymin')
3180 3473 if parmObj == None:
3181 3474 self.specGgraphHeight.clear()
3182 3475 else:
3183 3476 value1 = opObj.getParameterValue(parameterName='ymin')
3184 3477 value1 = str(value1)
3185 3478 value2 = opObj.getParameterValue(parameterName='ymax')
3186 3479 value2 = str(value2)
3187 3480 value = value1 + "," + value2
3188 3481 self.specGgraphHeight.setText(value)
3189 3482 self.specGgraphHeight.setEnabled(True)
3190 3483
3191 3484 parmObj = opObj.getParameterObj(parameterName='zmin')
3192 3485 if parmObj == None:
3193 3486 self.specGgraphDbsrange.clear()
3194 3487 else:
3195 3488 value1 = opObj.getParameterValue(parameterName='zmin')
3196 3489 value1 = str(value1)
3197 3490 value2 = opObj.getParameterValue(parameterName='zmax')
3198 3491 value2 = str(value2)
3199 3492 value = value1 + "," + value2
3200 3493 self.specGgraphDbsrange.setText(value)
3201 3494 self.specGgraphDbsrange.setEnabled(True)
3202 3495
3203 3496 parmObj = opObj.getParameterObj(parameterName="figpath")
3204 3497 if parmObj == None:
3205 3498 self.specGraphSaveRTIplot.setCheckState(0)
3206 3499 else:
3207 3500 self.specGraphSaveRTIplot.setCheckState(QtCore.Qt.Checked)
3208 3501 value = opObj.getParameterValue(parameterName='figpath')
3209 3502 self.specGraphPath.setText(value)
3210 3503 #---------add----#
3211 3504 parmObj = opObj.getParameterObj(parameterName="ftp")
3212 3505 if parmObj == None:
3213 3506 self.specGraphftpRTIplot.setCheckState(0)
3214 3507 else:
3215 3508 self.specGraphftpRTIplot.setCheckState(QtCore.Qt.Checked)
3216 3509 try:
3217 3510 value = opObj.getParameterValue(parameterName='wr_period')
3218 3511 except:
3219 3512 value = " "
3220 3513 self.specGgraphftpratio.setText(str(value))
3221 3514
3222 3515 opObj = puObj.getOperationObj(name='CoherenceMap')
3223 3516 # opObj = puObj.getOpObjfromParamValue(value="CoherenceMap")
3224 3517 if opObj == None:
3225 3518 self.specGraphCebCoherencmap.setCheckState(0)
3226 3519 self.specGraphSaveCoherencemap.setCheckState(0)
3227 3520 self.specGraphftpCoherencemap.setCheckState(0)
3228 3521
3229 3522 else:
3230 3523 operationCoherenceMap = "Enable"
3231 3524 self.specGraphCebCoherencmap.setCheckState(QtCore.Qt.Checked)
3232 3525 parmObj = opObj.getParameterObj(parameterName='xmin')
3233 3526 if parmObj == None:
3234 3527 self.specGgraphTminTmax.clear()
3235 3528 else:
3236 3529 value1 = opObj.getParameterValue(parameterName='xmin')
3237 3530 value1 = str(value1)
3238 3531 value2 = opObj.getParameterValue(parameterName='xmax')
3239 3532 value2 = str(value2)
3240 3533 value = value1 + "," + value2
3241 3534 self.specGgraphTminTmax.setText(value)
3242 3535 self.specGgraphTminTmax.setEnabled(True)
3243 3536
3244 3537 parmObj = opObj.getParameterObj(parameterName='timerange')
3245 3538 if parmObj == None:
3246 3539 self.specGgraphTimeRange.clear()
3247 3540 else:
3248 3541 value1 = opObj.getParameterValue(parameterName='timerange')
3249 3542 value1 = str(value1)
3250 3543 self.specGgraphTimeRange.setText(value1)
3251 3544 self.specGgraphTimeRange.setEnabled(True)
3252 3545
3253 3546 parmObj = opObj.getParameterObj(parameterName='ymin')
3254 3547 if parmObj == None:
3255 3548 self.specGgraphHeight.clear()
3256 3549 else:
3257 3550 value1 = opObj.getParameterValue(parameterName='ymin')
3258 3551 value1 = str(value1)
3259 3552 value2 = opObj.getParameterValue(parameterName='ymax')
3260 3553 value2 = str(value2)
3261 3554 value = value1 + "," + value2
3262 3555 self.specGgraphHeight.setText(value)
3263 3556 self.specGgraphHeight.setEnabled(True)
3264 3557
3265 3558 parmObj = opObj.getParameterObj(parameterName='zmin')
3266 3559 if parmObj == None:
3267 3560 self.specGgraphmagnitud.clear()
3268 3561 else:
3269 3562 value1 = opObj.getParameterValue(parameterName='zmin')
3270 3563 value1 = str(value1)
3271 3564 value2 = opObj.getParameterValue(parameterName='zmax')
3272 3565 value2 = str(value2)
3273 3566 value = value1 + "," + value2
3274 3567 self.specGgraphmagnitud.setText(value)
3275 3568 self.specGgraphmagnitud.setEnabled(True)
3276 3569
3277 3570 parmObj = opObj.getParameterObj(parameterName="figpath")
3278 3571 if parmObj == None:
3279 3572 self.specGraphSaveCoherencemap.setCheckState(0)
3280 3573 else:
3281 3574 self.specGraphSaveCoherencemap.setCheckState(QtCore.Qt.Checked)
3282 3575 value = opObj.getParameterValue(parameterName='figpath')
3283 3576 self.specGraphPath.setText(value)
3284 3577
3285 3578 parmObj = opObj.getParameterObj(parameterName="ftp")
3286 3579 if parmObj == None:
3287 3580 self.specGraphftpCoherencemap.setCheckState(0)
3288 3581 else:
3289 3582 self.specGraphftpCoherencemap.setCheckState(QtCore.Qt.Checked)
3290 3583 try:
3291 3584 value = opObj.getParameterValue(parameterName='wr_period')
3292 3585 except:
3293 3586 value = " "
3294 3587 self.specGgraphftpratio.setText(str(value))
3295 3588
3296 3589 opObj = puObj.getOperationObj(name='PowerProfilePlot')
3297 3590 # opObj = puObj.getOpObjfromParamValue(value="PowerProfilePlot")
3298 3591 if opObj == None:
3299 3592 self.specGraphPowerprofile.setCheckState(0)
3300 3593 self.specGraphSavePowerprofile.setCheckState(0)
3301 3594 operationPowerProfilePlot = "Disabled"
3302 3595 channelList = None
3303 3596 freq_vel = None
3304 3597 heightsrange = None
3305 3598 else:
3306 3599 operationPowerProfilePlot = "Enable"
3307 3600 self.specGraphPowerprofile.setCheckState(QtCore.Qt.Checked)
3308 3601 parmObj = opObj.getParameterObj(parameterName='xmin')
3309 3602 if parmObj == None:
3310 3603 self.specGgraphDbsrange.clear()
3311 3604 else:
3312 3605 value1 = opObj.getParameterValue(parameterName='xmin')
3313 3606 value1 = str(value1)
3314 3607 value2 = opObj.getParameterValue(parameterName='xmax')
3315 3608 value2 = str(value2)
3316 3609 value = value1 + "," + value2
3317 3610 self.specGgraphDbsrange.setText(value)
3318 3611 self.specGgraphDbsrange.setEnabled(True)
3319 3612
3320 3613 parmObj = opObj.getParameterObj(parameterName='ymin')
3321 3614 if parmObj == None:
3322 3615 self.specGgraphHeight.clear()
3323 3616 else:
3324 3617 value1 = opObj.getParameterValue(parameterName='ymin')
3325 3618 value1 = str(value1)
3326 3619 value2 = opObj.getParameterValue(parameterName='ymax')
3327 3620 value2 = str(value2)
3328 3621 value = value1 + "," + value2
3329 3622 self.specGgraphHeight.setText(value)
3330 3623 self.specGgraphHeight.setEnabled(True)
3331 3624
3332 3625 parmObj = opObj.getParameterObj(parameterName="figpath")
3333 3626 if parmObj == None:
3334 3627 self.specGraphSavePowerprofile.setCheckState(0)
3335 3628 else:
3336 3629 self.specGraphSavePowerprofile.setCheckState(QtCore.Qt.Checked)
3337 3630 value = opObj.getParameterValue(parameterName='figpath')
3338 3631 self.specGraphPath.setText(value)
3339 3632
3340 3633 parmObj = opObj.getParameterObj(parameterName="ftp")
3341 3634 if parmObj == None:
3342 3635 self.specGraphftpPowerprofile.setCheckState(0)
3343 3636 else:
3344 3637 self.specGraphftpPowerprofile.setCheckState(QtCore.Qt.Checked)
3345 3638 try:
3346 3639 value = opObj.getParameterValue(parameterName='wr_period')
3347 3640 except:
3348 3641 value = " "
3349 3642 self.specGgraphftpratio.setText(str(value))
3350 3643 # -noise
3351 3644 opObj = puObj.getOperationObj(name='Noise')
3352 3645 # opObj = puObj.getOpObjfromParamValue(value="Noise")
3353 3646 if opObj == None:
3354 3647 self.specGraphCebRTInoise.setCheckState(0)
3355 3648 self.specGraphSaveRTInoise.setCheckState(0)
3356 3649 self.specGraphftpRTInoise.setCheckState(0)
3357 3650 else:
3358 3651 self.specGraphCebRTInoise.setCheckState(QtCore.Qt.Checked)
3359 3652 parmObj = opObj.getParameterObj(parameterName='channelList')
3360 3653 if parmObj == None:
3361 3654 self.specGgraphChannelList.clear()
3362 3655 else:
3363 3656 value = opObj.getParameterValue(parameterName='channelList')
3364 3657 channelListRTINoise = str(value)[1:-1]
3365 3658 self.specGgraphChannelList.setText(channelListRTINoise)
3366 3659 self.specGgraphChannelList.setEnabled(True)
3367 3660
3368 3661 parmObj = opObj.getParameterObj(parameterName='xmin')
3369 3662 if parmObj == None:
3370 3663 self.specGgraphTminTmax.clear()
3371 3664 else:
3372 3665 value1 = opObj.getParameterValue(parameterName='xmin')
3373 3666 value1 = str(value1)
3374 3667 value2 = opObj.getParameterValue(parameterName='xmax')
3375 3668 value2 = str(value2)
3376 3669 value = value1 + "," + value2
3377 3670 self.specGgraphTminTmax.setText(value)
3378 3671 self.specGgraphTminTmax.setEnabled(True)
3379 3672
3380 3673 parmObj = opObj.getParameterObj(parameterName='timerange')
3381 3674 if parmObj == None:
3382 3675 self.specGgraphTimeRange.clear()
3383 3676 else:
3384 3677 value1 = opObj.getParameterValue(parameterName='timerange')
3385 3678 value1 = str(value1)
3386 3679 self.specGgraphTimeRange.setText(value1)
3387 3680 self.specGgraphTimeRange.setEnabled(True)
3388 3681
3389 3682
3390 3683 parmObj = opObj.getParameterObj(parameterName='ymin')
3391 3684 if parmObj == None:
3392 3685 self.specGgraphDbsrange.clear()
3393 3686 else:
3394 3687 value1 = opObj.getParameterValue(parameterName='ymin')
3395 3688 value1 = str(value1)
3396 3689 value2 = opObj.getParameterValue(parameterName='ymax')
3397 3690 value2 = str(value2)
3398 3691 value = value1 + "," + value2
3399 3692 self.specGgraphDbsrange.setText(value)
3400 3693 self.specGgraphDbsrange.setEnabled(True)
3401 3694
3402 3695 parmObj = opObj.getParameterObj(parameterName="figpath")
3403 3696 if parmObj == None:
3404 3697 self.specGraphSaveRTInoise.setCheckState(0)
3405 3698 else:
3406 3699 self.specGraphSaveRTInoise.setCheckState(QtCore.Qt.Checked)
3407 3700 value = opObj.getParameterValue(parameterName='figpath')
3408 3701 self.specGraphPath.setText(value)
3409 3702 #---------add----#
3410 3703 parmObj = opObj.getParameterObj(parameterName="ftp")
3411 3704 if parmObj == None:
3412 3705 self.specGraphftpRTInoise.setCheckState(0)
3413 3706 else:
3414 3707 self.specGraphftpRTInoise.setCheckState(QtCore.Qt.Checked)
3415 3708 try:
3416 3709 value = opObj.getParameterValue(parameterName='wr_period')
3417 3710 except:
3418 3711 value = " "
3419 3712 self.specGgraphftpratio.setText(str(value))
3420 3713
3421 3714 # outputSpectraWrite
3422 3715 opObj = puObj.getOperationObj(name='SpectraWriter')
3423 3716 if opObj == None:
3424 3717 self.specOutputPath.clear()
3425 3718 self.specOutputblocksperfile.clear()
3426 3719 self.specOutputprofileperblock.clear()
3427 3720 else:
3428 3721 value = opObj.getParameterObj(parameterName='path')
3429 3722 if value == None:
3430 3723 self.specOutputPath.clear()
3431 3724 else:
3432 3725 value = opObj.getParameterValue(parameterName='path')
3433 3726 path = str(value)
3434 3727 self.specOutputPath.setText(path)
3435 3728 value = opObj.getParameterObj(parameterName='blocksPerFile')
3436 3729 if value == None:
3437 3730 self.specOutputblocksperfile.clear()
3438 3731 else:
3439 3732 value = opObj.getParameterValue(parameterName='blocksPerFile')
3440 3733 blocksperfile = str(value)
3441 3734 self.specOutputblocksperfile.setText(blocksperfile)
3442 3735 value = opObj.getParameterObj(parameterName='profilesPerBlock')
3443 3736 if value == None:
3444 3737 self.specOutputprofileperblock.clear()
3445 3738 else:
3446 3739 value = opObj.getParameterValue(parameterName='profilesPerBlock')
3447 3740 profilesPerBlock = str(value)
3448 3741 self.specOutputprofileperblock.setText(profilesPerBlock)
3449 3742
3450 3743 if datatype == 'SpectraHeis':
3451 3744 opObj = puObj.getOperationObj(name="IncohInt4SpectraHeis")
3452 3745 if opObj == None:
3453 3746 self.specHeisOpIncoherent.clear()
3454 3747 self.specHeisOpCebIncoherent.setCheckState(0)
3455 3748 else:
3456 3749 for parmObj in opObj.getParameterObjList():
3457 3750 if parmObj.name == 'timeInterval':
3458 3751 value = opObj.getParameterValue(parameterName='timeInterval')
3459 3752 value = float(value)
3460 3753 self.specHeisOpIncoherent.setText(str(value))
3461 3754 self.specHeisOpIncoherent.setEnabled(True)
3462 3755 self.specHeisOpCebIncoherent.setCheckState(QtCore.Qt.Checked)
3463 3756 self.specHeisOpCobIncInt.setCurrentIndex(0)
3464 3757
3465 3758 # SpectraHeis Graph
3466 3759 opObj = puObj.getOperationObj(name='SpectraHeisScope')
3467 3760 # opObj = puObj.getOpObjfromParamValue(value="SpectraHeisScope")
3468 3761 if opObj == None:
3469 3762 self.specHeisGraphCebSpectraplot.setCheckState(0)
3470 3763 self.specHeisGraphSaveSpectra.setCheckState(0)
3471 3764 self.specHeisGraphftpSpectra.setCheckState(0)
3472 3765
3473 3766 else:
3474 3767 operationSpectraHeisScope = "Enable"
3475 3768 self.specHeisGraphCebSpectraplot.setCheckState(QtCore.Qt.Checked)
3476 3769 parmObj = opObj.getParameterObj(parameterName='channelList')
3477 3770 if parmObj == None:
3478 3771 self.specHeisGgraphChannelList.clear()
3479 3772 else:
3480 3773 value = opObj.getParameterValue(parameterName='channelList')
3481 3774 channelListSpectraHeisScope = str(value)[1:-1]
3482 3775 self.specHeisGgraphChannelList.setText(channelListSpectraHeisScope)
3483 3776 self.specHeisGgraphChannelList.setEnabled(True)
3484 3777
3485 3778 parmObj = opObj.getParameterObj(parameterName='xmin')
3486 3779 if parmObj == None:
3487 3780 self.specHeisGgraphXminXmax.clear()
3488 3781 else:
3489 3782 value1 = opObj.getParameterValue(parameterName='xmin')
3490 3783 value1 = str(value1)
3491 3784 value2 = opObj.getParameterValue(parameterName='xmax')
3492 3785 value2 = str(value2)
3493 3786 value = value1 + "," + value2
3494 3787 self.specHeisGgraphXminXmax.setText(value)
3495 3788 self.specHeisGgraphXminXmax.setEnabled(True)
3496 3789
3497 3790 parmObj = opObj.getParameterObj(parameterName='ymin')
3498 3791 if parmObj == None:
3499 3792 self.specHeisGgraphYminYmax.clear()
3500 3793 else:
3501 3794 value1 = opObj.getParameterValue(parameterName='ymin')
3502 3795 value1 = str(value1)
3503 3796 value2 = opObj.getParameterValue(parameterName='ymax')
3504 3797 value2 = str(value2)
3505 3798 value = value1 + "," + value2
3506 3799 self.specHeisGgraphYminYmax.setText(value)
3507 3800 self.specHeisGgraphYminYmax.setEnabled(True)
3508 3801
3509 3802 parmObj = opObj.getParameterObj(parameterName="figpath")
3510 3803 if parmObj == None:
3511 3804 self.specHeisGraphSaveSpectra.setCheckState(0)
3512 3805 else:
3513 3806 self.specHeisGraphSaveSpectra.setCheckState(QtCore.Qt.Checked)
3514 3807 value = opObj.getParameterValue(parameterName='figpath')
3515 3808 self.specHeisGraphPath.setText(value)
3516 3809
3517 3810 parmObj = opObj.getParameterObj(parameterName="ftp")
3518 3811 if parmObj == None:
3519 3812 self.specHeisGraphftpSpectra.setCheckState(0)
3520 3813 else:
3521 3814 self.specHeisGraphftpSpectra.setCheckState(QtCore.Qt.Checked)
3522 3815 try:
3523 3816 value = opObj.getParameterValue(parameterName='wr_period')
3524 3817 except:
3525 3818 value = " "
3526 3819 self.specHeisGgraphftpratio.setText(str(value))
3527 3820
3528 3821 opObj = puObj.getOperationObj(name='RTIfromSpectraHeis')
3529 3822 # opObj = puObj.getOpObjfromParamValue(value="RTIfromSpectraHeis")
3530 3823 if opObj == None:
3531 3824 self.specHeisGraphCebRTIplot.setCheckState(0)
3532 3825 self.specHeisGraphSaveRTIplot.setCheckState(0)
3533 3826 self.specHeisGraphftpRTIplot.setCheckState(0)
3534 3827 else:
3535 3828 self.specHeisGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
3536 3829 parmObj = opObj.getParameterObj(parameterName='channelList')
3537 3830 if parmObj == None:
3538 3831 self.specHeisGgraphChannelList.clear()
3539 3832 else:
3540 3833 value = opObj.getParameterValue(parameterName='channelList')
3541 3834 channelListRTIPlot = str(value)[1:-1]
3542 3835 self.specGgraphChannelList.setText(channelListRTIPlot)
3543 3836 self.specGgraphChannelList.setEnabled(True)
3544 3837
3545 3838 parmObj = opObj.getParameterObj(parameterName='xmin')
3546 3839 if parmObj == None:
3547 3840 self.specHeisGgraphTminTmax.clear()
3548 3841 else:
3549 3842 value1 = opObj.getParameterValue(parameterName='xmin')
3550 3843 value1 = str(value1)
3551 3844 value2 = opObj.getParameterValue(parameterName='xmax')
3552 3845 value2 = str(value2)
3553 3846 value = value1 + "," + value2
3554 3847 self.specHeisGgraphTminTmax.setText(value)
3555 3848 self.specHeisGgraphTminTmax.setEnabled(True)
3556 3849
3557 3850 parmObj = opObj.getParameterObj(parameterName='timerange')
3558 3851 if parmObj == None:
3559 3852 self.specGgraphTimeRange.clear()
3560 3853 else:
3561 3854 value1 = opObj.getParameterValue(parameterName='timerange')
3562 3855 value1 = str(value1)
3563 3856 self.specHeisGgraphTimeRange.setText(value1)
3564 3857 self.specHeisGgraphTimeRange.setEnabled(True)
3565 3858
3566 3859 parmObj = opObj.getParameterObj(parameterName='ymin')
3567 3860 if parmObj == None:
3568 3861 self.specHeisGgraphYminYmax.clear()
3569 3862 else:
3570 3863 value1 = opObj.getParameterValue(parameterName='ymin')
3571 3864 value1 = str(value1)
3572 3865 value2 = opObj.getParameterValue(parameterName='ymax')
3573 3866 value2 = str(value2)
3574 3867 value = value1 + "," + value2
3575 3868 self.specHeisGgraphYminYmax.setText(value)
3576 3869 self.specHeisGgraphYminYmax.setEnabled(True)
3577 3870
3578 3871 parmObj = opObj.getParameterObj(parameterName="figpath")
3579 3872 if parmObj == None:
3580 3873 self.specHeisGraphSaveRTIplot.setCheckState(0)
3581 3874 else:
3582 3875 self.specHeisGraphSaveRTIplot.setCheckState(QtCore.Qt.Checked)
3583 3876 value = opObj.getParameterValue(parameterName='figpath')
3584 3877 self.specHeisGraphPath.setText(value)
3585 3878 #---------add----#
3586 3879 parmObj = opObj.getParameterObj(parameterName="ftp")
3587 3880 if parmObj == None:
3588 3881 self.specHeisGraphftpRTIplot.setCheckState(0)
3589 3882 else:
3590 3883 self.specHeisGraphftpRTIplot.setCheckState(QtCore.Qt.Checked)
3591 3884 try:
3592 3885 value = opObj.getParameterValue(parameterName='wr_period')
3593 3886 except:
3594 3887 value = " "
3595 3888 self.specHeisGgraphftpratio.setText(str(value))
3596 3889
3597 3890
3598 3891
3599 3892 # outputSpectraHeisWrite
3600 3893 opObj = puObj.getOperationObj(name='FitsWriter')
3601 3894 if opObj == None:
3602 3895 self.specHeisOutputPath.clear()
3603 3896 self.specHeisOutputblocksperfile.clear()
3604 3897 self.specHeisOutputMetada.clear()
3605 3898 else:
3606 3899 value = opObj.getParameterObj(parameterName='path')
3607 3900 if value == None:
3608 3901 self.specHeisOutputPath.clear()
3609 3902 else:
3610 3903 value = opObj.getParameterValue(parameterName='path')
3611 3904 path = str(value)
3612 3905 self.specHeisOutputPath.setText(path)
3613 3906 value = opObj.getParameterObj(parameterName='dataBlocksPerFile')
3614 3907 if value == None:
3615 3908 self.specHeisOutputblocksperfile.clear()
3616 3909 else:
3617 3910 value = opObj.getParameterValue(parameterName='dataBlocksPerFile')
3618 3911 blocksperfile = str(value)
3619 3912 self.specHeisOutputblocksperfile.setText(blocksperfile)
3620 3913 value = opObj.getParameterObj(parameterName='metadatafile')
3621 3914 if value == None:
3622 3915 self.specHeisOutputMetada.clear()
3623 3916 else:
3624 3917 value = opObj.getParameterValue(parameterName='metadatafile')
3625 3918 metada = str(value)
3626 3919 self.specHeisOutputMetada.setText(metada)
3627 3920
3628 3921
3629 3922
3630 3923 def setspecGraph(self):
3631 3924
3632 3925 self.specGgraphChannelList.setEnabled(True)
3633 3926
3634 3927 def clearspecGraph(self):
3635 3928
3636 3929 self.specGgraphChannelList.clear()
3637 3930
3638 3931 def create_comm(self):
3639 3932
3640 3933 self.commCtrlPThread = CommCtrlProcessThread()
3641 3934 self.commCtrlPThread.start()
3642 3935
3643 3936 def create_updating_timer(self):
3644 3937 self.comm_data_timer = QtCore.QTimer(self)
3645 3938 self.comm_data_timer.timeout.connect(self.on_comm_updating_timer)
3646 3939 self.comm_data_timer.start(1000)
3647 3940
3648 3941 def create_figure(self):
3649 3942 self.queue_plot = Queue.Queue()
3650 3943 self.plotmanager = PlotManager(self.queue_plot)
3651 3944 self.plot_timer = QtCore.QTimer()
3652 3945 QtCore.QObject.connect(self.plot_timer, QtCore.SIGNAL("timeout()"), self.periodicCall)
3653 3946 self.plot_timer.start(100)
3654 3947 self.running = 1
3655 3948
3656 3949 def periodicCall(self):
3657 3950 """
3658 3951 Check every 100 ms if there is something new in the queue.
3659 3952 """
3660 3953 self.plotmanager.processIncoming()
3661 3954 if not self.running:
3662 3955 app.quit()
3663 3956
3664 3957 # def on_comm_data_timer(self):
3665 3958 # # lee el data_queue y la coloca en el queue de ploteo
3666 3959 # try:
3667 3960 # reply = self.commCtrlPThread.data_q.get(block=False)
3668 3961 # self.queue_plot.put(reply.data)
3669 3962 #
3670 3963 # except Queue.Empty:
3671 3964 # pass
3672 3965
3673 3966 def createProjectView(self, id):
3674 3967
3675 3968 self.create = False
3676 3969 project_name, description, datatype, data_path, starDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
3677 3970
3678 3971 projectObjView = Project()
3679 3972 projectObjView.setup(id=id, name=project_name, description=description)
3680 3973
3681 3974 self.__projectObjDict[id] = projectObjView
3682 3975
3683 3976 return projectObjView
3684 3977
3685 3978 def updateProjectView(self):
3686 3979
3687 3980 project_name, description, datatype, data_path, starDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
3688 3981
3689 3982 projectObjView = self.getSelectedProjectObj()
3690 3983 projectObjView.update(name=project_name, description=description)
3691 3984
3692 3985 return projectObjView
3693 3986
3694 3987 def createReadUnitView(self, projectObjView):
3695 3988
3696 project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, walk , set = self.getParmsFromProjectWindow()
3697 if set == None:
3698 readUnitConfObj = projectObjView.addReadUnit(datatype=datatype,
3699 path=data_path,
3700 startDate=startDate,
3701 endDate=endDate,
3702 startTime=startTime,
3703 endTime=endTime,
3704 online=online,
3705 delay=delay,
3706 walk=walk)
3707 else:
3989 project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, walk, set = self.getParmsFromProjectWindow()
3990
3991 if datatype == "Voltage" or datatype == "Spectra" or datatype == "Fits":
3708 3992 readUnitConfObj = projectObjView.addReadUnit(datatype=datatype,
3709 3993 path=data_path,
3710 3994 startDate=startDate,
3711 3995 endDate=endDate,
3712 3996 startTime=startTime,
3713 3997 endTime=endTime,
3714 3998 online=online,
3715 3999 delay=delay,
3716 4000 walk=walk,
3717 set=set)
3718
4001 set=set
4002 )
4003
4004 if datatype == "USRP":
4005 readUnitConfObj = projectObjView.addReadUnit(datatype=datatype,
4006 path=data_path,
4007 startDate=startDate,
4008 endDate=endDate,
4009 startTime=startTime,
4010 endTime=endTime,
4011 online=online,
4012 delay=delay,
4013 ippKm=set
4014 )
3719 4015 return readUnitConfObj
3720 4016
3721 4017 def updateReadUnitView(self, projectObjView, idReadUnit):
3722 4018
3723 4019 project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, walk , set = self.getParmsFromProjectWindow()
3724 4020
3725 4021 readUnitConfObj = projectObjView.getProcUnitObj(idReadUnit)
3726 4022
3727 if set == None:
3728
4023 if datatype == "Voltage" or datatype == "Spectra" or datatype == "Fits":
3729 4024 readUnitConfObj.update(datatype=datatype,
3730 4025 path=data_path,
3731 4026 startDate=startDate,
3732 4027 endDate=endDate,
3733 4028 startTime=startTime,
3734 4029 endTime=endTime,
3735 4030 online=online,
3736 4031 delay=delay,
3737 walk=walk)
3738
3739 else:
4032 walk=walk,
4033 set=set
4034 )
4035
4036 if datatype == "USRP":
3740 4037 readUnitConfObj.update(datatype=datatype,
3741 path=data_path,
3742 startDate=startDate,
3743 endDate=endDate,
3744 startTime=startTime,
3745 endTime=endTime,
3746 online=online,
3747 delay=delay,
3748 walk=walk,
3749 set=set)
3750
3751
4038 path=data_path,
4039 startDate=startDate,
4040 endDate=endDate,
4041 startTime=startTime,
4042 endTime=endTime,
4043 online=online,
4044 delay=delay,
4045 ippKm=set
4046 )
3752 4047
3753 4048 return readUnitConfObj
3754 4049
3755 4050 def createProcUnitView(self, projectObjView, datatype, inputId):
3756 4051
3757 4052 procUnitConfObj = projectObjView.addProcUnit(datatype=datatype, inputId=inputId)
3758 4053
3759 4054 self.__puObjDict[procUnitConfObj.getId()] = procUnitConfObj
3760 4055
3761 4056 return procUnitConfObj
3762 4057
3763 4058 def updateProcUnitView(self, id):
3764 4059
3765 4060 procUnitConfObj = projectObjView.getProcUnitObj(id)
3766 4061 procUnitConfObj.removeOperations()
3767 4062
3768 4063 return procUnitConfObj
3769 4064
3770 4065 def addPUWindow(self):
3771 4066
3772 4067 self.configUPWindowObj = UnitProcessWindow(self)
3773 fatherObj = self.getSelectedPUObj()
4068 fatherObj = self.getSelectedItemObj()
3774 4069 try:
3775 4070 fatherObj.getElementName()
3776 4071 except:
3777 4072 self.console.append("First left click on Project or Processing Unit")
3778 4073 return 0
3779 4074
3780 4075 if fatherObj.getElementName() == 'Project':
3781 4076 readUnitConfObj = fatherObj.getReadUnitObj()
3782 4077 self.configUPWindowObj.dataTypeProject = str(readUnitConfObj.datatype)
3783 4078
3784 4079 self.configUPWindowObj.getfromWindowList.append(fatherObj)
3785 4080 self.configUPWindowObj.loadTotalList()
3786 4081 self.configUPWindowObj.show()
3787 4082 self.configUPWindowObj.closed.connect(self.createPUWindow)
3788 4083
3789 4084 def createPUWindow(self):
3790 4085
3791 4086 self.console.clear()
3792 4087
3793 4088 if not self.configUPWindowObj.create:
3794 4089 return
3795 4090
3796 4091 fatherObj = self.configUPWindowObj.getFromWindow
3797 4092 datatype = self.configUPWindowObj.typeofUP
3798 4093
3799 4094 if fatherObj.getElementName() == 'Project':
3800 4095 inputId = fatherObj.getReadUnitId()
3801 4096 projectObjView = fatherObj
3802 4097 else:
3803 4098 inputId = fatherObj.getId()
3804 4099 projectObjView = self.getSelectedProjectObj()
3805 4100
3806 4101 #----------------------------
3807 4102 puObj = self.createProcUnitView(projectObjView, datatype, inputId)
3808 4103 #----------------------------
3809 4104 self.addPU2ProjectExplorer(id=puObj.getId(), name=datatype)
3810 4105
3811 4106 self.showtabPUCreated(datatype)
3812 4107
3813 self.setInputsPU_View(datatype)
4108 self.clearPUWindow(datatype)
3814 4109
3815 4110 self.showPUinitView()
3816 4111
3817 4112 def addFTPConf2Operation(self, puObj, opObj):
3818 4113
3819 4114 if self.temporalFTP.create:
3820 4115 server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.temporalFTP.recover()
3821 4116 else:
3822 4117 self.temporalFTP.setwithoutconfiguration()
3823 4118 server, remotefolder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.temporalFTP.recover()
3824 4119
3825 4120 # opObj.addParameter(name='server', value=server, format='str')
3826 4121 # opObj.addParameter(name='folder', value=remotefolder, format='str')
3827 4122 # opObj.addParameter(name='username', value=username, format='str')
3828 4123 # opObj.addParameter(name='password', value=password, format='str')
3829 4124
3830 4125 if ftp_wei:
3831 4126 opObj.addParameter(name='ftp_wei', value=int(ftp_wei), format='int')
3832 4127 if exp_code:
3833 4128 opObj.addParameter(name='exp_code', value=int(exp_code), format='int')
3834 4129 if sub_exp_code:
3835 4130 opObj.addParameter(name='sub_exp_code', value=int(sub_exp_code), format='int')
3836 4131 if plot_pos:
3837 4132 opObj.addParameter(name='plot_pos', value=int(plot_pos), format='int')
3838 4133
3839 4134 if puObj.datatype == "Spectra":
3840 4135 value = self.specGgraphftpratio.text()
3841 4136 if puObj.datatype == "SpectraHeis":
3842 4137 value = self.specHeisGgraphftpratio.text()
3843 4138
3844 4139 if not value == "":
3845 4140 try:
3846 4141 value = int(value)
3847 4142 except:
3848 4143 self.console.clear()
3849 4144 self.console.append("Please fill Ratio on the textbox")
3850 4145 return 0
3851 4146
3852 4147 opObj.addParameter(name='wr_period', value=value, format='int')
3853 4148
3854 4149 def createFTPProcUnitView(self, server, username, password, remotefolder,
3855 4150 ftp_wei, exp_code, sub_exp_code, plot_pos,
3856 4151 localfolder='./', extension='.png', period='60', protocol='ftp'):
3857 4152
3858 4153 projectObj = self.getSelectedProjectObj()
3859 4154 procUnitConfObj = projectObj.getProcUnitObjByName(name="SendToServer")
3860 4155
3861 4156 if not procUnitConfObj:
3862 4157 procUnitConfObj = projectObj.addProcUnit(name="SendToServer")
3863 4158 else:
3864 4159 procUnitConfObj.removeOperations()
3865 4160
3866 4161 procUnitConfObj.addParameter(name='server', value=server, format='str')
3867 4162 procUnitConfObj.addParameter(name='username', value=username, format='str')
3868 4163 procUnitConfObj.addParameter(name='password', value=password, format='str')
3869 4164 procUnitConfObj.addParameter(name='localfolder', value=localfolder, format='str')
3870 4165 procUnitConfObj.addParameter(name='remotefolder', value=remotefolder, format='str')
3871 4166 procUnitConfObj.addParameter(name='ext', value=extension, format='str')
3872 4167 procUnitConfObj.addParameter(name='period', value=period, format='int')
3873 4168 procUnitConfObj.addParameter(name='protocol', value=protocol, format='str')
3874 4169
3875 4170 procUnitConfObj.addParameter(name='ftp_wei', value=ftp_wei, format='str')
3876 4171 procUnitConfObj.addParameter(name='exp_code', value=exp_code, format='str')
3877 4172 procUnitConfObj.addParameter(name='sub_exp_code', value=sub_exp_code, format='str')
3878 4173 procUnitConfObj.addParameter(name='plot_pos', value=plot_pos, format='str')
3879 4174
3880 4175 self.__puObjDict[procUnitConfObj.getId()] = procUnitConfObj
3881 4176
3882 4177 self.__ftpProcUnitAdded = True
3883 4178 self.__ftpProcUnitId = procUnitConfObj.getId()
3884 4179
3885 4180 def removeFTPProcUnitView(self):
3886 4181
3887 4182 projectObj = self.getSelectedProjectObj()
3888 4183 procUnitConfObj = projectObj.getProcUnitObjByName(name="SendToServer")
3889 4184
3890 4185 self.__ftpProcUnitAdded = False
3891 4186 self.__ftpProcUnitId = None
3892 4187
3893 4188 if not procUnitConfObj:
3894 4189 return
3895 4190
3896 4191 projectObj.removeProcUnit(procUnitConfObj.getId())
3897 4192
3898 4193 if procUnitConfObj.getId() not in self.__puObjDict.keys():
3899 4194 return
3900 4195
3901 4196 self.__puObjDict.pop(procUnitConfObj.getId())
3902 4197
3903 4198 def bufferProject(self, caracteristica, principal, description):
3904 4199
3905 4200 self.projectProperCaracteristica.append(caracteristica)
3906 4201 self.projectProperPrincipal.append(principal)
3907 4202 self.projectProperDescripcion.append(description)
3908 4203 return self.projectProperCaracteristica, self.projectProperPrincipal, self.projectProperDescripcion
3909 4204
3910 4205
3911 4206 def showProjectProperties(self, projectObjView):
3912 4207
3913 4208 project_name, description = projectObjView.name, projectObjView.description
3914 4209
3915 4210 id = projectObjView.id
3916 4211 readUnitId = projectObjView.getReadUnitId()
3917 4212 readUnitObj = projectObjView.getProcUnitObj(readUnitId)
3918 4213 operationObj = readUnitObj.getOperationObj(name='run')
3919 4214
3920 4215
3921 4216 datatype = operationObj.getParameterValue(parameterName='datatype')
3922 4217 dpath = operationObj.getParameterValue(parameterName='path')
3923 4218 startDate = operationObj.getParameterValue(parameterName='startDate')
3924 4219 endDate = operationObj.getParameterValue(parameterName='endDate')
3925 4220 startDate = str(startDate)
3926 4221 endDate = str(endDate)
3927 4222 startDateList = startDate.split('-')
3928 4223 endDateList = endDate.split('-')
3929 4224 startDate = startDateList[0] + "/" + startDateList[1] + "/" + startDateList[2]
3930 4225 endDate = endDateList[0] + "/" + endDateList[1] + "/" + endDateList[2]
3931 4226
3932 4227 startTime = operationObj.getParameterValue(parameterName='startTime')
3933 4228 endTime = operationObj.getParameterValue(parameterName='endTime')
3934 4229 online = operationObj.getParameterValue(parameterName='online')
3935 4230 walk = operationObj.getParameterValue(parameterName='walk')
3936 4231 delay = operationObj.getParameterValue(parameterName='delay')
3937 4232 try:
3938 4233 set = operationObj.getParameterValue(parameterName='set')
3939 4234 except:
3940 4235 set = " "
3941 4236
3942 4237 if online == 0:
3943 4238 remode = "offline"
3944 4239 else:
3945 4240 remode = "online"
3946 4241
3947 4242 if walk == 0:
3948 4243 walk_str = 'On Files'
3949 4244 else:
3950 4245 walk_str = 'On Folder'
3951 4246
3952 4247 self.bufferProject("Properties", "Name", project_name),
3953 4248 self.bufferProject("Properties", "Data Path", dpath)
3954 4249 self.bufferProject("Properties", "Workspace", self.pathWorkSpace)
3955 4250 self.bufferProject("Parameters", "Read Mode ", remode)
3956 4251 self.bufferProject("Parameters", "DataType ", datatype)
3957 4252 self.bufferProject("Parameters", "Start Date", str(startDate))
3958 4253 self.bufferProject("Parameters", "End Date ", str(endDate))
3959 4254 self.bufferProject("Parameters", "Start Time", str(startTime))
3960 4255 self.bufferProject("Parameters", "End Time ", str(endTime))
3961 4256 self.bufferProject("Parameters", "Delay ", str(delay))
3962 4257 try:
3963 4258 set = operationObj.getParameterValue(parameterName='set')
3964 4259 self.bufferProject("Parameters", "Set ", set)
3965 4260 except:
3966 4261 set = " "
3967 4262 self.bufferProject("Parameters", "Walk ", str(walk_str))
3968 4263 self.bufferProject("Parameters", "Time zone", "Local")
3969 4264 self.bufferProject("Description", "Summary ", description)
3970 4265
3971 self.propertiesModel = treeModel()
3972 self.propertiesModel.showProjectParms(self.projectProperCaracteristica, self.projectProperPrincipal, self.projectProperDescripcion)
4266 self.propertiesModel = TreeModel()
4267 self.propertiesModel.showProperties(self.projectProperCaracteristica, self.projectProperPrincipal, self.projectProperDescripcion)
3973 4268 self.treeProjectProperties.setModel(self.propertiesModel)
3974 4269 self.treeProjectProperties.expandAll()
3975 4270 self.treeProjectProperties.resizeColumnToContents(0)
3976 4271 self.treeProjectProperties.resizeColumnToContents(1)
3977 4272
3978 4273 self.projectProperCaracteristica = []
3979 4274 self.projectProperPrincipal = []
3980 4275 self.projectProperDescripcion = []
3981 4276
3982 4277 return datatype , dpath , startDate , endDate, startTime, endTime, online, delay, walk, set
3983 4278
3984 4279 def showPUinitView(self):
3985 self.propertiesModel = treeModel()
4280 self.propertiesModel = TreeModel()
3986 4281 self.propertiesModel.initPUVoltageView()
3987 4282 self.treeProjectProperties.setModel(self.propertiesModel)
3988 4283 self.treeProjectProperties.expandAll()
3989 4284 self.treeProjectProperties.allColumnsShowFocus()
3990 4285 self.treeProjectProperties.resizeColumnToContents(1)
3991 4286
3992 4287 def bufferVoltage(self, caracteristica, principal, description):
3993 4288 self.volProperCaracteristica.append(caracteristica)
3994 4289 self.volProperPrincipal.append(principal)
3995 4290 self.volProperDescripcion.append(description)
3996 4291 return self.volProperCaracteristica, self.volProperPrincipal, self.volProperDescripcion
3997 4292
3998 4293 def showPUVoltageProperties(self, puObj):
3999 4294
4000 4295
4001 4296 type = puObj.name
4002 4297 self.bufferVoltage("Processing Unit", "Type", type)
4003 4298
4004 4299 opObj = puObj.getOperationObj(name="setRadarFrequency")
4005 4300 if opObj == None:
4006 4301 radarfrequency = None
4007 4302 else:
4008 4303 value = opObj.getParameterValue(parameterName='frequency')
4009 4304 value = str(value)
4010 4305 radarfrequency = value
4011 4306 self.bufferVoltage("Processing Unit", "Radar Frequency", radarfrequency)
4012 4307
4013 4308 opObj = puObj.getOperationObj(name="selectChannels")
4014 4309 if opObj == None:
4015 4310 channel = None
4016 4311 else:
4017 4312 value = opObj.getParameterValue(parameterName='channelList')
4018 4313 value = str(value)#[1:-1]
4019 4314 channel = value
4020 4315 self.bufferVoltage("Processing Unit", "Select Channel", channel)
4021 4316
4022 4317 opObj = puObj.getOperationObj(name="selectChannelsByIndex")
4023 4318 if opObj == None:
4024 4319 channel = None
4025 4320 else:
4026 4321 value = opObj.getParameterValue(parameterName='channelIndexList')
4027 4322 value = str(value)#[1:-1]
4028 4323 channel = value
4029 4324 self.bufferVoltage("Processing Unit", "Select Channel by Index", channel)
4030 4325
4031 4326 opObj = puObj.getOperationObj(name="selectHeights")
4032 4327 if opObj == None:
4033 4328 heights = None
4034 4329 else:
4035 4330 value1 = int(opObj.getParameterValue(parameterName='minHei'))
4036 4331 value1 = str(value1)
4037 4332 value2 = int(opObj.getParameterValue(parameterName='maxHei'))
4038 4333 value2 = str(value2)
4039 4334 value = value1 + "," + value2
4040 4335 heights = value
4041 4336 self.bufferVoltage("Processing Unit", "Select Heights", heights)
4042 4337
4043 4338
4044 4339 opObj = puObj.getOperationObj(name="filterByHeights")
4045 4340 if opObj == None:
4046 4341 filter = None
4047 4342 else:
4048 4343 value = opObj.getParameterValue(parameterName='window')
4049 4344 value = str(value)
4050 4345 filter = value
4051 4346 self.bufferVoltage("Processing Unit", "Filter", filter)
4052 4347
4053 4348
4054 4349 opObj = puObj.getOperationObj(name="ProfileSelector")
4055 4350 if opObj == None:
4056 4351 profile = None
4057 4352 else:
4058 4353 for parmObj in opObj.getParameterObjList():
4059 4354 if parmObj.name == "profileRangeList":
4060 4355 value = opObj.getParameterValue(parameterName='profileRangeList')
4061 4356 value = str(value)#[1:-1]
4062 4357 profile = value
4063 4358 self.bufferVoltage("Processing Unit", "Select Profile", profile)
4064 4359
4065 4360 if parmObj.name == "profileList":
4066 4361 value = opObj.getParameterValue(parameterName='profileList')
4067 4362 value = str(value)#[1:-1]
4068 4363 profile = value
4069 4364 self.bufferVoltage("Processing Unit", "Select Profile", profile)
4070 4365
4071 4366
4072 4367 opObj = puObj.getOperationObj(name="Decoder")
4073 4368 if opObj == None:
4074 4369 self.volOpCebDecodification.setCheckState(0)
4075 4370 code = None
4076 4371 mode = None
4077 4372 else:
4078 4373 self.volOpCebDecodification.setCheckState(QtCore.Qt.Checked)
4079 4374 try:
4080 4375 code = opObj.getParameterValue(parameterName='code')
4081 4376 nBaud = opObj.getParameterValue(parameterName='nBaud')
4082 4377 nCode = opObj.getParameterValue(parameterName='nCode')
4083 4378 code = numpy.array(code).reshape(nCode,nBaud)
4084 4379 except:
4085 4380 code = "Default"
4086 4381
4087 4382 self.bufferVoltage("Processing Unit", "Code", str(code).replace('\n',''))
4088 4383
4089 4384 try:
4090 4385 value = opObj.getParameterValue(parameterName='mode')
4091 4386 if int(value) == 0:
4092 4387 mode = "Time"
4093 4388 else:
4094 4389 mode = "freq" + str(value)
4095 4390 except:
4096 4391 mode = "Default"
4097 4392 self.bufferVoltage("Processing Unit", "Decoder mode", mode)
4098 4393
4099 4394 opObj = puObj.getOperationObj(name="deFlip")
4100 4395 if opObj == None:
4101 4396 value = None
4102 4397 else:
4103 4398 try:
4104 4399 value = opObj.getParameterValue(parameterName='channelList')
4105 4400 value = str(value)
4106 4401 except:
4107 4402 value = "All channels"
4108 4403
4109 4404 self.bufferVoltage("Processing Unit", "Flip", value)
4110 4405
4111 4406 opObj = puObj.getOperationObj(name="CohInt")
4112 4407 if opObj == None:
4113 4408 coherentintegration = None
4114 4409 else:
4115 4410 value = opObj.getParameterValue(parameterName='n')
4116 4411 coherentintegration = value
4117 4412 self.bufferVoltage("Processing Unit", "Coh Int", coherentintegration)
4118 4413
4119 4414
4120 4415 # graph
4121 4416 # opObj = puObj.getOperationObj(name='Plot')
4122 4417 opObj = puObj.getOperationObj(name='Scope')
4123 4418 if opObj == None:
4124 4419 self.volGraphCebshow.setCheckState(0)
4125 4420 operation = "Disabled"
4126 4421 channelList = None
4127 4422 freq_vel = None
4128 4423 heightsrange = None
4129 4424 else:
4130 4425 operation = 'Enabled'
4131 4426 self.bufferVoltage("Scope", "Operation", operation),
4132 4427 self.volGraphCebshow.setCheckState(QtCore.Qt.Checked)
4133 4428 value = opObj.getParameterObj(parameterName='channelList')
4134 4429 if value == None:
4135 4430 channelList = None
4136 4431 else:
4137 4432 value = opObj.getParameterValue(parameterName='channelList')
4138 4433 value = str(value)[1:-1]
4139 4434 channelList = value
4140 4435 self.bufferVoltage("Scope", "Channel List", channelList)
4141 4436
4142 4437
4143 4438 value1 = opObj.getParameterObj(parameterName='xmin')
4144 4439 if value1 == None:
4145 4440 freq_vel = None
4146 4441 else:
4147 4442 value1 = opObj.getParameterValue(parameterName='xmin')
4148 4443 value1 = str(value1)
4149 4444 value2 = opObj.getParameterObj(parameterName='xmax')
4150 4445 if value2 == None:
4151 4446 freq_vel = None
4152 4447 else:
4153 4448 value2 = opObj.getParameterValue(parameterName='xmax')
4154 4449 value2 = str(value2)
4155 4450 value = value1 + "," + value2
4156 4451 freq_vel = value
4157 4452 self.bufferVoltage("Scope", "Freq/Vel", freq_vel)
4158 4453
4159 4454 value1 = opObj.getParameterObj(parameterName='ymin')
4160 4455 if value1 == None:
4161 4456 heightsrange = None
4162 4457 else:
4163 4458 value1 = opObj.getParameterValue(parameterName='ymin')
4164 4459 value1 = str(value1)
4165 4460 value2 = opObj.getParameterObj(parameterName='ymax')
4166 4461 if value2 == None:
4167 4462 fheightsrange = None
4168 4463 else:
4169 4464 value2 = opObj.getParameterValue(parameterName='ymax')
4170 4465 value2 = str(value2)
4171 4466 value = value1 + "," + value2
4172 4467 heightsrange = value
4173 4468 self.bufferVoltage("Scope", "Height Range", heightsrange)
4174 4469
4175 4470 parmObj = opObj.getParameterObj(parameterName="figpath")
4176 4471 if parmObj == None:
4177 4472 self.volGraphCebSave.setCheckState(QtCore.Qt.Unchecked)
4178 4473 figpath = None
4179 4474 else:
4180 4475 self.volGraphCebSave.setCheckState(QtCore.Qt.Checked)
4181 4476 value = opObj.getParameterValue(parameterName='figpath')
4182 4477 figpath = value
4183 4478 self.bufferVoltage("Scope", "Path", figpath)
4184 4479 # outputVoltageWrite
4185 4480 opObj = puObj.getOperationObj(name='VoltageWriter')
4186 4481 if opObj == None:
4187 4482 pass
4188 4483 else:
4189 4484 operation = 'Enabled'
4190 4485 self.bufferVoltage("Output", "Operation", operation)
4191 4486 value = opObj.getParameterObj(parameterName='path')
4192 4487 if value == None:
4193 4488 path = None
4194 4489 else:
4195 4490 value = opObj.getParameterValue(parameterName='path')
4196 4491 path = str(value)
4197 4492 self.bufferVoltage("Output", "Path", path)
4198 4493 value = opObj.getParameterObj(parameterName='blocksPerFile')
4199 4494 if value == None:
4200 4495 blocksperfile = None
4201 4496 else:
4202 4497 value = opObj.getParameterValue(parameterName='blocksPerFile')
4203 4498 blocksperfile = str(value)
4204 4499 self.bufferVoltage("Output", "BlocksPerFile", blocksperfile)
4205 4500 value = opObj.getParameterObj(parameterName='profilesPerBlock')
4206 4501 if value == None:
4207 4502 profilesPerBlock = None
4208 4503 else:
4209 4504 value = opObj.getParameterValue(parameterName='profilesPerBlock')
4210 4505 profilesPerBlock = str(value)
4211 4506 self.bufferVoltage("Output", "ProfilesPerBlock", profilesPerBlock)
4212 4507
4213 4508
4214 4509 # set model PU Properties
4215 4510
4216 self.propertiesModel = treeModel()
4217 self.propertiesModel.showPUVoltageParms(self.volProperCaracteristica, self.volProperPrincipal, self.volProperDescripcion)
4511 self.propertiesModel = TreeModel()
4512 self.propertiesModel.showProperties(self.volProperCaracteristica, self.volProperPrincipal, self.volProperDescripcion)
4218 4513 self.volProperCaracteristica = []
4219 4514 self.volProperPrincipal = []
4220 4515 self.volProperDescripcion = []
4221 4516 self.treeProjectProperties.setModel(self.propertiesModel)
4222 4517 self.treeProjectProperties.expandAll()
4223 4518 self.treeProjectProperties.allColumnsShowFocus()
4224 4519 self.treeProjectProperties.resizeColumnToContents(0)
4225 4520 self.treeProjectProperties.resizeColumnToContents(1)
4226 4521
4227 4522 def bufferSpectra(self, caracteristica, principal, description):
4228 4523 self.specProperCaracteristica.append(caracteristica)
4229 4524 self.specProperPrincipal.append(principal)
4230 4525 self.specProperDescripcion.append(description)
4231 4526 return self.specProperCaracteristica, self.specProperPrincipal, self.specProperDescripcion
4232 4527
4233 4528 def showPUSpectraProperties(self, puObj):
4234 4529 type = puObj.name
4235 4530 self.bufferSpectra("Processing Unit", "Type", type)
4236 4531
4237 4532 opObj = puObj.getOperationObj(name="setRadarFrequency")
4238 4533 if opObj == None:
4239 4534 radarfrequency = None
4240 4535 else:
4241 4536 value = opObj.getParameterValue(parameterName='frequency')
4242 4537 value = str(value)
4243 4538 radarfrequency = value
4244 4539 self.bufferSpectra("Processing Unit", "Radar Frequency", radarfrequency)
4245 4540
4246 4541
4247 4542 opObj = puObj.getOperationObj(name="run")
4248 4543 if opObj == None:
4249 4544 self.specOpnFFTpoints.clear()
4250 4545 self.specOpProfiles.clear()
4251 4546 self.specOpippFactor.clear()
4252 4547 else:
4253 4548 parmObj = opObj.getParameterObj(parameterName='nProfiles')
4254 4549 if parmObj == None:
4255 4550 nProfiles = None
4256 4551 else:
4257 4552 value = opObj.getParameterValue(parameterName='nProfiles')
4258 4553 nProfiles = value
4259 4554 self.bufferSpectra("Processing Unit", "nProfiles", nProfiles)
4260 4555
4261 4556 parmObj = opObj.getParameterObj(parameterName='nFFTPoints')
4262 4557 if parmObj == None:
4263 4558 nFFTPoints = None
4264 4559 else:
4265 4560 value = opObj.getParameterValue(parameterName='nFFTPoints')
4266 4561 nFFTPoints = value
4267 4562 self.bufferSpectra("Processing Unit", "nFFTpoints", nFFTPoints)
4268 4563
4269 4564 parmObj = opObj.getParameterObj(parameterName='ippFactor')
4270 4565 if parmObj == None:
4271 4566 ippFactor = None
4272 4567 else:
4273 4568 value = opObj.getParameterValue(parameterName='ippFactor')
4274 4569 ippFactor = value
4275 4570 self.bufferSpectra("Processing Unit", "Ipp Factor", ippFactor)
4276 4571
4277 4572
4278 4573 opObj = puObj.getOperationObj(name="run")
4279 4574 if opObj == None:
4280 4575 pairsList = None
4281 4576 else:
4282 4577 parm = opObj.getParameterObj(parameterName='pairsList')
4283 4578 if parm == None:
4284 4579 pairsList = None
4285 4580 else:
4286 4581 value = opObj.getParameterValue(parameterName='pairsList')
4287 4582 value = str(value)[1:-1]
4288 4583 pairsList = value
4289 4584 self.bufferSpectra("Processing Unit", "PairsList", pairsList)
4290 4585
4291 4586
4292 4587 opObj = puObj.getOperationObj(name="selectChannels")
4293 4588 if opObj == None:
4294 4589 channel = None
4295 4590 else:
4296 4591 try:
4297 4592 value = opObj.getParameterValue(parameterName='channelList')
4298 4593 value = str(value)[1:-1]
4299 4594 channel = value
4300 4595
4301 4596 self.bufferSpectra("Processing Unit", "Channel List", channel)
4302 4597 except:
4303 4598 pass
4304 4599 try:
4305 4600 value = opObj.getParameterValue(parameterName='channelIndexList')
4306 4601 value = str(value)[1:-1]
4307 4602 channel = value
4308 4603
4309 4604 self.bufferSpectra("Processing Unit", "Channel Index List", channel)
4310 4605 except:
4311 4606 pass
4312 4607
4313 4608 opObj = puObj.getOperationObj(name="selectHeights")
4314 4609 if opObj == None:
4315 4610 heights = None
4316 4611 else:
4317 4612 value1 = int(opObj.getParameterValue(parameterName='minHei'))
4318 4613 value1 = str(value1)
4319 4614 value2 = int(opObj.getParameterValue(parameterName='maxHei'))
4320 4615 value2 = str(value2)
4321 4616 value = value1 + "," + value2
4322 4617 heights = value
4323 4618 self.bufferSpectra("Processing Unit", "Heights", heights)
4324 4619
4325 4620 opObj = puObj.getOperationObj(name="IncohInt")
4326 4621 if opObj == None:
4327 4622 incoherentintegration = None
4328 4623 else:
4329 4624 try:
4330 4625 value = opObj.getParameterValue(parameterName='timeInterval')
4331 4626 except:
4332 4627 value = opObj.getParameterValue(parameterName='n')
4333 4628
4334 4629 value = float(value)
4335 4630 incoherentintegration = str(value)
4336 4631 self.bufferSpectra("Processing Unit", "Incoherent Integration", incoherentintegration)
4337 4632
4338 4633
4339 4634 opObj = puObj.getOperationObj(name="removeDC")
4340 4635 if opObj == None:
4341 4636 removeDC = None
4342 4637 else:
4343 4638 value = opObj.getParameterValue(parameterName='mode')
4344 4639 self.bufferSpectra("Processing Unit", "Remove DC", value)
4345 4640
4346 4641 opObj = puObj.getOperationObj(name="removeInterference")
4347 4642 if opObj == None:
4348 4643 removeInterference = None
4349 4644 else:
4350 4645 self.bufferSpectra("Processing Unit", "Remove Interference", "1")
4351 4646
4352 4647 opObj = puObj.getOperationObj(name="getNoise")
4353 4648 if opObj == None:
4354 4649 getNoise = None
4355 4650 else:
4356 4651 value1 = opObj.getParameterObj(parameterName='minHei')
4357 4652 if value1 == None:
4358 4653 getNoise = None
4359 4654 getNoise = "Default"
4360 4655 self.bufferSpectra("Processing Unit", "Get Noise", getNoise)
4361 4656
4362 4657 else:
4363 4658 value1 = opObj.getParameterValue(parameterName='minHei')
4364 4659 value1 = str(value1)
4365 4660 value2 = opObj.getParameterObj(parameterName='maxHei')
4366 4661 if value2 == None:
4367 4662 getNoise = None
4368 4663 value = value1
4369 4664 getNoise = value
4370 4665 self.bufferSpectra("Processing Unit", "Get Noise", getNoise)
4371 4666 else:
4372 4667 value2 = opObj.getParameterValue(parameterName='maxHei')
4373 4668 value2 = str(value2)
4374 4669 value3 = opObj.getParameterObj(parameterName='minVel')
4375 4670 if value3 == None:
4376 4671 getNoise = None
4377 4672 value = value1 + "," + value2
4378 4673 getNoise = value
4379 4674 self.bufferSpectra("Processing Unit", "Get Noise", getNoise)
4380 4675 else:
4381 4676 value3 = opObj.getParameterValue(parameterName='minVel')
4382 4677 value3 = str(value3)
4383 4678 value4 = opObj.getParameterObj(parameterName='maxVel')
4384 4679 if value4 == None:
4385 4680 getNoise = None
4386 4681 value = value1 + "," + value2 + ',' + value3
4387 4682 getNoise = value
4388 4683 self.bufferSpectra("Processing Unit", "Get Noise", getNoise)
4389 4684 else:
4390 4685 value4 = opObj.getParameterValue(parameterName='maxVel')
4391 4686 value4 = str(value4)
4392 4687 value = value1 + "," + value2 + ',' + value3 + ',' + value4
4393 4688 getNoise = value
4394 4689 self.bufferSpectra("Processing Unit", "Get Noise", getNoise)
4395 4690
4396 4691 opObj = puObj.getOperationObj(name='SpectraPlot')
4397 4692 # opObj = puObj.getOpObjfromParamValue(value="SpectraPlot")
4398 4693
4399 4694 if opObj == None:
4400 4695 operationSpectraPlot = "Disabled"
4401 4696 freq_vel = None
4402 4697 heightsrange = None
4403 4698 channelListSpectraPlot = None
4404 4699 else:
4405 4700 operationSpectraPlot = "Enable"
4406 4701 self.bufferSpectra("Spectra Plot", "Operation", operationSpectraPlot)
4407 4702 parmObj = opObj.getParameterObj(parameterName='channelList')
4408 4703 if parmObj == None:
4409 4704 channelListSpectraPlot = None
4410 4705 else:
4411 4706 value = opObj.getParameterValue(parameterName='channelList')
4412 4707 channelListSpectraPlot = str(value)[1:-1]
4413 4708 self.bufferSpectra("Spectra Plot", "Channel List", channelListSpectraPlot)
4414 4709
4415 4710
4416 4711 value1 = opObj.getParameterObj(parameterName='xmin')
4417 4712 if value1 == None:
4418 4713 freq_vel = None
4419 4714 else:
4420 4715 value1 = opObj.getParameterValue(parameterName='xmin')
4421 4716 value1 = str(value1)
4422 4717 value2 = opObj.getParameterObj(parameterName='xmax')
4423 4718 if value2 == None:
4424 4719 freq_vel = None
4425 4720 else:
4426 4721 value2 = opObj.getParameterValue(parameterName='xmax')
4427 4722 value2 = str(value2)
4428 4723 value = value1 + "," + value2
4429 4724 freq_vel = value
4430 4725 self.bufferSpectra("Spectra Plot", "Freq/Vel", freq_vel)
4431 4726
4432 4727 value1 = opObj.getParameterObj(parameterName='ymin')
4433 4728 if value1 == None:
4434 4729 heightsrange = None
4435 4730 else:
4436 4731 value1 = opObj.getParameterValue(parameterName='ymin')
4437 4732 value1 = str(value1)
4438 4733 value2 = opObj.getParameterObj(parameterName='ymax')
4439 4734 if value2 == None:
4440 4735 fheightsrange = None
4441 4736 else:
4442 4737 value2 = opObj.getParameterValue(parameterName='ymax')
4443 4738 value2 = str(value2)
4444 4739 value = value1 + "," + value2
4445 4740 heightsrange = value
4446 4741 self.bufferSpectra("Spectra Plot", "Height Range", heightsrange)
4447 4742
4448 4743 value1 = opObj.getParameterObj(parameterName='zmin')
4449 4744 if value1 == None:
4450 4745 dBrange = None
4451 4746 else:
4452 4747 value1 = opObj.getParameterValue(parameterName='zmin')
4453 4748 value1 = str(value1)
4454 4749 value2 = opObj.getParameterObj(parameterName='zmax')
4455 4750 if value2 == None:
4456 4751 fdBrange = None
4457 4752 else:
4458 4753 value2 = opObj.getParameterValue(parameterName='zmax')
4459 4754 value2 = str(value2)
4460 4755 value = value1 + "," + value2
4461 4756 dbrange = value
4462 4757 self.bufferSpectra("Spectra Plot", "dB Range", dbrange)
4463 4758
4464 4759 parmObj = opObj.getParameterObj(parameterName="figpath")
4465 4760 if parmObj == None:
4466 4761 path = None
4467 4762 else:
4468 4763 path = opObj.getParameterValue(parameterName='figpath')
4469 4764 self.bufferSpectra("Spectra Plot", "Save Path", path)
4470 4765
4471 4766 parmObj = opObj.getParameterObj(parameterName="ftp")
4472 4767 if parmObj == None:
4473 4768 status = 'disable'
4474 4769 else:
4475 4770 status = 'enable'
4476 4771 self.bufferSpectra("Spectra Plot", "FTP", status)
4477 4772 self.showWr_Period(puObj, opObj, nameplotop="Spectra Plot")
4478 4773 # self.saveFTPvalues(opObj)
4479 4774
4480 4775 opObj = puObj.getOperationObj(name='CrossSpectraPlot')
4481 4776 # opObj = puObj.getOpObjfromParamValue(value="CrossSpectraPlot")
4482 4777 if opObj == None:
4483 4778 self.specGraphCebCrossSpectraplot.setCheckState(0)
4484 4779 operationCrossSpectraPlot = "Disabled"
4485 4780 channelList = None
4486 4781 freq_vel = None
4487 4782 heightsrange = None
4488 4783 else:
4489 4784 operationCrossSpectraPlot = "Enable"
4490 4785 self.specGraphCebCrossSpectraplot.setCheckState(QtCore.Qt.Checked)
4491 4786 self.bufferSpectra("Cross Spectra Plot", "Operation", operationCrossSpectraPlot)
4492 4787
4493 4788 value1 = opObj.getParameterObj(parameterName='xmin')
4494 4789 if value1 == None:
4495 4790 freq_vel = None
4496 4791 else:
4497 4792 value1 = opObj.getParameterValue(parameterName='xmin')
4498 4793 value1 = str(value1)
4499 4794 value2 = opObj.getParameterObj(parameterName='xmax')
4500 4795 if value2 == None:
4501 4796 freq_vel = None
4502 4797 else:
4503 4798 value2 = opObj.getParameterValue(parameterName='xmax')
4504 4799 value2 = str(value2)
4505 4800 value = value1 + "," + value2
4506 4801 freq_vel = value
4507 4802 self.bufferSpectra("Cross Spectra Plot", "Freq/Vel", freq_vel)
4508 4803
4509 4804 value1 = opObj.getParameterObj(parameterName='ymin')
4510 4805 if value1 == None:
4511 4806 heightsrange = None
4512 4807 else:
4513 4808 value1 = opObj.getParameterValue(parameterName='ymin')
4514 4809 value1 = str(value1)
4515 4810 value2 = opObj.getParameterObj(parameterName='ymax')
4516 4811 if value2 == None:
4517 4812 fheightsrange = None
4518 4813 else:
4519 4814 value2 = opObj.getParameterValue(parameterName='ymax')
4520 4815 value2 = str(value2)
4521 4816 value = value1 + "," + value2
4522 4817 heightsrange = value
4523 4818 self.bufferSpectra("Cross Spectra Plot", "Height Range", heightsrange)
4524 4819
4525 4820 value1 = opObj.getParameterObj(parameterName='zmin')
4526 4821 if value1 == None:
4527 4822 dBrange = None
4528 4823 else:
4529 4824 value1 = opObj.getParameterValue(parameterName='zmin')
4530 4825 value1 = str(value1)
4531 4826 value2 = opObj.getParameterObj(parameterName='zmax')
4532 4827 if value2 == None:
4533 4828 fdBrange = None
4534 4829 else:
4535 4830 value2 = opObj.getParameterValue(parameterName='zmax')
4536 4831 value2 = str(value2)
4537 4832 value = value1 + "," + value2
4538 4833 dbrange = value
4539 4834 self.bufferSpectra("Cross Spectra Plot", "dB Range", dbrange)
4540 4835
4541 4836 parmObj = opObj.getParameterObj(parameterName="figpath")
4542 4837 if parmObj == None:
4543 4838 path = None
4544 4839 else:
4545 4840 path = opObj.getParameterValue(parameterName='figpath')
4546 4841 self.bufferSpectra("Cross Spectra Plot", "Save Path", path)
4547 4842
4548 4843 parmObj = opObj.getParameterObj(parameterName="ftp")
4549 4844 if parmObj == None:
4550 4845 status = 'disable'
4551 4846 else:
4552 4847 status = 'enable'
4553 4848 self.bufferSpectra("Cross Spectra Plot", "FTP", status)
4554 4849 self.showWr_Period(puObj, opObj, nameplotop="Cross Spectra Plot")
4555 4850 # self.saveFTPvalues(opObj)
4556 4851
4557 4852 opObj = puObj.getOperationObj(name='RTIPlot')
4558 4853 # opObj = puObj.getOpObjfromParamValue(value="RTIPlot")
4559 4854 if opObj == None:
4560 4855 self.specGraphCebRTIplot.setCheckState(0)
4561 4856 operationRTIPlot = "Disabled"
4562 4857 channelList = None
4563 4858 freq_vel = None
4564 4859 heightsrange = None
4565 4860 else:
4566 4861 operationRTIPlot = "Enable"
4567 4862 self.specGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
4568 4863 self.bufferSpectra("RTI Plot", "Operation", operationRTIPlot)
4569 4864 parmObj = opObj.getParameterObj(parameterName='channelList')
4570 4865 if parmObj == None:
4571 4866 channelListRTIPlot = None
4572 4867 else:
4573 4868 value = opObj.getParameterValue(parameterName='channelList')
4574 4869 channelListRTIPlot = str(value)[1:-1]
4575 4870 self.bufferSpectra("RTI Plot", "Channel List", channelListRTIPlot)
4576 4871
4577 4872
4578 4873 value1 = opObj.getParameterObj(parameterName='xmin')
4579 4874 if value1 == None:
4580 4875 freq_vel = None
4581 4876 else:
4582 4877 value1 = opObj.getParameterValue(parameterName='xmin')
4583 4878 value1 = str(value1)
4584 4879 value2 = opObj.getParameterObj(parameterName='xmax')
4585 4880 if value2 == None:
4586 4881 freq_vel = None
4587 4882 else:
4588 4883 value2 = opObj.getParameterValue(parameterName='xmax')
4589 4884 value2 = str(value2)
4590 4885 value = value1 + "," + value2
4591 4886 tmintmax = value
4592 4887 self.bufferSpectra("RTI Plot", "Tmin,Tmax", tmintmax)
4593 4888
4594 4889 parmObj = opObj.getParameterObj(parameterName='timerange')
4595 4890 if parmObj == None:
4596 4891 timerange = None
4597 4892 else:
4598 4893 value = opObj.getParameterValue(parameterName='timerange')
4599 4894 timerange = str(value)
4600 4895 self.bufferSpectra("RTI Plot", "Time Range", timerange)
4601 4896
4602 4897 value1 = opObj.getParameterObj(parameterName='ymin')
4603 4898 if value1 == None:
4604 4899 heightsrange = None
4605 4900 else:
4606 4901 value1 = opObj.getParameterValue(parameterName='ymin')
4607 4902 value1 = str(value1)
4608 4903 value2 = opObj.getParameterObj(parameterName='ymax')
4609 4904 if value2 == None:
4610 4905 fheightsrange = None
4611 4906 else:
4612 4907 value2 = opObj.getParameterValue(parameterName='ymax')
4613 4908 value2 = str(value2)
4614 4909 value = value1 + "," + value2
4615 4910 heightsrange = value
4616 4911 self.bufferSpectra("RTI Plot", "Height Range", heightsrange)
4617 4912
4618 4913 value1 = opObj.getParameterObj(parameterName='zmin')
4619 4914 if value1 == None:
4620 4915 dBrange = None
4621 4916 else:
4622 4917 value1 = opObj.getParameterValue(parameterName='zmin')
4623 4918 value1 = str(value1)
4624 4919 value2 = opObj.getParameterObj(parameterName='zmax')
4625 4920 if value2 == None:
4626 4921 fdBrange = None
4627 4922 else:
4628 4923 value2 = opObj.getParameterValue(parameterName='zmax')
4629 4924 value2 = str(value2)
4630 4925 value = value1 + "," + value2
4631 4926 dbrange = value
4632 4927 self.bufferSpectra("RTI Plot", "dB Range", dbrange)
4633 4928
4634 4929 parmObj = opObj.getParameterObj(parameterName="figpath")
4635 4930 if parmObj == None:
4636 4931 path = None
4637 4932 else:
4638 4933 path = opObj.getParameterValue(parameterName='figpath')
4639 4934 self.bufferSpectra("RTI Plot", "Save Path", path)
4640 4935
4641 4936 parmObj = opObj.getParameterObj(parameterName="ftp")
4642 4937 if parmObj == None:
4643 4938 status = 'disable'
4644 4939 else:
4645 4940 status = 'enable'
4646 4941 self.bufferSpectra("RTI Plot", "FTP", status)
4647 4942 self.showWr_Period(puObj, opObj, nameplotop="RTI Plot")
4648 4943 # self.saveFTPvalues(opObj)
4649 4944
4650 4945 opObj = puObj.getOperationObj(name='CoherenceMap')
4651 4946 # opObj = puObj.getOpObjfromParamValue(value="CoherenceMap")
4652 4947 if opObj == None:
4653 4948 self.specGraphCebCoherencmap.setCheckState(0)
4654 4949 operationCoherenceMap = "Disabled"
4655 4950 channelList = None
4656 4951 freq_vel = None
4657 4952 heightsrange = None
4658 4953 else:
4659 4954 operationCoherenceMap = "Enable"
4660 4955 self.specGraphCebCoherencmap.setCheckState(QtCore.Qt.Checked)
4661 4956 self.bufferSpectra("Coherence Map Plot", "Operation", operationCoherenceMap)
4662 4957 parmObj = opObj.getParameterObj(parameterName='channelList')
4663 4958 if parmObj == None:
4664 4959 channelListRTIPlot = None
4665 4960 else:
4666 4961 value = opObj.getParameterValue(parameterName='channelList')
4667 4962 channelListRTIPlot = str(value)[1:-1]
4668 4963 self.bufferSpectra("Coherence Map Plot", "Channel List", channelListRTIPlot)
4669 4964
4670 4965
4671 4966 value1 = opObj.getParameterObj(parameterName='xmin')
4672 4967 if value1 == None:
4673 4968 freq_vel = None
4674 4969 else:
4675 4970 value1 = opObj.getParameterValue(parameterName='xmin')
4676 4971 value1 = str(value1)
4677 4972 value2 = opObj.getParameterObj(parameterName='xmax')
4678 4973 if value2 == None:
4679 4974 freq_vel = None
4680 4975 else:
4681 4976 value2 = opObj.getParameterValue(parameterName='xmax')
4682 4977 value2 = str(value2)
4683 4978 value = value1 + "," + value2
4684 4979 tmintmax = value
4685 4980 self.bufferSpectra("Coherence Map Plot", "Tmin,Tmax", tmintmax)
4686 4981
4687 4982 parmObj = opObj.getParameterObj(parameterName='timerange')
4688 4983 if parmObj == None:
4689 4984 timerange = None
4690 4985 else:
4691 4986 value = opObj.getParameterValue(parameterName='timerange')
4692 4987 timerange = str(value)
4693 4988 self.bufferSpectra("Coherence Map Plot", "Time Range", timerange)
4694 4989
4695 4990 value1 = opObj.getParameterObj(parameterName='ymin')
4696 4991 if value1 == None:
4697 4992 heightsrange = None
4698 4993 else:
4699 4994 value1 = opObj.getParameterValue(parameterName='ymin')
4700 4995 value1 = str(value1)
4701 4996 value2 = opObj.getParameterObj(parameterName='ymax')
4702 4997 if value2 == None:
4703 4998 fheightsrange = None
4704 4999 else:
4705 5000 value2 = opObj.getParameterValue(parameterName='ymax')
4706 5001 value2 = str(value2)
4707 5002 value = value1 + "," + value2
4708 5003 heightsrange = value
4709 5004 self.bufferSpectra("Coherence Map Plot", "Height Range", heightsrange)
4710 5005
4711 5006 value1 = opObj.getParameterObj(parameterName='zmin')
4712 5007 if value1 == None:
4713 5008 dBrange = None
4714 5009 else:
4715 5010 value1 = opObj.getParameterValue(parameterName='zmin')
4716 5011 value1 = str(value1)
4717 5012 value2 = opObj.getParameterObj(parameterName='zmax')
4718 5013 if value2 == None:
4719 5014 fdBrange = None
4720 5015 else:
4721 5016 value2 = opObj.getParameterValue(parameterName='zmax')
4722 5017 value2 = str(value2)
4723 5018 value = value1 + "," + value2
4724 5019 dbrange = value
4725 5020 self.bufferSpectra("Coherence Map Plot", "Magnitud", dbrange)
4726 5021
4727 5022 parmObj = opObj.getParameterObj(parameterName="figpath")
4728 5023 if parmObj == None:
4729 5024 path = None
4730 5025 else:
4731 5026 path = opObj.getParameterValue(parameterName='figpath')
4732 5027 self.bufferSpectra("Coherence Map Plot", "Save Path", path)
4733 5028
4734 5029 parmObj = opObj.getParameterObj(parameterName="ftp")
4735 5030 if parmObj == None:
4736 5031 status = 'disable'
4737 5032 else:
4738 5033 status = 'enable'
4739 5034 self.bufferSpectra("Coherence Map Plot", "FTP", status)
4740 5035 self.showWr_Period(puObj, opObj, nameplotop="Coherence Map Plot")
4741 5036 # self.saveFTPvalues(opObj)
4742 5037
4743 5038
4744 5039 opObj = puObj.getOperationObj(name='PowerProfilePlot')
4745 5040 # opObj = puObj.getOpObjfromParamValue(value="PowerProfilePlot")
4746 5041 if opObj == None:
4747 5042 self.specGraphPowerprofile.setCheckState(0)
4748 5043 operationPowerProfilePlot = "Disabled"
4749 5044 channelList = None
4750 5045 freq_vel = None
4751 5046 heightsrange = None
4752 5047 else:
4753 5048 operationPowerProfilePlot = "Enable"
4754 5049 self.specGraphPowerprofile.setCheckState(QtCore.Qt.Checked)
4755 5050 self.bufferSpectra("PowerProfile Plot", "Operation", operationPowerProfilePlot)
4756 5051 parmObj = opObj.getParameterObj(parameterName='channelList')
4757 5052 if parmObj == None:
4758 5053 channelListSpectraPlot = None
4759 5054 else:
4760 5055 value = opObj.getParameterValue(parameterName='channelList')
4761 5056 channelListSpectraPlot = str(value)[1:-1]
4762 5057 self.bufferSpectra("PowerProfile Plot", "Channel List", channelListSpectraPlot)
4763 5058
4764 5059
4765 5060 value1 = opObj.getParameterObj(parameterName='xmin')
4766 5061 if value1 == None:
4767 5062 freq_vel = None
4768 5063 else:
4769 5064 value1 = opObj.getParameterValue(parameterName='xmin')
4770 5065 value1 = str(value1)
4771 5066 value2 = opObj.getParameterObj(parameterName='xmax')
4772 5067 if value2 == None:
4773 5068 freq_vel = None
4774 5069 else:
4775 5070 value2 = opObj.getParameterValue(parameterName='xmax')
4776 5071 value2 = str(value2)
4777 5072 value = value1 + "," + value2
4778 5073 dbrange = value
4779 5074 self.bufferSpectra("PowerProfile Plot", "dbRange", dbrange)
4780 5075
4781 5076 value1 = opObj.getParameterObj(parameterName='ymin')
4782 5077 if value1 == None:
4783 5078 heightsrange = None
4784 5079 else:
4785 5080 value1 = opObj.getParameterValue(parameterName='ymin')
4786 5081 value1 = str(value1)
4787 5082 value2 = opObj.getParameterObj(parameterName='ymax')
4788 5083 if value2 == None:
4789 5084 fheightsrange = None
4790 5085 else:
4791 5086 value2 = opObj.getParameterValue(parameterName='ymax')
4792 5087 value2 = str(value2)
4793 5088 value = value1 + "," + value2
4794 5089 heightsrange = value
4795 5090 self.bufferSpectra("PowerProfile Plot", "Height Range", heightsrange)
4796 5091
4797 5092
4798 5093 parmObj = opObj.getParameterObj(parameterName="figpath")
4799 5094 if parmObj == None:
4800 5095 path = None
4801 5096 else:
4802 5097 path = opObj.getParameterValue(parameterName='figpath')
4803 5098 self.bufferSpectra("PowerProfile Plot", "Save Path", path)
4804 5099
4805 5100 parmObj = opObj.getParameterObj(parameterName="ftp")
4806 5101 if parmObj == None:
4807 5102 status = 'disable'
4808 5103 else:
4809 5104 status = 'enable'
4810 5105 self.bufferSpectra("PowerProfile Plot", "FTP", status)
4811 5106 self.showWr_Period(puObj, opObj, nameplotop="PowerProfile Plot")
4812 5107 # self.saveFTPvalues(opObj)
4813 5108
4814 5109 # noise
4815 5110 opObj = puObj.getOperationObj(name='Noise')
4816 5111 # opObj = puObj.getOpObjfromParamValue(value="Noise")
4817 5112 if opObj == None:
4818 5113 self.specGraphCebRTInoise.setCheckState(0)
4819 5114 operationRTINoise = "Disabled"
4820 5115 channelList = None
4821 5116 freq_vel = None
4822 5117 dbRange = None
4823 5118 else:
4824 5119 operationRTINoise = "Enable"
4825 5120 self.specGraphCebRTInoise.setCheckState(QtCore.Qt.Checked)
4826 5121 self.bufferSpectra("Noise Plot", "Operation", operationRTINoise)
4827 5122 parmObj = opObj.getParameterObj(parameterName='channelList')
4828 5123 if parmObj == None:
4829 5124 channelListRTINoise = None
4830 5125 else:
4831 5126 value = opObj.getParameterValue(parameterName='channelList')
4832 5127 channelListRTINoise = str(value)[1:-1]
4833 5128 self.bufferSpectra("Noise Plot", "Channel List", channelListRTINoise)
4834 5129
4835 5130
4836 5131 value1 = opObj.getParameterObj(parameterName='xmin')
4837 5132 if value1 == None:
4838 5133 freq_vel = None
4839 5134 else:
4840 5135 value1 = opObj.getParameterValue(parameterName='xmin')
4841 5136 value1 = str(value1)
4842 5137 value2 = opObj.getParameterObj(parameterName='xmax')
4843 5138 if value2 == None:
4844 5139 freq_vel = None
4845 5140 else:
4846 5141 value2 = opObj.getParameterValue(parameterName='xmax')
4847 5142 value2 = str(value2)
4848 5143 value = value1 + "," + value2
4849 5144 tmintmax = value
4850 5145 self.bufferSpectra("Noise Plot", "Tmin,Tmax", tmintmax)
4851 5146
4852 5147 parmObj = opObj.getParameterObj(parameterName='timerange')
4853 5148 if parmObj == None:
4854 5149 timerange = None
4855 5150 else:
4856 5151 value = opObj.getParameterValue(parameterName='timerange')
4857 5152 timerange = str(value)
4858 5153 self.bufferSpectra("Noise Plot", "Time Range", timerange)
4859 5154
4860 5155
4861 5156
4862 5157 value1 = opObj.getParameterObj(parameterName='ymin')
4863 5158 if value1 == None:
4864 5159 DBrange = None
4865 5160 else:
4866 5161 value1 = opObj.getParameterValue(parameterName='ymin')
4867 5162 value1 = str(value1)
4868 5163 value2 = opObj.getParameterObj(parameterName='ymax')
4869 5164 if value2 == None:
4870 5165 fdBrange = None
4871 5166 else:
4872 5167 value2 = opObj.getParameterValue(parameterName='ymax')
4873 5168 value2 = str(value2)
4874 5169 value = value1 + "," + value2
4875 5170 dBrange = value
4876 5171 self.bufferSpectra("Noise Plot", "dB Range", dBrange)
4877 5172
4878 5173 parmObj = opObj.getParameterObj(parameterName="figpath")
4879 5174 if parmObj == None:
4880 5175 path = None
4881 5176 else:
4882 5177 path = opObj.getParameterValue(parameterName='figpath')
4883 5178 self.bufferSpectra("Noise Plot", "Save Path", path)
4884 5179
4885 5180 parmObj = opObj.getParameterObj(parameterName="ftp")
4886 5181 if parmObj == None:
4887 5182 status = 'disable'
4888 5183 else:
4889 5184 status = 'enable'
4890 5185 self.bufferSpectra("Noise Plot", "FTP", status)
4891 5186 self.showWr_Period(puObj, opObj, nameplotop="Noise Plot")
4892 5187 # self.saveFTPvalues(opObj)
4893 5188
4894 5189 # outputSpectraWrite
4895 5190 opObj = puObj.getOperationObj(name='SpectraWriter')
4896 5191 if opObj == None:
4897 5192 pass
4898 5193 else:
4899 5194 operation = 'Enabled'
4900 5195 self.bufferSpectra("Output", "Operation", operation)
4901 5196 value = opObj.getParameterObj(parameterName='path')
4902 5197 if value == None:
4903 5198 path = None
4904 5199 else:
4905 5200 value = opObj.getParameterValue(parameterName='path')
4906 5201 path = str(value)
4907 5202 self.bufferSpectra("Output", "Path", path)
4908 5203 value = opObj.getParameterObj(parameterName='blocksPerFile')
4909 5204 if value == None:
4910 5205 blocksperfile = None
4911 5206 else:
4912 5207 value = opObj.getParameterValue(parameterName='blocksPerFile')
4913 5208 blocksperfile = str(value)
4914 5209 self.bufferSpectra("Output", "BlocksPerFile", blocksperfile)
4915 5210 value = opObj.getParameterObj(parameterName='profilesPerBlock')
4916 5211 if value == None:
4917 5212 profilesPerBlock = None
4918 5213 else:
4919 5214 value = opObj.getParameterValue(parameterName='profilesPerBlock')
4920 5215 profilesPerBlock = str(value)
4921 5216 self.bufferSpectra("Output", "ProfilesPerBlock", profilesPerBlock)
4922 5217
4923 5218 projectObj = self.getSelectedProjectObj()
4924 5219 ftpProcUnitConfObj = projectObj.getProcUnitObjByName(name="SendToServer")
4925 5220
4926 5221 if ftpProcUnitConfObj:
4927 5222
4928 5223 opObj = ftpProcUnitConfObj.getOperationObj(name='run')
4929 5224
4930 5225 server = opObj.getParameterValue(parameterName='server')
4931 5226 folder = opObj.getParameterValue(parameterName='remotefolder')
4932 5227 username = opObj.getParameterValue(parameterName='username')
4933 5228 password = opObj.getParameterValue(parameterName='password')
4934 5229 ftp_wei = opObj.getParameterValue(parameterName='ftp_wei')
4935 5230 exp_code = opObj.getParameterValue(parameterName='exp_code')
4936 5231 sub_exp_code = opObj.getParameterValue(parameterName='sub_exp_code')
4937 5232 plot_pos = opObj.getParameterValue(parameterName='plot_pos')
4938 5233 localfolder = opObj.getParameterValue(parameterName='localfolder')
4939 5234
4940 5235 self.bufferSpectra("FTP", "Server", server)
4941 5236 self.bufferSpectra("FTP", "Remote folder", folder)
4942 5237 self.bufferSpectra("FTP", "Local folder", localfolder)
4943 5238 self.bufferSpectra("FTP", "Username", username)
4944 5239 self.bufferSpectra("FTP", "Password", '*'*len(password))
4945 5240 self.bufferSpectra("FTP", "Ftp_wei", ftp_wei)
4946 5241 self.bufferSpectra("FTP", "Exp_code", exp_code)
4947 5242 self.bufferSpectra("FTP", "Sub_exp_code", sub_exp_code)
4948 5243 self.bufferSpectra("FTP", "Plot_pos", plot_pos)
4949 5244
4950 5245 # set model PU Properties
4951 5246
4952 self.propertiesModel = treeModel()
4953 self.propertiesModel.showPUSpectraParms(self.specProperCaracteristica, self.specProperPrincipal, self.specProperDescripcion)
5247 self.propertiesModel = TreeModel()
5248 self.propertiesModel.showProperties(self.specProperCaracteristica, self.specProperPrincipal, self.specProperDescripcion)
4954 5249
4955 5250 self.treeProjectProperties.setModel(self.propertiesModel)
4956 5251 self.treeProjectProperties.expandAll()
4957 5252 self.treeProjectProperties.allColumnsShowFocus()
4958 5253 self.treeProjectProperties.resizeColumnToContents(0)
4959 5254 self.treeProjectProperties.resizeColumnToContents(1)
4960 5255
4961 5256 self.specProperCaracteristica = []
4962 5257 self.specProperDescripcion = []
4963 5258 self.specProperPrincipal = []
4964 5259
4965 5260
4966 5261 def bufferSpectraHeis(self, caracteristica, principal, description):
4967 5262 self.specHeisProperCaracteristica.append(caracteristica)
4968 5263 self.specHeisProperPrincipal.append(principal)
4969 5264 self.specHeisProperDescripcion.append(description)
4970 5265 return self.specHeisProperCaracteristica, self.specHeisProperPrincipal, self.specHeisProperDescripcion
4971 5266
4972 5267
4973 5268 def showPUSpectraHeisProperties(self, puObj):
4974 5269 type = puObj.name
4975 5270 self.bufferSpectraHeis("Processing Unit", "Type", type)
4976 5271
4977 5272 opObj = puObj.getOperationObj(name="IncohInt4SpectraHeis")
4978 5273 if opObj == None:
4979 5274 incoherentintegration = None
4980 5275 else:
4981 5276 value = opObj.getParameterValue(parameterName='timeInterval')
4982 5277 value = float(value)
4983 5278 incoherentintegration = str(value)
4984 5279 self.bufferSpectraHeis("Processing Unit", "Incoherent Integration", incoherentintegration)
4985 5280 # spectraheis graph
4986 5281 opObj = puObj.getOperationObj(name='SpectraHeisScope')
4987 5282 # opObj = puObj.getOpObjfromParamValue(value="SpectraHeisScope")
4988 5283 if opObj == None:
4989 5284 self.specHeisGraphCebSpectraplot.setCheckState(0)
4990 5285 operationSpectraHeisPlot = "Disabled"
4991 5286 xmin_xmax = None
4992 5287 ymin_ymax = None
4993 5288 channelListSpectraPlot = None
4994 5289 else:
4995 5290 operationSpectraHeisPlot = "Enable"
4996 5291 self.specHeisGraphCebSpectraplot.setCheckState(QtCore.Qt.Checked)
4997 5292 self.bufferSpectraHeis("SpectraHeis Plot", "Operation", operationSpectraHeisPlot)
4998 5293 parmObj = opObj.getParameterObj(parameterName='channelList')
4999 5294 if parmObj == None:
5000 5295 channelListSpectraPlot = None
5001 5296 else:
5002 5297 value = opObj.getParameterValue(parameterName='channelList')
5003 5298 channelListSpectraPlot = str(value)[1:-1]
5004 5299 self.bufferSpectraHeis("SpectraHeis Plot", "Channel List", channelListSpectraPlot)
5005 5300
5006 5301
5007 5302 value1 = opObj.getParameterObj(parameterName='xmin')
5008 5303 if value1 == None:
5009 5304 xmin_xmax = None
5010 5305 else:
5011 5306 value1 = opObj.getParameterValue(parameterName='xmin')
5012 5307 value1 = str(value1)
5013 5308 value2 = opObj.getParameterObj(parameterName='xmax')
5014 5309 if value2 == None:
5015 5310 xmin_xmax = None
5016 5311 else:
5017 5312 value2 = opObj.getParameterValue(parameterName='xmax')
5018 5313 value2 = str(value2)
5019 5314 value = value1 + "," + value2
5020 5315 xmin_xmax = value
5021 5316 self.bufferSpectraHeis("SpectraHeis Plot", "Xmin-Xmax", xmin_xmax)
5022 5317
5023 5318 value1 = opObj.getParameterObj(parameterName='ymin')
5024 5319 if value1 == None:
5025 5320 ymin_ymax = None
5026 5321 else:
5027 5322 value1 = opObj.getParameterValue(parameterName='ymin')
5028 5323 value1 = str(value1)
5029 5324 value2 = opObj.getParameterObj(parameterName='ymax')
5030 5325 if value2 == None:
5031 5326 ymin_ymax = None
5032 5327 else:
5033 5328 value2 = opObj.getParameterValue(parameterName='ymax')
5034 5329 value2 = str(value2)
5035 5330 value = value1 + "," + value2
5036 5331 ymin_ymax = value
5037 5332 self.bufferSpectraHeis("SpectraHeis Plot", "Ymin-Ymax", ymin_ymax)
5038 5333
5039 5334 parmObj = opObj.getParameterObj(parameterName="figpath")
5040 5335 if parmObj == None:
5041 5336 path = None
5042 5337 else:
5043 5338 path = opObj.getParameterValue(parameterName='figpath')
5044 5339 self.bufferSpectraHeis("SpectraHeis Plot", "Save Path", path)
5045 5340
5046 5341 parmObj = opObj.getParameterObj(parameterName="ftp")
5047 5342 if parmObj == None:
5048 5343 status = 'disable'
5049 5344 else:
5050 5345 status = 'enable'
5051 5346 self.bufferSpectraHeis("SpectraHeis Plot", "FTP", status)
5052 5347 self.showWr_Period(puObj, opObj, nameplotop="SpectraHeis Plot")
5053 5348 # self.saveFTPvalues(opObj)
5054 5349
5055 5350 opObj = puObj.getOperationObj(name='RTIfromSpectraHeis')
5056 5351 # opObj = puObj.getOpObjfromParamValue(value="RTIfromSpectraHeis")
5057 5352 if opObj == None:
5058 5353 self.specHeisGraphCebRTIplot.setCheckState(0)
5059 5354 operationRTIPlot = "Disabled"
5060 5355 channelList = None
5061 5356 freq_vel = None
5062 5357 heightsrange = None
5063 5358 else:
5064 5359 operationRTIPlot = "Enable"
5065 5360 self.specHeisGraphCebRTIplot.setCheckState(QtCore.Qt.Checked)
5066 5361 self.bufferSpectraHeis("RTIHeis Plot", "Operation", operationRTIPlot)
5067 5362 parmObj = opObj.getParameterObj(parameterName='channelList')
5068 5363 if parmObj == None:
5069 5364 channelListRTIPlot = None
5070 5365 else:
5071 5366 value = opObj.getParameterValue(parameterName='channelList')
5072 5367 channelListRTIPlot = str(value)[1:-1]
5073 5368 self.bufferSpectraHeis("RTIHeis Plot", "Channel List", channelListRTIPlot)
5074 5369
5075 5370
5076 5371 value1 = opObj.getParameterObj(parameterName='xmin')
5077 5372 if value1 == None:
5078 5373 freq_vel = None
5079 5374 else:
5080 5375 value1 = opObj.getParameterValue(parameterName='xmin')
5081 5376 value1 = str(value1)
5082 5377 value2 = opObj.getParameterObj(parameterName='xmax')
5083 5378 if value2 == None:
5084 5379 freq_vel = None
5085 5380 else:
5086 5381 value2 = opObj.getParameterValue(parameterName='xmax')
5087 5382 value2 = str(value2)
5088 5383 value = value1 + "," + value2
5089 5384 tmintmax = value
5090 5385 self.bufferSpectraHeis("RTIHeis Plot", "Tmin,Tmax", tmintmax)
5091 5386
5092 5387 parmObj = opObj.getParameterObj(parameterName='timerange')
5093 5388 if parmObj == None:
5094 5389 timerange = None
5095 5390 else:
5096 5391 value = opObj.getParameterValue(parameterName='timerange')
5097 5392 timerange = str(value)
5098 5393 self.bufferSpectraHeis("RTIHeis Plot", "Time Range", timerange)
5099 5394
5100 5395 value1 = opObj.getParameterObj(parameterName='ymin')
5101 5396 if value1 == None:
5102 5397 heightsrange = None
5103 5398 else:
5104 5399 value1 = opObj.getParameterValue(parameterName='ymin')
5105 5400 value1 = str(value1)
5106 5401 value2 = opObj.getParameterObj(parameterName='ymax')
5107 5402 if value2 == None:
5108 5403 fheightsrange = None
5109 5404 else:
5110 5405 value2 = opObj.getParameterValue(parameterName='ymax')
5111 5406 value2 = str(value2)
5112 5407 value = value1 + "," + value2
5113 5408 heightsrange = value
5114 5409 self.bufferSpectraHeis("RTIHeis Plot", "Ymin-Ymax", heightsrange)
5115 5410
5116 5411 parmObj = opObj.getParameterObj(parameterName="figpath")
5117 5412 if parmObj == None:
5118 5413 path = None
5119 5414 else:
5120 5415 path = opObj.getParameterValue(parameterName='figpath')
5121 5416 self.bufferSpectraHeis("RTIHeis Plot", "Save Path", path)
5122 5417
5123 5418 parmObj = opObj.getParameterObj(parameterName="ftp")
5124 5419 if parmObj == None:
5125 5420 status = 'disable'
5126 5421 else:
5127 5422 status = 'enable'
5128 5423 self.bufferSpectraHeis("RTIHeis Plot", "FTP", status)
5129 5424 self.showWr_Period(puObj, opObj, nameplotop="RTIHeis Plot")
5130 5425 # self.saveFTPvalues(opObj)
5131 5426
5132 5427 # outputSpectraHeisWrite
5133 5428 opObj = puObj.getOperationObj(name='FitsWriter')
5134 5429 if opObj == None:
5135 5430 pass
5136 5431 else:
5137 5432 operation = 'Enabled'
5138 5433 self.bufferSpectraHeis("Output", "Operation", operation)
5139 5434 value = opObj.getParameterObj(parameterName='path')
5140 5435 if value == None:
5141 5436 path = None
5142 5437 else:
5143 5438 value = opObj.getParameterValue(parameterName='path')
5144 5439 path = str(value)
5145 5440 self.bufferSpectraHeis("Output", "Path", path)
5146 5441 value = opObj.getParameterObj(parameterName='dataBlocksPerFile')
5147 5442 if value == None:
5148 5443 blocksperfile = None
5149 5444 else:
5150 5445 value = opObj.getParameterValue(parameterName='dataBlocksPerFile')
5151 5446 blocksperfile = str(value)
5152 5447 self.bufferSpectraHeis("Output", "BlocksPerFile", blocksperfile)
5153 5448 value = opObj.getParameterObj(parameterName='metadatafile')
5154 5449 if value == None:
5155 5450 metadata = None
5156 5451 else:
5157 5452 value = opObj.getParameterValue(parameterName='metadatafile')
5158 5453 metadata = str(value)
5159 5454 self.bufferSpectraHeis("Output", "Metadata", metadata)
5160 5455
5161 5456 projectObj = self.getSelectedProjectObj()
5162 5457 ftpProcUnitConfObj = projectObj.getProcUnitObjByName(name="SendToServer")
5163 5458
5164 5459 if ftpProcUnitConfObj:
5165 5460
5166 5461 opObj = ftpProcUnitConfObj.getOperationObj(name='run')
5167 5462
5168 5463 server = opObj.getParameterValue(parameterName='server')
5169 5464 folder = opObj.getParameterValue(parameterName='folder')
5170 5465 username = opObj.getParameterValue(parameterName='username')
5171 5466 password = opObj.getParameterValue(parameterName='password')
5172 5467 ftp_wei = opObj.getParameterValue(parameterName='ftp_wei')
5173 5468 exp_code = opObj.getParameterValue(parameterName='exp_code')
5174 5469 sub_exp_code = opObj.getParameterValue(parameterName='sub_exp_code')
5175 5470 plot_pos = opObj.getParameterValue(parameterName='plot_pos')
5176 5471 localfolder = opObj.getParameterValue(parameterName='localfolder')
5177 5472
5178 5473 self.bufferSpectraHeis("FTP", "Server", server)
5179 5474 self.bufferSpectraHeis("FTP", "Remote folder", folder)
5180 5475 self.bufferSpectraHeis("FTP", "Local folder", localfolder)
5181 5476 self.bufferSpectraHeis("FTP", "Username", username)
5182 5477 self.bufferSpectraHeis("FTP", "Password", '*'*len(password))
5183 5478 self.bufferSpectraHeis("FTP", "Ftp_wei", ftp_wei)
5184 5479 self.bufferSpectraHeis("FTP", "Exp_code", exp_code)
5185 5480 self.bufferSpectraHeis("FTP", "Sub_exp_code", sub_exp_code)
5186 5481 self.bufferSpectraHeis("FTP", "Plot_pos", plot_pos)
5187 5482
5188 5483 # set model PU Properties
5189 5484
5190 self.propertiesModel = treeModel()
5191 self.propertiesModel.showPUSpectraHeisParms(self.specHeisProperCaracteristica, self.specHeisProperPrincipal, self.specHeisProperDescripcion)
5485 self.propertiesModel = TreeModel()
5486 self.propertiesModel.showProperties(self.specHeisProperCaracteristica, self.specHeisProperPrincipal, self.specHeisProperDescripcion)
5192 5487
5193 5488 self.treeProjectProperties.setModel(self.propertiesModel)
5194 5489 self.treeProjectProperties.expandAll()
5195 5490 self.treeProjectProperties.allColumnsShowFocus()
5196 5491 self.treeProjectProperties.resizeColumnToContents(0)
5197 5492 self.treeProjectProperties.resizeColumnToContents(1)
5198 5493
5199 5494 self.specHeisProperCaracteristica = []
5200 5495 self.specHeisProperDescripcion = []
5201 5496 self.specHeisProperPrincipal = []
5202 5497
5203 5498
5204 5499 def showWr_Period(self, puObj, opObj, nameplotop):
5205 5500 parmObj = opObj.getParameterObj(parameterName='wr_period')
5206 5501 if parmObj == None:
5207 5502 wr_period = None
5208 5503 else:
5209 5504 value = opObj.getParameterValue(parameterName='wr_period')
5210 5505 wr_period = str(value)
5211 5506 if puObj.datatype == "Spectra":
5212 5507 self.bufferSpectra(nameplotop, "wr_period", wr_period)
5213 5508 if puObj.datatype == "SpectraHeis":
5214 5509 self.bufferSpectraHeis(nameplotop, "wr_period", wr_period)
5215 5510
5216 5511 def saveFTPvalues(self, opObj):
5217 5512
5218 5513 parmObj = opObj.getParameterObj(parameterName="server")
5219 5514 if parmObj == None:
5220 5515 server = 'jro-app.igp.gob.pe'
5221 5516 else:
5222 5517 server = opObj.getParameterValue(parameterName='server')
5223 5518
5224 5519 parmObj = opObj.getParameterObj(parameterName="folder")
5225 5520 if parmObj == None:
5226 5521 folder = '/home/wmaster/graficos'
5227 5522 else:
5228 5523 folder = opObj.getParameterValue(parameterName='folder')
5229 5524
5230 5525 parmObj = opObj.getParameterObj(parameterName="username")
5231 5526 if parmObj == None:
5232 5527 username = 'wmaster'
5233 5528 else:
5234 5529 username = opObj.getParameterValue(parameterName='username')
5235 5530
5236 5531 parmObj = opObj.getParameterObj(parameterName="password")
5237 5532 if parmObj == None:
5238 5533 password = 'mst2010vhf'
5239 5534 else:
5240 5535 password = opObj.getParameterValue(parameterName='password')
5241 5536
5242 5537 parmObj = opObj.getParameterObj(parameterName="ftp_wei")
5243 5538 if parmObj == None:
5244 5539 ftp_wei = '0'
5245 5540 else:
5246 5541 ftp_wei = opObj.getParameterValue(parameterName='ftp_wei')
5247 5542
5248 5543 parmObj = opObj.getParameterObj(parameterName="exp_code")
5249 5544 if parmObj == None:
5250 5545 exp_code = '0'
5251 5546 else:
5252 5547 exp_code = opObj.getParameterValue(parameterName='exp_code')
5253 5548
5254 5549 parmObj = opObj.getParameterObj(parameterName="sub_exp_code")
5255 5550 if parmObj == None:
5256 5551 sub_exp_code = '0'
5257 5552 else:
5258 5553 sub_exp_code = opObj.getParameterValue(parameterName='sub_exp_code')
5259 5554
5260 5555 parmObj = opObj.getParameterObj(parameterName="plot_pos")
5261 5556 if parmObj == None:
5262 5557 plot_pos = '0'
5263 5558 else:
5264 5559 plot_pos = opObj.getParameterValue(parameterName='plot_pos')
5265 5560
5266 5561 parmObj = opObj.getParameterObj(parameterName="localfolder")
5267 5562 if parmObj == None:
5268 5563 localfolder = None
5269 5564 else:
5270 5565 localfolder = opObj.getParameterValue(parameterName='localfolder')
5271 5566
5272 5567 parmObj = opObj.getParameterObj(parameterName="extension")
5273 5568 if parmObj == None:
5274 5569 extension = None
5275 5570 else:
5276 5571 extension = opObj.getParameterValue(parameterName='extension')
5277 5572
5278 5573 self.temporalFTP.save(server, folder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos,
5279 5574 localfolder=localfolder,
5280 5575 extension=extension)
5281 5576
5282 5577 def addProject2ProjectExplorer(self, id, name):
5283 5578
5284 5579 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
5285 5580 self.parentItem = self.projectExplorerModel.invisibleRootItem()
5286 5581 self.parentItem.appendRow(itemTree)
5287 5582 self.parentItem = itemTree
5288 5583 self.projectExplorerTree.setCurrentIndex(self.parentItem.index())
5289 5584
5290 5585 self.selectedItemTree = itemTree
5291 5586
5292 5587 self.__itemTreeDict[id] = itemTree
5293 5588
5294 5589 def addPU2ProjectExplorer(self, id, name):
5295 5590 # id1= round(int(id)/10.)*10
5296 5591 # id= int(id)
5297 5592 # id=id-id1
5298 5593 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
5299 5594
5300 5595 self.parentItem = self.selectedItemTree
5301 5596 self.parentItem.appendRow(itemTree)
5302 5597 self.projectExplorerTree.expandAll()
5303 5598 self.parentItem = itemTree
5304 5599 self.projectExplorerTree.setCurrentIndex(self.parentItem.index())
5305 5600
5306 5601 self.selectedItemTree = itemTree
5307 5602
5308 5603 self.__itemTreeDict[id] = itemTree
5309 5604
5310 def addPU2PELoadXML(self, id, name, idParent):
5605 def addPU2PELoadXML(self, id, name, inputId):
5311 5606
5312 5607 itemTree = QtGui.QStandardItem(QtCore.QString(str(name)))
5313 if self.__itemTreeDict.has_key(idParent):
5314 self.parentItem = self.__itemTreeDict[idParent]
5608
5609 if self.__itemTreeDict.has_key(inputId):
5610 self.parentItem = self.__itemTreeDict[inputId]
5315 5611 else:
5316 self.parentItem = self.selectedItemTree
5612 self.parentItem = self.__itemTreeDict[inputId[0]]
5613
5317 5614 self.parentItem.appendRow(itemTree)
5318 5615 self.projectExplorerTree.expandAll()
5319 5616 self.parentItem = itemTree
5320 5617 self.projectExplorerTree.setCurrentIndex(self.parentItem.index())
5321 5618
5322 5619 self.selectedItemTree = itemTree
5323 5620
5324 5621 self.__itemTreeDict[id] = itemTree
5325 5622 # print "stop"
5326 5623
5327 5624 def getSelectedProjectObj(self):
5625 """
5626 Return the current project object selected. If a processing unit is
5627 actually selected this function returns associated project.
5328 5628
5629 None if any project or processing unit is selected
5630 """
5329 5631 for key in self.__itemTreeDict.keys():
5330 5632 if self.__itemTreeDict[key] != self.selectedItemTree:
5331 5633 continue
5332 5634
5333 5635 if self.__projectObjDict.has_key(key):
5334 5636 projectObj = self.__projectObjDict[key]
5637 return projectObj
5638
5639 puObj = self.__puObjDict[key]
5640
5641 if puObj.parentId == None:
5642 projectId = puObj.getId()[0]
5335 5643 else:
5336 puObj = self.__puObjDict[key]
5337 if puObj.parentId == None:
5338 id = puObj.getId()[0]
5339 else:
5340 id = puObj.parentId
5341 projectObj = self.__projectObjDict[id]
5644 projectId = puObj.parentId
5645
5646 projectObj = self.__projectObjDict[projectId]
5342 5647
5343 5648 return projectObj
5344 5649
5345 self.showWarning()
5346
5347 5650 return None
5348 5651
5349 def getSelectedPUObj(self):
5652 def getSelectedItemObj(self):
5653 """
5654 Return the current project or processing unit object selected
5350 5655
5656 None if any project or processing unit is selected
5657 """
5351 5658 for key in self.__itemTreeDict.keys():
5352 5659 if self.__itemTreeDict[key] != self.selectedItemTree:
5353 5660 continue
5354 5661
5355 5662 if self.__projectObjDict.has_key(key) == True:
5356 5663 fatherObj = self.__projectObjDict[key]
5357 5664 else:
5358 5665 fatherObj = self.__puObjDict[key]
5359 5666
5360 5667 return fatherObj
5361 5668
5362 self.showWarning()
5363
5364 5669 return None
5365 5670
5366 5671 def openProject(self):
5367 5672
5368 5673 self.actionStart.setEnabled(False)
5369 5674 self.actionStarToolbar.setEnabled(False)
5370 5675
5371 5676 self.create = False
5372 5677 self.frame_2.setEnabled(True)
5373 home = expanduser("~")
5374 self.dir = os.path.join(home, 'schain_workspace')
5678
5375 5679 # print self.dir
5376 filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open text file", self.dir, self.tr("Text Files (*.xml)")))
5680 filename = str(QtGui.QFileDialog.getOpenFileName(self, "Open text file", self.pathWorkSpace, self.tr("Text Files (*.xml)")))
5377 5681 self.console.clear()
5378 5682 projectObjLoad = Project()
5379 5683 try:
5380 5684 projectObjLoad.readXml(filename)
5381 5685 except:
5382 5686 self.console.clear()
5383 5687 self.console.append("The selected xml file could not be loaded ...")
5384 5688 return 0
5385 5689
5386 project_name, description = projectObjLoad.name, projectObjLoad.description
5690 self.refreshProjectWindow2(projectObjLoad)
5691 self.refreshProjectProperties(projectObjLoad)
5692 # project_name, description = projectObjLoad.name, projectObjLoad.description
5387 5693 id = projectObjLoad.id
5388 5694 self.__projectObjDict[id] = projectObjLoad
5389 # Project Properties
5390 datatype, data_path, startDate, endDate, startTime, endTime , online , delay, walk, set = self.showProjectProperties(projectObjLoad)
5391 # show ProjectView
5392 self.addProject2ProjectExplorer(id=id, name=project_name)
5393 self.refreshProjectWindow(project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, set)
5394
5395 if datatype == "Voltage":
5396 ext = '.r'
5397 self.specOpProfiles.setEnabled(True)
5398 self.specOpippFactor.setEnabled(True)
5399 elif datatype == "Spectra":
5400 ext = '.pdata'
5401 self.specOpProfiles.setEnabled(False)
5402 self.specOpippFactor.setEnabled(False)
5403 elif datatype == "Fits":
5404 ext = '.fits'
5405
5406 if online == 0:
5407 self.loadDays(data_path, ext, walk)
5408 else:
5409 self.proComStartDate.setEnabled(False)
5410 self.proComEndDate.setEnabled(False)
5411 self.proStartTime.setEnabled(False)
5412 self.proEndTime.setEnabled(False)
5413 self.frame_2.setEnabled(True)
5695 # # Project Properties
5696 # datatype, data_path, startDate, endDate, startTime, endTime , online , delay, walk, set = self.showProjectProperties(projectObjLoad)
5697 # # show ProjectView
5698 self.addProject2ProjectExplorer(id=id, name=projectObjLoad.name)
5699 # self.refreshProjectWindow(project_name, description, datatype, data_path, startDate, endDate, startTime, endTime, online, delay, set)
5700 #
5701 # if datatype == "Voltage":
5702 # ext = '.r'
5703 # self.specOpProfiles.setEnabled(True)
5704 # self.specOpippFactor.setEnabled(True)
5705 # elif datatype == "Spectra":
5706 # ext = '.pdata'
5707 # self.specOpProfiles.setEnabled(False)
5708 # self.specOpippFactor.setEnabled(False)
5709 # elif datatype == "Fits":
5710 # ext = '.fits'
5711 # elif datatype == "USRP":
5712 # ext = '.hdf5'
5713 #
5714 # if online == 0:
5715 # self.loadDays(data_path, ext, walk)
5716 # else:
5717 # self.proComStartDate.setEnabled(False)
5718 # self.proComEndDate.setEnabled(False)
5719 # self.proStartTime.setEnabled(False)
5720 # self.proEndTime.setEnabled(False)
5721 # self.frame_2.setEnabled(True)
5414 5722
5415 5723 self.tabWidgetProject.setEnabled(True)
5416 5724 self.tabWidgetProject.setCurrentWidget(self.tabProject)
5417 5725 # Disable tabProject after finish the creation
5418 5726 self.tabProject.setEnabled(True)
5419 5727 puObjorderList = OrderedDict(sorted(projectObjLoad.procUnitConfObjDict.items(), key=lambda x: x[0]))
5420 5728
5421 for inputId, puObj in puObjorderList.items():
5422 # print puObj.datatype, puObj.inputId,puObj.getId(),puObj.parentId
5423 self.__puObjDict[puObj.getId()] = puObj
5729 for puId, puObj in puObjorderList.items():
5730
5731 # print "%s %s %s %s %s" %(puObj.datatype, inputId, puObj.inputId, puObj.getId(), puObj.parentId)
5732
5733 self.__puObjDict[puId] = puObj
5424 5734
5425 if puObj.inputId != "0":
5426 self.addPU2PELoadXML(id=puObj.getId() , name=puObj.datatype , idParent=puObj.inputId)
5735 if puObj.inputId != '0':
5736 self.addPU2PELoadXML(id=puId , name=puObj.datatype , inputId=puObj.inputId)
5427 5737
5428 5738 if puObj.datatype == "Voltage":
5429 5739 self.refreshPUWindow(puObj.datatype, puObj)
5430 self.showPUVoltageProperties(puObj)
5740 self.refreshPUProperties(puObj)
5431 5741 self.showtabPUCreated(datatype=puObj.datatype)
5432 5742
5433 5743 if puObj.datatype == "Spectra":
5434 5744 self.refreshPUWindow(puObj.datatype, puObj)
5435 self.showPUSpectraProperties(puObj)
5745 self.refreshPUProperties(puObj)
5436 5746 self.showtabPUCreated(datatype=puObj.datatype)
5437 5747
5438 5748 if puObj.datatype == "SpectraHeis":
5439 5749 self.refreshPUWindow(puObj.datatype, puObj)
5440 self.showPUSpectraHeisProperties(puObj)
5750 self.refreshPUProperties(puObj)
5441 5751 self.showtabPUCreated(datatype=puObj.datatype)
5442 5752
5443 5753 if puObj.name == "SendToServer":
5444 5754 self.__ftpProcUnitAdded = True
5445 5755 self.__ftpProcUnitId = puObj.getId()
5446 5756
5447 5757 opObj = puObj.getOperationObj(name="run")
5448 5758 self.saveFTPvalues(opObj)
5449 5759
5450 self.console.clear()
5760 # self.console.clear()
5451 5761 self.console.append("The selected xml file has been loaded successfully")
5452 5762 # self.refreshPUWindow(datatype=datatype,puObj=puObj)
5453 5763
5454 5764 self.actionStart.setEnabled(True)
5455 5765 self.actionStarToolbar.setEnabled(True)
5456 5766
5457 5767 def on_comm_updating_timer(self):
5458 5768 # Verifica si algun proceso ha sido inicializado y sigue ejecutandose
5459 5769
5460 5770 if not self.__initialized:
5461 5771 return
5462 5772
5463 if not self.commCtrlPThread.isRunning():
5773 if not self.controllerObj.isAlive():
5464 5774 self.stopProject()
5465 5775
5466 5776 def playProject(self, ext=".xml"):
5467 5777
5468 5778 projectObj = self.getSelectedProjectObj()
5469 5779
5780 if not projectObj:
5781 print "Please select a project before pressing PLAY"
5782 return
5783
5470 5784 filename = os.path.join(str(self.pathWorkSpace),
5471 5785 "%s%s%s" %(str(projectObj.name), str(projectObj.id), ext)
5472 5786 )
5473 5787
5474 5788 self.console.clear()
5475 5789 filename = self.saveProject()
5476 5790 # projectObj.writeXml(filename)
5477 5791 if filename == None:
5478 5792 self.console.append("Process did not initialize.")
5479 5793 return
5480 5794
5481 5795 self.actionStart.setEnabled(False)
5482 5796 self.actionPause.setEnabled(True)
5483 5797 self.actionStop.setEnabled(True)
5484 5798
5485 5799 self.actionStarToolbar.setEnabled(False)
5486 5800 self.actionPauseToolbar.setEnabled(True)
5487 5801 self.actionStopToolbar.setEnabled(True)
5488 5802
5489 5803 self.console.append("Please Wait...")
5490 self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.PROCESS, filename))
5804 # self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.PROCESS, filename))
5805
5806 self.controllerObj = ControllerThread(filename)
5807 self.controllerObj.start()
5491 5808 sleep(0.5)
5492 5809 self.__initialized = True
5493 5810
5494 5811 def stopProject(self):
5495 5812
5496 5813 self.__initialized = False
5497 5814
5498 self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.STOP, True))
5815 # self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.STOP, True))
5816 self.controllerObj.stop()
5499 5817
5500 5818 self.actionStart.setEnabled(True)
5501 5819 self.actionPause.setEnabled(False)
5502 5820 self.actionStop.setEnabled(False)
5503 5821
5504 5822 self.actionStarToolbar.setEnabled(True)
5505 5823 self.actionPauseToolbar.setEnabled(False)
5506 5824 self.actionStopToolbar.setEnabled(False)
5507 5825
5508 5826 self.restorePauseIcon()
5509 5827
5510 5828 def pauseProject(self):
5511 5829
5512 self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.PAUSE, data=True))
5513
5830 # self.commCtrlPThread.cmd_q.put(ProcessCommand(ProcessCommand.PAUSE, data=True))
5831 self.controllerObj.pause()
5832
5514 5833 self.actionStart.setEnabled(False)
5515 5834 self.actionPause.setEnabled(True)
5516 5835 self.actionStop.setEnabled(True)
5517 5836
5518 5837 self.actionStarToolbar.setEnabled(False)
5519 5838 self.actionPauseToolbar.setEnabled(True)
5520 5839 self.actionStopToolbar.setEnabled(True)
5521 5840
5522 5841 def saveProject(self):
5523 5842
5524 5843 self.actionStart.setEnabled(False)
5525 5844 self.actionStarToolbar.setEnabled(False)
5526 5845
5527 5846 sts = True
5528 puObj = self.getSelectedPUObj()
5847 puObj = self.getSelectedItemObj()
5529 5848
5530 5849 if puObj != None:
5531 5850 if puObj.name == 'VoltageProc':
5532 5851 sts = self.on_volOpOk_clicked()
5533 5852 if puObj.name == 'SpectraProc':
5534 5853 sts = self.on_specOpOk_clicked()
5535 5854 if puObj.name == 'SpectraHeisProc':
5536 5855 sts = self.on_specHeisOpOk_clicked()
5537 5856
5538 5857 if not sts:
5539 5858 return None
5540 5859
5541 5860 projectObj = self.getSelectedProjectObj()
5542 5861 puObjorderList = OrderedDict(sorted(projectObj.procUnitConfObjDict.items(), key=lambda x: x[0]))
5543 5862
5544 5863 for inputId, puObj in puObjorderList.items():
5545 5864 # print puObj.datatype, puObj.inputId,puObj.getId(),puObj.parentId
5546 5865
5547 5866 if puObj.name == "VoltageProc":
5548 5867 self.refreshID(puObj)
5549 5868 if puObj.name == "SpectraProc":
5550 5869 self.refreshID(puObj)
5551 5870 if puObj.name == "SpectraHeisProc":
5552 5871 self.refreshID(puObj)
5553 5872
5554 5873 filename = os.path.join(str(self.pathWorkSpace),
5555 5874 "%s%s%s" %(str(projectObj.name), str(projectObj.id), '.xml')
5556 5875 )
5557 5876 projectObj.writeXml(filename)
5558 5877 self.console.append("Now, you can press the Start Icon on the toolbar")
5559 5878
5560 5879 self.actionStart.setEnabled(True)
5561 5880 self.actionStarToolbar.setEnabled(True)
5562 5881
5563 5882 return filename
5564 5883
5565 def deleteProjectorPU(self):
5884 def removeItemTreeFromProject(self):
5566 5885 """
5567 5886 Metodo para eliminar el proyecto en el dictionario de proyectos y en el dictionario de vista de arbol
5568 5887 """
5569 5888 for key in self.__itemTreeDict.keys():
5889
5890 #Check again because an item can delete multiple items (childs)
5891 if key not in self.__itemTreeDict.keys():
5892 continue
5893
5570 5894 if self.__itemTreeDict[key] != self.selectedItemTree:
5571 5895 continue
5572 5896
5573 5897 if self.__projectObjDict.has_key(key) == True:
5574 5898
5575 5899 del self.__projectObjDict[key]
5576 5900 del self.__itemTreeDict[key]
5577 5901
5578 5902 else:
5579 5903 puObj = self.__puObjDict[key]
5580 if puObj.parentId == None:
5581 id = puObj.getId()[0]
5582 else:
5583 id = puObj.parentId
5584 projectObj = self.__projectObjDict[id]
5904 idProjectParent = puObj.parentId
5905 projectObj = self.__projectObjDict[idProjectParent]
5906
5585 5907 del self.__puObjDict[key]
5586 5908 del self.__itemTreeDict[key]
5587 5909 del projectObj.procUnitConfObjDict[key]
5910
5588 5911 for key in projectObj.procUnitConfObjDict.keys():
5589 5912 if projectObj.procUnitConfObjDict[key].inputId != puObj.getId():
5590 5913 continue
5591 5914 del self.__puObjDict[projectObj.procUnitConfObjDict[key].getId()]
5592 5915 del self.__itemTreeDict[projectObj.procUnitConfObjDict[key].getId()]
5593 5916 del projectObj.procUnitConfObjDict[key]
5594 5917 # print projectObj.procUnitConfObjDict
5595 5918 # print self.__itemTreeDict,self.__projectObjDict,self.__puObjDict
5596 self.showWarning()
5597
5598 def showWarning(self):
5599 pass
5600 5919
5601 5920 def getParmsFromProjectWindow(self):
5602 5921 """
5603 5922 Return Inputs Project:
5604 5923 - id
5605 5924 - project_name
5606 5925 - datatype
5607 5926 - ext
5608 5927 - data_path
5609 5928 - readmode
5610 5929 - delay
5611 5930 - set
5612 5931 - walk
5613 5932 """
5614 5933 project_name = str(self.proName.text())
5615 5934 try:
5616 5935 name = str(self.proName.text())
5617 5936 except:
5618 5937 self.console.clear()
5619 5938 self.console.append("Please Write a name")
5620 5939 return 0
5621 5940
5622 5941 desc = str(self.proDescription.toPlainText())
5623 5942 datatype = str(self.proComDataType.currentText())
5624 5943 data_path = str(self.proDataPath.text())
5625 5944 if not os.path.exists(data_path):
5626 5945 self.proOk.setEnabled(False)
5627 5946 self.console.clear()
5628 5947 self.console.append("Write a correct a path")
5629 5948 return
5630 5949
5631 5950 online = int(self.online)
5632 5951 if online == 0:
5633 5952 delay = 0
5634 5953 set = 0
5635 5954 else:
5636 5955 delay = self.proDelay.text()
5637 5956 try:
5638 5957 delay = int(self.proDelay.text())
5639 5958 except:
5640 5959 self.console.clear()
5641 5960 self.console.append("Please Write a number for delay")
5642 5961 return 0
5643 5962
5644 5963 set = self.proSet.text()
5645 5964 try:
5646 5965 set = int(self.proSet.text())
5647 5966 except:
5648 5967 self.console.clear()
5649 5968 set = None
5650 5969
5651 5970
5652 5971 walk = int(self.walk)
5653 5972 starDate = str(self.proComStartDate.currentText())
5654 5973 endDate = str(self.proComEndDate.currentText())
5655 5974 reloj1 = self.proStartTime.time()
5656 5975 reloj2 = self.proEndTime.time()
5657 5976 startTime = str(reloj1.hour()) + ":" + str(reloj1.minute()) + ":" + str(reloj1.second())
5658 5977 endTime = str(reloj2.hour()) + ":" + str(reloj2.minute()) + ":" + str(reloj2.second())
5659 5978
5660 5979 return project_name, desc, datatype, data_path, starDate, endDate, startTime, endTime, online, delay, walk , set
5661 5980
5662 5981 def removefromtree(self, row):
5663 5982 self.parentItem.removeRow(row)
5664 5983
5665 5984
5666 5985 def setInputsProject_View(self):
5986
5667 5987 self.tabWidgetProject.setEnabled(True)
5668 5988 self.tabWidgetProject.setCurrentWidget(self.tabProject)
5669 5989 self.tabProject.setEnabled(True)
5670 5990 self.frame_2.setEnabled(False)
5671 5991 self.proName.clear()
5672 5992 self.proName.setFocus()
5673 5993 self.proName.setSelection(0, 0)
5674 5994 self.proName.setCursorPosition(0)
5675 5995 self.proDataType.setText('.r')
5676 5996 self.proDataPath.clear()
5677 5997 self.proComDataType.clear()
5678 5998 self.proComDataType.addItem("Voltage")
5679 5999 self.proComDataType.addItem("Spectra")
5680 6000 self.proComDataType.addItem("Fits")
6001 self.proComDataType.addItem("USRP")
5681 6002
5682 6003 self.proComStartDate.clear()
5683 6004 self.proComEndDate.clear()
5684 6005
5685 6006 startTime = "00:00:00"
5686 6007 endTime = "23:59:59"
5687 6008 starlist = startTime.split(":")
5688 6009 endlist = endTime.split(":")
5689 6010 self.proDelay.setText("0")
5690 6011 self.proSet.setText("0")
5691 6012 self.time.setHMS(int(starlist[0]), int(starlist[1]), int(starlist[2]))
5692 6013 self.proStartTime.setTime(self.time)
5693 6014 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
5694 6015 self.proEndTime.setTime(self.time)
5695 6016 self.proDescription.clear()
5696 6017 self.proOk.setEnabled(False)
5697 6018 self.console.clear()
5698 6019 # self.console.append("Please, Write a name Project")
5699 6020 # self.console.append("Introduce Project Parameters")DC
5700 6021 # self.console.append("Select data type Voltage( .rawdata) or Spectra(.pdata)")
5701 6022
5702 def setInputsPU_View(self, datatype):
6023 def clearPUWindow(self, datatype):
6024
5703 6025 projectObjView = self.getSelectedProjectObj()
5704 idReadUnit = projectObjView.getReadUnitId()
5705 readUnitObj = projectObjView.getProcUnitObj(idReadUnit)
6026
6027 if not projectObjView:
6028 return
6029
6030 puObj = self.getSelectedItemObj()
6031 inputId = puObj.getInputId()
6032 inputPUObj = projectObjView.getProcUnitObj(inputId)
5706 6033
5707 6034 if datatype == 'Voltage':
5708 6035 self.volOpComChannels.setEnabled(False)
5709 6036 self.volOpComHeights.setEnabled(False)
5710 6037 self.volOpFilter.setEnabled(False)
5711 6038 self.volOpComProfile.setEnabled(False)
5712 6039 self.volOpComCode.setEnabled(False)
5713 6040 self.volOpCohInt.setEnabled(False)
5714 6041 self.volOpChannel.setEnabled(False)
5715 6042 self.volOpHeights.setEnabled(False)
5716 6043 self.volOpProfile.setEnabled(False)
5717 6044 self.volOpRadarfrequency.setEnabled(False)
5718 6045 self.volOpCebChannels.setCheckState(0)
5719 6046 self.volOpCebRadarfrequency.setCheckState(0)
5720 6047 self.volOpCebHeights.setCheckState(0)
5721 6048 self.volOpCebFilter.setCheckState(0)
5722 6049 self.volOpCebProfile.setCheckState(0)
5723 6050 self.volOpCebDecodification.setCheckState(0)
5724 6051 self.volOpCebCohInt.setCheckState(0)
5725 6052
5726 6053 self.volOpChannel.clear()
5727 6054 self.volOpHeights.clear()
5728 6055 self.volOpProfile.clear()
5729 6056 self.volOpFilter.clear()
5730 6057 self.volOpCohInt.clear()
5731 6058 self.volOpRadarfrequency.clear()
5732 6059
5733 6060 if datatype == 'Spectra':
5734 6061
5735 if readUnitObj.datatype == 'Spectra':
6062 if inputPUObj.datatype == 'Spectra':
5736 6063 self.specOpnFFTpoints.setEnabled(False)
5737 6064 self.specOpProfiles.setEnabled(False)
5738 6065 self.specOpippFactor.setEnabled(False)
5739 6066 else:
5740 6067 self.specOpnFFTpoints.setEnabled(True)
5741 6068 self.specOpProfiles.setEnabled(True)
5742 6069 self.specOpippFactor.setEnabled(True)
5743 6070
5744 6071 self.specOpCebCrossSpectra.setCheckState(0)
5745 6072 self.specOpCebChannel.setCheckState(0)
5746 6073 self.specOpCebHeights.setCheckState(0)
5747 6074 self.specOpCebIncoherent.setCheckState(0)
5748 6075 self.specOpCebRemoveDC.setCheckState(0)
5749 6076 self.specOpCebRemoveInt.setCheckState(0)
5750 6077 self.specOpCebgetNoise.setCheckState(0)
5751 6078 self.specOpCebRadarfrequency.setCheckState(0)
5752 6079
5753 6080 self.specOpRadarfrequency.setEnabled(False)
5754 6081 self.specOppairsList.setEnabled(False)
5755 6082 self.specOpChannel.setEnabled(False)
5756 6083 self.specOpHeights.setEnabled(False)
5757 6084 self.specOpIncoherent.setEnabled(False)
5758 6085 self.specOpgetNoise.setEnabled(False)
5759 6086
5760 6087 self.specOpRadarfrequency.clear()
5761 6088 self.specOpnFFTpoints.clear()
5762 6089 self.specOpProfiles.clear()
5763 6090 self.specOpippFactor.clear
5764 6091 self.specOppairsList.clear()
5765 6092 self.specOpChannel.clear()
5766 6093 self.specOpHeights.clear()
5767 6094 self.specOpIncoherent.clear()
5768 6095 self.specOpgetNoise.clear()
5769 6096
5770 6097 self.specGraphCebSpectraplot.setCheckState(0)
5771 6098 self.specGraphCebCrossSpectraplot.setCheckState(0)
5772 6099 self.specGraphCebRTIplot.setCheckState(0)
5773 6100 self.specGraphCebRTInoise.setCheckState(0)
5774 6101 self.specGraphCebCoherencmap.setCheckState(0)
5775 6102 self.specGraphPowerprofile.setCheckState(0)
5776 6103
5777 6104 self.specGraphSaveSpectra.setCheckState(0)
5778 6105 self.specGraphSaveCross.setCheckState(0)
5779 6106 self.specGraphSaveRTIplot.setCheckState(0)
5780 6107 self.specGraphSaveRTInoise.setCheckState(0)
5781 6108 self.specGraphSaveCoherencemap.setCheckState(0)
5782 6109 self.specGraphSavePowerprofile.setCheckState(0)
5783 6110
5784 6111 self.specGraphftpRTIplot.setCheckState(0)
5785 6112 self.specGraphftpRTInoise.setCheckState(0)
5786 6113 self.specGraphftpCoherencemap.setCheckState(0)
5787 6114
5788 6115 self.specGraphPath.clear()
5789 6116 self.specGraphPrefix.clear()
5790 6117
5791 6118 self.specGgraphftpratio.clear()
5792 6119
5793 6120 self.specGgraphChannelList.clear()
5794 6121 self.specGgraphFreq.clear()
5795 6122 self.specGgraphHeight.clear()
5796 6123 self.specGgraphDbsrange.clear()
5797 6124 self.specGgraphmagnitud.clear()
5798 6125 self.specGgraphTminTmax.clear()
5799 6126 self.specGgraphTimeRange.clear()
5800 6127
5801 6128 if datatype == 'SpectraHeis':
5802 6129 self.specHeisOpCebIncoherent.setCheckState(0)
5803 6130 self.specHeisOpIncoherent.setEnabled(False)
5804 6131 self.specHeisOpIncoherent.clear()
5805 6132
5806 6133 self.specHeisGraphCebSpectraplot.setCheckState(0)
5807 6134 self.specHeisGraphCebRTIplot.setCheckState(0)
5808 6135
5809 6136 self.specHeisGraphSaveSpectra.setCheckState(0)
5810 6137 self.specHeisGraphSaveRTIplot.setCheckState(0)
5811 6138
5812 6139 self.specHeisGraphftpSpectra.setCheckState(0)
5813 6140 self.specHeisGraphftpRTIplot.setCheckState(0)
5814 6141
5815 6142 self.specHeisGraphPath.clear()
5816 6143 self.specHeisGraphPrefix.clear()
5817 6144 self.specHeisGgraphChannelList.clear()
5818 6145 self.specHeisGgraphXminXmax.clear()
5819 6146 self.specHeisGgraphYminYmax.clear()
5820 6147 self.specHeisGgraphTminTmax.clear()
5821 6148 self.specHeisGgraphTimeRange.clear()
5822 6149 self.specHeisGgraphftpratio.clear()
5823 6150
5824 6151
5825 6152
5826 6153
5827 6154
5828 6155 def showtabPUCreated(self, datatype):
5829 6156 if datatype == "Voltage":
5830 6157 self.tabVoltage.setEnabled(True)
5831 6158 self.tabProject.setEnabled(False)
5832 6159 self.tabSpectra.setEnabled(False)
5833 6160 self.tabCorrelation.setEnabled(False)
5834 6161 self.tabSpectraHeis.setEnabled(False)
5835 6162 self.tabWidgetProject.setCurrentWidget(self.tabVoltage)
5836 6163
5837 6164 if datatype == "Spectra":
5838 6165 self.tabVoltage.setEnabled(False)
5839 6166 self.tabProject.setEnabled(False)
5840 6167 self.tabSpectra.setEnabled(True)
5841 6168 self.tabCorrelation.setEnabled(False)
5842 6169 self.tabSpectraHeis.setEnabled(False)
5843 6170 self.tabWidgetProject.setCurrentWidget(self.tabSpectra)
5844 6171 if datatype == "SpectraHeis":
5845 6172 self.tabVoltage.setEnabled(False)
5846 6173 self.tabProject.setEnabled(False)
5847 6174 self.tabSpectra.setEnabled(False)
5848 6175 self.tabCorrelation.setEnabled(False)
5849 6176 self.tabSpectraHeis.setEnabled(True)
5850 6177 self.tabWidgetProject.setCurrentWidget(self.tabSpectraHeis)
5851 6178
5852
5853 def searchData(self, data_path, ext, walk, expLabel=''):
5854 dateList = []
5855 fileList = []
5856
5857 if not os.path.exists(data_path):
5858 return None
5859
5860 if walk == 0:
5861 files = os.listdir(data_path)
5862 for thisFile in files:
5863 thisExt = os.path.splitext(thisFile)[-1]
5864 if thisExt == ext:
5865 fileList.append(thisFile)
5866
5867 for thisFile in fileList:
5868 try:
5869 year = int(thisFile[1:5])
5870 doy = int(thisFile[5:8])
5871
5872 date = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
5873 dateformat = date.strftime("%Y/%m/%d")
5874
5875 if dateformat not in dateList:
5876 dateList.append(dateformat)
5877 except:
5878 continue
5879 # REVISION---------------------------------1
5880 if walk == 1:
5881
5882 dirList = os.listdir(data_path)
5883
5884 dirList.sort()
5885
5886 dateList = []
5887
5888 for thisDir in dirList:
5889
5890 if not isRadarPath(thisDir):
5891 self.console.clear()
5892 self.console.append("Please, Choose the Correct Path")
5893 self.proOk.setEnabled(False)
5894 continue
5895
5896 doypath = os.path.join(data_path, thisDir, expLabel)
5897 if not os.path.exists(doypath):
5898 self.console.clear()
5899 self.console.append("Please, Choose the Correct Path")
5900 return
5901 files = os.listdir(doypath)
5902 fileList = []
5903
5904 for thisFile in files:
5905 thisExt = os.path.splitext(thisFile)[-1]
5906 if thisExt != ext:
5907 self.console.clear()
5908 self.console.append("There is no datatype selected in the Path Directory")
5909 self.proOk.setEnabled(False)
5910 continue
5911
5912 if not isRadarFile(thisFile):
5913 self.proOk.setEnabled(False)
5914 self.console.clear()
5915 self.console.append("Please, Choose the Correct Path")
5916 continue
5917
5918 fileList.append(thisFile)
5919 break
5920
5921 if fileList == []:
5922 continue
5923
5924 year = int(thisDir[1:5])
5925 doy = int(thisDir[5:8])
5926
5927 date = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
5928 dateformat = date.strftime("%Y/%m/%d")
5929 dateList.append(dateformat)
5930
5931 if len(dateList) > 0:
5932 self.proOk.setEnabled(True)
5933 return dateList
5934
5935
5936 # self.proOk.setEnabled(False)
5937 return None
5938
5939 6179 def checkInputsProject(self):
5940 6180 """
5941 6181 Check Inputs Project:
5942 6182 - project_name
5943 6183 - datatype
5944 6184 - ext
5945 6185 - data_path
5946 6186 - readmode
5947 6187 - delay
5948 6188 - set
5949 6189 - walk
5950 6190 """
5951 6191 parms_ok = True
5952 6192 project_name = str(self.proName.text())
5953 6193 if project_name == '' or project_name == None:
5954 6194 outputstr = "Enter the Project Name"
5955 6195 self.console.append(outputstr)
5956 6196 parms_ok = False
5957 6197 project_name = None
5958 6198
5959 6199 datatype = str(self.proComDataType.currentText())
5960 if not(datatype in ['Voltage', 'Spectra', 'Fits']):
5961 outputstr = 'datatype = %s, this must be either Voltage, Spectra or SpectraHeis' % datatype
6200 if not(datatype in ['Voltage', 'Spectra', 'Fits', 'USRP']):
6201 outputstr = 'datatype = %s, this must be either Voltage, Spectra, SpectraHeis or USRP' % datatype
5962 6202 self.console.append(outputstr)
5963 6203 parms_ok = False
5964 6204 datatype = None
5965 6205
5966 6206 ext = str(self.proDataType.text())
5967 if not(ext in ['.r', '.pdata', '.fits']):
5968 outputstr = "extension files must be .r , .pdata or .fits"
6207 if not(ext in ['.r', '.pdata', '.fits', '.hdf5']):
6208 outputstr = "extension files must be .r , .pdata, .fits or .hdf5"
5969 6209 self.console.append(outputstr)
5970 6210 parms_ok = False
5971 6211 ext = None
5972 6212
5973 6213 data_path = str(self.proDataPath.text())
5974 6214
5975 6215 if data_path == '':
5976 6216 outputstr = 'Datapath is empty'
5977 6217 self.console.append(outputstr)
5978 6218 parms_ok = False
5979 6219 data_path = None
5980 6220
5981 6221 if data_path != None:
5982 if not os.path.exists(data_path):
6222 if not os.path.isdir(data_path):
5983 6223 outputstr = 'Datapath:%s does not exists' % data_path
5984 6224 self.console.append(outputstr)
5985 6225 parms_ok = False
5986 6226 data_path = None
5987 6227
5988 6228 read_mode = str(self.proComReadMode.currentText())
5989 6229 if not(read_mode in ['Online', 'Offline']):
5990 6230 outputstr = 'Read Mode: %s, this must be either Online or Offline' % read_mode
5991 6231 self.console.append(outputstr)
5992 6232 parms_ok = False
5993 6233 read_mode = None
5994 6234
5995 6235 try:
5996 6236 delay = int(str(self.proDelay.text()))
5997 6237 except:
5998 6238 outputstr = 'Delay: %s, this must be a integer number' % str(self.proName.text())
5999 6239 self.console.append(outputstr)
6000 6240 parms_ok = False
6001 6241 delay = None
6002 6242
6003 6243 try:
6004 6244 set = int(str(self.proSet.text()))
6005 6245 except:
6006 6246 # outputstr = 'Set: %s, this must be a integer number' % str(self.proName.text())
6007 6247 # self.console.append(outputstr)
6008 6248 # parms_ok = False
6009 6249 set = None
6010 6250
6011 6251 walk_str = str(self.proComWalk.currentText())
6012 6252 if walk_str == 'On Files':
6013 6253 walk = 0
6014 6254 elif walk_str == 'On Folder':
6015 6255 walk = 1
6016 6256 else:
6017 6257 outputstr = 'Walk: %s, this must be either On Files or On Folders' % walk_str
6018 6258 self.console.append(outputstr)
6019 6259 parms_ok = False
6020 6260 walk = None
6021 6261
6022 6262 return parms_ok, project_name, datatype, ext, data_path, read_mode, delay, walk, set
6023 6263
6024 6264 def checkInputsPUSave(self, datatype):
6025 6265 """
6026 6266 Check Inputs Spectra Save:
6027 6267 - path
6028 6268 - blocks Per File
6029 6269 - sufix
6030 6270 - dataformat
6031 6271 """
6032 6272 parms_ok = True
6033 6273
6034 6274 if datatype == "Voltage":
6035 6275 output_path = str(self.volOutputPath.text())
6036 6276 blocksperfile = str(self.volOutputblocksperfile.text())
6037 6277 profilesperblock = str(self.volOutputprofilesperblock.text())
6038 6278
6039 6279 if datatype == "Spectra":
6040 6280 output_path = str(self.specOutputPath.text())
6041 6281 blocksperfile = str(self.specOutputblocksperfile.text())
6042 6282 profilesperblock = str(self.specOutputprofileperblock.text())
6043 6283
6044 6284 if datatype == "SpectraHeis":
6045 6285 output_path = str(self.specHeisOutputPath.text())
6046 6286 blocksperfile = str(self.specHeisOutputblocksperfile.text())
6047 6287 metada = str(self.specHeisOutputMetada.text())
6048 6288
6049 6289 if output_path == '':
6050 6290 outputstr = 'Outputpath is empty'
6051 6291 self.console.append(outputstr)
6052 6292 parms_ok = False
6053 6293 data_path = None
6054 6294
6055 6295 if output_path != None:
6056 6296 if not os.path.exists(output_path):
6057 6297 outputstr = 'OutputPath:%s does not exists' % output_path
6058 6298 self.console.append(outputstr)
6059 6299 parms_ok = False
6060 6300 output_path = None
6061 6301
6062 6302
6063 6303 try:
6064 6304 profilesperblock = int(profilesperblock)
6065 6305 except:
6066 6306 if datatype == "Voltage":
6067 6307 outputstr = 'Profilesperblock: %s, this must be a integer number' % str(self.volOutputprofilesperblock.text())
6068 6308 self.console.append(outputstr)
6069 6309 parms_ok = False
6070 6310 profilesperblock = None
6071 6311
6072 6312 elif datatype == "Spectra":
6073 6313 outputstr = 'Profilesperblock: %s, this must be a integer number' % str(self.specOutputprofileperblock.text())
6074 6314 self.console.append(outputstr)
6075 6315 parms_ok = False
6076 6316 profilesperblock = None
6077 6317
6078 6318 try:
6079 6319 blocksperfile = int(blocksperfile)
6080 6320 except:
6081 6321 if datatype == "Voltage":
6082 6322 outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.volOutputblocksperfile.text())
6083 6323 elif datatype == "Spectra":
6084 6324 outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.specOutputblocksperfile.text())
6085 6325 elif datatype == "SpectraHeis":
6086 6326 outputstr = 'Blocksperfile: %s, this must be a integer number' % str(self.specHeisOutputblocksperfile.text())
6087 6327
6088 6328 self.console.append(outputstr)
6089 6329 parms_ok = False
6090 6330 blocksperfile = None
6091 6331
6092 6332 if datatype == "SpectraHeis":
6093 6333 if metada == '':
6094 6334 outputstr = 'Choose metada file'
6095 6335 self.console.append(outputstr)
6096 6336 parms_ok = False
6097 6337 if metada != None:
6098 6338 if not os.path.isfile(metada):
6099 6339 outputstr = 'Metadata:%s does not exists' % metada
6100 6340 self.console.append(outputstr)
6101 6341 parms_ok = False
6102 6342 output_path = None
6103 6343
6104 6344 if datatype == "Voltage":
6105 6345 return parms_ok, output_path, blocksperfile, profilesperblock
6106 6346
6107 6347
6108 6348 if datatype == "Spectra":
6109 6349 return parms_ok, output_path, blocksperfile, profilesperblock
6110 6350
6111 6351
6112 6352 if datatype == "SpectraHeis":
6113 6353 return parms_ok, output_path, blocksperfile, metada
6354
6355 def searchData(self, data_path, ext, walk, expLabel=''):
6356 dateList = []
6357 fileList = []
6358
6359 if not os.path.exists(data_path):
6360 return None
6361
6362 if walk == 0:
6363 files = os.listdir(data_path)
6364 for thisFile in files:
6365 thisExt = os.path.splitext(thisFile)[-1]
6366 if thisExt == ext:
6367 fileList.append(thisFile)
6368
6369 for thisFile in fileList:
6370 try:
6371 year = int(thisFile[1:5])
6372 doy = int(thisFile[5:8])
6373
6374 date = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
6375 dateformat = date.strftime("%Y/%m/%d")
6376
6377 if dateformat not in dateList:
6378 dateList.append(dateformat)
6379 except:
6380 continue
6381 # REVISION---------------------------------1
6382 if walk == 1:
6383
6384 dirList = os.listdir(data_path)
6385
6386 dirList.sort()
6387
6388 dateList = []
6389
6390 for thisDir in dirList:
6391
6392 if not isRadarPath(thisDir):
6393 self.console.clear()
6394 self.console.append("Please, Choose the Correct Path")
6395 self.proOk.setEnabled(False)
6396 continue
6397
6398 doypath = os.path.join(data_path, thisDir, expLabel)
6399 if not os.path.exists(doypath):
6400 self.console.clear()
6401 self.console.append("Please, Choose the Correct Path")
6402 return
6403 files = os.listdir(doypath)
6404 fileList = []
6405
6406 for thisFile in files:
6407 thisExt = os.path.splitext(thisFile)[-1]
6408 if thisExt != ext:
6409 self.console.clear()
6410 self.console.append("There is no datatype selected in the Path Directory")
6411 self.proOk.setEnabled(False)
6412 continue
6413
6414 if not isRadarFile(thisFile):
6415 self.proOk.setEnabled(False)
6416 self.console.clear()
6417 self.console.append("Please, Choose the Correct Path")
6418 continue
6419
6420 fileList.append(thisFile)
6421 break
6422
6423 if fileList == []:
6424 continue
6425
6426 year = int(thisDir[1:5])
6427 doy = int(thisDir[5:8])
6428
6429 date = datetime.date(year, 1, 1) + datetime.timedelta(doy - 1)
6430 dateformat = date.strftime("%Y/%m/%d")
6431 dateList.append(dateformat)
6432
6433 if len(dateList) > 0:
6434 self.proOk.setEnabled(True)
6435 return dateList
6436
6437
6438 # self.proOk.setEnabled(False)
6439 return None
6440
6441 def findDatafiles(self, data_path, ext, walk, expLabel=''):
6442
6443 dateList = []
6444 fileList = []
6445
6446 if ext == ".r":
6447 from schainpy.model.io.jroIO_base import JRODataReader
6448
6449 readerObj = JRODataReader()
6450 dateList = readerObj.findDatafiles(path=data_path,
6451 expLabel=expLabel,
6452 ext=ext,
6453 walk=walk)
6454
6455 if ext == ".pdata":
6456 from schainpy.model.io.jroIO_base import JRODataReader
6457
6458 readerObj = JRODataReader()
6459 dateList = readerObj.findDatafiles(path=data_path,
6460 expLabel=expLabel,
6461 ext=ext,
6462 walk=walk)
6463
6464 if ext == ".fits":
6465 from schainpy.model.io.jroIO_base import JRODataReader
6466
6467 readerObj = JRODataReader()
6468 dateList = readerObj.findDatafiles(path=data_path,
6469 expLabel=expLabel,
6470 ext=ext,
6471 walk=walk)
6472
6473 if ext == ".hdf5":
6474 from schainpy.model.io.jroIO_usrp import USRPReader
6475
6476 readerObj = USRPReader()
6477 dateList = readerObj.findDatafiles(path=data_path)
6478
6479 return dateList
6114 6480
6115 def loadDays(self, data_path, ext, walk):
6481 def loadDays(self, data_path, ext, walk, expLabel=''):
6116 6482 """
6117 6483 Method to loads day
6118 6484 """
6119 dateList = self.searchData(data_path, ext, walk)
6120 if dateList == None:
6485 self.proOk.setEnabled(False)
6486 self.dateList = []
6487
6488 dateList = self.findDatafiles(data_path, ext=ext, walk=walk, expLabel=expLabel)
6489
6490 if not dateList:
6121 6491 self.console.clear()
6122 6492 outputstr = "The path: %s is empty with file extension *%s" % (data_path, ext)
6123 6493 self.console.append(outputstr)
6124 6494 return
6125 6495
6126 self.dateList = dateList
6496 dateStrList = []
6127 6497 for thisDate in dateList:
6128 self.proComStartDate.addItem(thisDate)
6129 self.proComEndDate.addItem(thisDate)
6498 dateStr = thisDate.strftime("%Y/%m/%d")
6499
6500 self.proComStartDate.addItem(dateStr)
6501 self.proComEndDate.addItem(dateStr)
6502 dateStrList.append(dateStr)
6503
6130 6504 self.proComEndDate.setCurrentIndex(self.proComStartDate.count() - 1)
6131 6505
6132 def setWorkSpaceGUI(self, pathWorkSpace):
6133 self.pathWorkSpace = pathWorkSpace
6506 self.dateList = dateStrList
6507 self.proOk.setEnabled(True)
6508
6509 return self.dateList
6510
6511 def setWorkSpaceGUI(self, pathWorkSpace=None):
6512
6513 if pathWorkSpace == None:
6514 home = os.path.expanduser("~")
6515 pathWorkSpace = os.path.join(home,'schain_workspace')
6516
6517 self.pathWorkSpace = pathWorkSpace
6134 6518
6135 6519 """
6136 6520 Comandos Usados en Console
6137 6521 """
6138 6522 def __del__(self):
6139 6523 sys.stdout = sys.__stdout__
6140 6524 sys.stderr = sys.__stderr__
6141 6525
6142 6526 def normalOutputWritten(self, text):
6143 6527 color_black = QtGui.QColor(0,0,0)
6144 6528 self.console.setTextColor(color_black)
6145 6529 self.console.append(text)
6146 6530
6147 6531 def errorOutputWritten(self, text):
6148 6532 color_red = QtGui.QColor(255,0,0)
6149 6533 color_black = QtGui.QColor(0,0,0)
6150 6534
6151 6535 self.console.setTextColor(color_red)
6152 6536 self.console.append(text)
6153 6537 self.console.setTextColor(color_black)
6154 6538
6155 6539 def setParameter(self):
6156 6540
6157 6541 self.setWindowTitle("ROJ-Signal Chain")
6158 6542 self.setWindowIcon(QtGui.QIcon( os.path.join(FIGURES_PATH,"adn.jpg") ))
6159 6543
6160 6544 self.tabWidgetProject.setEnabled(False)
6161 6545 self.tabVoltage.setEnabled(False)
6162 6546 self.tabSpectra.setEnabled(False)
6163 6547 self.tabCorrelation.setEnabled(False)
6164 6548 self.frame_2.setEnabled(False)
6165 6549
6166 6550 self.actionCreate.setShortcut('Ctrl+N')
6167 6551 self.actionOpen.setShortcut('Ctrl+O')
6168 6552 self.actionSave.setShortcut('Ctrl+S')
6169 6553 self.actionClose.setShortcut('Ctrl+X')
6170 6554
6171 6555 self.actionStart.setShortcut('Ctrl+1')
6172 6556 self.actionPause.setShortcut('Ctrl+2')
6173 6557 self.actionStop.setShortcut('Ctrl+3')
6174 6558
6175 6559 self.actionFTP.setShortcut('Ctrl+F')
6176
6560
6561 self.actionStart.setEnabled(False)
6562 self.actionPause.setEnabled(False)
6563 self.actionStop.setEnabled(False)
6564
6177 6565 self.actionStarToolbar.setEnabled(False)
6178 6566 self.actionPauseToolbar.setEnabled(False)
6179 6567 self.actionStopToolbar.setEnabled(False)
6180 6568
6181 6569 self.proName.clear()
6182 6570 self.proDataPath.setText('')
6183 6571 self.console.setReadOnly(True)
6184 6572 self.console.append("Welcome to Signal Chain\nOpen a project or Create a new one")
6185 6573 self.proStartTime.setDisplayFormat("hh:mm:ss")
6186 6574 self.proDataType.setEnabled(False)
6187 6575 self.time = QtCore.QTime()
6188 6576 self.hour = 0
6189 6577 self.min = 0
6190 6578 self.sec = 0
6191 6579 self.proEndTime.setDisplayFormat("hh:mm:ss")
6192 6580 startTime = "00:00:00"
6193 6581 endTime = "23:59:59"
6194 6582 starlist = startTime.split(":")
6195 6583 endlist = endTime.split(":")
6196 6584 self.time.setHMS(int(starlist[0]), int(starlist[1]), int(starlist[2]))
6197 6585 self.proStartTime.setTime(self.time)
6198 6586 self.time.setHMS(int(endlist[0]), int(endlist[1]), int(endlist[2]))
6199 6587 self.proEndTime.setTime(self.time)
6200 6588 self.proOk.setEnabled(False)
6201 6589 # set model Project Explorer
6202 6590 self.projectExplorerModel = QtGui.QStandardItemModel()
6203 6591 self.projectExplorerModel.setHorizontalHeaderLabels(("Project Explorer",))
6204 6592 layout = QtGui.QVBoxLayout()
6205 6593 layout.addWidget(self.projectExplorerTree)
6206 6594 self.projectExplorerTree.setModel(self.projectExplorerModel)
6207 6595 self.projectExplorerTree.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
6208 6596 self.projectExplorerTree.customContextMenuRequested.connect(self.on_right_click)
6209 6597 self.projectExplorerTree.clicked.connect(self.on_click)
6210 6598 self.projectExplorerTree.expandAll()
6211 6599 # set model Project Properties
6212 6600
6213 self.propertiesModel = treeModel()
6601 self.propertiesModel = TreeModel()
6214 6602 self.propertiesModel.initProjectView()
6215 6603 self.treeProjectProperties.setModel(self.propertiesModel)
6216 6604 self.treeProjectProperties.expandAll()
6217 6605 self.treeProjectProperties.allColumnsShowFocus()
6218 6606 self.treeProjectProperties.resizeColumnToContents(1)
6219 6607
6220 6608 # set Project
6221 6609 self.proDelay.setEnabled(False)
6222 6610 self.proSet.setEnabled(False)
6223 6611 self.proDataType.setReadOnly(True)
6224 6612
6225 6613 # set Operation Voltage
6226 6614 self.volOpComChannels.setEnabled(False)
6227 6615 self.volOpComHeights.setEnabled(False)
6228 6616 self.volOpFilter.setEnabled(False)
6229 6617 self.volOpComProfile.setEnabled(False)
6230 6618 self.volOpComCode.setEnabled(False)
6231 6619 self.volOpFlip.setEnabled(False)
6232 6620 self.volOpCohInt.setEnabled(False)
6233 6621 self.volOpRadarfrequency.setEnabled(False)
6234 6622
6235 6623 self.volOpChannel.setEnabled(False)
6236 6624 self.volOpHeights.setEnabled(False)
6237 6625 self.volOpProfile.setEnabled(False)
6238 6626 self.volOpComMode.setEnabled(False)
6239 6627
6240 6628 self.volGraphPath.setEnabled(False)
6241 6629 self.volGraphPrefix.setEnabled(False)
6242 6630 self.volGraphToolPath.setEnabled(False)
6243 6631
6244 6632 # set Graph Voltage
6245 6633 self.volGraphChannelList.setEnabled(False)
6246 6634 self.volGraphfreqrange.setEnabled(False)
6247 6635 self.volGraphHeightrange.setEnabled(False)
6248 6636
6249 6637 # set Operation Spectra
6250 6638 self.specOpnFFTpoints.setEnabled(False)
6251 6639 self.specOpProfiles.setEnabled(False)
6252 6640 self.specOpippFactor.setEnabled(False)
6253 6641 self.specOppairsList.setEnabled(False)
6254 6642 self.specOpComChannel.setEnabled(False)
6255 6643 self.specOpComHeights.setEnabled(False)
6256 6644 self.specOpIncoherent.setEnabled(False)
6257 6645 self.specOpgetNoise.setEnabled(False)
6258 6646 self.specOpRadarfrequency.setEnabled(False)
6259 6647
6260 6648
6261 6649 self.specOpChannel.setEnabled(False)
6262 6650 self.specOpHeights.setEnabled(False)
6263 6651 # set Graph Spectra
6264 6652 self.specGgraphChannelList.setEnabled(False)
6265 6653 self.specGgraphFreq.setEnabled(False)
6266 6654 self.specGgraphHeight.setEnabled(False)
6267 6655 self.specGgraphDbsrange.setEnabled(False)
6268 6656 self.specGgraphmagnitud.setEnabled(False)
6269 6657 self.specGgraphTminTmax.setEnabled(False)
6270 6658 self.specGgraphTimeRange.setEnabled(False)
6271 6659 self.specGraphPath.setEnabled(False)
6272 6660 self.specGraphToolPath.setEnabled(False)
6273 6661 self.specGraphPrefix.setEnabled(False)
6274 6662
6275 6663 self.specGgraphftpratio.setEnabled(False)
6276 6664 # set Operation SpectraHeis
6277 6665 self.specHeisOpIncoherent.setEnabled(False)
6278 6666 self.specHeisOpCobIncInt.setEnabled(False)
6279 6667 # set Graph SpectraHeis
6280 6668 self.specHeisGgraphChannelList.setEnabled(False)
6281 6669 self.specHeisGgraphXminXmax.setEnabled(False)
6282 6670 self.specHeisGgraphYminYmax.setEnabled(False)
6283 6671 self.specHeisGgraphTminTmax.setEnabled(False)
6284 6672 self.specHeisGgraphTimeRange.setEnabled(False)
6285 6673 self.specHeisGgraphftpratio.setEnabled(False)
6286 6674 self.specHeisGraphPath.setEnabled(False)
6287 6675 self.specHeisGraphPrefix.setEnabled(False)
6288 6676 self.specHeisGraphToolPath.setEnabled(False)
6289 6677
6290 6678
6291 6679 # tool tip gui
6292 6680 QtGui.QToolTip.setFont(QtGui.QFont('SansSerif', 10))
6293 6681 self.projectExplorerTree.setToolTip('Right clik to add Project or Unit Process')
6294 6682 # tool tip gui project
6295 6683 self.proComWalk.setToolTip('<b>On Files</b>:<i>Search file in format .r or pdata</i> <b>On Folders</b>:<i>Search file in a directory DYYYYDOY</i>')
6296 6684 self.proComWalk.setCurrentIndex(0)
6297 6685 # tool tip gui volOp
6298 6686 self.volOpChannel.setToolTip('Example: 1,2,3,4,5')
6299 6687 self.volOpHeights.setToolTip('Example: 90,180')
6300 6688 self.volOpFilter.setToolTip('Example: 2')
6301 6689 self.volOpProfile.setToolTip('Example:0,127')
6302 6690 self.volOpCohInt.setToolTip('Example: 128')
6303 6691 self.volOpFlip.setToolTip('ChannelList where flip will be applied. Example: 0,2,3')
6304 6692 self.volOpOk.setToolTip('If you have finished, please Ok ')
6305 6693 # tool tip gui volGraph
6306 6694 self.volGraphfreqrange.setToolTip('Example: -30,30')
6307 6695 self.volGraphHeightrange.setToolTip('Example: 20,180')
6308 6696 # tool tip gui specOp
6309 6697 self.specOpnFFTpoints.setToolTip('Example: 128')
6310 6698 self.specOpProfiles.setToolTip('Example: 128')
6311 6699 self.specOpippFactor.setToolTip('Example:1.0')
6312 6700 self.specOpIncoherent.setToolTip('Example: 10')
6313 6701 self.specOpgetNoise.setToolTip('Example:20,180,30,120 (minHei,maxHei,minVel,maxVel)')
6314 6702
6315 6703 self.specOpChannel.setToolTip('Example: 0,1,2,3')
6316 6704 self.specOpHeights.setToolTip('Example: 90,180')
6317 6705 self.specOppairsList.setToolTip('Example: (0,1),(2,3)')
6318 6706 # tool tip gui specGraph
6319 6707
6320 6708 self.specGgraphChannelList.setToolTip('Example: 0,3,4')
6321 6709 self.specGgraphFreq.setToolTip('Example: -20,20')
6322 6710 self.specGgraphHeight.setToolTip('Example: 100,400')
6323 6711 self.specGgraphDbsrange.setToolTip('Example: 30,170')
6324 6712
6325 6713 self.specGraphPrefix.setToolTip('Example: EXPERIMENT_NAME')
6326 6714
6327 6715 sys.stdout = ShowMeConsole(textWritten=self.normalOutputWritten)
6328 sys.stderr = ShowMeConsole(textWritten=self.errorOutputWritten)
6716 # sys.stderr = ShowMeConsole(textWritten=self.errorOutputWritten)
6329 6717
6330 6718
6331 6719 class UnitProcessWindow(QMainWindow, Ui_UnitProcess):
6332 6720 """
6333 6721 Class documentation goes here.
6334 6722 """
6335 6723 closed = pyqtSignal()
6336 6724 create = False
6337 6725
6338 6726 def __init__(self, parent=None):
6339 6727 """
6340 6728 Constructor
6341 6729 """
6342 6730 QMainWindow.__init__(self, parent)
6343 6731 self.setupUi(self)
6344 6732 self.getFromWindow = None
6345 6733 self.getfromWindowList = []
6346 6734 self.dataTypeProject = None
6347 6735
6348 6736 self.listUP = None
6349 6737
6350 6738 @pyqtSignature("")
6351 6739 def on_unitPokbut_clicked(self):
6352 6740 """
6353 6741 Slot documentation goes here.
6354 6742 """
6355 6743 self.create = True
6356 6744 self.getFromWindow = self.getfromWindowList[int(self.comboInputBox.currentIndex())]
6357 6745 # self.nameofUP= str(self.nameUptxt.text())
6358 6746 self.typeofUP = str(self.comboTypeBox.currentText())
6359 6747 self.close()
6360 6748
6361 6749
6362 6750 @pyqtSignature("")
6363 6751 def on_unitPcancelbut_clicked(self):
6364 6752 """
6365 6753 Slot documentation goes here.
6366 6754 """
6367 6755 self.create = False
6368 6756 self.close()
6369 6757
6370 6758 def loadTotalList(self):
6371 6759 self.comboInputBox.clear()
6372 6760 for i in self.getfromWindowList:
6373 6761
6374 6762 name = i.getElementName()
6375 6763 if name == 'Project':
6376 6764 id = i.id
6377 6765 name = i.name
6378 6766 if self.dataTypeProject == 'Voltage':
6379 6767 self.comboTypeBox.clear()
6380 6768 self.comboTypeBox.addItem("Voltage")
6381 6769
6382 6770 if self.dataTypeProject == 'Spectra':
6383 6771 self.comboTypeBox.clear()
6384 6772 self.comboTypeBox.addItem("Spectra")
6385 6773 self.comboTypeBox.addItem("Correlation")
6386 6774 if self.dataTypeProject == 'Fits':
6387 6775 self.comboTypeBox.clear()
6388 6776 self.comboTypeBox.addItem("SpectraHeis")
6389 6777
6390 6778
6391 6779 if name == 'ProcUnit':
6392 6780 id = int(i.id) - 1
6393 6781 name = i.datatype
6394 6782 if name == 'Voltage':
6395 6783 self.comboTypeBox.clear()
6396 6784 self.comboTypeBox.addItem("Spectra")
6397 6785 self.comboTypeBox.addItem("SpectraHeis")
6398 6786 self.comboTypeBox.addItem("Correlation")
6399 6787 if name == 'Spectra':
6400 6788 self.comboTypeBox.clear()
6401 6789 self.comboTypeBox.addItem("Spectra")
6402 6790 self.comboTypeBox.addItem("SpectraHeis")
6403 6791 self.comboTypeBox.addItem("Correlation")
6404 6792 if name == 'SpectraHeis':
6405 6793 self.comboTypeBox.clear()
6406 6794 self.comboTypeBox.addItem("SpectraHeis")
6407 6795
6408 6796 self.comboInputBox.addItem(str(name))
6409 6797 # self.comboInputBox.addItem(str(name)+str(id))
6410 6798
6411 6799 def closeEvent(self, event):
6412 6800 self.closed.emit()
6413 6801 event.accept()
6414 6802
6415 6803 class Ftp(QMainWindow, Ui_Ftp):
6416 6804 """
6417 6805 Class documentation goes here.
6418 6806 """
6419 6807 create = False
6420 6808 closed = pyqtSignal()
6421 6809 server = None
6422 6810 folder = None
6423 6811 username = None
6424 6812 password = None
6425 6813 ftp_wei = None
6426 6814 exp_code = None
6427 6815 sub_exp_code = None
6428 6816 plot_pos = None
6429 6817
6430 6818 def __init__(self, parent=None):
6431 6819 """
6432 6820 Constructor
6433 6821 """
6434 6822 QMainWindow.__init__(self, parent)
6435 6823 self.setupUi(self)
6436 6824 self.setParameter()
6437 6825
6438 6826 def setParameter(self):
6439 6827 self.setWindowTitle("ROJ-Signal Chain")
6440 6828 self.serverFTP.setToolTip('Example: jro-app.igp.gob.pe')
6441 6829 self.folderFTP.setToolTip('Example: /home/wmaster/graficos')
6442 6830 self.usernameFTP.setToolTip('Example: myusername')
6443 6831 self.passwordFTP.setToolTip('Example: mypass ')
6444 6832 self.weightFTP.setToolTip('Example: 0')
6445 6833 self.expcodeFTP.setToolTip('Example: 0')
6446 6834 self.subexpFTP.setToolTip('Example: 0')
6447 6835 self.plotposFTP.setToolTip('Example: 0')
6448 6836
6449 6837 def setParmsfromTemporal(self, server, folder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos):
6450 6838 self.serverFTP.setText(str(server))
6451 6839 self.folderFTP.setText(str(folder))
6452 6840 self.usernameFTP.setText(str(username))
6453 6841 self.passwordFTP.setText(str(password))
6454 6842 self.weightFTP.setText(str(ftp_wei))
6455 6843 self.expcodeFTP.setText(str(exp_code))
6456 6844 self.subexpFTP.setText(str(sub_exp_code))
6457 6845 self.plotposFTP.setText(str(plot_pos))
6458 6846
6459 6847 def getParmsFromFtpWindow(self):
6460 6848 """
6461 6849 Return Inputs Project:
6462 6850 - server
6463 6851 - folder
6464 6852 - username
6465 6853 - password
6466 6854 - ftp_wei
6467 6855 - exp_code
6468 6856 - sub_exp_code
6469 6857 - plot_pos
6470 6858 """
6471 6859 name_server_ftp = str(self.serverFTP.text())
6472 6860 try:
6473 6861 name = str(self.serverFTP.text())
6474 6862 except:
6475 6863 self.console.clear()
6476 6864 self.console.append("Please Write a FTP Server")
6477 6865 return 0
6478 6866
6479 6867 folder_server_ftp = str(self.folderFTP.text())
6480 6868 try:
6481 6869 folder = str(self.folderFTP.text())
6482 6870 except:
6483 6871 self.console.clear()
6484 6872 self.console.append("Please Write a Folder")
6485 6873 return 0
6486 6874
6487 6875 username_ftp = str(self.usernameFTP.text())
6488 6876 try:
6489 6877 username = str(self.usernameFTP.text())
6490 6878 except:
6491 6879 self.console.clear()
6492 6880 self.console.append("Please Write a User Name")
6493 6881 return 0
6494 6882
6495 6883 password_ftp = str(self.passwordFTP.text())
6496 6884 try:
6497 6885 password = str(self.passwordFTP.text())
6498 6886 except:
6499 6887 self.console.clear()
6500 6888 self.console.append("Please Write a passwordFTP")
6501 6889 return 0
6502 6890
6503 6891 ftp_wei = self.weightFTP.text()
6504 6892 if not ftp_wei == "":
6505 6893 try:
6506 6894 ftp_wei = int(self.weightFTP.text())
6507 6895 except:
6508 6896 self.console.clear()
6509 6897 self.console.append("Please Write a ftp_wei number")
6510 6898 return 0
6511 6899
6512 6900 exp_code = self.expcodeFTP.text()
6513 6901 if not exp_code == "":
6514 6902 try:
6515 6903 exp_code = int(self.expcodeFTP.text())
6516 6904 except:
6517 6905 self.console.clear()
6518 6906 self.console.append("Please Write a exp_code number")
6519 6907 return 0
6520 6908
6521 6909
6522 6910 sub_exp_code = self.subexpFTP.text()
6523 6911 if not sub_exp_code == "":
6524 6912 try:
6525 6913 sub_exp_code = int(self.subexpFTP.text())
6526 6914 except:
6527 6915 self.console.clear()
6528 6916 self.console.append("Please Write a sub_exp_code number")
6529 6917 return 0
6530 6918
6531 6919 plot_pos = self.plotposFTP.text()
6532 6920 if not plot_pos == "":
6533 6921 try:
6534 6922 plot_pos = int(self.plotposFTP.text())
6535 6923 except:
6536 6924 self.console.clear()
6537 6925 self.console.append("Please Write a plot_pos number")
6538 6926 return 0
6539 6927
6540 6928 return name_server_ftp, folder_server_ftp, username_ftp, password_ftp, ftp_wei, exp_code, sub_exp_code, plot_pos
6541 6929
6542 6930 @pyqtSignature("")
6543 6931 def on_ftpOkButton_clicked(self):
6544 6932 server, folder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos = self.getParmsFromFtpWindow()
6545 6933 self.create = True
6546 6934 self.close()
6547 6935
6548 6936 @pyqtSignature("")
6549 6937 def on_ftpCancelButton_clicked(self):
6550 6938 self.create = False
6551 6939 self.close()
6552 6940
6553 6941 def closeEvent(self, event):
6554 6942 self.closed.emit()
6555 6943 event.accept()
6556 6944
6557 6945 class ftpBuffer():
6558 6946 server = None
6559 6947 folder = None
6560 6948 username = None
6561 6949 password = None
6562 6950 ftp_wei = None
6563 6951 exp_code = None
6564 6952 sub_exp_code = None
6565 6953 plot_pos = None
6566 6954 create = False
6567 6955 withoutconfig = False
6568 6956 createforView = False
6569 6957 localfolder = None
6570 6958 extension = None
6571 6959 period = None
6572 6960 protocol = None
6573 6961
6574 6962 def __init__(self):
6575 6963
6576 6964 self.create = False
6577 6965 self.server = None
6578 6966 self.folder = None
6579 6967 self.username = None
6580 6968 self.password = None
6581 6969 self.ftp_wei = None
6582 6970 self.exp_code = None
6583 6971 self.sub_exp_code = None
6584 6972 self.plot_pos = None
6585 6973 # self.create = False
6586 6974 self.localfolder = None
6587 6975 self.extension = None
6588 6976 self.period = None
6589 6977 self.protocol = None
6590 6978
6591 6979 def setwithoutconfiguration(self):
6592 6980
6593 6981 self.create = False
6594 6982 self.server = "jro-app.igp.gob.pe"
6595 6983 self.folder = "/home/wmaster/graficos"
6596 6984 self.username = "wmaster"
6597 6985 self.password = "mst2010vhf"
6598 6986 self.ftp_wei = "0"
6599 6987 self.exp_code = "0"
6600 6988 self.sub_exp_code = "0"
6601 6989 self.plot_pos = "0"
6602 6990 self.withoutconfig = True
6603 6991 self.localfolder = './'
6604 6992 self.extension = '.png'
6605 6993 self.period = '60'
6606 6994 self.protocol = 'ftp'
6607 6995 self.createforView = True
6608 6996
6609 6997 def save(self, server, folder, username, password, ftp_wei, exp_code, sub_exp_code, plot_pos, localfolder='./', extension='.png', period='60', protocol='ftp'):
6610 6998
6611 6999 self.server = server
6612 7000 self.folder = folder
6613 7001 self.username = username
6614 7002 self.password = password
6615 7003 self.ftp_wei = ftp_wei
6616 7004 self.exp_code = exp_code
6617 7005 self.sub_exp_code = sub_exp_code
6618 7006 self.plot_pos = plot_pos
6619 7007 self.create = True
6620 7008 self.withoutconfig = False
6621 7009 self.createforView = True
6622 7010 self.localfolder = localfolder
6623 7011
6624 7012
6625 7013 def recover(self):
6626 7014
6627 7015 return self.server, self.folder, self.username, self.password, self.ftp_wei, self.exp_code, self.sub_exp_code, self.plot_pos
6628 7016
6629 7017 class ShowMeConsole(QtCore.QObject):
6630 7018 textWritten = QtCore.pyqtSignal(str)
6631 7019 def write (self, text):
6632 7020 self.textWritten.emit(str(text))
6633 7021
6634 7022 class PlotManager():
6635 7023 def __init__(self, queue):
6636 7024 self.queue = queue
6637 7025 self.objPlotDict = {}
6638 7026
6639 7027 def processIncoming(self):
6640 7028 while self.queue.qsize():
6641 7029 try:
6642 7030 dataFromQueue = self.queue.get(True)
6643 7031 if dataFromQueue == None:
6644 7032 continue
6645 7033
6646 7034 dataPlot = dataFromQueue['data']
6647 7035 kwargs = dataFromQueue['kwargs']
6648 7036 id = kwargs['id']
6649 7037 if 'channelList' in kwargs.keys():
6650 7038 channelList = kwargs['channelList']
6651 7039 else:
6652 7040 channelList = None
6653 7041 plotname = kwargs.pop('type')
6654 7042
6655 7043 if not(id in self.objPlotDict.keys()):
6656 7044 className = eval(plotname)
6657 7045 self.objPlotDict[id] = className(id, channelList, dataPlot)
6658 7046 self.objPlotDict[id].show()
6659 7047
6660 7048 self.objPlotDict[id].run(dataPlot , **kwargs)
6661 7049
6662 7050 except Queue.Empty:
6663 7051 pass
6664 7052
6665 7053
Show file before | Show file after | Hide comments
@@ -1,115 +1,125
1 1 import threading
2 2 import Queue
3 3 try:
4 4 from gevent import sleep
5 5 except:
6 6 from time import sleep
7 7
8 8 from schainpy.controller import Project
9 9 from command import *
10 10
11 11 class ControllerThread(threading.Thread):
12
12 13 def __init__(self, filename, data_q=None):
14
13 15 super(ControllerThread, self).__init__()
16 self.setDaemon(True)
17
14 18 self.filename = filename
15 19 self.data_q = data_q
16 20 self.control = {'stop':False,'pause':False}
17 21
18 22 def stop(self):
19 23 self.control['stop'] = True
20 24
21 25 def pause(self):
22 26 self.control['pause'] = not(self.control['pause'])
23 27
24 28 def run(self):
25 29 self.control['stop'] = False
26 30 self.control['pause'] = False
27 31 self.controllerObj = Project(self.control, self.data_q)
28 32 self.controllerObj.readXml(self.filename)
29 33 self.controllerObj.createObjects()
30 34 self.controllerObj.connectObjects()
31 35 self.controllerObj.run()
32 36
33 37 class CommCtrlProcessThread(threading.Thread):
34 38 """ Implements the threading.Thread interface (start, join, etc.) and
35 39 can be controlled via the cmd_q Queue attribute. Replies are placed in
36 40 the reply_q Queue attribute.
37 41 """
38 42 def __init__(self, cmd_q=Queue.Queue(), reply_q=Queue.Queue()):
39 43 super(CommCtrlProcessThread, self).__init__()
40 44 self.cmd_q = cmd_q
41 45 # self.reply_q = reply_q
42 46
43 47 # self.print_q = Queue.Queue()
44 48 # self.data_q = Queue.Queue()
45 49
46 50
47 51 self.alive = threading.Event()
48 52 self.setDaemon(True)
49 53 self.alive.set()
50 54 self.socket = None
51 55
52 56 self.socketIO = None
53 57 self.mySocket = None
54 58
55 59 self.controllerObj = None
56 60
57 61 self.handlers = {
58 62 ProcessCommand.PROCESS: self._handle_ioPROCESSTHREAD,
59 63 ProcessCommand.MESSAGE: self._handle_ioMESSAGE,
60 64 ProcessCommand.DATA: self._handle_ioDATA,
61 65 ProcessCommand.STOP: self._handle_ioSTOP,
62 66 ProcessCommand.PAUSE: self._handle_ioPAUSE
63 67 }
64 68
65 69 def run(self):
66 70
67 71 while self.alive.isSet():
68 72 try:
69 73 cmd = self.cmd_q.get(True, 0.1)
70 74 self.handlers[cmd.type](cmd)
71 75 except Queue.Empty as e:
72 sleep(0.1)
73 76 continue
74 77
75 78 def isRunning(self):
76 79
77 80 if self.controllerObj == None:
78 81 return False
79 82
80 83 if self.controllerObj.isAlive():
81 84 return True
82 85
83 86 return False
84 87
85 88 def _handle_ioPROCESSTHREAD(self, cmd):
86 89 filename = cmd.data
87 90 self.controllerObj = ControllerThread(filename=filename)
88 91 self.controllerObj.start()
89 92
90 93 def _handle_ioPAUSE(self, cmd):
91 94 self.controllerObj.pause()
92 95
93 96 def _handle_ioSTOP(self, cmd):
94 97 self.controllerObj.stop()
98
99 while self.controllerObj.isAlive():
100 self.console.clear()
101 self.console.append("Close graphics before continue...")
102 sleep(0.1)
103
104
95 105 self.controllerObj.join()
96 106 # print "Process thread finished"
97 107
98 108 def _handle_ioDATA(self, cmd):
99 109 self.reply_q.put(self._success_reply_data(data=cmd.data))
100 110
101 111 def _handle_ioMESSAGE(self, cmd):
102 112 self.reply_q.put(self._success_reply_message(data=cmd.data))
103 113
104 114 def _success_reply_data(self, data=None):
105 115 return ClientReply(ClientReply.DATA, data)
106 116
107 117 def _success_reply_message(self, data=None):
108 118 return ClientReply(ClientReply.MESSAGE, data)
109 119
110 120 def join(self, timeout=None):
111 121 self.alive.clear()
112 122 threading.Thread.join(self, timeout)
113 123
114 124
115 125 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,171 +1,173
1 1
2 2 from PyQt4 import QtCore, QtGui
3 3
4 4 try:
5 5 _fromUtf8 = QtCore.QString.fromUtf8
6 6 except AttributeError:
7 7 def _fromUtf8(s):
8 8 return s
9 9
10 10 try:
11 11 _encoding = QtGui.QApplication.UnicodeUTF8
12 12 def _translate(context, text, disambig):
13 13 return QtGui.QApplication.translate(context, text, disambig, _encoding)
14 14 except AttributeError:
15 15 def _translate(context, text, disambig):
16 16 return QtGui.QApplication.translate(context, text, disambig)
17 17
18 18 class Ui_ProjectTab(object):
19 19
20 20 def setupUi(self):
21 21
22 22 self.tabProject = QtGui.QWidget()
23 23 self.tabProject.setObjectName(_fromUtf8("tabProject"))
24 24 self.gridLayout_15 = QtGui.QGridLayout(self.tabProject)
25 25 self.gridLayout_15.setObjectName(_fromUtf8("gridLayout_15"))
26 26 self.frame = QtGui.QFrame(self.tabProject)
27 27 self.frame.setFrameShape(QtGui.QFrame.StyledPanel)
28 28 self.frame.setFrameShadow(QtGui.QFrame.Raised)
29 29 self.frame.setObjectName(_fromUtf8("frame"))
30 30 self.gridLayout_2 = QtGui.QGridLayout(self.frame)
31 31 self.gridLayout_2.setObjectName(_fromUtf8("gridLayout_2"))
32 32 self.label = QtGui.QLabel(self.frame)
33 33 self.label.setObjectName(_fromUtf8("label"))
34 34 self.gridLayout_2.addWidget(self.label, 0, 0, 1, 1)
35 35 self.proName = QtGui.QLineEdit(self.frame)
36 36 self.proName.setObjectName(_fromUtf8("proName"))
37 37 self.gridLayout_2.addWidget(self.proName, 0, 1, 1, 8)
38 38 self.label_11 = QtGui.QLabel(self.frame)
39 39 self.label_11.setObjectName(_fromUtf8("label_11"))
40 40 self.gridLayout_2.addWidget(self.label_11, 1, 0, 1, 1)
41 41 self.proComDataType = QtGui.QComboBox(self.frame)
42 42 self.proComDataType.setObjectName(_fromUtf8("proComDataType"))
43 43 self.proComDataType.addItem(_fromUtf8(""))
44 44 self.proComDataType.addItem(_fromUtf8(""))
45 45 self.proComDataType.addItem(_fromUtf8(""))
46 self.proComDataType.addItem(_fromUtf8(""))
46 47 self.gridLayout_2.addWidget(self.proComDataType, 1, 1, 1, 5)
47 48 self.proDataType = QtGui.QLineEdit(self.frame)
48 49 self.proDataType.setObjectName(_fromUtf8("proDataType"))
49 50 self.gridLayout_2.addWidget(self.proDataType, 1, 6, 1, 3)
50 51 self.label_15 = QtGui.QLabel(self.frame)
51 52 self.label_15.setObjectName(_fromUtf8("label_15"))
52 53 self.gridLayout_2.addWidget(self.label_15, 2, 0, 1, 1)
53 54 self.proToolPath = QtGui.QToolButton(self.frame)
54 55 self.proToolPath.setObjectName(_fromUtf8("proToolPath"))
55 56 self.gridLayout_2.addWidget(self.proToolPath, 2, 1, 1, 1)
56 57 self.proDataPath = QtGui.QLineEdit(self.frame)
57 58 self.proDataPath.setObjectName(_fromUtf8("proDataPath"))
58 59 self.gridLayout_2.addWidget(self.proDataPath, 2, 2, 1, 7)
59 60 self.label_23 = QtGui.QLabel(self.frame)
60 61 self.label_23.setObjectName(_fromUtf8("label_23"))
61 62 self.gridLayout_2.addWidget(self.label_23, 3, 0, 1, 1)
62 63 self.proComReadMode = QtGui.QComboBox(self.frame)
63 64 self.proComReadMode.setObjectName(_fromUtf8("proComReadMode"))
64 65 self.proComReadMode.addItem(_fromUtf8(""))
65 66 self.proComReadMode.addItem(_fromUtf8(""))
66 67 self.gridLayout_2.addWidget(self.proComReadMode, 3, 1, 1, 2)
67 68 self.label_33 = QtGui.QLabel(self.frame)
68 69 self.label_33.setObjectName(_fromUtf8("label_33"))
69 70 self.gridLayout_2.addWidget(self.label_33, 3, 5, 1, 2)
70 71 self.proDelay = QtGui.QLineEdit(self.frame)
71 72 self.proDelay.setObjectName(_fromUtf8("proDelay"))
72 73 self.gridLayout_2.addWidget(self.proDelay, 3, 8, 1, 1)
73 74 self.label_32 = QtGui.QLabel(self.frame)
74 75 self.label_32.setObjectName(_fromUtf8("label_32"))
75 76 self.gridLayout_2.addWidget(self.label_32, 4, 0, 1, 1)
76 77 self.proComWalk = QtGui.QComboBox(self.frame)
77 78 self.proComWalk.setObjectName(_fromUtf8("proComWalk"))
78 79 self.proComWalk.addItem(_fromUtf8(""))
79 80 self.proComWalk.addItem(_fromUtf8(""))
80 81 self.gridLayout_2.addWidget(self.proComWalk, 4, 1, 1, 8)
81 82 self.proLoadButton = QtGui.QPushButton(self.frame)
82 83 self.proLoadButton.setObjectName(_fromUtf8("proLoadButton"))
83 84 self.gridLayout_2.addWidget(self.proLoadButton, 5, 0, 1, 9)
84 85 self.label_10 = QtGui.QLabel(self.frame)
85 86 self.label_10.setObjectName(_fromUtf8("label_10"))
86 87 self.gridLayout_2.addWidget(self.label_10, 3, 3, 1, 1)
87 88 self.proSet = QtGui.QLineEdit(self.frame)
88 89 self.proSet.setObjectName(_fromUtf8("proSet"))
89 90 self.gridLayout_2.addWidget(self.proSet, 3, 4, 1, 1)
90 91 self.gridLayout_15.addWidget(self.frame, 0, 0, 1, 1)
91 92 self.frame_2 = QtGui.QFrame(self.tabProject)
92 93 self.frame_2.setFrameShape(QtGui.QFrame.StyledPanel)
93 94 self.frame_2.setFrameShadow(QtGui.QFrame.Raised)
94 95 self.frame_2.setObjectName(_fromUtf8("frame_2"))
95 96 self.gridLayout_10 = QtGui.QGridLayout(self.frame_2)
96 97 self.gridLayout_10.setObjectName(_fromUtf8("gridLayout_10"))
97 98 self.label_27 = QtGui.QLabel(self.frame_2)
98 99 self.label_27.setObjectName(_fromUtf8("label_27"))
99 100 self.gridLayout_10.addWidget(self.label_27, 0, 0, 1, 1)
100 101 self.proComStartDate = QtGui.QComboBox(self.frame_2)
101 102 self.proComStartDate.setObjectName(_fromUtf8("proComStartDate"))
102 103 self.gridLayout_10.addWidget(self.proComStartDate, 0, 1, 1, 1)
103 104 self.label_28 = QtGui.QLabel(self.frame_2)
104 105 self.label_28.setObjectName(_fromUtf8("label_28"))
105 106 self.gridLayout_10.addWidget(self.label_28, 1, 0, 1, 1)
106 107 self.proComEndDate = QtGui.QComboBox(self.frame_2)
107 108 self.proComEndDate.setObjectName(_fromUtf8("proComEndDate"))
108 109 self.gridLayout_10.addWidget(self.proComEndDate, 1, 1, 1, 1)
109 110 self.label_2 = QtGui.QLabel(self.frame_2)
110 111 self.label_2.setObjectName(_fromUtf8("label_2"))
111 112 self.gridLayout_10.addWidget(self.label_2, 2, 0, 1, 1)
112 113 self.proStartTime = QtGui.QTimeEdit(self.frame_2)
113 114 self.proStartTime.setObjectName(_fromUtf8("proStartTime"))
114 115 self.gridLayout_10.addWidget(self.proStartTime, 2, 1, 1, 1)
115 116 self.label_3 = QtGui.QLabel(self.frame_2)
116 117 self.label_3.setObjectName(_fromUtf8("label_3"))
117 118 self.gridLayout_10.addWidget(self.label_3, 3, 0, 1, 1)
118 119 self.proEndTime = QtGui.QTimeEdit(self.frame_2)
119 120 self.proEndTime.setObjectName(_fromUtf8("proEndTime"))
120 121 self.gridLayout_10.addWidget(self.proEndTime, 3, 1, 1, 1)
121 122 self.label_30 = QtGui.QLabel(self.frame_2)
122 123 self.label_30.setObjectName(_fromUtf8("label_30"))
123 124 self.gridLayout_10.addWidget(self.label_30, 4, 0, 1, 1)
124 125 self.proDescription = QtGui.QTextEdit(self.frame_2)
125 126 self.proDescription.setObjectName(_fromUtf8("proDescription"))
126 127 self.gridLayout_10.addWidget(self.proDescription, 4, 1, 1, 1)
127 128 self.gridLayout_15.addWidget(self.frame_2, 1, 0, 1, 1)
128 129 self.frame_3 = QtGui.QFrame(self.tabProject)
129 130 self.frame_3.setFrameShape(QtGui.QFrame.StyledPanel)
130 131 self.frame_3.setFrameShadow(QtGui.QFrame.Raised)
131 132 self.frame_3.setObjectName(_fromUtf8("frame_3"))
132 133 self.gridLayout_14 = QtGui.QGridLayout(self.frame_3)
133 134 self.gridLayout_14.setObjectName(_fromUtf8("gridLayout_14"))
134 135 self.proOk = QtGui.QPushButton(self.frame_3)
135 136 self.proOk.setObjectName(_fromUtf8("proOk"))
136 137 self.gridLayout_14.addWidget(self.proOk, 0, 0, 1, 1)
137 138 self.proClear = QtGui.QPushButton(self.frame_3)
138 139 self.proClear.setObjectName(_fromUtf8("proClear"))
139 140 self.gridLayout_14.addWidget(self.proClear, 0, 1, 1, 1)
140 141 self.gridLayout_15.addWidget(self.frame_3, 2, 0, 1, 1)
141 142
142 143 self.tabWidgetProject.addTab(self.tabProject, _fromUtf8(""))
143 144
144 145 def retranslateUi(self):
145 146
146 147 self.label.setText(_translate("MainWindow", "Project Name :", None))
147 148 self.label_11.setText(_translate("MainWindow", "DataType :", None))
148 149 self.proComDataType.setItemText(0, _translate("MainWindow", "Voltage", None))
149 150 self.proComDataType.setItemText(1, _translate("MainWindow", "Spectra", None))
150 151 self.proComDataType.setItemText(2, _translate("MainWindow", "Fits", None))
152 self.proComDataType.setItemText(3, _translate("MainWindow", "USRP", None))
151 153 self.label_15.setText(_translate("MainWindow", "DataPath :", None))
152 154 self.proToolPath.setText(_translate("MainWindow", "...", None))
153 155 self.label_23.setText(_translate("MainWindow", "Read Mode:", None))
154 156 self.proComReadMode.setItemText(0, _translate("MainWindow", "Offline", None))
155 157 self.proComReadMode.setItemText(1, _translate("MainWindow", "Online", None))
156 158 self.label_33.setText(_translate("MainWindow", "Delay:", None))
157 159 self.label_32.setText(_translate("MainWindow", "Walk :", None))
158 160 self.proComWalk.setItemText(0, _translate("MainWindow", "On Files", None))
159 161 self.proComWalk.setItemText(1, _translate("MainWindow", "On Folder", None))
160 162 self.proLoadButton.setText(_translate("MainWindow", "Load", None))
161 163 self.label_10.setText(_translate("MainWindow", "Set:", None))
162 164 self.label_27.setText(_translate("MainWindow", "Star Date:", None))
163 165 self.label_28.setText(_translate("MainWindow", "End Date:", None))
164 166 self.label_2.setText(_translate("MainWindow", "Start Time:", None))
165 167 self.label_3.setText(_translate("MainWindow", "End Time:", None))
166 168 self.label_30.setText(_translate("MainWindow", "Description:", None))
167 169 self.proOk.setText(_translate("MainWindow", "Ok", None))
168 170 self.proClear.setText(_translate("MainWindow", "Clear", None))
169 171
170 172 self.tabWidgetProject.setTabText(self.tabWidgetProject.indexOf(self.tabProject), _translate("MainWindow", "Project", None))
171 173 No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,903 +1,903
1 1 import numpy
2 2 import time
3 3 import os
4 4 import h5py
5 5 import re
6 6
7 7 from schainpy.model.data.jrodata import *
8 8 from schainpy.model.proc.jroproc_base import ProcessingUnit, Operation
9 9 from schainpy.model.io.jroIO_base import *
10 10
11 11
12 12 class HDF5Reader(ProcessingUnit):
13 13
14 14 ext = ".hdf5"
15 15
16 16 optchar = "D"
17 17
18 18 timezone = None
19 19
20 20 secStart = None
21 21
22 22 secEnd = None
23 23
24 24 fileIndex = None
25 25
26 26 blockIndex = None
27 27
28 28 blocksPerFile = None
29 29
30 30 path = None
31 31
32 32 #List of Files
33 33
34 34 filenameList = None
35 35
36 36 datetimeList = None
37 37
38 38 #Hdf5 File
39 39
40 40 fpMetadata = None
41 41
42 42 pathMeta = None
43 43
44 44 listMetaname = None
45 45
46 46 listMeta = None
47 47
48 48 listDataname = None
49 49
50 50 listData = None
51 51
52 52 listShapes = None
53 53
54 54 fp = None
55 55
56 56 #dataOut reconstruction
57 57
58 58 dataOut = None
59 59
60 60 nRecords = None
61 61
62 62
63 63 def __init__(self):
64 64 self.dataOut = self.__createObjByDefault()
65 65 return
66 66
67 67 def __createObjByDefault(self):
68 68
69 69 dataObj = Parameters()
70 70
71 71 return dataObj
72 72
73 73 def setup(self,path=None,
74 74 startDate=None,
75 75 endDate=None,
76 76 startTime=datetime.time(0,0,0),
77 77 endTime=datetime.time(23,59,59),
78 78 walk=True,
79 79 timezone='ut',
80 80 all=0,
81 81 online=False,
82 82 ext=None):
83 83
84 84 if ext==None:
85 85 ext = self.ext
86 86 self.timezone = timezone
87 87 # self.all = all
88 88 # self.online = online
89 89 self.path = path
90 90
91 91 startDateTime = datetime.datetime.combine(startDate,startTime)
92 92 endDateTime = datetime.datetime.combine(endDate,endTime)
93 93 secStart = (startDateTime-datetime.datetime(1970,1,1)).total_seconds()
94 94 secEnd = (endDateTime-datetime.datetime(1970,1,1)).total_seconds()
95 95
96 96 self.secStart = secStart
97 97 self.secEnd = secEnd
98 98
99 99 if not(online):
100 100 #Busqueda de archivos offline
101 101 self.__searchFilesOffline(path, startDate, endDate, ext, startTime, endTime, secStart, secEnd, walk)
102 102 else:
103 103 self.__searchFilesOnline(path, walk)
104 104
105 105 if not(self.filenameList):
106 106 print "There is no files into the folder: %s"%(path)
107 107 sys.exit(-1)
108 108
109 109 # self.__getExpParameters()
110 110
111 111 self.fileIndex = -1
112 112
113 113 self.__setNextFileOffline()
114 114
115 115 self.__readMetadata()
116 116
117 117 self.blockIndex = 0
118 118
119 119 return
120 120
121 121 def __searchFilesOffline(self,
122 122 path,
123 123 startDate,
124 124 endDate,
125 125 ext,
126 126 startTime=datetime.time(0,0,0),
127 127 endTime=datetime.time(23,59,59),
128 128 secStart = 0,
129 129 secEnd = numpy.inf,
130 130 walk=True):
131 131
132 132 # self.__setParameters(path, startDate, endDate, startTime, endTime, walk)
133 133 #
134 134 # self.__checkPath()
135 135 #
136 136 # self.__findDataForDates()
137 137 #
138 138 # self.__selectDataForTimes()
139 139 #
140 140 # for i in range(len(self.filenameList)):
141 141 # print "%s" %(self.filenameList[i])
142 142
143 143 pathList = []
144 144
145 145 if not walk:
146 146 #pathList.append(path)
147 147 multi_path = path.split(',')
148 148 for single_path in multi_path:
149 149 pathList.append(single_path)
150 150
151 151 else:
152 152 #dirList = []
153 153 multi_path = path.split(',')
154 154 for single_path in multi_path:
155 155 dirList = []
156 156 for thisPath in os.listdir(single_path):
157 157 if not os.path.isdir(os.path.join(single_path,thisPath)):
158 158 continue
159 if not isDoyFolder(thisPath):
159 if not isRadarFolder(thisPath):
160 160 continue
161 161
162 162 dirList.append(thisPath)
163 163
164 164 if not(dirList):
165 165 return None, None
166 166
167 167 thisDate = startDate
168 168
169 169 while(thisDate <= endDate):
170 170 year = thisDate.timetuple().tm_year
171 171 doy = thisDate.timetuple().tm_yday
172 172
173 173 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
174 174 if len(matchlist) == 0:
175 175 thisDate += datetime.timedelta(1)
176 176 continue
177 177 for match in matchlist:
178 178 pathList.append(os.path.join(single_path,match))
179 179
180 180 thisDate += datetime.timedelta(1)
181 181
182 182 if pathList == []:
183 183 print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
184 184 return None, None
185 185
186 186 print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
187 187
188 188 filenameList = []
189 189 datetimeList = []
190 190 pathDict = {}
191 191 filenameList_to_sort = []
192 192
193 193 for i in range(len(pathList)):
194 194
195 195 thisPath = pathList[i]
196 196
197 197 fileList = glob.glob1(thisPath, "*%s" %ext)
198 198 fileList.sort()
199 199 pathDict.setdefault(fileList[0])
200 200 pathDict[fileList[0]] = i
201 201 filenameList_to_sort.append(fileList[0])
202 202
203 203 filenameList_to_sort.sort()
204 204
205 205 for file in filenameList_to_sort:
206 206 thisPath = pathList[pathDict[file]]
207 207
208 208 fileList = glob.glob1(thisPath, "*%s" %ext)
209 209 fileList.sort()
210 210
211 211 for file in fileList:
212 212
213 213 filename = os.path.join(thisPath,file)
214 214 thisDatetime = self.__isFileinThisTime(filename, secStart, secEnd)
215 215
216 216 if not(thisDatetime):
217 217 continue
218 218
219 219 filenameList.append(filename)
220 220 datetimeList.append(thisDatetime)
221 221
222 222 if not(filenameList):
223 223 print "Any file was found for the time range %s - %s" %(startTime, endTime)
224 224 return None, None
225 225
226 226 print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
227 227 print
228 228
229 229 for i in range(len(filenameList)):
230 230 print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
231 231
232 232 self.filenameList = filenameList
233 233 self.datetimeList = datetimeList
234 234
235 235 return pathList, filenameList
236 236
237 237 def __isFileinThisTime(self, filename, startSeconds, endSeconds):
238 238 """
239 239 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
240 240
241 241 Inputs:
242 242 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
243 243
244 244 startTime : tiempo inicial del rango seleccionado en formato datetime.time
245 245
246 246 endTime : tiempo final del rango seleccionado en formato datetime.time
247 247
248 248 Return:
249 249 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
250 250 fecha especificado, de lo contrario retorna False.
251 251
252 252 Excepciones:
253 253 Si el archivo no existe o no puede ser abierto
254 254 Si la cabecera no puede ser leida.
255 255
256 256 """
257 257
258 258 try:
259 259 fp = fp = h5py.File(filename,'r')
260 260 except IOError:
261 261 traceback.print_exc()
262 262 raise IOError, "The file %s can't be opened" %(filename)
263 263
264 264 grp = fp['Data']
265 265 timeAux = grp['time']
266 266 time0 = timeAux[:][0].astype(numpy.float) #Time Vector
267 267
268 268 fp.close()
269 269
270 270 if self.timezone == 'lt':
271 271 time0 -= 5*3600
272 272
273 273 boolTimer = numpy.logical_and(time0 >= startSeconds,time0 < endSeconds)
274 274
275 275 if not (numpy.any(boolTimer)):
276 276 return None
277 277
278 278 thisDatetime = datetime.datetime.utcfromtimestamp(time0[0])
279 279 return thisDatetime
280 280
281 281 def __checkPath(self):
282 282 if os.path.exists(self.path):
283 283 self.status = 1
284 284 else:
285 285 self.status = 0
286 286 print 'Path:%s does not exists'%self.path
287 287
288 288 return
289 289
290 290 def __setNextFileOffline(self):
291 291 idFile = self.fileIndex
292 292 idFile += 1
293 293
294 294 if not(idFile < len(self.filenameList)):
295 295 print "No more Files"
296 296 return 0
297 297
298 298 filename = self.filenameList[idFile]
299 299
300 300 filePointer = h5py.File(filename,'r')
301 301
302 302 self.flagIsNewFile = 1
303 303 self.fileIndex = idFile
304 304 self.filename = filename
305 305
306 306 self.fp = filePointer
307 307
308 308 print "Setting the file: %s"%self.filename
309 309
310 310 self.__readMetadata()
311 311 self.__setBlockList()
312 312 # self.nRecords = self.fp['Data'].attrs['blocksPerFile']
313 313 self.nRecords = self.fp['Data'].attrs['nRecords']
314 314 self.blockIndex = 0
315 315 return 1
316 316
317 317 def __setBlockList(self):
318 318 '''
319 319 self.fp
320 320 self.startDateTime
321 321 self.endDateTime
322 322
323 323 self.blockList
324 324 self.blocksPerFile
325 325
326 326 '''
327 327 filePointer = self.fp
328 328 secStart = self.secStart
329 329 secEnd = self.secEnd
330 330
331 331 grp = filePointer['Data']
332 332 timeVector = grp['time'].value.astype(numpy.float)[0]
333 333
334 334 if self.timezone == 'lt':
335 335 timeVector -= 5*3600
336 336
337 337 ind = numpy.where(numpy.logical_and(timeVector >= secStart , timeVector < secEnd))[0]
338 338
339 339 self.blockList = ind
340 340 self.blocksPerFile = len(ind)
341 341
342 342 return
343 343
344 344 def __readMetadata(self):
345 345 '''
346 346 self.pathMeta
347 347
348 348 self.listShapes
349 349 self.listMetaname
350 350 self.listMeta
351 351
352 352 '''
353 353
354 354 grp = self.fp['Data']
355 355 pathMeta = os.path.join(self.path, grp.attrs['metadata'])
356 356
357 357 if pathMeta == self.pathMeta:
358 358 return
359 359 else:
360 360 self.pathMeta = pathMeta
361 361
362 362 filePointer = h5py.File(self.pathMeta,'r')
363 363 groupPointer = filePointer['Metadata']
364 364
365 365 listMetaname = []
366 366 listMetadata = []
367 367 for item in groupPointer.items():
368 368 name = item[0]
369 369
370 370 if name=='array dimensions':
371 371 table = groupPointer[name][:]
372 372 listShapes = {}
373 373 for shapes in table:
374 374 listShapes[shapes[0]] = numpy.array([shapes[1],shapes[2],shapes[3],shapes[4]])
375 375 else:
376 376 data = groupPointer[name].value
377 377 listMetaname.append(name)
378 378 listMetadata.append(data)
379 379
380 380 if name=='type':
381 381 self.__initDataOut(data)
382 382
383 383 filePointer.close()
384 384
385 385 self.listShapes = listShapes
386 386 self.listMetaname = listMetaname
387 387 self.listMeta = listMetadata
388 388
389 389 return
390 390
391 391 def __readData(self):
392 392 grp = self.fp['Data']
393 393 listdataname = []
394 394 listdata = []
395 395
396 396 for item in grp.items():
397 397 name = item[0]
398 398
399 399 if name == 'time':
400 400 listdataname.append('utctime')
401 401 timeAux = grp[name].value.astype(numpy.float)[0]
402 402 listdata.append(timeAux)
403 403 continue
404 404
405 405 listdataname.append(name)
406 406 array = self.__setDataArray(self.nRecords, grp[name],self.listShapes[name])
407 407 listdata.append(array)
408 408
409 409 self.listDataname = listdataname
410 410 self.listData = listdata
411 411 return
412 412
413 413 def __setDataArray(self, nRecords, dataset, shapes):
414 414
415 415 nChannels = shapes[0] #Dimension 0
416 416
417 417 nPoints = shapes[1] #Dimension 1, number of Points or Parameters
418 418
419 419 nSamples = shapes[2] #Dimension 2, number of samples or ranges
420 420
421 421 mode = shapes[3]
422 422
423 423 # if nPoints>1:
424 424 # arrayData = numpy.zeros((nRecords,nChannels,nPoints,nSamples))
425 425 # else:
426 426 # arrayData = numpy.zeros((nRecords,nChannels,nSamples))
427 427 #
428 428 # chn = 'channel'
429 429 #
430 430 # for i in range(nChannels):
431 431 #
432 432 # data = dataset[chn + str(i)].value
433 433 #
434 434 # if nPoints>1:
435 435 # data = numpy.rollaxis(data,2)
436 436 #
437 437 # arrayData[:,i,:] = data
438 438
439 439 arrayData = numpy.zeros((nRecords,nChannels,nPoints,nSamples))
440 440 doSqueeze = False
441 441 if mode == 0:
442 442 strds = 'channel'
443 443 nDatas = nChannels
444 444 newShapes = (nRecords,nPoints,nSamples)
445 445 if nPoints == 1:
446 446 doSqueeze = True
447 447 axisSqueeze = 2
448 448 else:
449 449 strds = 'param'
450 450 nDatas = nPoints
451 451 newShapes = (nRecords,nChannels,nSamples)
452 452 if nChannels == 1:
453 453 doSqueeze = True
454 454 axisSqueeze = 1
455 455
456 456 for i in range(nDatas):
457 457
458 458 data = dataset[strds + str(i)].value
459 459 data = data.reshape(newShapes)
460 460
461 461 if mode == 0:
462 462 arrayData[:,i,:,:] = data
463 463 else:
464 464 arrayData[:,:,i,:] = data
465 465
466 466 if doSqueeze:
467 467 arrayData = numpy.squeeze(arrayData, axis=axisSqueeze)
468 468
469 469 return arrayData
470 470
471 471 def __initDataOut(self, type):
472 472
473 473 # if type =='Parameters':
474 474 # self.dataOut = Parameters()
475 475 # elif type =='Spectra':
476 476 # self.dataOut = Spectra()
477 477 # elif type =='Voltage':
478 478 # self.dataOut = Voltage()
479 479 # elif type =='Correlation':
480 480 # self.dataOut = Correlation()
481 481
482 482 return
483 483
484 484 def __setDataOut(self):
485 485 listMeta = self.listMeta
486 486 listMetaname = self.listMetaname
487 487 listDataname = self.listDataname
488 488 listData = self.listData
489 489
490 490 blockIndex = self.blockIndex
491 491 blockList = self.blockList
492 492
493 493 for i in range(len(listMeta)):
494 494 setattr(self.dataOut,listMetaname[i],listMeta[i])
495 495
496 496 for j in range(len(listData)):
497 497 if listDataname[j]=='utctime':
498 498 # setattr(self.dataOut,listDataname[j],listData[j][blockList[blockIndex]])
499 499 setattr(self.dataOut,'utctimeInit',listData[j][blockList[blockIndex]])
500 500 continue
501 501
502 502 setattr(self.dataOut,listDataname[j],listData[j][blockList[blockIndex],:])
503 503
504 504 return self.dataOut.data_param
505 505
506 506 def getData(self):
507 507
508 508 # if self.flagNoMoreFiles:
509 509 # self.dataOut.flagNoData = True
510 510 # print 'Process finished'
511 511 # return 0
512 512 #
513 513 if self.blockIndex==self.blocksPerFile:
514 514 if not( self.__setNextFileOffline() ):
515 515 self.dataOut.flagNoData = True
516 516 return 0
517 517
518 518 #
519 519 # if self.datablock == None: # setear esta condicion cuando no hayan datos por leers
520 520 # self.dataOut.flagNoData = True
521 521 # return 0
522 522
523 523 self.__readData()
524 524 self.__setDataOut()
525 525 self.dataOut.flagNoData = False
526 526
527 527 self.blockIndex += 1
528 528
529 529 return
530 530
531 531 def run(self, **kwargs):
532 532
533 533 if not(self.isConfig):
534 534 self.setup(**kwargs)
535 535 # self.setObjProperties()
536 536 self.isConfig = True
537 537
538 538 self.getData()
539 539
540 540 return
541 541
542 542 class HDF5Writer(Operation):
543 543
544 544 ext = ".hdf5"
545 545
546 546 optchar = "D"
547 547
548 548 metaoptchar = "M"
549 549
550 550 metaFile = None
551 551
552 552 path = None
553 553
554 554 setFile = None
555 555
556 556 fp = None
557 557
558 558 grp = None
559 559
560 560 ds = None
561 561
562 562 firsttime = True
563 563
564 564 #Configurations
565 565
566 566 blocksPerFile = None
567 567
568 568 blockIndex = None
569 569
570 570 dataOut = None
571 571
572 572 #Data Arrays
573 573
574 574 dataList = None
575 575
576 576 metadataList = None
577 577
578 578 arrayDim = None
579 579
580 580 tableDim = None
581 581
582 582 # dtype = [('arrayName', 'S20'),('nChannels', 'i'), ('nPoints', 'i'), ('nSamples', 'i'),('mode', 'b')]
583 583
584 584 dtype = [('arrayName', 'S20'),('nDimensions', 'i'), ('dim2', 'i'), ('dim1', 'i'),('dim0', 'i'),('mode', 'b')]
585 585
586 586 mode = None
587 587
588 588 nDatas = None #Number of datasets to be stored per array
589 589
590 590 nDims = None #Number Dimensions in each dataset
591 591
592 592 def __init__(self):
593 593
594 594 Operation.__init__(self)
595 595 self.isConfig = False
596 596 return
597 597
598 598
599 599 def setup(self, dataOut, **kwargs):
600 600
601 601 self.path = kwargs['path']
602 602
603 603 if kwargs.has_key('ext'):
604 604 self.ext = kwargs['ext']
605 605
606 606 if kwargs.has_key('blocksPerFile'):
607 607 self.blocksPerFile = kwargs['blocksPerFile']
608 608 else:
609 609 self.blocksPerFile = 10
610 610
611 611 self.metadataList = kwargs['metadataList']
612 612
613 613 self.dataList = kwargs['dataList']
614 614
615 615 self.dataOut = dataOut
616 616
617 617 if kwargs.has_key('mode'):
618 618 mode = kwargs['mode']
619 619
620 620 if type(mode) == int:
621 621 mode = numpy.zeros(len(self.dataList)) + mode
622 622 else:
623 623 mode = numpy.zeros(len(self.dataList))
624 624
625 625 self.mode = mode
626 626
627 627 arrayDim = numpy.zeros((len(self.dataList),5))
628 628
629 629 #Table dimensions
630 630
631 631 dtype0 = self.dtype
632 632
633 633 tableList = []
634 634
635 635 for i in range(len(self.dataList)):
636 636
637 637 dataAux = getattr(self.dataOut, self.dataList[i])
638 638
639 639 if type(dataAux)==float or type(dataAux)==int:
640 640 arrayDim[i,0] = 1
641 641 else:
642 642 arrayDim0 = dataAux.shape
643 643 arrayDim[i,0] = len(arrayDim0)
644 644 arrayDim[i,4] = mode[i]
645 645
646 646 if len(arrayDim0) == 3:
647 647 arrayDim[i,1:-1] = numpy.array(arrayDim0)
648 648 elif len(arrayDim0) == 2:
649 649 arrayDim[i,2:-1] = numpy.array(arrayDim0) #nHeights
650 650 elif len(arrayDim0) == 1:
651 651 arrayDim[i,3] = arrayDim0
652 652 elif len(arrayDim0) == 0:
653 653 arrayDim[i,0] = 1
654 654 arrayDim[i,3] = 1
655 655
656 656 table = numpy.array((self.dataList[i],) + tuple(arrayDim[i,:]),dtype = dtype0)
657 657 tableList.append(table)
658 658
659 659 self.arrayDim = arrayDim
660 660 self.tableDim = numpy.array(tableList, dtype = dtype0)
661 661 self.blockIndex = 0
662 662
663 663 return
664 664
665 665 def putMetadata(self):
666 666
667 667 fp = self.createMetadataFile()
668 668 self.writeMetadata(fp)
669 669 fp.close()
670 670 return
671 671
672 672 def createMetadataFile(self):
673 673 ext = self.ext
674 674 path = self.path
675 675 setFile = self.setFile
676 676
677 677 timeTuple = time.localtime(self.dataOut.utctime)
678 678 subfolder = ''
679 679
680 680 fullpath = os.path.join( path, subfolder )
681 681 if not( os.path.exists(fullpath) ):
682 682 os.mkdir(fullpath)
683 683 setFile = -1 #inicializo mi contador de seteo
684 684 else:
685 685 filesList = os.listdir( fullpath )
686 686 if len( filesList ) > 0:
687 687 filesList = sorted( filesList, key=str.lower )
688 688 filen = filesList[-1]
689 689 # el filename debera tener el siguiente formato
690 690 # 0 1234 567 89A BCDE (hex)
691 691 # x YYYY DDD SSS .ext
692 692 if isNumber( filen[8:11] ):
693 693 setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
694 694 else:
695 695 setFile = -1
696 696 else:
697 697 setFile = -1 #inicializo mi contador de seteo
698 698
699 699 setFile += 1
700 700
701 701 file = '%s%4.4d%3.3d%3.3d%s' % (self.metaoptchar,
702 702 timeTuple.tm_year,
703 703 timeTuple.tm_yday,
704 704 setFile,
705 705 ext )
706 706
707 707 filename = os.path.join( path, subfolder, file )
708 708 self.metaFile = file
709 709 #Setting HDF5 File
710 710 fp = h5py.File(filename,'w')
711 711
712 712 return fp
713 713
714 714 def writeMetadata(self, fp):
715 715
716 716 grp = fp.create_group("Metadata")
717 717 grp.create_dataset('array dimensions', data = self.tableDim, dtype = self.dtype)
718 718
719 719 for i in range(len(self.metadataList)):
720 720 grp.create_dataset(self.metadataList[i], data=getattr(self.dataOut, self.metadataList[i]))
721 721 return
722 722
723 723 def setNextFile(self):
724 724
725 725 ext = self.ext
726 726 path = self.path
727 727 setFile = self.setFile
728 728 mode = self.mode
729 729
730 730 if self.fp != None:
731 731 self.fp.close()
732 732
733 733 timeTuple = time.localtime(self.dataOut.utctime)
734 734 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
735 735
736 736 fullpath = os.path.join( path, subfolder )
737 737 if not( os.path.exists(fullpath) ):
738 738 os.mkdir(fullpath)
739 739 setFile = -1 #inicializo mi contador de seteo
740 740 else:
741 741 filesList = os.listdir( fullpath )
742 742 if len( filesList ) > 0:
743 743 filesList = sorted( filesList, key=str.lower )
744 744 filen = filesList[-1]
745 745 # el filename debera tener el siguiente formato
746 746 # 0 1234 567 89A BCDE (hex)
747 747 # x YYYY DDD SSS .ext
748 748 if isNumber( filen[8:11] ):
749 749 setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
750 750 else:
751 751 setFile = -1
752 752 else:
753 753 setFile = -1 #inicializo mi contador de seteo
754 754
755 755 setFile += 1
756 756
757 757 file = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
758 758 timeTuple.tm_year,
759 759 timeTuple.tm_yday,
760 760 setFile,
761 761 ext )
762 762
763 763 filename = os.path.join( path, subfolder, file )
764 764
765 765 #Setting HDF5 File
766 766 fp = h5py.File(filename,'w')
767 767 grp = fp.create_group("Data")
768 768 grp.attrs['metadata'] = self.metaFile
769 769
770 770 # grp.attrs['blocksPerFile'] = 0
771 771
772 772 ds = []
773 773 data = []
774 774
775 775 nDatas = numpy.zeros(len(self.dataList))
776 776 nDims = self.arrayDim[:,0]
777 777
778 778 for i in range(len(self.dataList)):
779 779
780 780 if nDims[i]==1:
781 781 ds0 = grp.create_dataset(self.dataList[i], (1,1), maxshape=(1,None) , chunks = True, dtype='S20')
782 782 ds.append(ds0)
783 783 data.append([])
784 784
785 785 else:
786 786
787 787 if mode[i]==0:
788 788 strMode = "channel"
789 789 nDatas[i] = self.arrayDim[i,1]
790 790 else:
791 791 strMode = "param"
792 792 nDatas[i] = self.arrayDim[i,2]
793 793
794 794 if nDims[i]==2:
795 795 nDatas[i] = self.arrayDim[i,2]
796 796
797 797 grp0 = grp.create_group(self.dataList[i])
798 798
799 799 for j in range(int(nDatas[i])):
800 800 tableName = strMode + str(j)
801 801
802 802 if nDims[i] == 3:
803 803 ds0 = grp0.create_dataset(tableName, (1,1,1) , maxshape=(None,None,None), chunks=True)
804 804 else:
805 805 ds0 = grp0.create_dataset(tableName, (1,1) , maxshape=(None,None), chunks=True)
806 806
807 807 ds.append(ds0)
808 808 data.append([])
809 809
810 810 self.nDatas = nDatas
811 811 self.nDims = nDims
812 812
813 813 #Saving variables
814 814 print 'Writing the file: %s'%filename
815 815 self.fp = fp
816 816 self.grp = grp
817 817 self.ds = ds
818 818 self.data = data
819 819
820 820 self.setFile = setFile
821 821 self.firsttime = True
822 822 self.blockIndex = 0
823 823 return
824 824
825 825 def putData(self):
826 826 self.setBlock()
827 827 self.writeBlock()
828 828
829 829 if self.blockIndex == self.blocksPerFile:
830 830 self.setNextFile()
831 831 return
832 832
833 833 def setBlock(self):
834 834 '''
835 835 data Array configured
836 836
837 837
838 838 self.data
839 839 '''
840 840 #Creating Arrays
841 841 data = self.data
842 842 nDatas = self.nDatas
843 843 nDims = self.nDims
844 844 mode = self.mode
845 845 ind = 0
846 846
847 847 for i in range(len(self.dataList)):
848 848 dataAux = getattr(self.dataOut,self.dataList[i])
849 849
850 850 if nDims[i] == 1:
851 851 data[ind] = numpy.array([str(dataAux)]).reshape((1,1))
852 852 if not self.firsttime:
853 853 data[ind] = numpy.hstack((self.ds[ind][:], self.data[ind]))
854 854 ind += 1
855 855
856 856 else:
857 857 for j in range(int(nDatas[i])):
858 858 if (mode[i] == 0) or (nDims[i] == 2): #In case division per channel or Dimensions is only 1
859 859 data[ind] = dataAux[j,:]
860 860 else:
861 861 data[ind] = dataAux[:,j,:]
862 862
863 863 if nDims[i] == 3:
864 864 data[ind] = data[ind].reshape((data[ind].shape[0],data[ind].shape[1],1))
865 865
866 866 if not self.firsttime:
867 867 data[ind] = numpy.dstack((self.ds[ind][:], data[ind]))
868 868
869 869 else:
870 870 data[ind] = data[ind].reshape((1,data[ind].shape[0]))
871 871
872 872 if not self.firsttime:
873 873 data[ind] = numpy.vstack((self.ds[ind][:], data[ind]))
874 874 ind += 1
875 875
876 876 self.data = data
877 877 return
878 878
879 879 def writeBlock(self):
880 880 '''
881 881 Saves the block in the HDF5 file
882 882 '''
883 883 for i in range(len(self.ds)):
884 884 self.ds[i].resize(self.data[i].shape)
885 885 self.ds[i][:] = self.data[i]
886 886
887 887 self.blockIndex += 1
888 888
889 889 self.grp.attrs.modify('nRecords', self.blockIndex)
890 890
891 891 self.firsttime = False
892 892 return
893 893
894 894 def run(self, dataOut, **kwargs):
895 895 if not(self.isConfig):
896 896 self.setup(dataOut, **kwargs)
897 897 self.isConfig = True
898 898 self.putMetadata()
899 899 self.setNextFile()
900 900
901 901 self.putData()
902 902 return
903 903
Show file before | Show file after | Hide comments
@@ -1,1348 +1,1451
1 1 '''
2 2 Created on Jul 2, 2014
3 3
4 4 @author: roj-idl71
5 5 '''
6 6 import os
7 7 import sys
8 8 import glob
9 9 import time
10 10 import numpy
11 11 import fnmatch
12 12 import time, datetime
13 13 #import h5py
14 14 import traceback
15 15
16 16 try:
17 17 from gevent import sleep
18 18 except:
19 19 from time import sleep
20 20
21 21 from schainpy.model.data.jroheaderIO import PROCFLAG, BasicHeader, SystemHeader, RadarControllerHeader, ProcessingHeader
22 22
23 23 LOCALTIME = True
24 24
25 25 def isNumber(cad):
26 26 """
27 27 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
28 28
29 29 Excepciones:
30 30 Si un determinado string no puede ser convertido a numero
31 31 Input:
32 32 str, string al cual se le analiza para determinar si convertible a un numero o no
33 33
34 34 Return:
35 35 True : si el string es uno numerico
36 36 False : no es un string numerico
37 37 """
38 38 try:
39 39 float( cad )
40 40 return True
41 41 except:
42 42 return False
43 43
44 44 def isThisFileinRange(filename, startUTSeconds, endUTSeconds):
45 45 """
46 46 Esta funcion determina si un archivo de datos se encuentra o no dentro del rango de fecha especificado.
47 47
48 48 Inputs:
49 49 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
50 50
51 51 startUTSeconds : fecha inicial del rango seleccionado. La fecha esta dada en
52 52 segundos contados desde 01/01/1970.
53 53 endUTSeconds : fecha final del rango seleccionado. La fecha esta dada en
54 54 segundos contados desde 01/01/1970.
55 55
56 56 Return:
57 57 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
58 58 fecha especificado, de lo contrario retorna False.
59 59
60 60 Excepciones:
61 61 Si el archivo no existe o no puede ser abierto
62 62 Si la cabecera no puede ser leida.
63 63
64 64 """
65 65 basicHeaderObj = BasicHeader(LOCALTIME)
66 66
67 67 try:
68 68 fp = open(filename,'rb')
69 69 except IOError:
70 70 traceback.print_exc()
71 71 raise IOError, "The file %s can't be opened" %(filename)
72 72
73 73 sts = basicHeaderObj.read(fp)
74 74 fp.close()
75 75
76 76 if not(sts):
77 77 print "Skipping the file %s because it has not a valid header" %(filename)
78 78 return 0
79 79
80 80 if not ((startUTSeconds <= basicHeaderObj.utc) and (endUTSeconds > basicHeaderObj.utc)):
81 81 return 0
82 82
83 83 return 1
84 84
85 85 def isFileinThisTime(filename, startTime, endTime):
86 86 """
87 87 Retorna 1 si el archivo de datos se encuentra dentro del rango de horas especificado.
88 88
89 89 Inputs:
90 90 filename : nombre completo del archivo de datos en formato Jicamarca (.r)
91 91
92 92 startTime : tiempo inicial del rango seleccionado en formato datetime.time
93 93
94 94 endTime : tiempo final del rango seleccionado en formato datetime.time
95 95
96 96 Return:
97 97 Boolean : Retorna True si el archivo de datos contiene datos en el rango de
98 98 fecha especificado, de lo contrario retorna False.
99 99
100 100 Excepciones:
101 101 Si el archivo no existe o no puede ser abierto
102 102 Si la cabecera no puede ser leida.
103 103
104 104 """
105 105
106 106
107 107 try:
108 108 fp = open(filename,'rb')
109 109 except IOError:
110 110 traceback.print_exc()
111 111 raise IOError, "The file %s can't be opened" %(filename)
112 112
113 113 basicHeaderObj = BasicHeader(LOCALTIME)
114 114 sts = basicHeaderObj.read(fp)
115 115 fp.close()
116 116
117 117 thisDatetime = basicHeaderObj.datatime
118 118 thisTime = thisDatetime.time()
119 119
120 120 if not(sts):
121 121 print "Skipping the file %s because it has not a valid header" %(filename)
122 122 return None
123 123
124 124 if not ((startTime <= thisTime) and (endTime > thisTime)):
125 125 return None
126 126
127 127 return thisDatetime
128 128
129 129 def getFileFromSet(path, ext, set):
130 130 validFilelist = []
131 131 fileList = os.listdir(path)
132 132
133 133 # 0 1234 567 89A BCDE
134 134 # H YYYY DDD SSS .ext
135 135
136 136 for thisFile in fileList:
137 137 try:
138 138 year = int(thisFile[1:5])
139 139 doy = int(thisFile[5:8])
140 140 except:
141 141 continue
142 142
143 143 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
144 144 continue
145 145
146 146 validFilelist.append(thisFile)
147 147
148 148 myfile = fnmatch.filter(validFilelist,'*%4.4d%3.3d%3.3d*'%(year,doy,set))
149 149
150 150 if len(myfile)!= 0:
151 151 return myfile[0]
152 152 else:
153 153 filename = '*%4.4d%3.3d%3.3d%s'%(year,doy,set,ext.lower())
154 154 print 'the filename %s does not exist'%filename
155 155 print '...going to the last file: '
156 156
157 157 if validFilelist:
158 158 validFilelist = sorted( validFilelist, key=str.lower )
159 159 return validFilelist[-1]
160 160
161 161 return None
162 162
163 163 def getlastFileFromPath(path, ext):
164 164 """
165 165 Depura el fileList dejando solo los que cumplan el formato de "PYYYYDDDSSS.ext"
166 166 al final de la depuracion devuelve el ultimo file de la lista que quedo.
167 167
168 168 Input:
169 169 fileList : lista conteniendo todos los files (sin path) que componen una determinada carpeta
170 170 ext : extension de los files contenidos en una carpeta
171 171
172 172 Return:
173 173 El ultimo file de una determinada carpeta, no se considera el path.
174 174 """
175 175 validFilelist = []
176 176 fileList = os.listdir(path)
177 177
178 178 # 0 1234 567 89A BCDE
179 179 # H YYYY DDD SSS .ext
180 180
181 181 for thisFile in fileList:
182 182
183 183 year = thisFile[1:5]
184 184 if not isNumber(year):
185 185 continue
186 186
187 187 doy = thisFile[5:8]
188 188 if not isNumber(doy):
189 189 continue
190 190
191 191 year = int(year)
192 192 doy = int(doy)
193 193
194 194 if (os.path.splitext(thisFile)[-1].lower() != ext.lower()):
195 195 continue
196 196
197 197 validFilelist.append(thisFile)
198 198
199 199 if validFilelist:
200 200 validFilelist = sorted( validFilelist, key=str.lower )
201 201 return validFilelist[-1]
202 202
203 203 return None
204 204
205 205 def checkForRealPath(path, foldercounter, year, doy, set, ext):
206 206 """
207 207 Por ser Linux Case Sensitive entonces checkForRealPath encuentra el nombre correcto de un path,
208 208 Prueba por varias combinaciones de nombres entre mayusculas y minusculas para determinar
209 209 el path exacto de un determinado file.
210 210
211 211 Example :
212 212 nombre correcto del file es .../.../D2009307/P2009307367.ext
213 213
214 214 Entonces la funcion prueba con las siguientes combinaciones
215 215 .../.../y2009307367.ext
216 216 .../.../Y2009307367.ext
217 217 .../.../x2009307/y2009307367.ext
218 218 .../.../x2009307/Y2009307367.ext
219 219 .../.../X2009307/y2009307367.ext
220 220 .../.../X2009307/Y2009307367.ext
221 221 siendo para este caso, la ultima combinacion de letras, identica al file buscado
222 222
223 223 Return:
224 224 Si encuentra la cobinacion adecuada devuelve el path completo y el nombre del file
225 225 caso contrario devuelve None como path y el la ultima combinacion de nombre en mayusculas
226 226 para el filename
227 227 """
228 228 fullfilename = None
229 229 find_flag = False
230 230 filename = None
231 231
232 232 prefixDirList = [None,'d','D']
233 233 if ext.lower() == ".r": #voltage
234 234 prefixFileList = ['d','D']
235 235 elif ext.lower() == ".pdata": #spectra
236 236 prefixFileList = ['p','P']
237 237 else:
238 238 return None, filename
239 239
240 240 #barrido por las combinaciones posibles
241 241 for prefixDir in prefixDirList:
242 242 thispath = path
243 243 if prefixDir != None:
244 244 #formo el nombre del directorio xYYYYDDD (x=d o x=D)
245 245 if foldercounter == 0:
246 246 thispath = os.path.join(path, "%s%04d%03d" % ( prefixDir, year, doy ))
247 247 else:
248 248 thispath = os.path.join(path, "%s%04d%03d_%02d" % ( prefixDir, year, doy , foldercounter))
249 249 for prefixFile in prefixFileList: #barrido por las dos combinaciones posibles de "D"
250 250 filename = "%s%04d%03d%03d%s" % ( prefixFile, year, doy, set, ext ) #formo el nombre del file xYYYYDDDSSS.ext
251 251 fullfilename = os.path.join( thispath, filename ) #formo el path completo
252 252
253 253 if os.path.exists( fullfilename ): #verifico que exista
254 254 find_flag = True
255 255 break
256 256 if find_flag:
257 257 break
258 258
259 259 if not(find_flag):
260 260 return None, filename
261 261
262 262 return fullfilename, filename
263 263
264 def isDoyFolder(folder):
264 def isRadarFolder(folder):
265 265 try:
266 266 year = int(folder[1:5])
267 except:
268 return 0
269
270 try:
271 267 doy = int(folder[5:8])
272 268 except:
273 269 return 0
274 270
275 271 return 1
276 272
273 def isRadarFile(file):
274 try:
275 year = int(file[1:5])
276 doy = int(file[5:8])
277 set = int(file[8:11])
278 except:
279 return 0
280
281 return 1
282
283 def getDateFromRadarFile(file):
284 try:
285 year = int(file[1:5])
286 doy = int(file[5:8])
287 set = int(file[8:11])
288 except:
289 return None
290
291 thisDate = datetime.date(year, 1, 1) + datetime.timedelta(doy-1)
292 return thisDate
293
277 294 class JRODataIO:
278 295
279 296 c = 3E8
280 297
281 298 isConfig = False
282 299
283 300 basicHeaderObj = None
284 301
285 302 systemHeaderObj = None
286 303
287 304 radarControllerHeaderObj = None
288 305
289 306 processingHeaderObj = None
290 307
291 308 online = 0
292 309
293 310 dtype = None
294 311
295 312 pathList = []
296 313
297 314 filenameList = []
298 315
299 316 filename = None
300 317
301 318 ext = None
302 319
303 320 flagIsNewFile = 1
304 321
305 322 flagDiscontinuousBlock = 0
306 323
307 324 flagIsNewBlock = 0
308 325
309 326 fp = None
310 327
311 328 firstHeaderSize = 0
312 329
313 330 basicHeaderSize = 24
314 331
315 332 versionFile = 1103
316 333
317 334 fileSize = None
318 335
319 336 # ippSeconds = None
320 337
321 338 fileSizeByHeader = None
322 339
323 340 fileIndex = None
324 341
325 342 profileIndex = None
326 343
327 344 blockIndex = None
328 345
329 346 nTotalBlocks = None
330 347
331 348 maxTimeStep = 30
332 349
333 350 lastUTTime = None
334 351
335 352 datablock = None
336 353
337 354 dataOut = None
338 355
339 356 blocksize = None
340 357
341 358 getByBlock = False
342 359
343 360 def __init__(self):
344 361
345 362 raise ValueError, "Not implemented"
346 363
347 364 def run(self):
348 365
349 366 raise ValueError, "Not implemented"
350 367
351 368 class JRODataReader(JRODataIO):
352 369
353 370 nReadBlocks = 0
354 371
355 372 delay = 10 #number of seconds waiting a new file
356 373
357 374 nTries = 3 #quantity tries
358 375
359 376 nFiles = 3 #number of files for searching
360 377
361 378 path = None
362 379
363 380 foldercounter = 0
364 381
365 382 flagNoMoreFiles = 0
366 383
367 384 datetimeList = []
368 385
369 386 __isFirstTimeOnline = 1
370 387
371 388 __printInfo = True
372 389
373 390 profileIndex = None
374 391
375 392 nTxs = 1
376 393
377 394 txIndex = None
378 395
379 396 def __init__(self):
380 397
381 398 """
382 399
383 400 """
384 401
385 raise ValueError, "This method has not been implemented"
402 # raise NotImplementedError, "This method has not been implemented"
386 403
387 404
388 405 def createObjByDefault(self):
389 406 """
390 407
391 408 """
392 raise ValueError, "This method has not been implemented"
409 raise NotImplementedError, "This method has not been implemented"
393 410
394 411 def getBlockDimension(self):
395 412
396 raise ValueError, "No implemented"
413 raise NotImplementedError, "No implemented"
397 414
398 415 def __searchFilesOffLine(self,
399 416 path,
400 startDate,
401 endDate,
417 startDate=None,
418 endDate=None,
402 419 startTime=datetime.time(0,0,0),
403 420 endTime=datetime.time(23,59,59),
404 421 set=None,
405 422 expLabel='',
406 423 ext='.r',
407 424 walk=True):
408 425
426 self.filenameList = []
427 self.datetimeList = []
428
409 429 pathList = []
410 430
411 431 if not walk:
412 432 #pathList.append(path)
413 433 multi_path = path.split(',')
414 434 for single_path in multi_path:
415 435 pathList.append(single_path)
416 436
417 437 else:
418 438 #dirList = []
419 439 multi_path = path.split(',')
420 440 for single_path in multi_path:
421 441 dirList = []
422 442 for thisPath in os.listdir(single_path):
423 443 if not os.path.isdir(os.path.join(single_path,thisPath)):
424 444 continue
425 if not isDoyFolder(thisPath):
445 if not isRadarFolder(thisPath):
426 446 continue
427 447
428 448 dirList.append(thisPath)
429 449
430 450 if not(dirList):
431 451 return None, None
432
433 thisDate = startDate
434
435 while(thisDate <= endDate):
436 year = thisDate.timetuple().tm_year
437 doy = thisDate.timetuple().tm_yday
438
439 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
440 if len(matchlist) == 0:
452
453 if startDate and endDate:
454 thisDate = startDate
455
456 while(thisDate <= endDate):
457 year = thisDate.timetuple().tm_year
458 doy = thisDate.timetuple().tm_yday
459
460 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
461 if len(matchlist) == 0:
462 thisDate += datetime.timedelta(1)
463 continue
464 for match in matchlist:
465 pathList.append(os.path.join(single_path,match,expLabel))
466
441 467 thisDate += datetime.timedelta(1)
442 continue
443 for match in matchlist:
444 pathList.append(os.path.join(single_path,match,expLabel))
445
446 thisDate += datetime.timedelta(1)
468 else:
469 for thiDir in dirList:
470 pathList.append(os.path.join(single_path,thiDir,expLabel))
447 471
448 472 if pathList == []:
449 473 print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
450 474 return None, None
451 475
452 476 print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
453 477
454 478 filenameList = []
455 479 datetimeList = []
456 480 pathDict = {}
457 481 filenameList_to_sort = []
458 482
459 483 for i in range(len(pathList)):
460 484
461 485 thisPath = pathList[i]
462 486
463 487 fileList = glob.glob1(thisPath, "*%s" %ext)
464 488 if len(fileList) < 1:
465 489 continue
466 490 fileList.sort()
467 491 pathDict.setdefault(fileList[0])
468 492 pathDict[fileList[0]] = i
469 493 filenameList_to_sort.append(fileList[0])
470 494
471 495 filenameList_to_sort.sort()
472 496
473 497 for file in filenameList_to_sort:
474 498 thisPath = pathList[pathDict[file]]
475 499
476 500 fileList = glob.glob1(thisPath, "*%s" %ext)
477 501 fileList.sort()
478 502
479 503 for file in fileList:
480 504
481 505 filename = os.path.join(thisPath,file)
482 506 thisDatetime = isFileinThisTime(filename, startTime, endTime)
483 507
484 508 if not(thisDatetime):
485 509 continue
486 510
487 511 filenameList.append(filename)
488 512 datetimeList.append(thisDatetime)
489 513
490 514 if not(filenameList):
491 515 print "Any file was found for the time range %s - %s" %(startTime, endTime)
492 516 return None, None
493 517
494 518 print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
495 519 print
496 520
497 521 for i in range(len(filenameList)):
498 522 print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
499 523
500 524 self.filenameList = filenameList
501 525 self.datetimeList = datetimeList
502 526
503 527 return pathList, filenameList
504 528
505 529 def __searchFilesOnLine(self, path, expLabel = "", ext = None, walk=True, set=None):
506 530
507 531 """
508 532 Busca el ultimo archivo de la ultima carpeta (determinada o no por startDateTime) y
509 533 devuelve el archivo encontrado ademas de otros datos.
510 534
511 535 Input:
512 536 path : carpeta donde estan contenidos los files que contiene data
513 537
514 538 expLabel : Nombre del subexperimento (subfolder)
515 539
516 540 ext : extension de los files
517 541
518 542 walk : Si es habilitado no realiza busquedas dentro de los ubdirectorios (doypath)
519 543
520 544 Return:
521 545 directory : eL directorio donde esta el file encontrado
522 546 filename : el ultimo file de una determinada carpeta
523 547 year : el anho
524 548 doy : el numero de dia del anho
525 549 set : el set del archivo
526 550
527 551
528 552 """
529 553 dirList = []
530 554
531 555 if not walk:
532 556 fullpath = path
533 557 foldercounter = 0
534 558 else:
535 559 #Filtra solo los directorios
536 560 for thisPath in os.listdir(path):
537 561 if not os.path.isdir(os.path.join(path,thisPath)):
538 562 continue
539 if not isDoyFolder(thisPath):
563 if not isRadarFolder(thisPath):
540 564 continue
541 565
542 566 dirList.append(thisPath)
543 567
544 568 if not(dirList):
545 569 return None, None, None, None, None, None
546 570
547 571 dirList = sorted( dirList, key=str.lower )
548 572
549 573 doypath = dirList[-1]
550 574 foldercounter = int(doypath.split('_')[1]) if len(doypath.split('_'))>1 else 0
551 575 fullpath = os.path.join(path, doypath, expLabel)
552 576
553 577
554 578 print "%s folder was found: " %(fullpath )
555 579
556 580 if set == None:
557 581 filename = getlastFileFromPath(fullpath, ext)
558 582 else:
559 583 filename = getFileFromSet(fullpath, ext, set)
560 584
561 585 if not(filename):
562 586 return None, None, None, None, None, None
563 587
564 588 print "%s file was found" %(filename)
565 589
566 590 if not(self.__verifyFile(os.path.join(fullpath, filename))):
567 591 return None, None, None, None, None, None
568 592
569 593 year = int( filename[1:5] )
570 594 doy = int( filename[5:8] )
571 595 set = int( filename[8:11] )
572 596
573 597 return fullpath, foldercounter, filename, year, doy, set
574 598
575 599 def __setNextFileOffline(self):
576 600
577 601 idFile = self.fileIndex
578 602
579 603 while (True):
580 604 idFile += 1
581 605 if not(idFile < len(self.filenameList)):
582 606 self.flagNoMoreFiles = 1
583 607 # print "[Reading] No more Files"
584 608 return 0
585 609
586 610 filename = self.filenameList[idFile]
587 611
588 612 if not(self.__verifyFile(filename)):
589 613 continue
590 614
591 615 fileSize = os.path.getsize(filename)
592 616 fp = open(filename,'rb')
593 617 break
594 618
595 619 self.flagIsNewFile = 1
596 620 self.fileIndex = idFile
597 621 self.filename = filename
598 622 self.fileSize = fileSize
599 623 self.fp = fp
600 624
601 625 # print "[Reading] Setting the file: %s"%self.filename
602 626
603 627 return 1
604 628
605 629 def __setNextFileOnline(self):
606 630 """
607 631 Busca el siguiente file que tenga suficiente data para ser leida, dentro de un folder especifico, si
608 632 no encuentra un file valido espera un tiempo determinado y luego busca en los posibles n files
609 633 siguientes.
610 634
611 635 Affected:
612 636 self.flagIsNewFile
613 637 self.filename
614 638 self.fileSize
615 639 self.fp
616 640 self.set
617 641 self.flagNoMoreFiles
618 642
619 643 Return:
620 644 0 : si luego de una busqueda del siguiente file valido este no pudo ser encontrado
621 645 1 : si el file fue abierto con exito y esta listo a ser leido
622 646
623 647 Excepciones:
624 648 Si un determinado file no puede ser abierto
625 649 """
626 650 nFiles = 0
627 651 fileOk_flag = False
628 652 firstTime_flag = True
629 653
630 654 self.set += 1
631 655
632 656 if self.set > 999:
633 657 self.set = 0
634 658 self.foldercounter += 1
635 659
636 660 #busca el 1er file disponible
637 661 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
638 662 if fullfilename:
639 663 if self.__verifyFile(fullfilename, False):
640 664 fileOk_flag = True
641 665
642 666 #si no encuentra un file entonces espera y vuelve a buscar
643 667 if not(fileOk_flag):
644 668 for nFiles in range(self.nFiles+1): #busco en los siguientes self.nFiles+1 files posibles
645 669
646 670 if firstTime_flag: #si es la 1era vez entonces hace el for self.nTries veces
647 671 tries = self.nTries
648 672 else:
649 673 tries = 1 #si no es la 1era vez entonces solo lo hace una vez
650 674
651 675 for nTries in range( tries ):
652 676 if firstTime_flag:
653 677 print "\t[Reading] Waiting %0.2f sec for the file \"%s\" , try %03d ..." % ( self.delay, filename, nTries+1 )
654 678 sleep( self.delay )
655 679 else:
656 680 print "\t[Reading] Searching the next \"%s%04d%03d%03d%s\" file ..." % (self.optchar, self.year, self.doy, self.set, self.ext)
657 681
658 682 fullfilename, filename = checkForRealPath( self.path, self.foldercounter, self.year, self.doy, self.set, self.ext )
659 683 if fullfilename:
660 684 if self.__verifyFile(fullfilename):
661 685 fileOk_flag = True
662 686 break
663 687
664 688 if fileOk_flag:
665 689 break
666 690
667 691 firstTime_flag = False
668 692
669 693 print "\t[Reading] Skipping the file \"%s\" due to this file doesn't exist" % filename
670 694 self.set += 1
671 695
672 696 if nFiles == (self.nFiles-1): #si no encuentro el file buscado cambio de carpeta y busco en la siguiente carpeta
673 697 self.set = 0
674 698 self.doy += 1
675 699 self.foldercounter = 0
676 700
677 701 if fileOk_flag:
678 702 self.fileSize = os.path.getsize( fullfilename )
679 703 self.filename = fullfilename
680 704 self.flagIsNewFile = 1
681 705 if self.fp != None: self.fp.close()
682 706 self.fp = open(fullfilename, 'rb')
683 707 self.flagNoMoreFiles = 0
684 708 # print '[Reading] Setting the file: %s' % fullfilename
685 709 else:
686 710 self.fileSize = 0
687 711 self.filename = None
688 712 self.flagIsNewFile = 0
689 713 self.fp = None
690 714 self.flagNoMoreFiles = 1
691 715 # print '[Reading] No more files to read'
692 716
693 717 return fileOk_flag
694 718
695 719 def setNextFile(self):
696 720 if self.fp != None:
697 721 self.fp.close()
698 722
699 723 if self.online:
700 724 newFile = self.__setNextFileOnline()
701 725 else:
702 726 newFile = self.__setNextFileOffline()
703 727
704 728 if not(newFile):
705 729 print '[Reading] No more files to read'
706 730 return 0
707 731
708 732 print '[Reading] Setting the file: %s' % self.filename
709 733
710 734 self.__readFirstHeader()
711 735 self.nReadBlocks = 0
712 736 return 1
713 737
714 738 def __waitNewBlock(self):
715 739 """
716 740 Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
717 741
718 742 Si el modo de lectura es OffLine siempre retorn 0
719 743 """
720 744 if not self.online:
721 745 return 0
722 746
723 747 if (self.nReadBlocks >= self.processingHeaderObj.dataBlocksPerFile):
724 748 return 0
725 749
726 750 currentPointer = self.fp.tell()
727 751
728 752 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
729 753
730 754 for nTries in range( self.nTries ):
731 755
732 756 self.fp.close()
733 757 self.fp = open( self.filename, 'rb' )
734 758 self.fp.seek( currentPointer )
735 759
736 760 self.fileSize = os.path.getsize( self.filename )
737 761 currentSize = self.fileSize - currentPointer
738 762
739 763 if ( currentSize >= neededSize ):
740 764 self.basicHeaderObj.read(self.fp)
741 765 return 1
742 766
743 767 if self.fileSize == self.fileSizeByHeader:
744 768 # self.flagEoF = True
745 769 return 0
746 770
747 771 print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
748 772 sleep( self.delay )
749 773
750 774
751 775 return 0
752 776
753 777 def waitDataBlock(self,pointer_location):
754 778
755 779 currentPointer = pointer_location
756 780
757 781 neededSize = self.processingHeaderObj.blockSize #+ self.basicHeaderSize
758 782
759 783 for nTries in range( self.nTries ):
760 784 self.fp.close()
761 785 self.fp = open( self.filename, 'rb' )
762 786 self.fp.seek( currentPointer )
763 787
764 788 self.fileSize = os.path.getsize( self.filename )
765 789 currentSize = self.fileSize - currentPointer
766 790
767 791 if ( currentSize >= neededSize ):
768 792 return 1
769 793
770 794 print "[Reading] Waiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
771 795 sleep( self.delay )
772 796
773 797 return 0
774 798
775 799 def __jumpToLastBlock(self):
776 800
777 801 if not(self.__isFirstTimeOnline):
778 802 return
779 803
780 804 csize = self.fileSize - self.fp.tell()
781 805 blocksize = self.processingHeaderObj.blockSize
782 806
783 807 #salta el primer bloque de datos
784 808 if csize > self.processingHeaderObj.blockSize:
785 809 self.fp.seek(self.fp.tell() + blocksize)
786 810 else:
787 811 return
788 812
789 813 csize = self.fileSize - self.fp.tell()
790 814 neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
791 815 while True:
792 816
793 817 if self.fp.tell()<self.fileSize:
794 818 self.fp.seek(self.fp.tell() + neededsize)
795 819 else:
796 820 self.fp.seek(self.fp.tell() - neededsize)
797 821 break
798 822
799 823 # csize = self.fileSize - self.fp.tell()
800 824 # neededsize = self.processingHeaderObj.blockSize + self.basicHeaderSize
801 825 # factor = int(csize/neededsize)
802 826 # if factor > 0:
803 827 # self.fp.seek(self.fp.tell() + factor*neededsize)
804 828
805 829 self.flagIsNewFile = 0
806 830 self.__isFirstTimeOnline = 0
807 831
808 832 def __setNewBlock(self):
809 833
810 834 if self.fp == None:
811 835 return 0
812 836
813 837 if self.online:
814 838 self.__jumpToLastBlock()
815 839
816 840 if self.flagIsNewFile:
817 841 return 1
818 842
819 843 self.lastUTTime = self.basicHeaderObj.utc
820 844 currentSize = self.fileSize - self.fp.tell()
821 845 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
822 846
823 847 if (currentSize >= neededSize):
824 848 self.basicHeaderObj.read(self.fp)
825 849 return 1
826 850
827 851 if self.__waitNewBlock():
828 852 return 1
829 853
830 854 if not(self.setNextFile()):
831 855 return 0
832 856
833 857 deltaTime = self.basicHeaderObj.utc - self.lastUTTime #
834 858
835 859 self.flagDiscontinuousBlock = 0
836 860
837 861 if deltaTime > self.maxTimeStep:
838 862 self.flagDiscontinuousBlock = 1
839 863
840 864 return 1
841 865
842 866 def readNextBlock(self):
843 867 if not(self.__setNewBlock()):
844 868 return 0
845 869
846 870 if not(self.readBlock()):
847 871 return 0
848 872
849 873 return 1
850 874
851 875 def __readFirstHeader(self):
852 876
853 877 self.basicHeaderObj.read(self.fp)
854 878 self.systemHeaderObj.read(self.fp)
855 879 self.radarControllerHeaderObj.read(self.fp)
856 880 self.processingHeaderObj.read(self.fp)
857 881
858 882 self.firstHeaderSize = self.basicHeaderObj.size
859 883
860 884 datatype = int(numpy.log2((self.processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
861 885 if datatype == 0:
862 886 datatype_str = numpy.dtype([('real','<i1'),('imag','<i1')])
863 887 elif datatype == 1:
864 888 datatype_str = numpy.dtype([('real','<i2'),('imag','<i2')])
865 889 elif datatype == 2:
866 890 datatype_str = numpy.dtype([('real','<i4'),('imag','<i4')])
867 891 elif datatype == 3:
868 892 datatype_str = numpy.dtype([('real','<i8'),('imag','<i8')])
869 893 elif datatype == 4:
870 894 datatype_str = numpy.dtype([('real','<f4'),('imag','<f4')])
871 895 elif datatype == 5:
872 896 datatype_str = numpy.dtype([('real','<f8'),('imag','<f8')])
873 897 else:
874 898 raise ValueError, 'Data type was not defined'
875 899
876 900 self.dtype = datatype_str
877 901 #self.ippSeconds = 2 * 1000 * self.radarControllerHeaderObj.ipp / self.c
878 902 self.fileSizeByHeader = self.processingHeaderObj.dataBlocksPerFile * self.processingHeaderObj.blockSize + self.firstHeaderSize + self.basicHeaderSize*(self.processingHeaderObj.dataBlocksPerFile - 1)
879 903 # self.dataOut.channelList = numpy.arange(self.systemHeaderObj.numChannels)
880 904 # self.dataOut.channelIndexList = numpy.arange(self.systemHeaderObj.numChannels)
881 905 self.getBlockDimension()
882 906
883 907 def __verifyFile(self, filename, msgFlag=True):
884 908 msg = None
885 909 try:
886 910 fp = open(filename, 'rb')
887 911 currentPosition = fp.tell()
888 912 except IOError:
889 913 traceback.print_exc()
890 914 if msgFlag:
891 915 print "[Reading] The file %s can't be opened" % (filename)
892 916 return False
893 917
894 918 neededSize = self.processingHeaderObj.blockSize + self.firstHeaderSize
895 919
896 920 if neededSize == 0:
897 921 basicHeaderObj = BasicHeader(LOCALTIME)
898 922 systemHeaderObj = SystemHeader()
899 923 radarControllerHeaderObj = RadarControllerHeader()
900 924 processingHeaderObj = ProcessingHeader()
901 925
902 926 try:
903 927 if not( basicHeaderObj.read(fp) ): raise IOError
904 928 if not( systemHeaderObj.read(fp) ): raise IOError
905 929 if not( radarControllerHeaderObj.read(fp) ): raise IOError
906 930 if not( processingHeaderObj.read(fp) ): raise IOError
907 931 # data_type = int(numpy.log2((processingHeaderObj.processFlags & PROCFLAG.DATATYPE_MASK))-numpy.log2(PROCFLAG.DATATYPE_CHAR))
908 932
909 933 neededSize = processingHeaderObj.blockSize + basicHeaderObj.size
910 934
911 935 except IOError:
912 936 traceback.print_exc()
913 937 if msgFlag:
914 938 print "[Reading] The file %s is empty or it hasn't enough data" % filename
915 939
916 940 fp.close()
917 941 return False
918 942 else:
919 943 msg = "[Reading] Skipping the file %s due to it hasn't enough data" %filename
920 944
921 945 fp.close()
922 946 fileSize = os.path.getsize(filename)
923 947 currentSize = fileSize - currentPosition
924 948 if currentSize < neededSize:
925 949 if msgFlag and (msg != None):
926 950 print msg #print"\tSkipping the file %s due to it hasn't enough data" %filename
927 951 return False
928 952
929 953 return True
930 954
955 def findDatafiles(self, path, startDate=None, endDate=None, expLabel='', ext='.r', walk=True):
956
957 dateList = []
958 pathList = []
959
960 if not walk:
961 #pathList.append(path)
962 multi_path = path.split(',')
963 for single_path in multi_path:
964
965 ok = False
966 fileList = glob.glob1(single_path, "*"+ext)
967
968 for thisFile in fileList:
969
970 if not os.path.isfile(os.path.join(single_path, thisFile)):
971 continue
972
973 if not isRadarFile(thisFile):
974 continue
975
976 ok = True
977 thisDate = getDateFromRadarFile(thisFile)
978
979 if thisDate not in dateList:
980 dateList.append(thisDate)
981
982 if ok:
983 pathList.append(single_path)
984
985 return dateList
986
987 multi_path = path.split(',')
988 for single_path in multi_path:
989
990 dirList = []
991
992 for thisPath in os.listdir(single_path):
993
994 if not os.path.isdir(os.path.join(single_path,thisPath)):
995 continue
996
997 if not isRadarFolder(thisPath):
998 continue
999
1000 dirList.append(thisPath)
1001
1002 if not dirList:
1003 return dateList
1004
1005 if startDate and endDate:
1006 thisDate = startDate
1007
1008 while(thisDate <= endDate):
1009 year = thisDate.timetuple().tm_year
1010 doy = thisDate.timetuple().tm_yday
1011
1012 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
1013 if len(matchlist) == 0:
1014 thisDate += datetime.timedelta(1)
1015 continue
1016
1017 for match in matchlist:
1018 pathList.append(os.path.join(single_path,match,expLabel))
1019 dateList.append(thisDate)
1020
1021 thisDate += datetime.timedelta(1)
1022 else:
1023 for thiDir in dirList:
1024 year = int(folder[1:5])
1025 doy = int(folder[5:8])
1026 thisDate = datetime.date(year,1,1) + datetime.timedelta(doy-1)
1027
1028 pathList.append(os.path.join(single_path,thiDir,expLabel))
1029 dateList.append(thisDate)
1030
1031 return dateList
1032
1033
931 1034 def setup(self,
932 1035 path=None,
933 1036 startDate=None,
934 1037 endDate=None,
935 1038 startTime=datetime.time(0,0,0),
936 1039 endTime=datetime.time(23,59,59),
937 1040 set=None,
938 1041 expLabel = "",
939 1042 ext = None,
940 1043 online = False,
941 1044 delay = 60,
942 1045 walk = True,
943 1046 getblock = False,
944 1047 nTxs = 1):
945 1048
946 1049 if path == None:
947 1050 raise ValueError, "[Reading] The path is not valid"
948 1051
949 1052 if ext == None:
950 1053 ext = self.ext
951 1054
952 1055 if online:
953 1056 print "[Reading] Searching files in online mode..."
954 1057
955 1058 for nTries in range( self.nTries ):
956 1059 fullpath, foldercounter, file, year, doy, set = self.__searchFilesOnLine(path=path, expLabel=expLabel, ext=ext, walk=walk, set=set)
957 1060
958 1061 if fullpath:
959 1062 break
960 1063
961 1064 print '[Reading] Waiting %0.2f sec for an valid file in %s: try %02d ...' % (self.delay, path, nTries+1)
962 1065 sleep( self.delay )
963 1066
964 1067 if not(fullpath):
965 1068 print "[Reading] There 'isn't any valid file in %s" % path
966 1069 return None
967 1070
968 1071 self.year = year
969 1072 self.doy = doy
970 1073 self.set = set - 1
971 1074 self.path = path
972 1075 self.foldercounter = foldercounter
973 1076 last_set = None
974 1077
975 1078 else:
976 1079 print "[Reading] Searching files in offline mode ..."
977 1080 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
978 1081 startTime=startTime, endTime=endTime,
979 1082 set=set, expLabel=expLabel, ext=ext,
980 1083 walk=walk)
981 1084
982 1085 if not(pathList):
983 1086 print "[Reading] No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
984 1087 datetime.datetime.combine(startDate,startTime).ctime(),
985 1088 datetime.datetime.combine(endDate,endTime).ctime())
986 1089
987 1090 sys.exit(-1)
988 1091
989 1092
990 1093 self.fileIndex = -1
991 1094 self.pathList = pathList
992 1095 self.filenameList = filenameList
993 1096 file_name = os.path.basename(filenameList[-1])
994 1097 basename, ext = os.path.splitext(file_name)
995 1098 last_set = int(basename[-3:])
996 1099
997 1100 self.online = online
998 1101 self.delay = delay
999 1102 ext = ext.lower()
1000 1103 self.ext = ext
1001 1104 self.getByBlock = getblock
1002 1105 self.nTxs = int(nTxs)
1003 1106
1004 1107 if not(self.setNextFile()):
1005 1108 if (startDate!=None) and (endDate!=None):
1006 1109 print "[Reading] No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
1007 1110 elif startDate != None:
1008 1111 print "[Reading] No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
1009 1112 else:
1010 1113 print "[Reading] No files"
1011 1114
1012 1115 sys.exit(-1)
1013 1116
1014 1117 # self.updateDataHeader()
1015 1118 if last_set != None:
1016 1119 self.dataOut.last_block = last_set * self.processingHeaderObj.dataBlocksPerFile + self.basicHeaderObj.dataBlock
1017 1120 return
1018 1121
1019 1122 def getBasicHeader(self):
1020 1123
1021 1124 self.dataOut.utctime = self.basicHeaderObj.utc + self.basicHeaderObj.miliSecond/1000. + self.profileIndex * self.radarControllerHeaderObj.ippSeconds
1022 1125
1023 1126 self.dataOut.flagDiscontinuousBlock = self.flagDiscontinuousBlock
1024 1127
1025 1128 self.dataOut.timeZone = self.basicHeaderObj.timeZone
1026 1129
1027 1130 self.dataOut.dstFlag = self.basicHeaderObj.dstFlag
1028 1131
1029 1132 self.dataOut.errorCount = self.basicHeaderObj.errorCount
1030 1133
1031 1134 self.dataOut.useLocalTime = self.basicHeaderObj.useLocalTime
1032 1135
1033 1136 self.dataOut.ippSeconds = self.radarControllerHeaderObj.ippSeconds/self.nTxs
1034 1137
1035 1138 self.dataOut.nProfiles = self.processingHeaderObj.profilesPerBlock*self.nTxs
1036 1139
1037 1140
1038 1141 def getFirstHeader(self):
1039 1142
1040 1143 raise ValueError, "This method has not been implemented"
1041 1144
1042 1145 def getData(self):
1043 1146
1044 1147 raise ValueError, "This method has not been implemented"
1045 1148
1046 1149 def hasNotDataInBuffer(self):
1047 1150
1048 1151 raise ValueError, "This method has not been implemented"
1049 1152
1050 1153 def readBlock(self):
1051 1154
1052 1155 raise ValueError, "This method has not been implemented"
1053 1156
1054 1157 def isEndProcess(self):
1055 1158
1056 1159 return self.flagNoMoreFiles
1057 1160
1058 1161 def printReadBlocks(self):
1059 1162
1060 1163 print "[Reading] Number of read blocks per file %04d" %self.nReadBlocks
1061 1164
1062 1165 def printTotalBlocks(self):
1063 1166
1064 1167 print "[Reading] Number of read blocks %04d" %self.nTotalBlocks
1065 1168
1066 1169 def printNumberOfBlock(self):
1067 1170
1068 1171 if self.flagIsNewBlock:
1069 1172 print "[Reading] Block No. %04d, Total blocks %04d -> %s" %(self.basicHeaderObj.dataBlock, self.nTotalBlocks, self.dataOut.datatime.ctime())
1070 1173 self.dataOut.blocknow = self.basicHeaderObj.dataBlock
1071 1174
1072 1175 def printInfo(self):
1073 1176
1074 1177 if self.__printInfo == False:
1075 1178 return
1076 1179
1077 1180 self.basicHeaderObj.printInfo()
1078 1181 self.systemHeaderObj.printInfo()
1079 1182 self.radarControllerHeaderObj.printInfo()
1080 1183 self.processingHeaderObj.printInfo()
1081 1184
1082 1185 self.__printInfo = False
1083 1186
1084 1187
1085 1188 def run(self, **kwargs):
1086 1189
1087 1190 if not(self.isConfig):
1088 1191
1089 1192 # self.dataOut = dataOut
1090 1193 self.setup(**kwargs)
1091 1194 self.isConfig = True
1092 1195
1093 1196 self.getData()
1094 1197
1095 1198 class JRODataWriter(JRODataIO):
1096 1199
1097 1200 """
1098 1201 Esta clase permite escribir datos a archivos procesados (.r o ,pdata). La escritura
1099 1202 de los datos siempre se realiza por bloques.
1100 1203 """
1101 1204
1102 1205 blockIndex = 0
1103 1206
1104 1207 path = None
1105 1208
1106 1209 setFile = None
1107 1210
1108 1211 profilesPerBlock = None
1109 1212
1110 1213 blocksPerFile = None
1111 1214
1112 1215 nWriteBlocks = 0
1113 1216
1114 1217 def __init__(self, dataOut=None):
1115 1218 raise ValueError, "Not implemented"
1116 1219
1117 1220
1118 1221 def hasAllDataInBuffer(self):
1119 1222 raise ValueError, "Not implemented"
1120 1223
1121 1224
1122 1225 def setBlockDimension(self):
1123 1226 raise ValueError, "Not implemented"
1124 1227
1125 1228
1126 1229 def writeBlock(self):
1127 1230 raise ValueError, "No implemented"
1128 1231
1129 1232
1130 1233 def putData(self):
1131 1234 raise ValueError, "No implemented"
1132 1235
1133 1236
1134 1237 def setBasicHeader(self):
1135 1238
1136 1239 self.basicHeaderObj.size = self.basicHeaderSize #bytes
1137 1240 self.basicHeaderObj.version = self.versionFile
1138 1241 self.basicHeaderObj.dataBlock = self.nTotalBlocks
1139 1242
1140 1243 utc = numpy.floor(self.dataOut.utctime)
1141 1244 milisecond = (self.dataOut.utctime - utc)* 1000.0
1142 1245
1143 1246 self.basicHeaderObj.utc = utc
1144 1247 self.basicHeaderObj.miliSecond = milisecond
1145 1248 self.basicHeaderObj.timeZone = self.dataOut.timeZone
1146 1249 self.basicHeaderObj.dstFlag = self.dataOut.dstFlag
1147 1250 self.basicHeaderObj.errorCount = self.dataOut.errorCount
1148 1251
1149 1252 def setFirstHeader(self):
1150 1253 """
1151 1254 Obtiene una copia del First Header
1152 1255
1153 1256 Affected:
1154 1257
1155 1258 self.basicHeaderObj
1156 1259 self.systemHeaderObj
1157 1260 self.radarControllerHeaderObj
1158 1261 self.processingHeaderObj self.
1159 1262
1160 1263 Return:
1161 1264 None
1162 1265 """
1163 1266
1164 1267 raise ValueError, "No implemented"
1165 1268
1166 1269 def __writeFirstHeader(self):
1167 1270 """
1168 1271 Escribe el primer header del file es decir el Basic header y el Long header (SystemHeader, RadarControllerHeader, ProcessingHeader)
1169 1272
1170 1273 Affected:
1171 1274 __dataType
1172 1275
1173 1276 Return:
1174 1277 None
1175 1278 """
1176 1279
1177 1280 # CALCULAR PARAMETROS
1178 1281
1179 1282 sizeLongHeader = self.systemHeaderObj.size + self.radarControllerHeaderObj.size + self.processingHeaderObj.size
1180 1283 self.basicHeaderObj.size = self.basicHeaderSize + sizeLongHeader
1181 1284
1182 1285 self.basicHeaderObj.write(self.fp)
1183 1286 self.systemHeaderObj.write(self.fp)
1184 1287 self.radarControllerHeaderObj.write(self.fp)
1185 1288 self.processingHeaderObj.write(self.fp)
1186 1289
1187 1290 self.dtype = self.dataOut.dtype
1188 1291
1189 1292 def __setNewBlock(self):
1190 1293 """
1191 1294 Si es un nuevo file escribe el First Header caso contrario escribe solo el Basic Header
1192 1295
1193 1296 Return:
1194 1297 0 : si no pudo escribir nada
1195 1298 1 : Si escribio el Basic el First Header
1196 1299 """
1197 1300 if self.fp == None:
1198 1301 self.setNextFile()
1199 1302
1200 1303 if self.flagIsNewFile:
1201 1304 return 1
1202 1305
1203 1306 if self.blockIndex < self.processingHeaderObj.dataBlocksPerFile:
1204 1307 self.basicHeaderObj.write(self.fp)
1205 1308 return 1
1206 1309
1207 1310 if not( self.setNextFile() ):
1208 1311 return 0
1209 1312
1210 1313 return 1
1211 1314
1212 1315
1213 1316 def writeNextBlock(self):
1214 1317 """
1215 1318 Selecciona el bloque siguiente de datos y los escribe en un file
1216 1319
1217 1320 Return:
1218 1321 0 : Si no hizo pudo escribir el bloque de datos
1219 1322 1 : Si no pudo escribir el bloque de datos
1220 1323 """
1221 1324 if not( self.__setNewBlock() ):
1222 1325 return 0
1223 1326
1224 1327 self.writeBlock()
1225 1328
1226 1329 return 1
1227 1330
1228 1331 def setNextFile(self):
1229 1332 """
1230 1333 Determina el siguiente file que sera escrito
1231 1334
1232 1335 Affected:
1233 1336 self.filename
1234 1337 self.subfolder
1235 1338 self.fp
1236 1339 self.setFile
1237 1340 self.flagIsNewFile
1238 1341
1239 1342 Return:
1240 1343 0 : Si el archivo no puede ser escrito
1241 1344 1 : Si el archivo esta listo para ser escrito
1242 1345 """
1243 1346 ext = self.ext
1244 1347 path = self.path
1245 1348
1246 1349 if self.fp != None:
1247 1350 self.fp.close()
1248 1351
1249 1352 timeTuple = time.localtime( self.dataOut.utctime)
1250 1353 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
1251 1354
1252 1355 fullpath = os.path.join( path, subfolder )
1253 1356 if not( os.path.exists(fullpath) ):
1254 1357 os.mkdir(fullpath)
1255 1358 self.setFile = -1 #inicializo mi contador de seteo
1256 1359 else:
1257 1360 filesList = os.listdir( fullpath )
1258 1361 if len( filesList ) > 0:
1259 1362 filesList = sorted( filesList, key=str.lower )
1260 1363 filen = filesList[-1]
1261 1364 # el filename debera tener el siguiente formato
1262 1365 # 0 1234 567 89A BCDE (hex)
1263 1366 # x YYYY DDD SSS .ext
1264 1367 if isNumber( filen[8:11] ):
1265 1368 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
1266 1369 else:
1267 1370 self.setFile = -1
1268 1371 else:
1269 1372 self.setFile = -1 #inicializo mi contador de seteo
1270 1373
1271 1374 setFile = self.setFile
1272 1375 setFile += 1
1273 1376
1274 1377 filen = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
1275 1378 timeTuple.tm_year,
1276 1379 timeTuple.tm_yday,
1277 1380 setFile,
1278 1381 ext )
1279 1382
1280 1383 filename = os.path.join( path, subfolder, filen )
1281 1384
1282 1385 fp = open( filename,'wb' )
1283 1386
1284 1387 self.blockIndex = 0
1285 1388
1286 1389 #guardando atributos
1287 1390 self.filename = filename
1288 1391 self.subfolder = subfolder
1289 1392 self.fp = fp
1290 1393 self.setFile = setFile
1291 1394 self.flagIsNewFile = 1
1292 1395
1293 1396 self.setFirstHeader()
1294 1397
1295 1398 print '[Writing] file: %s'%self.filename
1296 1399
1297 1400 self.__writeFirstHeader()
1298 1401
1299 1402 return 1
1300 1403
1301 1404 def setup(self, dataOut, path, blocksPerFile, profilesPerBlock=64, set=0, ext=None):
1302 1405 """
1303 1406 Setea el tipo de formato en la cual sera guardada la data y escribe el First Header
1304 1407
1305 1408 Inputs:
1306 1409 path : el path destino en el cual se escribiran los files a crear
1307 1410 format : formato en el cual sera salvado un file
1308 1411 set : el setebo del file
1309 1412
1310 1413 Return:
1311 1414 0 : Si no realizo un buen seteo
1312 1415 1 : Si realizo un buen seteo
1313 1416 """
1314 1417
1315 1418 if ext == None:
1316 1419 ext = self.ext
1317 1420
1318 1421 ext = ext.lower()
1319 1422
1320 1423 self.ext = ext
1321 1424
1322 1425 self.path = path
1323 1426
1324 1427 self.setFile = set - 1
1325 1428
1326 1429 self.blocksPerFile = blocksPerFile
1327 1430
1328 1431 self.profilesPerBlock = profilesPerBlock
1329 1432
1330 1433 self.dataOut = dataOut
1331 1434
1332 1435 if not(self.setNextFile()):
1333 1436 print "[Writing] There isn't a next file"
1334 1437 return 0
1335 1438
1336 1439 self.setBlockDimension()
1337 1440
1338 1441 return 1
1339 1442
1340 1443 def run(self, dataOut, **kwargs):
1341 1444
1342 1445 if not(self.isConfig):
1343 1446
1344 1447 self.setup(dataOut, **kwargs)
1345 1448 self.isConfig = True
1346 1449
1347 1450 self.putData()
1348 1451
Show file before | Show file after | Hide comments
@@ -1,849 +1,849
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
13 13 try:
14 14 from gevent import sleep
15 15 except:
16 16 from time import sleep
17 17
18 18 try:
19 19 import pyfits
20 20 except:
21 21 """
22 22 """
23 23
24 24 from xml.etree.ElementTree import ElementTree
25 25
26 from jroIO_base import isDoyFolder, isNumber
26 from jroIO_base import isRadarFolder, isNumber
27 27 from schainpy.model.proc.jroproc_base import Operation, ProcessingUnit
28 28
29 29 class Fits:
30 30 name=None
31 31 format=None
32 32 array =None
33 33 data =None
34 34 thdulist=None
35 35 prihdr=None
36 36 hdu=None
37 37
38 38 def __init__(self):
39 39
40 40 pass
41 41
42 42 def setColF(self,name,format,array):
43 43 self.name=name
44 44 self.format=format
45 45 self.array=array
46 46 a1=numpy.array([self.array],dtype=numpy.float32)
47 47 self.col1 = pyfits.Column(name=self.name, format=self.format, array=a1)
48 48 return self.col1
49 49
50 50 # def setColP(self,name,format,data):
51 51 # self.name=name
52 52 # self.format=format
53 53 # self.data=data
54 54 # a2=numpy.array([self.data],dtype=numpy.float32)
55 55 # self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
56 56 # return self.col2
57 57
58 58
59 59 def writeData(self,name,format,data):
60 60 self.name=name
61 61 self.format=format
62 62 self.data=data
63 63 a2=numpy.array([self.data],dtype=numpy.float32)
64 64 self.col2 = pyfits.Column(name=self.name, format=self.format, array=a2)
65 65 return self.col2
66 66
67 67 def cFImage(self,idblock,year,month,day,hour,minute,second):
68 68 self.hdu= pyfits.PrimaryHDU(idblock)
69 69 self.hdu.header.set("Year",year)
70 70 self.hdu.header.set("Month",month)
71 71 self.hdu.header.set("Day",day)
72 72 self.hdu.header.set("Hour",hour)
73 73 self.hdu.header.set("Minute",minute)
74 74 self.hdu.header.set("Second",second)
75 75 return self.hdu
76 76
77 77
78 78 def Ctable(self,colList):
79 79 self.cols=pyfits.ColDefs(colList)
80 80 self.tbhdu = pyfits.new_table(self.cols)
81 81 return self.tbhdu
82 82
83 83
84 84 def CFile(self,hdu,tbhdu):
85 85 self.thdulist=pyfits.HDUList([hdu,tbhdu])
86 86
87 87 def wFile(self,filename):
88 88 if os.path.isfile(filename):
89 89 os.remove(filename)
90 90 self.thdulist.writeto(filename)
91 91
92 92
93 93 class ParameterConf:
94 94 ELEMENTNAME = 'Parameter'
95 95 def __init__(self):
96 96 self.name = ''
97 97 self.value = ''
98 98
99 99 def readXml(self, parmElement):
100 100 self.name = parmElement.get('name')
101 101 self.value = parmElement.get('value')
102 102
103 103 def getElementName(self):
104 104 return self.ELEMENTNAME
105 105
106 106 class Metadata:
107 107
108 108 def __init__(self, filename):
109 109 self.parmConfObjList = []
110 110 self.readXml(filename)
111 111
112 112 def readXml(self, filename):
113 113 self.projectElement = None
114 114 self.procUnitConfObjDict = {}
115 115 self.projectElement = ElementTree().parse(filename)
116 116 self.project = self.projectElement.tag
117 117
118 118 parmElementList = self.projectElement.getiterator(ParameterConf().getElementName())
119 119
120 120 for parmElement in parmElementList:
121 121 parmConfObj = ParameterConf()
122 122 parmConfObj.readXml(parmElement)
123 123 self.parmConfObjList.append(parmConfObj)
124 124
125 125 class FitsWriter(Operation):
126 126
127 127 def __init__(self):
128 128 self.isConfig = False
129 129 self.dataBlocksPerFile = None
130 130 self.blockIndex = 0
131 131 self.flagIsNewFile = 1
132 132 self.fitsObj = None
133 133 self.optchar = 'P'
134 134 self.ext = '.fits'
135 135 self.setFile = 0
136 136
137 137 def setFitsHeader(self, dataOut, metadatafile):
138 138
139 139 header_data = pyfits.PrimaryHDU()
140 140
141 141 metadata4fits = Metadata(metadatafile)
142 142 for parameter in metadata4fits.parmConfObjList:
143 143 parm_name = parameter.name
144 144 parm_value = parameter.value
145 145
146 146 # if parm_value == 'fromdatadatetime':
147 147 # value = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())
148 148 # elif parm_value == 'fromdataheights':
149 149 # value = dataOut.nHeights
150 150 # elif parm_value == 'fromdatachannel':
151 151 # value = dataOut.nChannels
152 152 # elif parm_value == 'fromdatasamples':
153 153 # value = dataOut.nFFTPoints
154 154 # else:
155 155 # value = parm_value
156 156
157 157 header_data.header[parm_name] = parm_value
158 158
159 159
160 160 header_data.header['DATETIME'] = time.strftime("%b %d %Y %H:%M:%S", dataOut.datatime.timetuple())
161 161 header_data.header['CHANNELLIST'] = str(dataOut.channelList)
162 162 header_data.header['NCHANNELS'] = dataOut.nChannels
163 163 #header_data.header['HEIGHTS'] = dataOut.heightList
164 164 header_data.header['NHEIGHTS'] = dataOut.nHeights
165 165
166 166 header_data.header['IPPSECONDS'] = dataOut.ippSeconds
167 167 header_data.header['NCOHINT'] = dataOut.nCohInt
168 168 header_data.header['NINCOHINT'] = dataOut.nIncohInt
169 169 header_data.header['TIMEZONE'] = dataOut.timeZone
170 170 header_data.header['NBLOCK'] = self.blockIndex
171 171
172 172 header_data.writeto(self.filename)
173 173
174 174 self.addExtension(dataOut.heightList,'HEIGHTLIST')
175 175
176 176
177 177 def setup(self, dataOut, path, dataBlocksPerFile, metadatafile):
178 178
179 179 self.path = path
180 180 self.dataOut = dataOut
181 181 self.metadatafile = metadatafile
182 182 self.dataBlocksPerFile = dataBlocksPerFile
183 183
184 184 def open(self):
185 185 self.fitsObj = pyfits.open(self.filename, mode='update')
186 186
187 187
188 188 def addExtension(self, data, tagname):
189 189 self.open()
190 190 extension = pyfits.ImageHDU(data=data, name=tagname)
191 191 #extension.header['TAG'] = tagname
192 192 self.fitsObj.append(extension)
193 193 self.write()
194 194
195 195 def addData(self, data):
196 196 self.open()
197 197 extension = pyfits.ImageHDU(data=data, name=self.fitsObj[0].header['DATATYPE'])
198 198 extension.header['UTCTIME'] = self.dataOut.utctime
199 199 self.fitsObj.append(extension)
200 200 self.blockIndex += 1
201 201 self.fitsObj[0].header['NBLOCK'] = self.blockIndex
202 202
203 203 self.write()
204 204
205 205 def write(self):
206 206
207 207 self.fitsObj.flush(verbose=True)
208 208 self.fitsObj.close()
209 209
210 210
211 211 def setNextFile(self):
212 212
213 213 ext = self.ext
214 214 path = self.path
215 215
216 216 timeTuple = time.localtime( self.dataOut.utctime)
217 217 subfolder = 'd%4.4d%3.3d' % (timeTuple.tm_year,timeTuple.tm_yday)
218 218
219 219 fullpath = os.path.join( path, subfolder )
220 220 if not( os.path.exists(fullpath) ):
221 221 os.mkdir(fullpath)
222 222 self.setFile = -1 #inicializo mi contador de seteo
223 223 else:
224 224 filesList = os.listdir( fullpath )
225 225 if len( filesList ) > 0:
226 226 filesList = sorted( filesList, key=str.lower )
227 227 filen = filesList[-1]
228 228
229 229 if isNumber( filen[8:11] ):
230 230 self.setFile = int( filen[8:11] ) #inicializo mi contador de seteo al seteo del ultimo file
231 231 else:
232 232 self.setFile = -1
233 233 else:
234 234 self.setFile = -1 #inicializo mi contador de seteo
235 235
236 236 setFile = self.setFile
237 237 setFile += 1
238 238
239 239 thisFile = '%s%4.4d%3.3d%3.3d%s' % (self.optchar,
240 240 timeTuple.tm_year,
241 241 timeTuple.tm_yday,
242 242 setFile,
243 243 ext )
244 244
245 245 filename = os.path.join( path, subfolder, thisFile )
246 246
247 247 self.blockIndex = 0
248 248 self.filename = filename
249 249 self.setFile = setFile
250 250 self.flagIsNewFile = 1
251 251
252 252 print 'Writing the file: %s'%self.filename
253 253
254 254 self.setFitsHeader(self.dataOut, self.metadatafile)
255 255
256 256 return 1
257 257
258 258 def writeBlock(self):
259 259 self.addData(self.dataOut.data_spc)
260 260 self.flagIsNewFile = 0
261 261
262 262
263 263 def __setNewBlock(self):
264 264
265 265 if self.flagIsNewFile:
266 266 return 1
267 267
268 268 if self.blockIndex < self.dataBlocksPerFile:
269 269 return 1
270 270
271 271 if not( self.setNextFile() ):
272 272 return 0
273 273
274 274 return 1
275 275
276 276 def writeNextBlock(self):
277 277 if not( self.__setNewBlock() ):
278 278 return 0
279 279 self.writeBlock()
280 280 return 1
281 281
282 282 def putData(self):
283 283 if self.flagIsNewFile:
284 284 self.setNextFile()
285 285 self.writeNextBlock()
286 286
287 287 def run(self, dataOut, **kwargs):
288 288 if not(self.isConfig):
289 289 self.setup(dataOut, **kwargs)
290 290 self.isConfig = True
291 291 self.putData()
292 292
293 293
294 294 class FitsReader(ProcessingUnit):
295 295
296 296 # __TIMEZONE = time.timezone
297 297
298 298 expName = None
299 299 datetimestr = None
300 300 utc = None
301 301 nChannels = None
302 302 nSamples = None
303 303 dataBlocksPerFile = None
304 304 comments = None
305 305 lastUTTime = None
306 306 header_dict = None
307 307 data = None
308 308 data_header_dict = None
309 309
310 310 def __init__(self):
311 311 self.isConfig = False
312 312 self.ext = '.fits'
313 313 self.setFile = 0
314 314 self.flagNoMoreFiles = 0
315 315 self.flagIsNewFile = 1
316 316 self.flagDiscontinuousBlock = None
317 317 self.fileIndex = None
318 318 self.filename = None
319 319 self.fileSize = None
320 320 self.fitsObj = None
321 321 self.timeZone = None
322 322 self.nReadBlocks = 0
323 323 self.nTotalBlocks = 0
324 324 self.dataOut = self.createObjByDefault()
325 325 self.maxTimeStep = 10# deberia ser definido por el usuario usando el metodo setup()
326 326 self.blockIndex = 1
327 327
328 328 def createObjByDefault(self):
329 329
330 330 dataObj = Fits()
331 331
332 332 return dataObj
333 333
334 334 def isFileinThisTime(self, filename, startTime, endTime, useLocalTime=False):
335 335 try:
336 336 fitsObj = pyfits.open(filename,'readonly')
337 337 except:
338 338 raise IOError, "The file %s can't be opened" %(filename)
339 339
340 340 header = fitsObj[0].header
341 341 struct_time = time.strptime(header['DATETIME'], "%b %d %Y %H:%M:%S")
342 342 utc = time.mktime(struct_time) - time.timezone #TIMEZONE debe ser un parametro del header FITS
343 343
344 344 ltc = utc
345 345 if useLocalTime:
346 346 ltc -= time.timezone
347 347 thisDatetime = datetime.datetime.utcfromtimestamp(ltc)
348 348 thisTime = thisDatetime.time()
349 349
350 350 if not ((startTime <= thisTime) and (endTime > thisTime)):
351 351 return None
352 352
353 353 return thisDatetime
354 354
355 355 def __setNextFileOnline(self):
356 356 raise ValueError, "No implemented"
357 357
358 358 def __setNextFileOffline(self):
359 359 idFile = self.fileIndex
360 360
361 361 while (True):
362 362 idFile += 1
363 363 if not(idFile < len(self.filenameList)):
364 364 self.flagNoMoreFiles = 1
365 365 print "No more Files"
366 366 return 0
367 367
368 368 filename = self.filenameList[idFile]
369 369
370 370 # if not(self.__verifyFile(filename)):
371 371 # continue
372 372
373 373 fileSize = os.path.getsize(filename)
374 374 fitsObj = pyfits.open(filename,'readonly')
375 375 break
376 376
377 377 self.flagIsNewFile = 1
378 378 self.fileIndex = idFile
379 379 self.filename = filename
380 380 self.fileSize = fileSize
381 381 self.fitsObj = fitsObj
382 382 self.blockIndex = 0
383 383 print "Setting the file: %s"%self.filename
384 384
385 385 return 1
386 386
387 387 def __setValuesFromHeader(self):
388 388
389 389 self.dataOut.header = self.header_dict
390 390 self.dataOut.expName = self.expName
391 391 self.dataOut.nChannels = self.nChannels
392 392 self.dataOut.timeZone = self.timeZone
393 393 self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
394 394 self.dataOut.comments = self.comments
395 395 # self.dataOut.timeInterval = self.timeInterval
396 396 self.dataOut.channelList = self.channelList
397 397 self.dataOut.heightList = self.heightList
398 398
399 399 self.dataOut.nCohInt = self.nCohInt
400 400 self.dataOut.nIncohInt = self.nIncohInt
401 401
402 402 def readHeader(self):
403 403 headerObj = self.fitsObj[0]
404 404
405 405 self.header_dict = headerObj.header
406 406 if 'EXPNAME' in headerObj.header.keys():
407 407 self.expName = headerObj.header['EXPNAME']
408 408
409 409 if 'DATATYPE' in headerObj.header.keys():
410 410 self.dataType = headerObj.header['DATATYPE']
411 411
412 412 self.datetimestr = headerObj.header['DATETIME']
413 413 channelList = headerObj.header['CHANNELLIST']
414 414 channelList = channelList.split('[')
415 415 channelList = channelList[1].split(']')
416 416 channelList = channelList[0].split(',')
417 417 channelList = [int(ch) for ch in channelList]
418 418 self.channelList = channelList
419 419 self.nChannels = headerObj.header['NCHANNELS']
420 420 self.nHeights = headerObj.header['NHEIGHTS']
421 421 self.ippSeconds = headerObj.header['IPPSECONDS']
422 422 self.nCohInt = headerObj.header['NCOHINT']
423 423 self.nIncohInt = headerObj.header['NINCOHINT']
424 424 self.dataBlocksPerFile = headerObj.header['NBLOCK']
425 425 self.timeZone = headerObj.header['TIMEZONE']
426 426
427 427 # self.timeInterval = self.ippSeconds * self.nCohInt * self.nIncohInt
428 428
429 429 if 'COMMENT' in headerObj.header.keys():
430 430 self.comments = headerObj.header['COMMENT']
431 431
432 432 self.readHeightList()
433 433
434 434 def readHeightList(self):
435 435 self.blockIndex = self.blockIndex + 1
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 readExtension(self):
441 441 obj = self.fitsObj[self.blockIndex]
442 442 self.heightList = obj.data
443 443 self.blockIndex = self.blockIndex + 1
444 444
445 445 def setNextFile(self):
446 446
447 447 if self.online:
448 448 newFile = self.__setNextFileOnline()
449 449 else:
450 450 newFile = self.__setNextFileOffline()
451 451
452 452 if not(newFile):
453 453 return 0
454 454
455 455 self.readHeader()
456 456 self.__setValuesFromHeader()
457 457 self.nReadBlocks = 0
458 458 # self.blockIndex = 1
459 459 return 1
460 460
461 461 def __searchFilesOffLine(self,
462 462 path,
463 463 startDate,
464 464 endDate,
465 465 startTime=datetime.time(0,0,0),
466 466 endTime=datetime.time(23,59,59),
467 467 set=None,
468 468 expLabel='',
469 469 ext='.fits',
470 470 walk=True):
471 471
472 472 pathList = []
473 473
474 474 if not walk:
475 475 pathList.append(path)
476 476
477 477 else:
478 478 dirList = []
479 479 for thisPath in os.listdir(path):
480 480 if not os.path.isdir(os.path.join(path,thisPath)):
481 481 continue
482 if not isDoyFolder(thisPath):
482 if not isRadarFolder(thisPath):
483 483 continue
484 484
485 485 dirList.append(thisPath)
486 486
487 487 if not(dirList):
488 488 return None, None
489 489
490 490 thisDate = startDate
491 491
492 492 while(thisDate <= endDate):
493 493 year = thisDate.timetuple().tm_year
494 494 doy = thisDate.timetuple().tm_yday
495 495
496 496 matchlist = fnmatch.filter(dirList, '?' + '%4.4d%3.3d' % (year,doy) + '*')
497 497 if len(matchlist) == 0:
498 498 thisDate += datetime.timedelta(1)
499 499 continue
500 500 for match in matchlist:
501 501 pathList.append(os.path.join(path,match,expLabel))
502 502
503 503 thisDate += datetime.timedelta(1)
504 504
505 505 if pathList == []:
506 506 print "Any folder was found for the date range: %s-%s" %(startDate, endDate)
507 507 return None, None
508 508
509 509 print "%d folder(s) was(were) found for the date range: %s - %s" %(len(pathList), startDate, endDate)
510 510
511 511 filenameList = []
512 512 datetimeList = []
513 513
514 514 for i in range(len(pathList)):
515 515
516 516 thisPath = pathList[i]
517 517
518 518 fileList = glob.glob1(thisPath, "*%s" %ext)
519 519 fileList.sort()
520 520
521 521 for thisFile in fileList:
522 522
523 523 filename = os.path.join(thisPath,thisFile)
524 524 thisDatetime = self.isFileinThisTime(filename, startTime, endTime)
525 525
526 526 if not(thisDatetime):
527 527 continue
528 528
529 529 filenameList.append(filename)
530 530 datetimeList.append(thisDatetime)
531 531
532 532 if not(filenameList):
533 533 print "Any file was found for the time range %s - %s" %(startTime, endTime)
534 534 return None, None
535 535
536 536 print "%d file(s) was(were) found for the time range: %s - %s" %(len(filenameList), startTime, endTime)
537 537 print
538 538
539 539 for i in range(len(filenameList)):
540 540 print "%s -> [%s]" %(filenameList[i], datetimeList[i].ctime())
541 541
542 542 self.filenameList = filenameList
543 543 self.datetimeList = datetimeList
544 544
545 545 return pathList, filenameList
546 546
547 547 def setup(self, path=None,
548 548 startDate=None,
549 549 endDate=None,
550 550 startTime=datetime.time(0,0,0),
551 551 endTime=datetime.time(23,59,59),
552 552 set=0,
553 553 expLabel = "",
554 554 ext = None,
555 555 online = False,
556 556 delay = 60,
557 557 walk = True):
558 558
559 559 if path == None:
560 560 raise ValueError, "The path is not valid"
561 561
562 562 if ext == None:
563 563 ext = self.ext
564 564
565 565 if not(online):
566 566 print "Searching files in offline mode ..."
567 567 pathList, filenameList = self.__searchFilesOffLine(path, startDate=startDate, endDate=endDate,
568 568 startTime=startTime, endTime=endTime,
569 569 set=set, expLabel=expLabel, ext=ext,
570 570 walk=walk)
571 571
572 572 if not(pathList):
573 573 print "No *%s files into the folder %s \nfor the range: %s - %s"%(ext, path,
574 574 datetime.datetime.combine(startDate,startTime).ctime(),
575 575 datetime.datetime.combine(endDate,endTime).ctime())
576 576
577 577 sys.exit(-1)
578 578
579 579 self.fileIndex = -1
580 580 self.pathList = pathList
581 581 self.filenameList = filenameList
582 582
583 583 self.online = online
584 584 self.delay = delay
585 585 ext = ext.lower()
586 586 self.ext = ext
587 587
588 588 if not(self.setNextFile()):
589 589 if (startDate!=None) and (endDate!=None):
590 590 print "No files in range: %s - %s" %(datetime.datetime.combine(startDate,startTime).ctime(), datetime.datetime.combine(endDate,endTime).ctime())
591 591 elif startDate != None:
592 592 print "No files in range: %s" %(datetime.datetime.combine(startDate,startTime).ctime())
593 593 else:
594 594 print "No files"
595 595
596 596 sys.exit(-1)
597 597
598 598
599 599
600 600 def readBlock(self):
601 601 dataObj = self.fitsObj[self.blockIndex]
602 602
603 603 self.data = dataObj.data
604 604 self.data_header_dict = dataObj.header
605 605 self.utc = self.data_header_dict['UTCTIME']
606 606
607 607 self.flagIsNewFile = 0
608 608 self.blockIndex += 1
609 609 self.nTotalBlocks += 1
610 610 self.nReadBlocks += 1
611 611
612 612 return 1
613 613
614 614 def __jumpToLastBlock(self):
615 615 raise ValueError, "No implemented"
616 616
617 617 def __waitNewBlock(self):
618 618 """
619 619 Return 1 si se encontro un nuevo bloque de datos, 0 de otra forma.
620 620
621 621 Si el modo de lectura es OffLine siempre retorn 0
622 622 """
623 623 if not self.online:
624 624 return 0
625 625
626 626 if (self.nReadBlocks >= self.dataBlocksPerFile):
627 627 return 0
628 628
629 629 currentPointer = self.fp.tell()
630 630
631 631 neededSize = self.processingHeaderObj.blockSize + self.basicHeaderSize
632 632
633 633 for nTries in range( self.nTries ):
634 634
635 635 self.fp.close()
636 636 self.fp = open( self.filename, 'rb' )
637 637 self.fp.seek( currentPointer )
638 638
639 639 self.fileSize = os.path.getsize( self.filename )
640 640 currentSize = self.fileSize - currentPointer
641 641
642 642 if ( currentSize >= neededSize ):
643 643 self.__rdBasicHeader()
644 644 return 1
645 645
646 646 print "\tWaiting %0.2f seconds for the next block, try %03d ..." % (self.delay, nTries+1)
647 647 sleep( self.delay )
648 648
649 649
650 650 return 0
651 651
652 652 def __setNewBlock(self):
653 653
654 654 if self.online:
655 655 self.__jumpToLastBlock()
656 656
657 657 if self.flagIsNewFile:
658 658 return 1
659 659
660 660 self.lastUTTime = self.utc
661 661
662 662 if self.online:
663 663 if self.__waitNewBlock():
664 664 return 1
665 665
666 666 if self.nReadBlocks < self.dataBlocksPerFile:
667 667 return 1
668 668
669 669 if not(self.setNextFile()):
670 670 return 0
671 671
672 672 deltaTime = self.utc - self.lastUTTime
673 673
674 674 self.flagDiscontinuousBlock = 0
675 675
676 676 if deltaTime > self.maxTimeStep:
677 677 self.flagDiscontinuousBlock = 1
678 678
679 679 return 1
680 680
681 681
682 682 def readNextBlock(self):
683 683 if not(self.__setNewBlock()):
684 684 return 0
685 685
686 686 if not(self.readBlock()):
687 687 return 0
688 688
689 689 return 1
690 690
691 691
692 692 def getData(self):
693 693
694 694 if self.flagNoMoreFiles:
695 695 self.dataOut.flagNoData = True
696 696 print 'Process finished'
697 697 return 0
698 698
699 699 self.flagDiscontinuousBlock = 0
700 700 self.flagIsNewBlock = 0
701 701
702 702 if not(self.readNextBlock()):
703 703 return 0
704 704
705 705 if self.data == None:
706 706 self.dataOut.flagNoData = True
707 707 return 0
708 708
709 709 self.dataOut.data = self.data
710 710 self.dataOut.data_header = self.data_header_dict
711 711 self.dataOut.utctime = self.utc
712 712
713 713 # self.dataOut.header = self.header_dict
714 714 # self.dataOut.expName = self.expName
715 715 # self.dataOut.nChannels = self.nChannels
716 716 # self.dataOut.timeZone = self.timeZone
717 717 # self.dataOut.dataBlocksPerFile = self.dataBlocksPerFile
718 718 # self.dataOut.comments = self.comments
719 719 # # self.dataOut.timeInterval = self.timeInterval
720 720 # self.dataOut.channelList = self.channelList
721 721 # self.dataOut.heightList = self.heightList
722 722 self.dataOut.flagNoData = False
723 723
724 724 return self.dataOut.data
725 725
726 726 def run(self, **kwargs):
727 727
728 728 if not(self.isConfig):
729 729 self.setup(**kwargs)
730 730 self.isConfig = True
731 731
732 732 self.getData()
733 733
734 734 class SpectraHeisWriter(Operation):
735 735 # set = None
736 736 setFile = None
737 737 idblock = None
738 738 doypath = None
739 739 subfolder = None
740 740
741 741 def __init__(self):
742 742 self.wrObj = Fits()
743 743 # self.dataOut = dataOut
744 744 self.nTotalBlocks=0
745 745 # self.set = None
746 746 self.setFile = None
747 747 self.idblock = 0
748 748 self.wrpath = None
749 749 self.doypath = None
750 750 self.subfolder = None
751 751 self.isConfig = False
752 752
753 753 def isNumber(str):
754 754 """
755 755 Chequea si el conjunto de caracteres que componen un string puede ser convertidos a un numero.
756 756
757 757 Excepciones:
758 758 Si un determinado string no puede ser convertido a numero
759 759 Input:
760 760 str, string al cual se le analiza para determinar si convertible a un numero o no
761 761
762 762 Return:
763 763 True : si el string es uno numerico
764 764 False : no es un string numerico
765 765 """
766 766 try:
767 767 float( str )
768 768 return True
769 769 except:
770 770 return False
771 771
772 772 def setup(self, dataOut, wrpath):
773 773
774 774 if not(os.path.exists(wrpath)):
775 775 os.mkdir(wrpath)
776 776
777 777 self.wrpath = wrpath
778 778 # self.setFile = 0
779 779 self.dataOut = dataOut
780 780
781 781 def putData(self):
782 782 name= time.localtime( self.dataOut.utctime)
783 783 ext=".fits"
784 784
785 785 if self.doypath == None:
786 786 self.subfolder = 'F%4.4d%3.3d_%d' % (name.tm_year,name.tm_yday,time.mktime(datetime.datetime.now().timetuple()))
787 787 self.doypath = os.path.join( self.wrpath, self.subfolder )
788 788 os.mkdir(self.doypath)
789 789
790 790 if self.setFile == None:
791 791 # self.set = self.dataOut.set
792 792 self.setFile = 0
793 793 # if self.set != self.dataOut.set:
794 794 ## self.set = self.dataOut.set
795 795 # self.setFile = 0
796 796
797 797 #make the filename
798 798 thisFile = 'D%4.4d%3.3d_%3.3d%s' % (name.tm_year,name.tm_yday,self.setFile,ext)
799 799
800 800 filename = os.path.join(self.wrpath,self.subfolder, thisFile)
801 801
802 802 idblock = numpy.array([self.idblock],dtype="int64")
803 803 header=self.wrObj.cFImage(idblock=idblock,
804 804 year=time.gmtime(self.dataOut.utctime).tm_year,
805 805 month=time.gmtime(self.dataOut.utctime).tm_mon,
806 806 day=time.gmtime(self.dataOut.utctime).tm_mday,
807 807 hour=time.gmtime(self.dataOut.utctime).tm_hour,
808 808 minute=time.gmtime(self.dataOut.utctime).tm_min,
809 809 second=time.gmtime(self.dataOut.utctime).tm_sec)
810 810
811 811 c=3E8
812 812 deltaHeight = self.dataOut.heightList[1] - self.dataOut.heightList[0]
813 813 freq=numpy.arange(-1*self.dataOut.nHeights/2.,self.dataOut.nHeights/2.)*(c/(2*deltaHeight*1000))
814 814
815 815 colList = []
816 816
817 817 colFreq=self.wrObj.setColF(name="freq", format=str(self.dataOut.nFFTPoints)+'E', array=freq)
818 818
819 819 colList.append(colFreq)
820 820
821 821 nchannel=self.dataOut.nChannels
822 822
823 823 for i in range(nchannel):
824 824 col = self.wrObj.writeData(name="PCh"+str(i+1),
825 825 format=str(self.dataOut.nFFTPoints)+'E',
826 826 data=10*numpy.log10(self.dataOut.data_spc[i,:]))
827 827
828 828 colList.append(col)
829 829
830 830 data=self.wrObj.Ctable(colList=colList)
831 831
832 832 self.wrObj.CFile(header,data)
833 833
834 834 self.wrObj.wFile(filename)
835 835
836 836 #update the setFile
837 837 self.setFile += 1
838 838 self.idblock += 1
839 839
840 840 return 1
841 841
842 842 def run(self, dataOut, **kwargs):
843 843
844 844 if not(self.isConfig):
845 845
846 846 self.setup(dataOut, **kwargs)
847 847 self.isConfig = True
848 848
849 849 self.putData() No newline at end of file
Show file before | Show file after | Hide comments
@@ -1,517 +1,577
1 1 '''
2 2 Created on Jul 3, 2014
3 3
4 4 @author: roj-idl71
5 5 '''
6 6 import datetime
7 7 import numpy
8 8
9 9 try:
10 10 from gevent import sleep
11 11 except:
12 12 from time import sleep
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 try:
19 19 import digital_rf_hdf5
20 20 except:
21 21 print 'You should install "digital_rf_hdf5" module if you want to read USRP data'
22 22
23 23 class USRPReader(ProcessingUnit):
24 24 '''
25 25 classdocs
26 26 '''
27 27
28 28 def __init__(self):
29 29 '''
30 30 Constructor
31 31 '''
32 32
33 33 ProcessingUnit.__init__(self)
34 34
35 35 self.dataOut = Voltage()
36 36 self.__printInfo = True
37 37 self.__flagDiscontinuousBlock = False
38 38 self.__bufferIndex = 9999999
39 39
40 40 self.__ippKm = None
41 41 self.__codeType = 0
42 42 self.__nCode = None
43 43 self.__nBaud = None
44 44 self.__code = None
45 45
46 46 def __getCurrentSecond(self):
47 47
48 48 return self.__thisUnixSample/self.__sample_rate
49 49
50 50 thisSecond = property(__getCurrentSecond, "I'm the 'thisSecond' property.")
51 51
52 52 def __setFileHeader(self):
53 53 '''
54 54 In this method will be initialized every parameter of dataOut object (header, no data)
55 55 '''
56 56
57 57 self.dataOut.radarControllerHeaderObj = RadarControllerHeader(ippKm=self.__ippKm,
58 58 txA=0,
59 59 txB=0,
60 60 nWindows=1,
61 61 nHeights=self.__nSamples,
62 62 firstHeight=self.__firstHeigth,
63 63 deltaHeight=self.__deltaHeigth,
64 64 codeType=self.__codeType,
65 65 nCode=self.__nCode, nBaud=self.__nBaud,
66 66 code = self.__code)
67 67
68 68 self.dataOut.systemHeaderObj = SystemHeader(nSamples=self.__nSamples,
69 69 nProfiles=1024,
70 70 nChannels=len(self.__channelList),
71 71 adcResolution=14)
72 72
73 73 self.dataOut.type = "Voltage"
74 74
75 75 self.dataOut.data = None
76 76
77 77 self.dataOut.dtype = numpy.dtype([('real','<i8'),('imag','<i8')])
78 78
79 79 # self.dataOut.nChannels = 0
80 80
81 81 # self.dataOut.nHeights = 0
82 82
83 83 self.dataOut.nProfiles = 1
84 84
85 85 self.dataOut.heightList = self.__firstHeigth + numpy.arange(self.__nSamples, dtype = numpy.float)*self.__deltaHeigth
86 86
87 87 self.dataOut.channelList = self.__channelList
88 88
89 89 self.dataOut.blocksize = self.dataOut.getNChannels() * self.dataOut.getNHeights()
90 90
91 91 # self.dataOut.channelIndexList = None
92 92
93 93 self.dataOut.flagNoData = True
94 94
95 95 #Set to TRUE if the data is discontinuous
96 96 self.dataOut.flagDiscontinuousBlock = False
97 97
98 98 self.dataOut.utctime = None
99 99
100 100 self.dataOut.timeZone = self.__timezone/60 #timezone like jroheader, difference in minutes between UTC and localtime
101 101
102 102 self.dataOut.dstFlag = 0
103 103
104 104 self.dataOut.errorCount = 0
105 105
106 106 self.dataOut.nCohInt = 1
107 107
108 108 self.dataOut.flagDecodeData = False #asumo que la data esta decodificada
109 109
110 110 self.dataOut.flagDeflipData = False #asumo que la data esta sin flip
111 111
112 112 self.dataOut.flagShiftFFT = False
113 113
114 114 self.dataOut.ippSeconds = 1.0*self.__nSamples/self.__sample_rate
115 115
116 116 #Time interval between profiles
117 117 #self.dataOut.timeInterval = self.dataOut.ippSeconds * self.dataOut.nCohInt
118 118
119 119 self.dataOut.frequency = self.__frequency
120 120
121 121 self.dataOut.realtime = self.__online
122
123 def findDatafiles(self, path, startDate=None, endDate=None):
124
125 try:
126 digitalReadObj = digital_rf_hdf5.read_hdf5(path, load_all_metadata=True)
127 except:
128 digitalReadObj = digital_rf_hdf5.read_hdf5(path)
129
130 channelNameList = digitalReadObj.get_channels()
131
132 metadata_dict = digitalReadObj.get_rf_file_metadata(channelNameList[0])
133
134 sample_rate = metadata_dict['sample_rate'][0]
135
136 this_metadata_file = digitalReadObj.get_metadata(channelNameList[0])
137
138 try:
139 timezone = this_metadata_file['timezone'].value
140 except:
141 timezone = 0
142
143 startUTCSecond, endUTCSecond = digitalReadObj.get_bounds(channelNameList[0])/sample_rate - timezone
144
145 startDatetime = datetime.datetime.utcfromtimestamp(startUTCSecond)
146 endDatatime = datetime.datetime.utcfromtimestamp(endUTCSecond)
147
148 if not startDate:
149 startDate = startDatetime.date()
150
151 if not endDate:
152 endDate = endDatatime.date()
153
154 dateList = []
155
156 thisDatetime = startDatetime
157
158 while(thisDatetime<=endDatatime):
159
160 thisDate = thisDatetime.date()
161
162 if thisDate < startDate:
163 continue
164
165 if thisDate > endDate:
166 break
167
168 dateList.append(thisDate)
169 thisDatetime += datetime.timedelta(1)
122 170
171 return dateList
172
123 173 def setup(self, path = None,
124 174 startDate = None,
125 175 endDate = None,
126 176 startTime = datetime.time(0,0,0),
127 177 endTime = datetime.time(23,59,59),
128 178 channelList = None,
129 179 nSamples = None,
130 ippKm = None,
180 ippKm = 60,
131 181 online = False,
132 wait = 60,
133 nbuffer = 1024*4):
182 delay = 60,
183 buffer_size = None,
184 nbuffer = 1024,
185 **kwargs):
134 186 '''
135 187 In this method we should set all initial parameters.
136 188
137 189 Inputs:
138 190 path
139 191 startDate
140 192 endDate
141 193 startTime
142 194 endTime
143 195 set
144 196 expLabel
145 197 ext
146 198 online
147 wait
199 delay
148 200 '''
201
202 if not buffer_size:
203 buffer_size = nbuffer
204
149 205 try:
150 206 self.digitalReadObj = digital_rf_hdf5.read_hdf5(path, load_all_metadata=True)
151 207 except:
152 208 self.digitalReadObj = digital_rf_hdf5.read_hdf5(path)
153 209
154 210 channelNameList = self.digitalReadObj.get_channels()
155 211
156 212 if not channelNameList:
157 213 raise IOError, "[Reading] The path doesn,t have any files .. "
158 214
159 215 if not channelList:
160 216 channelList = range(len(channelNameList))
161 217
162 218 ########## Reading metadata ######################
163 219
164 220 metadata_dict = self.digitalReadObj.get_rf_file_metadata(channelNameList[channelList[0]])
165 221
166 222 self.__sample_rate = metadata_dict['sample_rate'][0]
167 223 self.__samples_per_file = metadata_dict['samples_per_file'][0]
168 224 self.__deltaHeigth = 1e6*0.15/self.__sample_rate
169 225
170 226 this_metadata_file = self.digitalReadObj.get_metadata(channelNameList[channelList[0]])
171 227
172 228 self.__frequency = this_metadata_file['center_frequencies'].value
173 229 try:
174 230 self.__timezone = this_metadata_file['timezone'].value
175 231 except:
176 232 self.__timezone = 0
177 233
178 234 self.__firstHeigth = 0
179 235
180 236 try:
181 237 codeType = this_metadata_file['codeType'].value
182 238 except:
183 239 codeType = 0
184 240
185 241 nCode = 0
186 242 nBaud = 0
187 243 code = None
188 244
189 245 if codeType:
190 246 nCode = this_metadata_file['nCode'].value
191 247 nBaud = this_metadata_file['nBaud'].value
192 248 code = this_metadata_file['code'].value
193 249
194 250 if not ippKm:
195 251 try:
196 252 #seconds to km
197 253 ippKm = 1e6*0.15*this_metadata_file['ipp'].value
198 254 except:
199 255 ippKm = None
200 256
201 257 ####################################################
202 258 startUTCSecond = None
203 259 endUTCSecond = None
204 260
205 261 if startDate:
206 262 startDatetime = datetime.datetime.combine(startDate, startTime)
207 263 startUTCSecond = (startDatetime-datetime.datetime(1970,1,1)).total_seconds() + self.__timezone
208 264
209 265 if endDate:
210 266 endDatetime = datetime.datetime.combine(endDate, endTime)
211 267 endUTCSecond = (endDatetime-datetime.datetime(1970,1,1)).total_seconds() + self.__timezone
212 268
213 269 start_index, end_index = self.digitalReadObj.get_bounds(channelNameList[channelList[0]])
214 270
215 271 if not startUTCSecond:
216 272 startUTCSecond = start_index/self.__sample_rate
217 273
218 274 if start_index > startUTCSecond*self.__sample_rate:
219 275 startUTCSecond = start_index/self.__sample_rate
220 276
221 277 if not endUTCSecond:
222 278 endUTCSecond = end_index/self.__sample_rate
223 279
224 280 if end_index < endUTCSecond*self.__sample_rate:
225 281 endUTCSecond = end_index/self.__sample_rate
226 282
227 283 if not nSamples:
228 284 if not ippKm:
229 285 raise ValueError, "[Reading] nSamples or ippKm should be defined"
230 286
231 287 nSamples = ippKm / (1e6*0.15/self.__sample_rate)
232 288
233 289 channelBoundList = []
234 290 channelNameListFiltered = []
235 291
236 292 for thisIndexChannel in channelList:
237 293 thisChannelName = channelNameList[thisIndexChannel]
238 294 start_index, end_index = self.digitalReadObj.get_bounds(thisChannelName)
239 295 channelBoundList.append((start_index, end_index))
240 296 channelNameListFiltered.append(thisChannelName)
241 297
242 298 self.profileIndex = 0
243 299
300 self.__delay = delay
244 301 self.__ippKm = ippKm
245 302 self.__codeType = codeType
246 303 self.__nCode = nCode
247 304 self.__nBaud = nBaud
248 305 self.__code = code
249 306
250 307 self.__datapath = path
251 308 self.__online = online
252 309 self.__channelList = channelList
253 310 self.__channelNameList = channelNameListFiltered
254 311 self.__channelBoundList = channelBoundList
255 312 self.__nSamples = nSamples
256 self.__samples_to_read = nbuffer*nSamples
313 self.__samples_to_read = buffer_size*nSamples
257 314 self.__nChannels = len(self.__channelList)
258 315
259 316 self.__startUTCSecond = startUTCSecond
260 317 self.__endUTCSecond = endUTCSecond
261 318
262 319 self.__timeInterval = 1.0 * self.__samples_to_read/self.__sample_rate #Time interval
263 320
264 321 if online:
265 322 # self.__thisUnixSample = int(endUTCSecond*self.__sample_rate - 4*self.__samples_to_read)
266 323 startUTCSecond = numpy.floor(endUTCSecond)
267 324
268 325 self.__thisUnixSample = int(startUTCSecond*self.__sample_rate) - self.__samples_to_read
269 326
270 327 self.__data_buffer = numpy.zeros((self.__nChannels, self.__samples_to_read), dtype = numpy.complex)
271 328
272 329 self.__setFileHeader()
273 330 self.isConfig = True
274 331
275 332 print "[Reading] USRP Data was found from %s to %s " %(
276 333 datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
277 334 datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
278 335 )
279 336
280 337 print "[Reading] Starting process from ", datetime.datetime.utcfromtimestamp(startUTCSecond - self.__timezone), " to ", datetime.datetime.utcfromtimestamp(endUTCSecond - self.__timezone)
281 338
282 339 def __reload(self):
283 340
284 341 if not self.__online:
285 342 return
286 343
287 344 # print
288 345 # print "%s not in range [%s, %s]" %(
289 346 # datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
290 347 # datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
291 348 # datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
292 349 # )
293 350 print "[Reading] reloading metadata ..."
294 351
295 self.digitalReadObj.reload(complete_update=True)
352 try:
353 self.digitalReadObj.reload(complete_update=True)
354 except:
355 self.digitalReadObj.reload()
296 356
297 357 start_index, end_index = self.digitalReadObj.get_bounds(self.__channelNameList[self.__channelList[0]])
298 358
299 359 if start_index > self.__startUTCSecond*self.__sample_rate:
300 360 self.__startUTCSecond = 1.0*start_index/self.__sample_rate
301 361
302 362 if end_index > self.__endUTCSecond*self.__sample_rate:
303 363 self.__endUTCSecond = 1.0*end_index/self.__sample_rate
304 364 print
305 365 print "[Reading] New timerange found [%s, %s] " %(
306 366 datetime.datetime.utcfromtimestamp(self.__startUTCSecond - self.__timezone),
307 367 datetime.datetime.utcfromtimestamp(self.__endUTCSecond - self.__timezone)
308 368 )
309 369
310 370 return True
311 371
312 372 return False
313 373
314 374 def __readNextBlock(self, seconds=30, volt_scale = 218776):
315 375 '''
316 376 '''
317 377
318 378 #Set the next data
319 379 self.__flagDiscontinuousBlock = False
320 380 self.__thisUnixSample += self.__samples_to_read
321 381
322 382 if self.__thisUnixSample + 2*self.__samples_to_read > self.__endUTCSecond*self.__sample_rate:
323 383 print "[Reading] There are no more data into selected timerange"
324 384
325 385 self.__reload()
326 386
327 387 if self.__thisUnixSample + 2*self.__samples_to_read > self.__endUTCSecond*self.__sample_rate:
328 388 self.__thisUnixSample -= self.__samples_to_read
329 389 return False
330 390
331 391 indexChannel = 0
332 392
333 393 dataOk = False
334 394
335 395 for thisChannelName in self.__channelNameList:
336 396
337 397 try:
338 398 result = self.digitalReadObj.read_vector_c81d(self.__thisUnixSample,
339 399 self.__samples_to_read,
340 400 thisChannelName)
341 401
342 402 except IOError, e:
343 403 #read next profile
344 404 self.__flagDiscontinuousBlock = True
345 405 print e
346 406 break
347 407
348 408 if result.shape[0] != self.__samples_to_read:
349 409 self.__flagDiscontinuousBlock = True
350 410 print "[Reading] %s: Too few samples were found, just %d samples" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
351 411 result.shape[0])
352 412 break
353 413
354 414 self.__data_buffer[indexChannel,:] = result*volt_scale
355 415
356 416 indexChannel += 1
357 417
358 418 dataOk = True
359 419
360 420 self.__utctime = self.__thisUnixSample/self.__sample_rate
361 421
362 422 if not dataOk:
363 423 return False
364 424
365 425 print "[Reading] %s: %d samples <> %f sec" %(datetime.datetime.utcfromtimestamp(self.thisSecond - self.__timezone),
366 426 self.__samples_to_read,
367 427 self.__timeInterval)
368 428
369 429 self.__bufferIndex = 0
370 430
371 431 return True
372 432
373 433 def __isBufferEmpty(self):
374 434
375 435 if self.__bufferIndex <= self.__samples_to_read - self.__nSamples:
376 436 return False
377 437
378 438 return True
379 439
380 440 def getData(self, seconds=30, nTries=5):
381 441
382 442 '''
383 443 This method gets the data from files and put the data into the dataOut object
384 444
385 445 In addition, increase el the buffer counter in one.
386 446
387 447 Return:
388 448 data : retorna un perfil de voltages (alturas * canales) copiados desde el
389 449 buffer. Si no hay mas archivos a leer retorna None.
390 450
391 451 Affected:
392 452 self.dataOut
393 453 self.profileIndex
394 454 self.flagDiscontinuousBlock
395 455 self.flagIsNewBlock
396 456 '''
397 457
398 458 err_counter = 0
399 459 self.dataOut.flagNoData = True
400 460
401 461 if self.__isBufferEmpty():
402 462
403 463 self.__flagDiscontinuousBlock = False
404 464
405 465 while True:
406 466 if self.__readNextBlock():
407 467 break
408 468
409 469 if self.__thisUnixSample > self.__endUTCSecond*self.__sample_rate:
410 470 return False
411 471
412 472 if self.__flagDiscontinuousBlock:
413 473 print '[Reading] discontinuous block found ... continue with the next block'
414 474 continue
415 475
416 476 if not self.__online:
417 477 return False
418 478
419 479 err_counter += 1
420 480 if err_counter > nTries:
421 481 return False
422 482
423 483 print '[Reading] waiting %d seconds to read a new block' %seconds
424 484 sleep(seconds)
425 485
426 486 self.dataOut.data = self.__data_buffer[:,self.__bufferIndex:self.__bufferIndex+self.__nSamples]
427 487 self.dataOut.utctime = (self.__thisUnixSample + self.__bufferIndex)/self.__sample_rate
428 488 self.dataOut.flagNoData = False
429 489 self.dataOut.flagDiscontinuousBlock = self.__flagDiscontinuousBlock
430 490
431 491 self.__bufferIndex += self.__nSamples
432 492 self.profileIndex += 1
433 493
434 494 return True
435 495
436 496 def printInfo(self):
437 497 '''
438 498 '''
439 499 if self.__printInfo == False:
440 500 return
441 501
442 502 # self.systemHeaderObj.printInfo()
443 503 # self.radarControllerHeaderObj.printInfo()
444 504
445 505 self.__printInfo = False
446 506
447 507 def printNumberOfBlock(self):
448 508 '''
449 509 '''
450 510
451 511 print self.profileIndex
452 512
453 513 def run(self, **kwargs):
454 514 '''
455 515 This method will be called many times so here you should put all your code
456 516 '''
457 517
458 518 if not self.isConfig:
459 519 self.setup(**kwargs)
460 520
461 self.getData()
521 self.getData(seconds=self.__delay)
462 522
463 523 return
464 524
465 525 class USRPWriter(Operation):
466 526 '''
467 527 classdocs
468 528 '''
469 529
470 530 def __init__(self):
471 531 '''
472 532 Constructor
473 533 '''
474 534 self.dataOut = None
475 535
476 536 def setup(self, dataIn, path, blocksPerFile, set=0, ext=None):
477 537 '''
478 538 In this method we should set all initial parameters.
479 539
480 540 Input:
481 541 dataIn : Input data will also be outputa data
482 542
483 543 '''
484 544 self.dataOut = dataIn
485 545
486 546
487 547
488 548
489 549
490 550 self.isConfig = True
491 551
492 552 return
493 553
494 554 def run(self, dataIn, **kwargs):
495 555 '''
496 556 This method will be called many times so here you should put all your code
497 557
498 558 Inputs:
499 559
500 560 dataIn : object with the data
501 561
502 562 '''
503 563
504 564 if not self.isConfig:
505 565 self.setup(dataIn, **kwargs)
506 566
507 567
508 568 if __name__ == '__main__':
509 569
510 570 readObj = USRPReader()
511 571
512 572 while True:
513 573 readObj.run(path='/Volumes/DATA/haystack/passive_radar/')
514 574 # readObj.printInfo()
515 575 readObj.printNumberOfBlock()
516 576
517 577 No newline at end of file
General Comments 0
You need to be logged in to leave comments. Login now